jit 0.0.0 → 1.0.0

data/lib/command/rm.rb

@@ -0,0 +1,105 @@
+require "pathname"
+
+require_relative "./base"
+require_relative "../repository/inspector"
+
+module Command
+  class Rm < Base
+
+    BOTH_CHANGED      = "staged content different from both the file and the HEAD"
+    INDEX_CHANGED     = "changes staged in the index"
+    WORKSPACE_CHANGED = "local modifications"
+
+    def define_options
+      @parser.on("--cached")      { @options[:cached]    = true }
+      @parser.on("-f", "--force") { @options[:force]     = true }
+      @parser.on("-r")            { @options[:recursive] = true }
+    end
+
+    def run
+      repo.index.load_for_update
+
+      @head_oid     = repo.refs.read_head
+      @inspector    = Repository::Inspector.new(repo)
+      @uncommitted  = []
+      @unstaged     = []
+      @both_changed = []
+
+      @args = @args.flat_map { |path| expand_path(path) }
+                   .map { |path| Pathname.new(path) }
+
+      @args.each { |path| plan_removal(path) }
+      exit_on_errors
+
+      @args.each { |path| remove_file(path) }
+      repo.index.write_updates
+
+      exit 0
+
+    rescue => error
+      repo.index.release_lock
+      @stderr.puts "fatal: #{ error.message }"
+      exit 128
+    end
+
+    private
+
+    def expand_path(path)
+      if repo.index.tracked_directory?(path)
+        return repo.index.child_paths(path) if @options[:recursive]
+        raise "not removing '#{ path }' recursively without -r"
+      end
+
+      return [path] if repo.index.tracked_file?(path)
+      raise "pathspec '#{ path }' did not match any files"
+    end
+
+    def plan_removal(path)
+      return if @options[:force]
+
+      stat = repo.workspace.stat_file(path)
+      raise "jit rm: '#{ path }': Operation not permitted" if stat&.directory?
+
+      item  = repo.database.load_tree_entry(@head_oid, path)
+      entry = repo.index.entry_for_path(path)
+
+      staged_change   = @inspector.compare_tree_to_index(item, entry)
+      unstaged_change = @inspector.compare_index_to_workspace(entry, stat) if stat
+
+      if staged_change and unstaged_change
+        @both_changed.push(path)
+      elsif staged_change
+        @uncommitted.push(path) unless @options[:cached]
+      elsif unstaged_change
+        @unstaged.push(path) unless @options[:cached]
+      end
+    end
+
+    def remove_file(path)
+      repo.index.remove(path)
+      repo.workspace.remove(path) unless @options[:cached]
+      puts "rm '#{ path }'"
+    end
+
+    def exit_on_errors
+      return if [@both_changed, @uncommitted, @unstaged].all?(&:empty?)
+
+      print_errors(@both_changed, BOTH_CHANGED)
+      print_errors(@uncommitted, INDEX_CHANGED)
+      print_errors(@unstaged, WORKSPACE_CHANGED)
+
+      repo.index.release_lock
+      exit 1
+    end
+
+    def print_errors(paths, message)
+      return if paths.empty?
+
+      files_have = (paths.size == 1) ? "file has" : "files have"
+
+      @stderr.puts "error: the following #{ files_have } #{ message }:"
+      paths.each { |path| @stderr.puts "    #{ path }" }
+    end
+
+  end
+end

data/lib/command/shared/fast_forward.rb

@@ -0,0 +1,19 @@
+require_relative "../../merge/common_ancestors"
+
+module Command
+  module FastForward
+
+    def fast_forward_error(old_oid, new_oid)
+      return nil unless old_oid and new_oid
+      return "fetch first" unless repo.database.has?(old_oid)
+      return "non-fast-forward" unless fast_forward?(old_oid, new_oid)
+    end
+
+    def fast_forward?(old_oid, new_oid)
+      common = ::Merge::CommonAncestors.new(repo.database, old_oid, [new_oid])
+      common.find
+      common.marked?(old_oid, :parent2)
+    end
+
+  end
+end

data/lib/command/shared/print_diff.rb

