jit 0.0.0 → 1.0.0

data/lib/command/fetch.rb

@@ -0,0 +1,116 @@
+require "set"
+
+require_relative "./base"
+require_relative "./shared/fast_forward"
+require_relative "./shared/receive_objects"
+require_relative "./shared/remote_client"
+require_relative "../remotes"
+require_relative "../rev_list"
+
+module Command
+  class Fetch < Base
+
+    include FastForward
+    include ReceiveObjects
+    include RemoteClient
+
+    CAPABILITIES = ["ofs-delta"]
+    UPLOAD_PACK  = "git-upload-pack"
+
+    def define_options
+      @parser.on("-f", "--force") { @options[:force] = true }
+
+      @parser.on "--upload-pack=<upload-pack>" do |uploader|
+        @options[:uploader] = uploader
+      end
+    end
+
+    def run
+      configure
+      start_agent("fetch", @uploader, @fetch_url, CAPABILITIES)
+
+      recv_references
+      send_want_list
+      send_have_list
+      recv_objects
+      update_remote_refs
+
+      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"])
+
+      name   = @args.fetch(0, branch_remote || Remotes::DEFAULT_REMOTE)
+      remote = repo.remotes.get(name)
+
+      @fetch_url   = remote&.fetch_url || @args[0]
+      @uploader    = @options[:uploader] || remote&.uploader || UPLOAD_PACK
+      @fetch_specs = (@args.size > 1) ? @args.drop(1) : remote&.fetch_specs
+    end
+
+    def send_want_list
+      @targets = Remotes::Refspec.expand(@fetch_specs, @remote_refs.keys)
+      wanted   = Set.new
+
+      @local_refs = {}
+
+      @targets.each do |target, (source, _)|
+        local_oid  = repo.refs.read_ref(target)
+        remote_oid = @remote_refs[source]
+
+        next if local_oid == remote_oid
+
+        @local_refs[target] = local_oid
+        wanted.add(remote_oid)
+      end
+
+      wanted.each { |oid| @conn.send_packet("want #{ oid }") }
+      @conn.send_packet(nil)
+
+      exit 0 if wanted.empty?
+    end
+
+    def send_have_list
+      options  = { :all => true, :missing => true }
+      rev_list = ::RevList.new(repo, [], options)
+
+      rev_list.each { |commit| @conn.send_packet("have #{ commit.oid }") }
+      @conn.send_packet("done")
+
+      @conn.recv_until(Pack::SIGNATURE) {}
+    end
+
+    def recv_objects
+      unpack_limit = repo.config.get(["fetch", "unpackLimit"])
+      recv_packed_objects(unpack_limit, Pack::SIGNATURE)
+    end
+
+    def update_remote_refs
+      @stderr.puts "From #{ @fetch_url }"
+
+      @errors = {}
+      @local_refs.each { |target, oid| attempt_ref_update(target, oid) }
+    end
+
+    def attempt_ref_update(target, old_oid)
+      source, forced = @targets[target]
+
+      new_oid   = @remote_refs[source]
+      ref_names = [source, target]
+      ff_error  = fast_forward_error(old_oid, new_oid)
+
+      if @options[:force] or forced or ff_error == nil
+        repo.refs.update_ref(target, new_oid)
+      else
+        error = @errors[target] = ff_error
+      end
+
+      report_ref_update(ref_names, error, old_oid, new_oid, ff_error == nil)
+    end
+
+  end
+end

data/lib/command/init.rb

@@ -0,0 +1,41 @@
+require "fileutils"
+
+require_relative "./base"
+require_relative "../config"
+require_relative "../refs"
+
+module Command
+  class Init < Base
+
+    DEFAULT_BRANCH = "master"
+
+    def run
+      path = @args.fetch(0, @dir)
+
+      root_path = expanded_pathname(path)
+      git_path  = root_path.join(".git")
+
+      ["objects", "refs/heads"].each do |dir|
+        begin
+          FileUtils.mkdir_p(git_path.join(dir))
+        rescue Errno::EACCES => error
+          @stderr.puts "fatal: #{ error.message }"
+          exit 1
+        end
+      end
+
+      config = ::Config.new(git_path.join("config"))
+      config.open_for_update
+      config.set(["core", "bare"], false)
+      config.save
+
+      refs = Refs.new(git_path)
+      path = File.join("refs", "heads", DEFAULT_BRANCH)
+      refs.update_head("ref: #{ path }")
+
+      puts "Initialized empty Jit repository in #{ git_path }"
+      exit 0
+    end
+
+  end
+end

data/lib/command/log.rb

