jit 0.0.0 → 1.0.0

data/lib/command/push.rb

@@ -0,0 +1,172 @@
+require_relative "./base"
+require_relative "./shared/fast_forward"
+require_relative "./shared/remote_client"
+require_relative "./shared/send_objects"
+require_relative "../remotes"
+require_relative "../revision"
+
+module Command
+  class Push < Base
+
+    include FastForward
+    include RemoteClient
+    include SendObjects
+
+    CAPABILITIES = ["report-status"]
+    RECEIVE_PACK = "git-receive-pack"
+
+    UNPACK_LINE = /^unpack (.+)$/
+    UPDATE_LINE = /^(ok|ng) (\S+)(.*)$/
+
+    def define_options
+      @parser.on("-f", "--force") { @options[:force] = true }
+
+      @parser.on "--receive-pack=<receive-pack>" do |receiver|
+        @options[:receiver] = receiver
+      end
+    end
+
+    def run
+      configure
+      start_agent("push", @receiver, @push_url, CAPABILITIES)
+
+      recv_references
+      send_update_requests
+      send_objects
+      print_summary
+      recv_report_status
+
+      exit (@errors.empty? ? 0 : 1)
+    end
+
+    private
+
+    def configure
+      current_branch = repo.refs.current_ref.short_name
+      branch_remote  = repo.config.get(["branch", current_branch, "remote"])
+      branch_merge   = repo.config.get(["branch", current_branch, "merge"])
+
+      name   = @args.fetch(0, branch_remote || Remotes::DEFAULT_REMOTE)
+      remote = repo.remotes.get(name)
+
+      @push_url    = remote&.push_url || @args[0]
+      @fetch_specs = remote&.fetch_specs || []
+      @receiver    = @options[:receiver] || remote&.receiver || RECEIVE_PACK
+
+      if @args.size > 1
+        @push_specs = @args.drop(1)
+      elsif branch_merge
+        spec = Remotes::Refspec.new(current_branch, branch_merge, false)
+        @push_specs = [spec.to_s]
+      else
+        @push_specs = remote&.push_specs
+      end
+    end
+
+    def send_update_requests
+      @updates = {}
+      @errors  = []
+
+      local_refs = repo.refs.list_all_refs.map(&:path).sort
+      targets    = Remotes::Refspec.expand(@push_specs, local_refs)
+
+      targets.each do |target, (source, forced)|
+        select_update(target, source, forced)
+      end
+
+      @updates.each { |ref, (*, old, new)| send_update(ref, old, new) }
+      @conn.send_packet(nil)
+    end
+
+    def select_update(target, source, forced)
+      return select_deletion(target) unless source
+
+      old_oid = @remote_refs[target]
+      new_oid = Revision.new(repo, source).resolve
+
+      return if old_oid == new_oid
+
+      ff_error = fast_forward_error(old_oid, new_oid)
+
+      if @options[:force] or forced or ff_error == nil
+        @updates[target] = [source, ff_error, old_oid, new_oid]
+      else
+        @errors.push([[source, target], ff_error])
+      end
+    end
+
+    def select_deletion(target)
+      if @conn.capable?("delete-refs")
+        @updates[target] = [nil, nil, @remote_refs[target], nil]
+      else
+        @errors.push([[nil, target], "remote does not support deleting refs"])
+      end
+    end
+
+    def send_update(ref, old_oid, new_oid)
+      old_oid = nil_to_zero(old_oid)
+      new_oid = nil_to_zero(new_oid)
+
+      @conn.send_packet("#{ old_oid } #{ new_oid } #{ ref }")
+    end
+
+    def nil_to_zero(oid)
+      oid == nil ? ZERO_OID : oid
+    end
+
+    def send_objects
+      revs = @updates.values.map(&:last).compact
+      return if revs.empty?
+
+      revs += @remote_refs.values.map { |oid| "^#{ oid }" }
+
+      send_packed_objects(revs)
+    end
+
+    def print_summary
+      if @updates.empty? and @errors.empty?
+        @stderr.puts "Everything up-to-date"
+      else
+        @stderr.puts "To #{ @push_url }"
+        @errors.each { |ref_names, error| report_ref_update(ref_names, error) }
+      end
+    end
+
+    def recv_report_status
+      return unless @conn.capable?("report-status") and not @updates.empty?
+
+      unpack_result = UNPACK_LINE.match(@conn.recv_packet)[1]
+
+      unless unpack_result == "ok"
+        @stderr.puts "error: remote unpack failed: #{ unpack_result }"
+      end
+
+      @conn.recv_until(nil) { |line| handle_status(line) }
+    end
+
+    def handle_status(line)
+      return unless match = UPDATE_LINE.match(line)
+
+      status = match[1]
+      ref    = match[2]
+      error  = (status == "ok") ? nil : match[3].strip
+
+      @errors.push([ref, error]) if error
+      report_update(ref, error)
+
+      targets = Remotes::Refspec.expand(@fetch_specs, [ref])
+
+      targets.each do |local_ref, (remote_ref, _)|
+        new_oid = @updates[remote_ref].last
+        repo.refs.update_ref(local_ref, new_oid) unless error
+      end
+    end
+
+    def report_update(target, error)
+      source, ff_error, old_oid, new_oid = @updates[target]
+      ref_names = [source, target]
+      report_ref_update(ref_names, error, old_oid, new_oid, ff_error == nil)
+    end
+
+  end
+end

