jit 0.0.0 → 1.0.0

data/lib/command/shared/write_commit.rb

@@ -0,0 +1,167 @@
+module Command
+  module WriteCommit
+
+    CONFLICT_MESSAGE = <<~MSG
+      hint: Fix them up in the work tree, and then use 'jit add/rm <file>'
+      hint: as appropriate to mark resolution and make a commit.
+      fatal: Exiting because of an unresolved conflict.
+    MSG
+
+    MERGE_NOTES = <<~MSG
+
+      It looks like you may be committing a merge.
+      If this is not correct, please remove the file
+      \t.git/MERGE_HEAD
+      and try again.
+    MSG
+
+    CHERRY_PICK_NOTES = <<~MSG
+
+      It looks like you may be committing a cherry-pick.
+      If this is not correct, please remove the file
+      \t.git/CHERRY_PICK_HEAD
+      and try again.
+    MSG
+
+    def define_write_commit_options
+      @options[:edit] = :auto
+      @parser.on("-e", "--[no-]edit") { |value| @options[:edit] = value }
+
+      @parser.on "-m <message>", "--message=<message>" do |message|
+        @options[:message] = message
+        @options[:edit]    = false if @options[:edit] == :auto
+      end
+
+      @parser.on "-F <file>", "--file=<file>" do |file|
+        @options[:file] = expanded_pathname(file)
+        @options[:edit] = false if @options[:edit] == :auto
+      end
+    end
+
+    def read_message
+      if @options.has_key?(:message)
+        "#{ @options[:message] }\n"
+      elsif @options.has_key?(:file)
+        File.read(@options[:file])
+      end
+    end
+
+    def write_commit(parents, message)
+      unless message
+        @stderr.puts "Aborting commit due to empty commit message."
+        exit 1
+      end
+
+      tree   = write_tree
+      author = current_author
+      commit = Database::Commit.new(parents, tree.oid, author, author, message)
+
+      repo.database.store(commit)
+      repo.refs.update_head(commit.oid)
+
+      commit
+    end
+
+    def write_tree
+      root = Database::Tree.build(repo.index.each_entry)
+      root.traverse { |tree| repo.database.store(tree) }
+      root
+    end
+
+    def current_author
+      config_name  = repo.config.get(["user", "name"])
+      config_email = repo.config.get(["user", "email"])
+
+      name  = @env.fetch("GIT_AUTHOR_NAME", config_name)
+      email = @env.fetch("GIT_AUTHOR_EMAIL", config_email)
+
+      Database::Author.new(name, email, Time.now)
+    end
+
+    def print_commit(commit)
+      ref  = repo.refs.current_ref
+      info = ref.head? ? "detached HEAD" : ref.short_name
+      oid  = repo.database.short_oid(commit.oid)
+
+      info.concat(" (root-commit)") unless commit.parent
+      info.concat(" #{ oid }")
+
+      puts "[#{ info }] #{ commit.title_line }"
+    end
+
+    def pending_commit
+      @pending_commit ||= repo.pending_commit
+    end
+
+    def resume_merge(type)
+      case type
+      when :merge       then write_merge_commit
+      when :cherry_pick then write_cherry_pick_commit
+      when :revert      then write_revert_commit
+      end
+
+      exit 0
+    end
+
+    def write_merge_commit
+      handle_conflicted_index
+
+      parents = [repo.refs.read_head, pending_commit.merge_oid]
+      message = compose_merge_message(MERGE_NOTES)
+      write_commit(parents, message)
+
+      pending_commit.clear(:merge)
+    end
+
+    def write_cherry_pick_commit
+      handle_conflicted_index
+
+      parents = [repo.refs.read_head]
+      message = compose_merge_message(CHERRY_PICK_NOTES)
+
+      pick_oid = pending_commit.merge_oid(:cherry_pick)
+      commit   = repo.database.load(pick_oid)
+
+      picked = Database::Commit.new(parents, write_tree.oid,
+                                    commit.author, current_author,
+                                    message)
+
+      repo.database.store(picked)
+      repo.refs.update_head(picked.oid)
+      pending_commit.clear(:cherry_pick)
+    end
+
+    def write_revert_commit
+      handle_conflicted_index
+
+      parents = [repo.refs.read_head]
+      message = compose_merge_message
+      write_commit(parents, message)
+
+      pending_commit.clear(:revert)
+    end
+
+    def compose_merge_message(notes = nil)
+      edit_file(commit_message_path) do |editor|
+        editor.puts(pending_commit.merge_message)
+        editor.note(notes) if notes
+        editor.puts("")
+        editor.note(Commit::COMMIT_NOTES)
+      end
+    end
+
+    def commit_message_path
+      repo.git_path.join("COMMIT_EDITMSG")
+    end
+
+    def handle_conflicted_index
+      return unless repo.index.conflict?
+
+      message = "Committing is not possible because you have unmerged files"
+      @stderr.puts "error: #{ message }."
+      @stderr.puts CONFLICT_MESSAGE
+      exit 128
+    end
+
+  end
+end