@@ -0,0 +1,188 @@
+require_relative "./base"
+require_relative "./shared/print_diff"
+require_relative "../rev_list"
+
+module Command
+  class Log < Base
+
+    include PrintDiff
+
+    def define_options
+      @rev_list_opts = {}
+      @parser.on("--all")      { @rev_list_opts[:all]      = true }
+      @parser.on("--branches") { @rev_list_opts[:branches] = true }
+      @parser.on("--remotes")  { @rev_list_opts[:remotes]  = true }
+
+      @options[:decorate] = "auto"
+      @options[:abbrev]   = :auto
+      @options[:format]   = "medium"
+      @options[:patch]    = false
+
+      define_print_diff_options
+
+      @parser.on "--decorate[=<format>]" do |format|
+        @options[:decorate] = format || "short"
+      end
+
+      @parser.on "--no-decorate" do
+        @options[:decorate] = "no"
+      end
+
+      @parser.on "--[no-]abbrev-commit" do |value|
+        @options[:abbrev] = value
+      end
+
+      @parser.on "--pretty=<format>", "--format=<format>" do |format|
+        @options[:format] = format
+      end
+
+      @parser.on "--oneline" do
+        @options[:abbrev] = true if @options[:abbrev] == :auto
+        @options[:format] = "oneline"
+      end
+
+      @parser.on "--cc" do
+        @options[:combined] = @options[:patch] = true
+      end
+    end
+
+    def run
+      setup_pager
+
+      @reverse_refs = repo.refs.reverse_refs
+      @current_ref  = repo.refs.current_ref
+
+      @rev_list = ::RevList.new(repo, @args, @rev_list_opts)
+      @rev_list.each { |commit| show_commit(commit) }
+
+      exit 0
+    end
+
+    private
+
+    def blank_line
+      return if @options[:format] == "oneline"
+      puts "" if defined? @blank_line
+      @blank_line = true
+    end
+
+    def show_commit(commit)
+      case @options[:format]
+      when "medium"  then show_commit_medium(commit)
+      when "oneline" then show_commit_oneline(commit)
+      end
+
+      show_patch(commit)
+    end
+
+    def show_commit_medium(commit)
+      author = commit.author
+
+      blank_line
+      puts fmt(:yellow, "commit #{ abbrev(commit) }") + decorate(commit)
+
+      if commit.merge?
+        oids = commit.parents.map { |oid| repo.database.short_oid(oid) }
+        puts "Merge: #{ oids.join(" ") }"
+      end
+
+      puts "Author: #{ author.name } <#{ author.email }>"
+      puts "Date:   #{ author.readable_time }"
+      blank_line
+      commit.message.each_line { |line| puts "    #{ line }" }
+    end
+
+    def show_commit_oneline(commit)
+      id = fmt(:yellow, abbrev(commit)) + decorate(commit)
+      puts "#{ id } #{ commit.title_line }"
+    end
+
+    def abbrev(commit)
+      if @options[:abbrev] == true
+        repo.database.short_oid(commit.oid)
+      else
+        commit.oid
+      end
+    end
+
+    def decorate(commit)
+      case @options[:decorate]
+      when "auto" then return "" unless @isatty
+      when "no"   then return ""
+      end
+
+      refs = @reverse_refs[commit.oid]
+      return "" if refs.empty?
+
+      head, refs = refs.partition { |ref| ref.head? and not @current_ref.head? }
+      names = refs.map { |ref| decoration_name(head.first, ref) }
+
+      fmt(:yellow, " (") + names.join(fmt(:yellow, ", ")) + fmt(:yellow, ")")
+    end
+
+    def decoration_name(head, ref)
+      case @options[:decorate]
+      when "short", "auto" then name = ref.short_name
+      when "full"          then name = ref.path
+      end
+
+      name = fmt(ref_color(ref), name)
+
+      if head and ref == @current_ref
+        name = fmt(ref_color(head), "#{ head.path } -> #{ name }")
+      end
+
+      name
+    end
+
+    def ref_color(ref)
+      return [:bold, :cyan]  if ref.head?
+      return [:bold, :green] if ref.branch?
+      return [:bold, :red]   if ref.remote?
+    end
+
+    def show_patch(commit)
+      return unless @options[:patch]
+      return show_merge_patch(commit) if commit.merge?
+
+      diff  = @rev_list.tree_diff(commit.parent, commit.oid)
+      paths = diff.keys.sort_by(&:to_s)
+
+      blank_line
+
+      paths.each do |path|
+        old_item, new_item = diff[path]
+        print_diff(from_diff_item(path, old_item), from_diff_item(path, new_item))
+      end
+    end
+
+    def show_merge_patch(commit)
+      return unless @options[:combined]
+
+      diffs = commit.parents.map { |oid| @rev_list.tree_diff(oid, commit.oid) }
+
+      paths = diffs.first.keys.select do |path|
+        diffs.drop(1).all? { |diff| diff.has_key?(path) }
+      end
+
+      blank_line
+
+      paths.each do |path|
+        parents = diffs.map { |diff| from_diff_item(path, diff[path][0]) }
+        child   = from_diff_item(path, diffs.first[path][1])
+
+        print_combined_diff(parents, child)
+      end
+    end
+
+    def from_diff_item(path, item)
+      if item
+        blob = repo.database.load(item.oid)
+        Target.new(path, item.oid, item.mode.to_s(8), blob.data)
+      else
+        Target.new(path, NULL_OID, nil, "")
+      end
+    end
+
+  end
+end

