panel/app/models/site/repository.rb

# frozen_string_literal: true

class Site
  # Acciones para el repositorio Git de un sitio.  Por ahora hacemos un
  # uso muy básico de Git, con lo que asumimos varias cosas, por ejemplo
  # que un sitio tiene un solo origen, que siempre se trabaja con la
  # rama master, etc.
  class Repository
    attr_reader :rugged, :path

    # @param [String] la ruta del repositorio
    def initialize(path)
      @path = path
      @rugged = Rugged::Repository.new(path)
    end

    # Obtiene la rama por defecto a partir de la referencia actual
    #
    # Por ejemplo "refs/heads/no-master" => "no-master"
    #
    # XXX: No memoizamos para obtener siempre el nombre de la rama
    # actual, aunque por ahora asumimos que siempre estamos en la misma,
    # internamente (ej. vía shell) podríamos cambiarla.
    #
    # @return [String]
    def default_branch
      rugged.head.canonical_name.split('/', 3).last
    end

    # Obtiene el origin
    #
    # @return [Rugged::Remote]
    def origin
      @origin ||= rugged.remotes.find do |remote|
        remote.name == 'origin'
      end
    end

    # Trae los cambios del repositorio de origen sin aplicarlos y
    # devuelve la cantidad de commits pendientes.
    #
    # XXX: Prestar atención a la velocidad de respuesta cuando tengamos
    # repositorios remotos.
    #
    # @return [Integer]
    def fetch
      if origin.check_connection :fetch
        rugged.fetch(origin)[:received_objects]
      else
        0
      end
    end

    # Incorpora los cambios en el repositorio actual
    #
    # @return [Rugged::Commit]
    def merge(usuarie)
      merge = rugged.merge_commits(head_commit, remote_head_commit)

      # No hacemos nada si hay conflictos, pero notificarnos
      begin
        raise MergeConflictsException if merge.conflicts?
      rescue MergeConflictsException => e
        ExceptionNotifier.notify_exception(e, data: { path: path, merge: merge })
        return # No hacer nada
      end

      commit = Rugged::Commit
               .create(rugged, update_ref: 'HEAD',
                               parents: [head_commit, remote_head_commit],
                               tree: merge.write_tree(rugged),
                               message: I18n.t('sites.fetch.merge.message'),
                               author: author(usuarie), committer: committer)

      # Forzamos el checkout para mover el HEAD al último commit y
      # escribir los cambios
      rugged.checkout 'HEAD', strategy: :force
      commit
    end

    # El último commit
    #
    # @return [Rugged::Commit]
    def head_commit
      rugged.branches[default_branch].target
    end

    # El último commit del repositorio remoto
    #
    # XXX: Realmente no recuerdo por qué esto era necesario ~f
    #
    # @return [Rugged::Commit]
    def remote_head_commit
      rugged.branches["origin/#{default_branch}"].target
    end

    # Compara los commits entre el repositorio remoto y el actual para
    # que luego los podamos mostrar.
    def commits
      walker = Rugged::Walker.new rugged

      # Obtenemos todos los commits que existen en origin/master que no
      # están en la rama master local
      walker.push "refs/remotes/origin/#{default_branch}"
      walker.hide "refs/heads/#{default_branch}"

      walker.each.to_a
    end

    # Hay commits sin aplicar?
    def needs_pull?
      fetch
      !commits.empty?
    end

    # Guarda los cambios en git
    def commit(file:, usuarie:, message:, remove: false)
      file = [file] unless file.respond_to? :each

      file.each do |f|
        remove ? rm(f) : add(f)
      end

      # Escribir los cambios para que el repositorio se vea tal cual
      rugged.index.write

      Rugged::Commit.create(rugged, message: message, update_ref: 'HEAD',
                                    parents: [rugged.head.target],
                                    tree: rugged.index.write_tree,
                                    author: author(usuarie),
                                    committer: committer)
    end

    def author(author)
      { name: author.name, email: author.email, time: Time.now }
    end

    def committer
      { name: 'Sutty', email: "sutty@#{Site.domain}", time: Time.now }
    end

    def add(file)
      rugged.index.add(relativize(file))
    end

    def rm(file)
      rugged.index.remove(relativize(file))
    end

    private

    def relativize(file)
      Pathname.new(file).relative_path_from(Pathname.new(path)).to_s
    end
  end
end