@@ -0,0 +1,116 @@
+require "pathname"
+require_relative "../../diff"
+
+module Command
+  module PrintDiff
+
+    DIFF_FORMATS = {
+      :context => :normal,
+      :meta    => :bold,
+      :frag    => :cyan,
+      :old     => :red,
+      :new     => :green
+    }
+
+    NULL_OID  = "0" * 40
+    NULL_PATH = "/dev/null"
+
+    Target = Struct.new(:path, :oid, :mode, :data) do
+      def diff_path
+        mode ? path : NULL_PATH
+      end
+    end
+
+    def define_print_diff_options
+      @parser.on("-p", "-u", "--patch") { @options[:patch] = true  }
+      @parser.on("-s", "--no-patch")    { @options[:patch] = false }
+    end
+
+    private
+
+    def diff_fmt(name, text)
+      key   = ["color", "diff", name]
+      style = repo.config.get(key)&.split(/ +/) || DIFF_FORMATS.fetch(name)
+
+      fmt(style, text)
+    end
+
+    def header(string)
+      puts diff_fmt(:meta, string)
+    end
+
+    def short(oid)
+      repo.database.short_oid(oid)
+    end
+
+    def print_diff(a, b)
+      return if a.oid == b.oid and a.mode == b.mode
+
+      a.path = Pathname.new("a").join(a.path)
+      b.path = Pathname.new("b").join(b.path)
+
+      header("diff --git #{ a.path } #{ b.path }")
+      print_diff_mode(a, b)
+      print_diff_content(a, b)
+    end
+
+    def print_diff_mode(a, b)
+      if a.mode == nil
+        header("new file mode #{ b.mode }")
+      elsif b.mode == nil
+        header("deleted file mode #{ a.mode }")
+      elsif a.mode != b.mode
+        header("old mode #{ a.mode }")
+        header("new mode #{ b.mode }")
+      end
+    end
+
+    def print_diff_content(a, b)
+      return if a.oid == b.oid
+
+      oid_range = "index #{ short a.oid }..#{ short b.oid }"
+      oid_range.concat(" #{ a.mode }") if a.mode == b.mode
+
+      header(oid_range)
+      header("--- #{ a.diff_path }")
+      header("+++ #{ b.diff_path }")
+
+      hunks = ::Diff.diff_hunks(a.data, b.data)
+      hunks.each { |hunk| print_diff_hunk(hunk) }
+    end
+
+    def print_combined_diff(as, b)
+      header("diff --cc #{ b.path }")
+
+      a_oids = as.map { |a| short a.oid }
+      oid_range = "index #{ a_oids.join(",") }..#{ short b.oid }"
+      header(oid_range)
+
+      unless as.all? { |a| a.mode == b.mode }
+        header("mode #{ as.map(&:mode).join(",") }..#{ b.mode }")
+      end
+
+      header("--- a/#{ b.diff_path }")
+      header("+++ b/#{ b.diff_path }")
+
+      hunks = ::Diff.combined_hunks(as.map(&:data), b.data)
+      hunks.each { |hunk| print_diff_hunk(hunk) }
+    end
+
+    def print_diff_hunk(hunk)
+      puts diff_fmt(:frag, hunk.header)
+      hunk.edits.each { |edit| print_diff_edit(edit) }
+    end
+
+    def print_diff_edit(edit)
+      text = edit.to_s.rstrip
+
+      case edit.type
+      when :eql then puts diff_fmt(:context, text)
+      when :ins then puts diff_fmt(:new, text)
+      when :del then puts diff_fmt(:old, text)
+      end
+    end
+
+  end
+end

data/lib/command/shared/receive_objects.rb

@@ -0,0 +1,37 @@
+require_relative "../../pack"
+require_relative "../../progress"
+
+module Command
+  module ReceiveObjects
+
+    UNPACK_LIMIT = 100
+
+    def recv_packed_objects(unpack_limit = nil, prefix = "")
+      stream   = Pack::Stream.new(@conn.input, prefix)
+      reader   = Pack::Reader.new(stream)
+      progress = Progress.new(@stderr) unless @conn.input == STDIN
+
+      reader.read_header
+
+      factory   = select_processor_class(reader, unpack_limit)
+      processor = factory.new(repo.database, reader, stream, progress)
+
+      processor.process_pack
+    end
+
+    def select_processor_class(reader, unpack_limit)
+      unpack_limit ||= transfer_unpack_limit
+
+      if unpack_limit and reader.count > unpack_limit
+        Pack::Indexer
+      else
+        Pack::Unpacker
+      end
+    end
+
+    def transfer_unpack_limit
+      repo.config.get(["transfer", "unpackLimit"]) || UNPACK_LIMIT
+    end
+
+  end
+end

data/lib/command/shared/remote_agent.rb

