jit 0.0.0 → 1.0.0

data/lib/command/checkout.rb

@@ -0,0 +1,104 @@
+require_relative "./base"
+require_relative "../revision"
+
+module Command
+  class Checkout < Base
+
+    DETACHED_HEAD_MESSAGE = <<~MSG
+      You are in 'detached HEAD' state. You can look around, make experimental
+      changes and commit them, and you can discard any commits you make in this
+      state without impacting any branches by performing another checkout.
+
+      If you want to create a new branch to retain commits you create, you may
+      do so (now or later) by using the branch command. Example:
+
+        jit branch <new-branch-name>
+    MSG
+
+    def run
+      @target = @args[0]
+
+      @current_ref = repo.refs.current_ref
+      @current_oid = @current_ref.read_oid
+
+      revision    = Revision.new(repo, @target)
+      @target_oid = revision.resolve(Revision::COMMIT)
+
+      repo.index.load_for_update
+
+      tree_diff = repo.database.tree_diff(@current_oid, @target_oid)
+      migration = repo.migration(tree_diff)
+      migration.apply_changes
+
+      repo.index.write_updates
+      repo.refs.set_head(@target, @target_oid)
+      @new_ref = repo.refs.current_ref
+
+      print_previous_head
+      print_detachment_notice
+      print_new_head
+
+      exit 0
+
+    rescue Repository::Migration::Conflict
+      handle_migration_conflict(migration)
+
+    rescue Revision::InvalidObject => error
+      handle_invalid_object(revision, error)
+    end
+
+    private
+
+    def handle_migration_conflict(migration)
+      repo.index.release_lock
+
+      migration.errors.each do |message|
+        @stderr.puts "error: #{ message }"
+      end
+      @stderr.puts "Aborting"
+      exit 1
+    end
+
+    def handle_invalid_object(revision, error)
+      revision.errors.each do |err|
+        @stderr.puts "error: #{ err.message }"
+        err.hint.each { |line| @stderr.puts "hint: #{ line }" }
+      end
+      @stderr.puts "error: #{ error.message }"
+      exit 1
+    end
+
+    def print_previous_head
+      if @current_ref.head? and @current_oid != @target_oid
+        print_head_position("Previous HEAD position was", @current_oid)
+      end
+    end
+
+    def print_detachment_notice
+      return unless @new_ref.head? and not @current_ref.head?
+
+      @stderr.puts "Note: checking out '#{ @target }'."
+      @stderr.puts ""
+      @stderr.puts DETACHED_HEAD_MESSAGE
+      @stderr.puts ""
+    end
+
+    def print_new_head
+      if @new_ref.head?
+        print_head_position("HEAD is now at", @target_oid)
+      elsif @new_ref == @current_ref
+        @stderr.puts "Already on '#{ @target }'"
+      else
+        @stderr.puts "Switched to branch '#{ @target }'"
+      end
+    end
+
+    def print_head_position(message, oid)
+      commit = repo.database.load(oid)
+      short  = repo.database.short_oid(commit.oid)
+
+      @stderr.puts "#{ message } #{ short } #{ commit.title_line }"
+    end
+
+  end
+end

data/lib/command/cherry_pick.rb

@@ -0,0 +1,51 @@
+require_relative "./base"
+require_relative "./shared/sequencing"
+require_relative "./shared/write_commit"
+require_relative "../merge/inputs"
+require_relative "../rev_list"
+
+module Command
+  class CherryPick < Base
+
+    include Sequencing
+    include WriteCommit
+
+    private
+
+    def merge_type
+      :cherry_pick
+    end
+
+    def store_commit_sequence
+      commits = ::RevList.new(repo, @args.reverse, :walk => false)
+      commits.reverse_each { |commit| sequencer.pick(commit) }
+    end
+
+    def pick(commit)
+      inputs = pick_merge_inputs(commit)
+      resolve_merge(inputs)
+      fail_on_conflict(inputs, commit.message) if repo.index.conflict?
+
+      picked = Database::Commit.new([inputs.left_oid], write_tree.oid,
+                                    commit.author, current_author,
+                                    commit.message)
+
+      finish_commit(picked)
+    end
+
+    def pick_merge_inputs(commit)
+      short  = repo.database.short_oid(commit.oid)
+      parent = select_parent(commit)
+
+      left_name  = Refs::HEAD
+      left_oid   = repo.refs.read_head
+      right_name = "#{ short }... #{ commit.title_line.strip }"
+      right_oid  = commit.oid
+
+      ::Merge::CherryPick.new(left_name, right_name,
+                              left_oid, right_oid,
+                              [parent])
+    end
+
+  end
+end