data/lib/command/status.rb

@@ -0,0 +1,210 @@
+require_relative "./base"
+
+module Command
+  class Status < Base
+
+    LABEL_WIDTH = 12
+
+    LONG_STATUS = {
+      :added    => "new file:",
+      :deleted  => "deleted:",
+      :modified => "modified:"
+    }
+
+    SHORT_STATUS = {
+      :added    => "A",
+      :deleted  => "D",
+      :modified => "M"
+    }
+
+    CONFLICT_LABEL_WIDTH = 17
+
+    CONFLICT_LONG_STATUS = {
+      [1, 2, 3] => "both modified:",
+      [1, 2]    => "deleted by them:",
+      [1, 3]    => "deleted by us:",
+      [2, 3]    => "both added:",
+      [2]       => "added by us:",
+      [3]       => "added by them:"
+    }
+
+    CONFLICT_SHORT_STATUS = {
+      [1, 2, 3] => "UU",
+      [1, 2]    => "UD",
+      [1, 3]    => "DU",
+      [2, 3]    => "AA",
+      [2]       => "AU",
+      [3]       => "UA"
+    }
+
+    UI_LABELS = { :normal => LONG_STATUS, :conflict => CONFLICT_LONG_STATUS }
+    UI_WIDTHS = { :normal => LABEL_WIDTH, :conflict => CONFLICT_LABEL_WIDTH }
+
+    def define_options
+      @options[:format] = "long"
+      @parser.on("--porcelain") { @options[:format] = "porcelain" }
+    end
+
+    def run
+      repo.index.load_for_update
+      @status = repo.status
+      repo.index.write_updates
+
+      print_results
+      exit 0
+    end
+
+    private
+
+    def print_results
+      case @options[:format]
+      when "long"      then print_long_format
+      when "porcelain" then print_porcelain_format
+      end
+    end
+
+    def print_long_format
+      print_branch_status
+      print_upstream_status
+      print_pending_commit_status
+
+      print_changes("Changes to be committed",
+          @status.index_changes, :green)
+
+      print_changes("Unmerged paths",
+          @status.conflicts, :red, :conflict)
+
+      print_changes("Changes not staged for commit",
+          @status.workspace_changes, :red)
+
+      print_changes("Untracked files",
+          @status.untracked_files, :red)
+
+      print_commit_status
+    end
+
+    def print_branch_status
+      current = repo.refs.current_ref
+
+      if current.head?
+        puts fmt(:red, "Not currently on any branch.")
+      else
+        puts "On branch #{ current.short_name }"
+      end
+    end
+
+    def print_upstream_status
+      divergence = repo.divergence(repo.refs.current_ref)
+      return unless divergence.upstream
+
+      base   = repo.refs.short_name(divergence.upstream)
+      ahead  = divergence.ahead
+      behind = divergence.behind
+
+      if ahead == 0 and behind == 0
+        puts "Your branch is up to date with '#{ base }'."
+      elsif behind == 0
+        puts "Your branch is ahead of '#{ base }' by #{ commits ahead }."
+      elsif ahead == 0
+        puts "Your branch is behind '#{ base }' by #{ commits behind }, " +
+             "and can be fast-forwarded."
+      else
+        puts <<~MSG
+          Your branch and '#{ base }' have diverged,
+          and have #{ ahead } and #{ behind } different commits each, respectively.
+        MSG
+      end
+
+      puts ""
+    end
+
+    def commits(n)
+      n == 1 ? "1 commit" : "#{ n } commits"
+    end
+
+    def print_pending_commit_status
+      case repo.pending_commit.merge_type
+      when :merge
+        if @status.conflicts.empty?
+          puts "All conflicts fixed but you are still merging."
+          hint "use 'jit commit' to conclude merge"
+        else
+          puts "You have unmerged paths."
+          hint "fix conflicts and run 'jit commit'"
+          hint "use 'jit merge --abort' to abort the merge"
+        end
+        puts ""
+      when :cherry_pick
+        print_pending_type("cherry-pick")
+      when :revert
+        print_pending_type("revert")
+      end
+    end
+
+    def print_pending_type(op)
+      oid = repo.database.short_oid(repo.pending_commit.merge_oid)
+      puts "You are currently #{ op }ing commit #{ oid }."
+
+      if @status.conflicts.empty?
+        hint "all conflicts fixed: run 'jit #{ op } --continue'"
+      else
+        hint "fix conflicts and run 'jit #{ op } --continue'"
+      end
+      hint "use 'jit #{ op } --abort' to cancel the #{ op } operation"
+      puts ""
+    end
+
+    def hint(message)
+      puts "  (#{ message })"
+    end
+
+    def print_changes(message, changeset, style, label_set = :normal)
+      return if changeset.empty?
+
+      labels = UI_LABELS[label_set]
+      width  = UI_WIDTHS[label_set]
+
+      puts "#{ message }:"
+      puts ""
+      changeset.each do |path, type|
+        status = type ? labels[type].ljust(width, " ") : ""
+        puts "\t" + fmt(style, status + path)
+      end
+      puts ""
+    end
+
+    def print_commit_status
+      return if @status.index_changes.any?
+
+      if @status.workspace_changes.any?
+        puts "no changes added to commit"
+      elsif @status.untracked_files.any?
+        puts "nothing added to commit but untracked files present"
+      else
+        puts "nothing to commit, working tree clean"
+      end
+    end
+
+    def print_porcelain_format
+      @status.changed.each do |path|
+        status = status_for(path)
+        puts "#{ status } #{ path }"
+      end
+
+      @status.untracked_files.each do |path|
+        puts "?? #{ path }"
+      end
+    end
+
+    def status_for(path)
+      if @status.conflicts.has_key?(path)
+        CONFLICT_SHORT_STATUS[@status.conflicts[path]]
+      else
+        left  = SHORT_STATUS.fetch(@status.index_changes[path], " ")
+        right = SHORT_STATUS.fetch(@status.workspace_changes[path], " ")
+        left + right
+      end
+    end
+
+  end
+end