@@ -0,0 +1,44 @@
+require_relative "../../repository"
+require_relative "../../remotes/protocol"
+
+module Command
+  module RemoteAgent
+
+    ZERO_OID = "0" * 40
+
+    def accept_client(name, capabilities = [])
+      @conn = Remotes::Protocol.new(name, @stdin, @stdout, capabilities)
+    end
+
+    def repo
+      @repo ||= Repository.new(detect_git_dir)
+    end
+
+    def detect_git_dir
+      pathname = expanded_pathname(@args[0])
+      dirs = pathname.ascend.flat_map { |dir| [dir, dir.join(".git")] }
+      dirs.find { |dir| git_repository?(dir) }
+    end
+
+    def git_repository?(dirname)
+      File.file?(dirname.join("HEAD")) and
+      File.directory?(dirname.join("objects")) and
+      File.directory?(dirname.join("refs"))
+    end
+
+    def send_references
+      refs = repo.refs.list_all_refs
+      sent = false
+
+      refs.sort_by(&:path).each do |symref|
+        next unless oid = symref.read_oid
+        @conn.send_packet("#{ oid.downcase } #{ symref.path }")
+        sent = true
+      end
+
+      @conn.send_packet("#{ ZERO_OID } capabilities^{}") unless sent
+      @conn.send_packet(nil)
+    end
+
+  end
+end

data/lib/command/shared/remote_client.rb

@@ -0,0 +1,82 @@
+require "open3"
+require "shellwords"
+require "uri"
+
+require_relative "../../remotes/protocol"
+
+module Command
+  module RemoteClient
+
+    REF_LINE = /^([0-9a-f]+) (.*)$/
+    ZERO_OID = "0" * 40
+
+    def start_agent(name, program, url, capabilities = [])
+      argv = build_agent_command(program, url)
+      input, output, _ = Open3.popen2(Shellwords.shelljoin(argv))
+      @conn = Remotes::Protocol.new(name, output, input, capabilities)
+    end
+
+    def build_agent_command(program, url)
+      uri  = URI.parse(url)
+      argv = Shellwords.shellsplit(program) + [uri.path]
+
+      case uri.scheme
+      when "file" then argv
+      when "ssh"  then ssh_command(uri, argv)
+      end
+    end
+
+    def ssh_command(uri, argv)
+      ssh  = ["ssh", uri.host]
+      ssh += ["-p", uri.port.to_s] if uri.port
+      ssh += ["-l", uri.user] if uri.user
+
+      ssh + [Shellwords.shelljoin(argv)]
+    end
+
+    def recv_references
+      @remote_refs = {}
+
+      @conn.recv_until(nil) do |line|
+        oid, ref = REF_LINE.match(line).captures
+        @remote_refs[ref] = oid.downcase unless oid == ZERO_OID
+      end
+    end
+
+    def report_ref_update(ref_names, error, old_oid = nil, new_oid = nil, is_ff = false)
+      return show_ref_update("!", "[rejected]", ref_names, error) if error
+      return if old_oid == new_oid
+
+      if old_oid == nil
+        show_ref_update("*", "[new branch]", ref_names)
+      elsif new_oid == nil
+        show_ref_update("-", "[deleted]", ref_names)
+      else
+        report_range_update(ref_names, old_oid, new_oid, is_ff)
+      end
+    end
+
+    def report_range_update(ref_names, old_oid, new_oid, is_ff)
+      old_oid = repo.database.short_oid(old_oid)
+      new_oid = repo.database.short_oid(new_oid)
+
+      if is_ff
+        revisions = "#{ old_oid }..#{ new_oid }"
+        show_ref_update(" ", revisions, ref_names)
+      else
+        revisions = "#{ old_oid }...#{ new_oid }"
+        show_ref_update("+", revisions, ref_names, "forced update")
+      end
+    end
+
+    def show_ref_update(flag, summary, ref_names, reason = nil)
+      names = ref_names.compact.map { |name| repo.refs.short_name(name) }
+
+      message = " #{ flag } #{ summary } #{ names.join(" -> ") }"
+      message.concat(" (#{ reason })") if reason
+
+      @stderr.puts message
+    end
+
+  end
+end

data/lib/command/shared/send_objects.rb