data/lib/command/receive_pack.rb

@@ -0,0 +1,92 @@
+require_relative "./base"
+require_relative "./shared/fast_forward"
+require_relative "./shared/receive_objects"
+require_relative "./shared/remote_agent"
+
+module Command
+  class ReceivePack < Base
+
+    include FastForward
+    include ReceiveObjects
+    include RemoteAgent
+
+    CAPABILITIES = ["no-thin", "report-status", "delete-refs", "ofs-delta"]
+
+    def run
+      accept_client("receive-pack", CAPABILITIES)
+
+      send_references
+      recv_update_requests
+      recv_objects
+      update_refs
+
+      exit 0
+    end
+
+    private
+
+    def recv_update_requests
+      @requests = {}
+
+      @conn.recv_until(nil) do |line|
+        old_oid, new_oid, ref = line.split(/ +/)
+        @requests[ref] = [old_oid, new_oid].map { |oid| zero_to_nil(oid) }
+      end
+    end
+
+    def zero_to_nil(oid)
+      oid == ZERO_OID ? nil : oid
+    end
+
+    def recv_objects
+      @unpack_error = nil
+      unpack_limit = repo.config.get(["receive", "unpackLimit"])
+      recv_packed_objects(unpack_limit) if @requests.values.any?(&:last)
+      report_status("unpack ok")
+    rescue => error
+      @unpack_error = error
+      report_status("unpack #{ error.message }")
+    end
+
+    def update_refs
+      @requests.each { |ref, (old, new)| update_ref(ref, old, new) }
+      report_status(nil)
+    end
+
+    def update_ref(ref, old_oid, new_oid)
+      return report_status("ng #{ ref } unpacker error") if @unpack_error
+
+      validate_update(ref, old_oid, new_oid)
+      repo.refs.compare_and_swap(ref, old_oid, new_oid)
+      report_status("ok #{ ref }")
+    rescue => error
+      report_status("ng #{ ref } #{ error.message }")
+    end
+
+    def validate_update(ref, old_oid, new_oid)
+      if repo.config.get(["receive", "denyDeletes"])
+        raise "deletion prohibited" unless new_oid
+      end
+
+      if repo.config.get(["receive", "denyNonFastForwards"])
+        raise "non-fast-forward" if fast_forward_error(old_oid, new_oid)
+      end
+
+      return unless repo.config.get(["core", "bare"]) == false and
+                    repo.refs.current_ref.path == ref
+
+      unless repo.config.get(["receive", "denyCurrentBranch"]) == false
+        raise "branch is currently checked out" if new_oid
+      end
+
+      unless repo.config.get(["receive", "denyDeleteCurrent"]) == false
+        raise "deletion of the current branch prohibited" unless new_oid
+      end
+    end
+
+    def report_status(line)
+      @conn.send_packet(line) if @conn.capable?("report-status")
+    end
+
+  end
+end

data/lib/command/remote.rb

@@ -0,0 +1,55 @@
+require_relative "./base"
+
+module Command
+  class Remote < Base
+
+    def define_options
+      @parser.on("-v", "--verbose") { @options[:verbose] = true }
+
+      @options[:tracked] = []
+      @parser.on("-t <branch>") { |branch| @options[:tracked].push(branch) }
+    end
+
+    def run
+      case @args.shift
+      when "add"    then add_remote
+      when "remove" then remove_remote
+      else               list_remotes
+      end
+    end
+
+    private
+
+    def add_remote
+      name, url = @args[0], @args[1]
+      repo.remotes.add(name, url, @options[:tracked])
+      exit 0
+    rescue Remotes::InvalidRemote => error
+      @stderr.puts "fatal: #{ error.message }"
+      exit 128
+    end
+
+    def remove_remote
+      repo.remotes.remove(@args[0])
+      exit 0
+    rescue Remotes::InvalidRemote => error
+      @stderr.puts "fatal: #{ error.message }"
+      exit 128
+    end
+
+    def list_remotes
+      repo.remotes.list_remotes.each { |name| list_remote(name) }
+      exit 0
+    end
+
+    def list_remote(name)
+      return puts name unless @options[:verbose]
+
+      remote = repo.remotes.get(name)
+
+      puts "#{ name }\t#{ remote.fetch_url } (fetch)"
+      puts "#{ name }\t#{ remote.push_url } (push)"
+    end
+
+  end
+end