data/lib/command/upload_pack.rb

@@ -0,0 +1,54 @@
+require "set"
+
+require_relative "./base"
+require_relative "./shared/remote_agent"
+require_relative "./shared/send_objects"
+
+module Command
+  class UploadPack < Base
+
+    include RemoteAgent
+    include SendObjects
+
+    CAPABILITIES = ["ofs-delta"]
+
+    def run
+      accept_client("upload-pack", CAPABILITIES)
+
+      send_references
+      recv_want_list
+      recv_have_list
+      send_objects
+
+      exit 0
+    end
+
+    private
+
+    def recv_want_list
+      @wanted = recv_oids("want", nil)
+      exit 0 if @wanted.empty?
+    end
+
+    def recv_have_list
+      @remote_has = recv_oids("have", "done")
+      @conn.send_packet("NAK")
+    end
+
+    def recv_oids(prefix, terminator)
+      pattern = /^#{ prefix } ([0-9a-f]+)$/
+      result  = Set.new
+
+      @conn.recv_until(terminator) do |line|
+        result.add(pattern.match(line)[1])
+      end
+      result
+    end
+
+    def send_objects
+      revs = @wanted + @remote_has.map { |oid| "^#{ oid }" }
+      send_packed_objects(revs)
+    end
+
+  end
+end

data/lib/config.rb