data/lib/command/merge.rb

@@ -0,0 +1,148 @@
+require_relative "./base"
+require_relative "./shared/write_commit"
+require_relative "../merge/inputs"
+require_relative "../merge/resolve"
+require_relative "../revision"
+
+module Command
+  class Merge < Base
+
+    include WriteCommit
+
+    COMMIT_NOTES = <<~MSG
+      Please enter a commit message to explain why this merge is necessary,
+      especially if it merges an updated upstream into a topic branch.
+
+      Lines starting with '#' will be ignored, and an empty message aborts
+      the commit.
+    MSG
+
+    def define_options
+      define_write_commit_options
+
+      @options[:mode] = :run
+
+      @parser.on("--abort")    { @options[:mode] = :abort    }
+      @parser.on("--continue") { @options[:mode] = :continue }
+    end
+
+    def run
+      handle_abort if @options[:mode] == :abort
+      handle_continue if @options[:mode] == :continue
+      handle_in_progress_merge if pending_commit.in_progress?
+
+      @inputs = ::Merge::Inputs.new(repo, Revision::HEAD, @args[0])
+      repo.refs.update_ref(Refs::ORIG_HEAD, @inputs.left_oid)
+
+      handle_merged_ancestor if @inputs.already_merged?
+      handle_fast_forward if @inputs.fast_forward?
+
+      pending_commit.start(@inputs.right_oid)
+      resolve_merge
+      commit_merge
+
+      exit 0
+    end
+
+    private
+
+    def resolve_merge
+      repo.index.load_for_update
+
+      merge = ::Merge::Resolve.new(repo, @inputs)
+      merge.on_progress { |info| puts info }
+      merge.execute
+
+      repo.index.write_updates
+      fail_on_conflict if repo.index.conflict?
+    end
+
+    def fail_on_conflict
+      edit_file(pending_commit.message_path) do |editor|
+        editor.puts(read_message || default_commit_message)
+        editor.puts("")
+        editor.note("Conflicts:")
+        repo.index.conflict_paths.each { |name| editor.note("\t#{ name }") }
+        editor.close
+      end
+
+      puts "Automatic merge failed; fix conflicts and then commit the result."
+      exit 1
+    end
+
+    def commit_merge
+      parents = [@inputs.left_oid, @inputs.right_oid]
+      message = compose_message
+
+      write_commit(parents, message)
+
+      pending_commit.clear
+    end
+
+    def compose_message
+      edit_file(pending_commit.message_path) do |editor|
+        editor.puts(read_message || default_commit_message)
+        editor.puts("")
+        editor.note(COMMIT_NOTES)
+
+        editor.close unless @options[:edit]
+      end
+    end
+
+    def default_commit_message
+      "Merge commit '#{ @inputs.right_name }'"
+    end
+
+    def handle_merged_ancestor
+      puts "Already up to date."
+      exit 0
+    end
+
+    def handle_fast_forward
+      a = repo.database.short_oid(@inputs.left_oid)
+      b = repo.database.short_oid(@inputs.right_oid)
+
+      puts "Updating #{ a }..#{ b }"
+      puts "Fast-forward"
+
+      repo.index.load_for_update
+
+      tree_diff = repo.database.tree_diff(@inputs.left_oid, @inputs.right_oid)
+      repo.migration(tree_diff).apply_changes
+
+      repo.index.write_updates
+      repo.refs.update_head(@inputs.right_oid)
+
+      exit 0
+    end
+
+    def handle_abort
+      repo.pending_commit.clear
+
+      repo.index.load_for_update
+      repo.hard_reset(repo.refs.read_head)
+      repo.index.write_updates
+
+      exit 0
+    rescue Repository::PendingCommit::Error => error
+      @stderr.puts "fatal: #{ error.message }"
+      exit 128
+    end
+
+    def handle_continue
+      repo.index.load
+      resume_merge(:merge)
+    rescue Repository::PendingCommit::Error => error
+      @stderr.puts "fatal: #{ error.message }"
+      exit 128
+    end
+
+    def handle_in_progress_merge
+      message = "Merging is not possible because you have unmerged files"
+      @stderr.puts "error: #{ message }."
+      @stderr.puts CONFLICT_MESSAGE
+      exit 128
+    end
+
+  end
+end