data/lib/command/reset.rb

@@ -0,0 +1,64 @@
+require "pathname"
+
+require_relative "./base"
+require_relative "../revision"
+
+module Command
+  class Reset < Base
+
+    def define_options
+      @options[:mode] = :mixed
+
+      @parser.on("--soft")  { @options[:mode] = :soft  }
+      @parser.on("--mixed") { @options[:mode] = :mixed }
+      @parser.on("--hard")  { @options[:mode] = :hard  }
+    end
+
+    def run
+      select_commit_oid
+
+      repo.index.load_for_update
+      reset_files
+      repo.index.write_updates
+
+      if @args.empty?
+        head_oid = repo.refs.update_head(@commit_oid)
+        repo.refs.update_ref(Refs::ORIG_HEAD, head_oid)
+      end
+
+      exit 0
+    end
+
+    private
+
+    def select_commit_oid
+      revision = @args.fetch(0, Revision::HEAD)
+      @commit_oid = Revision.new(repo, revision).resolve
+      @args.shift
+    rescue Revision::InvalidObject
+      @commit_oid = repo.refs.read_head
+    end
+
+    def reset_files
+      return if @options[:mode] == :soft
+      return repo.hard_reset(@commit_oid) if @options[:mode] == :hard
+
+      if @args.empty?
+        repo.index.clear!
+        reset_path(nil)
+      else
+        @args.each { |path| reset_path(Pathname.new(path)) }
+      end
+    end
+
+    def reset_path(pathname)
+      listing = repo.database.load_tree_list(@commit_oid, pathname)
+      repo.index.remove(pathname) if pathname
+
+      listing.each do |path, entry|
+        repo.index.add_from_db(path, entry)
+      end
+    end
+
+  end
+end

data/lib/command/rev_list.rb

@@ -0,0 +1,33 @@
+require_relative "./base"
+require_relative "../rev_list"
+
+module Command
+  class RevList < Base
+
+    def define_options
+      @parser.on("--all")      { @options[:all]      = true }
+      @parser.on("--branches") { @options[:branches] = true }
+      @parser.on("--remotes")  { @options[:remotes]  = true }
+
+      @parser.on("--ignore-missing") { @options[:missing] = true }
+      @parser.on("--objects")        { @options[:objects] = true }
+      @parser.on("--reverse")        { @options[:reverse] = true }
+
+      @options[:walk] = true
+      @parser.on("--do-walk") { @options[:walk] = true  }
+      @parser.on("--no-walk") { @options[:walk] = false }
+    end
+
+    def run
+      rev_list = ::RevList.new(repo, @args, @options)
+      iterator = @options[:reverse] ? :reverse_each : :each
+
+      rev_list.__send__(iterator) do |object, path|
+        puts "#{ object.oid } #{ path }".strip
+      end
+
+      exit 0
+    end
+
+  end
+end

data/lib/command/revert.rb

@@ -0,0 +1,69 @@
+require_relative "./base"
+require_relative "./shared/sequencing"
+require_relative "./shared/write_commit"
+require_relative "../merge/inputs"
+require_relative "../rev_list"
+
+module Command
+  class Revert < Base
+
+    include Sequencing
+    include WriteCommit
+
+    private
+
+    def merge_type
+      :revert
+    end
+
+    def store_commit_sequence
+      commits = ::RevList.new(repo, @args, :walk => false)
+      commits.each { |commit| sequencer.revert(commit) }
+    end
+
+    def revert(commit)
+      inputs  = revert_merge_inputs(commit)
+      message = revert_commit_message(commit)
+
+      resolve_merge(inputs)
+      fail_on_conflict(inputs, message) if repo.index.conflict?
+
+      author  = current_author
+      message = edit_revert_message(message)
+      picked  = Database::Commit.new([inputs.left_oid], write_tree.oid,
+                                     author, author, message)
+
+      finish_commit(picked)
+    end
+
+    def revert_merge_inputs(commit)
+      short = repo.database.short_oid(commit.oid)
+
+      left_name  = Refs::HEAD
+      left_oid   = repo.refs.read_head
+      right_name = "parent of #{ short }... #{ commit.title_line.strip }"
+      right_oid  = select_parent(commit)
+
+      ::Merge::CherryPick.new(left_name, right_name,
+                              left_oid, right_oid,
+                              [commit.oid])
+    end
+
+    def revert_commit_message(commit)
+      <<~MESSAGE
+        Revert "#{ commit.title_line.strip }"
+
+        This reverts commit #{ commit.oid }.
+      MESSAGE
+    end
+
+    def edit_revert_message(message)
+      edit_file(commit_message_path) do |editor|
+        editor.puts(message)
+        editor.puts("")
+        editor.note(Commit::COMMIT_NOTES)
+      end
+    end
+
+  end
+end