data/lib/command/commit.rb

@@ -0,0 +1,86 @@
+require "pathname"
+require_relative "./base"
+require_relative "./shared/write_commit"
+require_relative "../revision"
+
+module Command
+  class Commit < Base
+
+    include WriteCommit
+
+    COMMIT_NOTES = <<~MSG
+      Please enter the commit message for your changes. Lines starting
+      with '#' will be ignored, and an empty message aborts the commit.
+    MSG
+
+    def define_options
+      define_write_commit_options
+
+      @parser.on("--amend") { @options[:amend] = true }
+
+      @parser.on "-C <commit>", "--reuse-message=<commit>" do |commit|
+        @options[:reuse] = commit
+        @options[:edit]  = false
+      end
+
+      @parser.on "-c <commit>", "--reedit-message=<commit>" do |commit|
+        @options[:reuse] = commit
+        @options[:edit]  = true
+      end
+    end
+
+    def run
+      repo.index.load
+
+      handle_amend if @options[:amend]
+
+      merge_type = pending_commit.merge_type
+      resume_merge(merge_type) if merge_type
+
+      parent  = repo.refs.read_head
+      message = compose_message(read_message || reused_message)
+      commit  = write_commit([*parent], message)
+
+      print_commit(commit)
+
+      exit 0
+    end
+
+    private
+
+    def compose_message(message)
+      edit_file(commit_message_path) do |editor|
+        editor.puts(message || "")
+        editor.puts("")
+        editor.note(COMMIT_NOTES)
+
+        editor.close unless @options[:edit]
+      end
+    end
+
+    def reused_message
+      return nil unless @options.has_key?(:reuse)
+
+      revision = Revision.new(repo, @options[:reuse])
+      commit   = repo.database.load(revision.resolve)
+
+      commit.message
+    end
+
+    def handle_amend
+      old  = repo.database.load(repo.refs.read_head)
+      tree = write_tree
+
+      message   = compose_message(old.message)
+      committer = current_author
+
+      new = Database::Commit.new(old.parents, tree.oid, old.author, committer, message)
+      repo.database.store(new)
+      repo.refs.update_head(new.oid)
+
+      print_commit(new)
+      exit 0
+    end
+
+  end
+end

data/lib/command/config.rb

@@ -0,0 +1,126 @@
+require_relative "./base"
+
+module Command
+  class Config < Base
+
+    def define_options
+      @parser.on("--local")  { @options[:file] = :local  }
+      @parser.on("--global") { @options[:file] = :global }
+      @parser.on("--system") { @options[:file] = :system }
+
+      @parser.on "-f <config-file>", "--file=<config-file>" do |file|
+        @options[:file] = file
+      end
+
+      @parser.on("--add <name>")         { |name| @options[:add]       = name }
+      @parser.on("--replace-all <name>") { |name| @options[:replace]   = name }
+      @parser.on("--get-all <name>")     { |name| @options[:get_all]   = name }
+      @parser.on("--unset <name>")       { |name| @options[:unset]     = name }
+      @parser.on("--unset-all <name>")   { |name| @options[:unset_all] = name }
+
+      @parser.on "--remove-section <name>" do |name|
+        @options[:remove_section] = name
+      end
+    end
+
+    def run
+      add_variable     if @options[:add]
+      replace_variable if @options[:replace]
+      get_all_values   if @options[:get_all]
+      unset_single     if @options[:unset]
+      unset_all        if @options[:unset_all]
+      remove_section   if @options[:remove_section]
+
+      key, value = parse_key(@args[0]), @args[1]
+
+      if value
+        edit_config { |config| config.set(key, value) }
+      else
+        read_config { |config| [*config.get(key)] }
+      end
+
+    rescue ::Config::ParseError => error
+      @stderr.puts "error: #{ error.message }"
+      exit 3
+    end
+
+    private
+
+    def add_variable
+      key = parse_key(@options[:add])
+      edit_config { |config| config.add(key, @args[0]) }
+    end
+
+    def replace_variable
+      key = parse_key(@options[:replace])
+      edit_config { |config| config.replace_all(key, @args[0]) }
+    end
+
+    def unset_single
+      key = parse_key(@options[:unset])
+      edit_config { |config| config.unset(key) }
+    end
+
+    def unset_all
+      key = parse_key(@options[:unset_all])
+      edit_config { |config| config.unset_all(key) }
+    end
+
+    def remove_section
+      key = @options[:remove_section].split(".", 2)
+      edit_config { |config| config.remove_section(key) }
+    end
+
+    def get_all_values
+      key = parse_key(@options[:get_all])
+      read_config { |config| config.get_all(key) }
+    end
+
+    def read_config
+      config = repo.config
+      config = config.file(@options[:file]) if @options[:file]
+
+      config.open
+      values = yield config
+
+      exit 1 if values.empty?
+
+      values.each { |value| puts value }
+      exit 0
+    end
+
+    def edit_config
+      config = repo.config.file(@options.fetch(:file, :local))
+      config.open_for_update
+      yield config
+      config.save
+
+      exit 0
+
+    rescue ::Config::Conflict => error
+      @stderr.puts "error: #{ error.message }"
+      exit 5
+    end
+
+    def parse_key(name)
+      section, *subsection, var = name.split(".")
+
+      unless var
+        @stderr.puts "error: key does not contain a section: #{ name }"
+        exit 2
+      end
+
+      unless ::Config.valid_key?([section, var])
+        @stderr.puts "error: invalid key: #{ name }"
+        exit 1
+      end
+
+      if subsection.empty?
+        [section, var]
+      else
+        [section, subsection.join("."), var]
+      end
+    end
+
+  end
+end