@@ -0,0 +1,24 @@
+require_relative "../../pack"
+require_relative "../../progress"
+require_relative "../../rev_list"
+
+module Command
+  module SendObjects
+
+    def send_packed_objects(revs)
+      rev_opts = { :objects => true, :missing => true }
+      rev_list = ::RevList.new(repo, revs, rev_opts)
+
+      pack_compression = repo.config.get(["pack", "compression"]) ||
+                         repo.config.get(["core", "compression"])
+
+      writer = Pack::Writer.new(@conn.output, repo.database,
+                                :compression => pack_compression,
+                                :allow_ofs   => @conn.capable?("ofs-delta"),
+                                :progress    => Progress.new(@stderr))
+
+      writer.write_objects(rev_list)
+    end
+
+  end
+end

data/lib/command/shared/sequencing.rb

@@ -0,0 +1,146 @@
+require_relative "../../merge/resolve"
+require_relative "../../repository/sequencer"
+
+module Command
+  module Sequencing
+
+    CONFLICT_NOTES = <<~MSG
+      after resolving the conflicts, mark the corrected paths
+      with 'jit add <paths>' or 'jit rm <paths>'
+      and commit the result with 'jit commit'
+    MSG
+
+    def define_options
+      @options[:mode] = :run
+
+      @parser.on("--continue") { @options[:mode] = :continue }
+      @parser.on("--abort")    { @options[:mode] = :abort    }
+      @parser.on("--quit" )    { @options[:mode] = :quit     }
+
+      @parser.on "-m <parent>", "--mainline=<parent>", Integer do |parent|
+        @options[:mainline] = parent
+      end
+    end
+
+    def run
+      case @options[:mode]
+      when :continue then handle_continue
+      when :abort    then handle_abort
+      when :quit     then handle_quit
+      end
+
+      sequencer.start(@options)
+      store_commit_sequence
+      resume_sequencer
+    end
+
+    private
+
+    def sequencer
+      @sequencer ||= Repository::Sequencer.new(repo)
+    end
+
+    def resolve_merge(inputs)
+      repo.index.load_for_update
+      ::Merge::Resolve.new(repo, inputs).execute
+      repo.index.write_updates
+    end
+
+    def fail_on_conflict(inputs, message)
+      sequencer.dump
+      pending_commit.start(inputs.right_oid, merge_type)
+
+      edit_file(pending_commit.message_path) do |editor|
+        editor.puts(message)
+        editor.puts("")
+        editor.note("Conflicts:")
+        repo.index.conflict_paths.each { |name| editor.note("\t#{ name }") }
+        editor.close
+      end
+
+      @stderr.puts "error: could not apply #{ inputs.right_name }"
+      CONFLICT_NOTES.each_line { |line| @stderr.puts "hint: #{ line }" }
+      exit 1
+    end
+
+    def finish_commit(commit)
+      repo.database.store(commit)
+      repo.refs.update_head(commit.oid)
+      print_commit(commit)
+    end
+
+    def handle_continue
+      repo.index.load
+
+      case pending_commit.merge_type
+      when :cherry_pick then write_cherry_pick_commit
+      when :revert      then write_revert_commit
+      end
+
+      sequencer.load
+      sequencer.drop_command
+      resume_sequencer
+
+    rescue Repository::PendingCommit::Error => error
+      @stderr.puts "fatal: #{ error.message }"
+      exit 128
+    end
+
+    def resume_sequencer
+      loop do
+        action, commit = sequencer.next_command
+        break unless commit
+
+        case action
+        when :pick   then pick(commit)
+        when :revert then revert(commit)
+        end
+        sequencer.drop_command
+      end
+
+      sequencer.quit
+      exit 0
+    end
+
+    def select_parent(commit)
+      mainline = sequencer.get_option("mainline")
+
+      if commit.merge?
+        return commit.parents[mainline - 1] if mainline
+
+        @stderr.puts <<~ERROR
+          error: commit #{ commit.oid } is a merge but no -m option was given
+        ERROR
+        exit 1
+      else
+        return commit.parent unless mainline
+
+        @stderr.puts <<~ERROR
+          error: mainline was specified but commit #{ commit.oid } is not a merge
+        ERROR
+        exit 1
+      end
+    end
+
+    def handle_abort
+      pending_commit.clear(merge_type) if pending_commit.in_progress?
+      repo.index.load_for_update
+
+      begin
+        sequencer.abort
+      rescue => error
+        @stderr.puts "warning: #{ error.message }"
+      end
+
+      repo.index.write_updates
+      exit 0
+    end
+
+    def handle_quit
+      pending_commit.clear(merge_type) if pending_commit.in_progress?
+      sequencer.quit
+      exit 0
+    end
+
+  end
+end