@@ -0,0 +1,240 @@
+require_relative "./lockfile"
+
+class Config
+  SECTION_LINE  = /^\s*\[([a-z0-9-]+)( "(.+)")?\]\s*($|#|;)/i
+  VARIABLE_LINE = /^\s*([a-z][a-z0-9-]*)\s*=\s*(.*?)\s*($|#|;)/i
+  BLANK_LINE    = /^\s*($|#|;)/
+  INTEGER       = /^-?[1-9][0-9]*$/
+
+  VALID_SECTION  = /^[a-z0-9-]+$/i
+  VALID_VARIABLE = /^[a-z][a-z0-9-]*$/i
+
+  Conflict   = Class.new(StandardError)
+  ParseError = Class.new(StandardError)
+
+  Line = Struct.new(:text, :section, :variable) do
+    def normal_variable
+      Variable.normalize(variable&.name)
+    end
+  end
+
+  Section = Struct.new(:name) do
+    def self.normalize(name)
+      return [] if name.empty?
+      [name.first.downcase, name.drop(1).join(".")]
+    end
+
+    def headling_line
+      line = "[#{ name.first }"
+      line.concat(%' "#{ name.drop(1).join(".") }"') if name.size > 1
+      line.concat("]\n")
+    end
+  end
+
+  Variable = Struct.new(:name, :value) do
+    def self.normalize(name)
+      name&.downcase
+    end
+
+    def self.serialize(name, value)
+      "\t#{ name } = #{ value }\n"
+    end
+  end
+
+  def self.valid_key?(key)
+    VALID_SECTION =~ key.first and VALID_VARIABLE =~ key.last
+  end
+
+  def initialize(path)
+    @path     = path
+    @lockfile = Lockfile.new(path)
+    @lines    = nil
+  end
+
+  def open
+    read_config_file unless @lines
+  end
+
+  def open_for_update
+    @lockfile.hold_for_update
+    read_config_file
+  end
+
+  def save
+    @lines.each do |section, lines|
+      lines.each { |line| @lockfile.write(line.text) }
+    end
+    @lockfile.commit
+  end
+
+  def get(key)
+    get_all(key).last
+  end
+
+  def get_all(key)
+    key, var = split_key(key)
+    _, lines = find_lines(key, var)
+
+    lines.map { |line| line.variable.value }
+  end
+
+  def add(key, value)
+    key, var   = split_key(key)
+    section, _ = find_lines(key, var)
+
+    add_variable(section, key, var, value)
+  end
+
+  def set(key, value)
+    key, var       = split_key(key)
+    section, lines = find_lines(key, var)
+
+    case lines.size
+    when 0 then add_variable(section, key, var, value)
+    when 1 then update_variable(lines.first, var, value)
+    else
+      message = "cannot overwrite multiple values with a single value"
+      raise Conflict, message
+    end
+  end
+
+  def replace_all(key, value)
+    key, var       = split_key(key)
+    section, lines = find_lines(key, var)
+
+    remove_all(section, lines)
+    add_variable(section, key, var, value)
+  end
+
+  def unset(key)
+    unset_all(key) do |lines|
+      raise Conflict, "#{ key } has multiple values" if lines.size > 1
+    end
+  end
+
+  def unset_all(key)
+    key, var       = split_key(key)
+    section, lines = find_lines(key, var)
+
+    return unless section
+    yield lines if block_given?
+
+    remove_all(section, lines)
+    lines = lines_for(section)
+    remove_section(key) if lines.size == 1
+  end
+
+  def remove_section(key)
+    key = Section.normalize(key)
+    @lines.delete(key) ? true : false
+  end
+
+  def subsections(name)
+    name, _  = Section.normalize([name])
+    sections = @lines.keys
+
+    sections.select { |main, _| main == name }
+            .reject { |_, sub| sub == nil }
+            .map(&:last)
+  end
+
+  def section?(key)
+    key = Section.normalize(key)
+    @lines.has_key?(key)
+  end
+
+  private
+
+  def line_count
+    @lines.each_value.reduce(0) { |n, lines| n + lines.size }
+  end
+
+  def lines_for(section)
+    @lines[Section.normalize(section.name)]
+  end
+
+  def split_key(key)
+    key = key.map(&:to_s)
+    var = key.pop
+
+    [key, var]
+  end
+
+  def find_lines(key, var)
+    name = Section.normalize(key)
+    return [nil, []] unless @lines.has_key?(name)
+
+    lines   = @lines[name]
+    section = lines.first.section
+    normal  = Variable.normalize(var)
+
+    lines = lines.select { |l| normal == l.normal_variable }
+    [section, lines]
+  end
+
+  def add_section(key)
+    section = Section.new(key)
+    line    = Line.new(section.headling_line, section)
+
+    lines_for(section).push(line)
+    section
+  end
+
+  def add_variable(section, key, var, value)
+    section ||= add_section(key)
+
+    text = Variable.serialize(var, value)
+    var  = Variable.new(var, value)
+    line = Line.new(text, section, var)
+
+    lines_for(section).push(line)
+  end
+
+  def update_variable(line, var, value)
+    line.variable.value = value
+    line.text = Variable.serialize(var, value)
+  end
+
+  def remove_all(section, lines)
+    lines.each { |line| lines_for(section).delete(line) }
+  end
+
+  def read_config_file
+    @lines  = Hash.new { |hash, key| hash[key] = [] }
+    section = Section.new([])
+
+    File.open(@path, File::RDONLY) do |file|
+      until file.eof?
+        line    = parse_line(section, file.readline)
+        section = line.section
+
+        lines_for(section).push(line)
+      end
+    end
+  rescue Errno::ENOENT
+  end
+
+  def parse_line(section, line)
+    if match = SECTION_LINE.match(line)
+      section = Section.new([match[1], match[3]].compact)
+      Line.new(line, section)
+    elsif match = VARIABLE_LINE.match(line)
+      variable = Variable.new(match[1], parse_value(match[2]))
+      Line.new(line, section, variable)
+    elsif match = BLANK_LINE.match(line)
+      Line.new(line, section, nil)
+    else
+      message = "bad config line #{ line_count + 1 } in file #{ @path }"
+      raise ParseError, message
+    end
+  end
+
+  def parse_value(value)
+    case value
+    when "yes", "on", "true"  then true
+    when "no", "off", "false" then false
+    when INTEGER              then value.to_i
+    else                           value
+    end
+  end
+end