data/lib/command/diff.rb

@@ -0,0 +1,114 @@
+require_relative "./base"
+require_relative "./shared/print_diff"
+
+module Command
+  class Diff < Base
+
+    include PrintDiff
+
+    def define_options
+      @options[:patch] = true
+      define_print_diff_options
+
+      @parser.on "--cached", "--staged" do
+        @options[:cached] = true
+      end
+
+      @parser.on("-1", "--base")   { @options[:stage] = 1 }
+      @parser.on("-2", "--ours")   { @options[:stage] = 2 }
+      @parser.on("-3", "--theirs") { @options[:stage] = 3 }
+    end
+
+    def run
+      repo.index.load
+      @status = repo.status
+
+      setup_pager
+
+      if @options[:cached]
+        diff_head_index
+      else
+        diff_index_workspace
+      end
+
+      exit 0
+    end
+
+    private
+
+    def diff_head_index
+      return unless @options[:patch]
+
+      @status.index_changes.each do |path, state|
+        case state
+        when :added    then print_diff(from_nothing(path), from_index(path))
+        when :modified then print_diff(from_head(path), from_index(path))
+        when :deleted  then print_diff(from_head(path), from_nothing(path))
+        end
+      end
+    end
+
+    def diff_index_workspace
+      return unless @options[:patch]
+
+      paths = @status.conflicts.keys + @status.workspace_changes.keys
+
+      paths.sort.each do |path|
+        if @status.conflicts.has_key?(path)
+          print_conflict_diff(path)
+        else
+          print_workspace_diff(path)
+        end
+      end
+    end
+
+    def print_conflict_diff(path)
+      targets = (0..3).map { |stage| from_index(path, stage) }
+      left, right = targets[2], targets[3]
+
+      if @options[:stage]
+        puts "* Unmerged path #{ path }"
+        print_diff(targets[@options[:stage]], from_file(path))
+      elsif left and right
+        print_combined_diff([left, right], from_file(path))
+      else
+        puts "* Unmerged path #{ path }"
+      end
+    end
+
+    def print_workspace_diff(path)
+      case @status.workspace_changes[path]
+      when :modified then print_diff(from_index(path), from_file(path))
+      when :deleted  then print_diff(from_index(path), from_nothing(path))
+      end
+    end
+
+    def from_head(path)
+      entry = @status.head_tree.fetch(path)
+      blob  = repo.database.load(entry.oid)
+
+      Target.new(path, entry.oid, entry.mode.to_s(8), blob.data)
+    end
+
+    def from_index(path, stage = 0)
+      entry = repo.index.entry_for_path(path, stage)
+      return nil unless entry
+
+      blob = repo.database.load(entry.oid)
+      Target.new(path, entry.oid, entry.mode.to_s(8), blob.data)
+    end
+
+    def from_file(path)
+      blob = Database::Blob.new(repo.workspace.read_file(path))
+      oid  = repo.database.hash_object(blob)
+      mode = Index::Entry.mode_for_stat(@status.stats[path])
+
+      Target.new(path, oid, mode.to_s(8), blob.data)
+    end
+
+    def from_nothing(path)
+      Target.new(path, NULL_OID, nil, "")
+    end
+
+  end
+end