jit 0.0.0 → 1.0.0

data/lib/repository/migration.rb

@@ -0,0 +1,168 @@
+require "set"
+require_relative "./inspector"
+
+class Repository
+  class Migration
+
+    Conflict = Class.new(StandardError)
+
+    MESSAGES = {
+      :stale_file => [
+        "Your local changes to the following files would be overwritten by checkout:",
+        "Please commit your changes or stash them before you switch branches."
+      ],
+      :stale_directory => [
+        "Updating the following directories would lose untracked files in them:",
+        "\n"
+      ],
+      :untracked_overwritten => [
+        "The following untracked working tree files would be overwritten by checkout:",
+        "Please move or remove them before you switch branches."
+      ],
+      :untracked_removed => [
+        "The following untracked working tree files would be removed by checkout:",
+        "Please move or remove them before you switch branches."
+      ]
+    }
+
+    attr_reader :changes, :mkdirs, :rmdirs, :errors
+
+    def initialize(repository, tree_diff)
+      @repo = repository
+      @diff = tree_diff
+
+      @inspector = Inspector.new(repository)
+
+      @changes = { :create => [], :update => [], :delete => [] }
+      @mkdirs  = Set.new
+      @rmdirs  = Set.new
+      @errors  = []
+
+      @conflicts = {
+        :stale_file            => SortedSet.new,
+        :stale_directory       => SortedSet.new,
+        :untracked_overwritten => SortedSet.new,
+        :untracked_removed     => SortedSet.new
+      }
+    end
+
+    def apply_changes
+      plan_changes
+      update_workspace
+      update_index
+    end
+
+    def blob_data(oid)
+      @repo.database.load(oid).data
+    end
+
+    private
+
+    def plan_changes
+      @diff.each do |path, (old_item, new_item)|
+        check_for_conflict(path, old_item, new_item)
+        record_change(path, old_item, new_item)
+      end
+
+      collect_errors
+    end
+
+    def update_workspace
+      @repo.workspace.apply_migration(self)
+    end
+
+    def update_index
+      @changes[:delete].each do |path, _|
+        @repo.index.remove(path)
+      end
+
+      [:create, :update].each do |action|
+        @changes[action].each do |path, entry|
+          stat = @repo.workspace.stat_file(path)
+          @repo.index.add(path, entry.oid, stat)
+        end
+      end
+    end
+
+    def record_change(path, old_item, new_item)
+      if old_item == nil
+        @mkdirs.merge(path.dirname.descend)
+        action = :create
+      elsif new_item == nil
+        @rmdirs.merge(path.dirname.descend)
+        action = :delete
+      else
+        @mkdirs.merge(path.dirname.descend)
+        action = :update
+      end
+      @changes[action].push([path, new_item])
+    end
+
+    def check_for_conflict(path, old_item, new_item)
+      entry = @repo.index.entry_for_path(path)
+
+      if index_differs_from_trees(entry, old_item, new_item)
+        @conflicts[:stale_file].add(path.to_s)
+        return
+      end
+
+      stat = @repo.workspace.stat_file(path)
+      type = get_error_type(stat, entry, new_item)
+
+      if stat == nil
+        parent = untracked_parent(path)
+        @conflicts[type].add(entry ? path.to_s : parent.to_s) if parent
+
+      elsif stat.file?
+        changed = @inspector.compare_index_to_workspace(entry, stat)
+        @conflicts[type].add(path.to_s) if changed
+
+      elsif stat.directory?
+        trackable = @inspector.trackable_file?(path, stat)
+        @conflicts[type].add(path.to_s) if trackable
+      end
+    end
+
+    def get_error_type(stat, entry, item)
+      if entry
+        :stale_file
+      elsif stat&.directory?
+        :stale_directory
+      elsif item
+        :untracked_overwritten
+      else
+        :untracked_removed
+      end
+    end
+
+    def index_differs_from_trees(entry, old_item, new_item)
+      @inspector.compare_tree_to_index(old_item, entry) and
+      @inspector.compare_tree_to_index(new_item, entry)
+    end
+
+    def untracked_parent(path)
+      path.dirname.ascend.find do |parent|
+        next if parent.to_s == "."
+
+        parent_stat = @repo.workspace.stat_file(parent)
+        next unless parent_stat&.file?
+
+        @inspector.trackable_file?(parent, parent_stat)
+      end
+    end
+
+    def collect_errors
+      @conflicts.each do |type, paths|
+        next if paths.empty?
+
+        lines = paths.map { |name| "\t#{ name }" }
+        header, footer = MESSAGES.fetch(type)
+
+        @errors.push([header, *lines, footer].join("\n"))
+      end
+
+      raise Conflict unless @errors.empty?
+    end
+
+  end
+end

data/lib/repository/pending_commit.rb

@@ -0,0 +1,60 @@
+class Repository
+  class PendingCommit
+
+    Error = Class.new(StandardError)
+
+    HEAD_FILES = {
+      :merge       => "MERGE_HEAD",
+      :cherry_pick => "CHERRY_PICK_HEAD",
+      :revert      => "REVERT_HEAD"
+    }
+
+    attr_reader :message_path
+
+    def initialize(pathname)
+      @pathname     = pathname
+      @message_path = pathname.join("MERGE_MSG")
+    end
+
+    def start(oid, type = :merge)
+      path  = @pathname.join(HEAD_FILES.fetch(type))
+      flags = File::WRONLY | File::CREAT | File::EXCL
+      File.open(path, flags) { |f| f.puts(oid) }
+    end
+
+    def in_progress?
+      not merge_type.nil?
+    end
+
+    def merge_type
+      HEAD_FILES.each do |type, name|
+        path = @pathname.join(name)
+        return type if File.file?(path)
+      end
+
+      nil
+    end
+
+    def merge_oid(type = :merge)
+      head_path = @pathname.join(HEAD_FILES.fetch(type))
+      File.read(head_path).strip
+    rescue Errno::ENOENT
+      name = head_path.basename
+      raise Error, "There is no merge in progress (#{ name } missing)."
+    end
+
+    def merge_message
+      File.read(@message_path)
+    end
+
+    def clear(type = :merge)
+      head_path = @pathname.join(HEAD_FILES.fetch(type))
+      File.unlink(head_path)
+      File.unlink(@message_path)
+    rescue Errno::ENOENT
+      name = head_path.basename
+      raise Error, "There is no merge to abort (#{ name } missing)."
+    end
+
+  end
+end

data/lib/repository/sequencer.rb

@@ -0,0 +1,118 @@
+require "fileutils"
+
+require_relative "../config"
+require_relative "../lockfile"
+
+class Repository
+  class Sequencer
+
+    UNSAFE_MESSAGE = "You seem to have moved HEAD. Not rewinding, check your HEAD!"
+
+    def initialize(repository)
+      @repo       = repository
+      @pathname   = repository.git_path.join("sequencer")
+      @abort_path = @pathname.join("abort-safety")
+      @head_path  = @pathname.join("head")
+      @todo_path  = @pathname.join("todo")
+      @config     = Config.new(@pathname.join("opts"))
+      @todo_file  = nil
+      @commands   = []
+    end
+
+    def start(options)
+      Dir.mkdir(@pathname)
+
+      head_oid = @repo.refs.read_head
+      write_file(@head_path, head_oid)
+      write_file(@abort_path, head_oid)
+
+      @config.open_for_update
+      options.each { |key, value| @config.set(["options", key], value) }
+      @config.save
+
+      open_todo_file
+    end
+
+    def get_option(name)
+      @config.open
+      @config.get(["options", name])
+    end
+
+    def pick(commit)
+      @commands.push([:pick, commit])
+    end
+
+    def revert(commit)
+      @commands.push([:revert, commit])
+    end
+
+    def next_command
+      @commands.first
+    end
+
+    def drop_command
+      @commands.shift
+      write_file(@abort_path, @repo.refs.read_head)
+    end
+
+    def load
+      open_todo_file
+      return unless File.file?(@todo_path)
+
+      @commands = File.read(@todo_path).lines.map do |line|
+        action, oid, _ = /^(\S+) (\S+) (.*)$/.match(line).captures
+
+        oids   = @repo.database.prefix_match(oid)
+        commit = @repo.database.load(oids.first)
+        [action.to_sym, commit]
+      end
+    end
+
+    def dump
+      return unless @todo_file
+
+      @commands.each do |action, commit|
+        short = @repo.database.short_oid(commit.oid)
+        @todo_file.write("#{ action } #{ short } #{ commit.title_line }")
+      end
+
+      @todo_file.commit
+    end
+
+    def abort
+      head_oid = File.read(@head_path).strip
+      expected = File.read(@abort_path).strip
+      actual   = @repo.refs.read_head
+
+      quit
+
+      raise UNSAFE_MESSAGE unless actual == expected
+
+      @repo.hard_reset(head_oid)
+      orig_head = @repo.refs.update_head(head_oid)
+      @repo.refs.update_ref(Refs::ORIG_HEAD, orig_head)
+    end
+
+    def quit
+      FileUtils.rm_rf(@pathname)
+    end
+
+    private
+
+    def write_file(path, content)
+      lockfile = Lockfile.new(path)
+      lockfile.hold_for_update
+      lockfile.write(content)
+      lockfile.write("\n")
+      lockfile.commit
+    end
+
+    def open_todo_file
+      return unless File.directory?(@pathname)
+
+      @todo_file = Lockfile.new(@todo_path)
+      @todo_file.hold_for_update
+    end
+
+  end
+end

data/lib/repository/status.rb

@@ -0,0 +1,98 @@
+require "set"
+
+require_relative "./inspector"
+require_relative "../sorted_hash"
+
+class Repository
+  class Status
+
+    attr_reader :changed,
+                :stats,
+                :head_tree,
+                :index_changes,
+                :conflicts,
+                :workspace_changes,
+                :untracked_files
+
+    def initialize(repository, commit_oid = nil)
+      @repo  = repository
+      @stats = {}
+
+      @inspector = Inspector.new(@repo)
+
+      @changed           = SortedSet.new
+      @index_changes     = SortedHash.new
+      @conflicts         = SortedHash.new
+      @workspace_changes = SortedHash.new
+      @untracked_files   = SortedSet.new
+
+      commit_oid ||= @repo.refs.read_head
+      @head_tree   = @repo.database.load_tree_list(commit_oid)
+
+      scan_workspace
+      check_index_entries
+      collect_deleted_head_files
+    end
+
+    private
+
+    def record_change(path, set, type)
+      @changed.add(path)
+      set[path] = type
+    end
+
+    def scan_workspace(prefix = nil)
+      @repo.workspace.list_dir(prefix).each do |path, stat|
+        if @repo.index.tracked?(path)
+          @stats[path] = stat if stat.file?
+          scan_workspace(path) if stat.directory?
+        elsif @inspector.trackable_file?(path, stat)
+          path += File::SEPARATOR if stat.directory?
+          @untracked_files.add(path)
+        end
+      end
+    end
+
+    def check_index_entries
+      @repo.index.each_entry do |entry|
+        if entry.stage == 0
+          check_index_against_workspace(entry)
+          check_index_against_head_tree(entry)
+        else
+          @changed.add(entry.path)
+          @conflicts[entry.path] ||= []
+          @conflicts[entry.path].push(entry.stage)
+        end
+      end
+    end
+
+    def check_index_against_workspace(entry)
+      stat   = @stats[entry.path]
+      status = @inspector.compare_index_to_workspace(entry, stat)
+
+      if status
+        record_change(entry.path, @workspace_changes, status)
+      else
+        @repo.index.update_entry_stat(entry, stat)
+      end
+    end
+
+    def check_index_against_head_tree(entry)
+      item   = @head_tree[entry.path]
+      status = @inspector.compare_tree_to_index(item, entry)
+
+      if status
+        record_change(entry.path, @index_changes, status)
+      end
+    end
+
+    def collect_deleted_head_files
+      @head_tree.each_key do |path|
+        unless @repo.index.tracked_file?(path)
+          record_change(path, @index_changes, :deleted)
+        end
+      end
+    end
+
+  end
+end

data/lib/rev_list.rb

@@ -0,0 +1,244 @@
+require "pathname"
+require "set"
+
+require_relative "./revision"
+
+class RevList
+  include Enumerable
+
+  RANGE   = /^(.*)\.\.(.*)$/
+  EXCLUDE = /^\^(.+)$/
+
+  def initialize(repo, revs, options = {})
+    @repo    = repo
+    @commits = {}
+    @flags   = Hash.new { |hash, oid| hash[oid] = Set.new }
+    @queue   = []
+    @limited = false
+    @prune   = []
+    @diffs   = {}
+    @output  = []
+    @pending = []
+    @paths   = {}
+
+    @objects = options.fetch(:objects, false)
+    @missing = options.fetch(:missing, false)
+    @walk    = options.fetch(:walk, true)
+
+    include_refs(repo.refs.list_all_refs) if options[:all]
+    include_refs(repo.refs.list_branches) if options[:branches]
+    include_refs(repo.refs.list_remotes)  if options[:remotes]
+
+    revs.each { |rev| handle_revision(rev) }
+    handle_revision(Revision::HEAD) if @queue.empty?
+  end
+
+  def each
+    limit_list if @limited
+    mark_edges_uninteresting if @objects
+    traverse_commits { |commit| yield commit }
+    traverse_pending { |object| yield object, @paths[object.oid] }
+  end
+
+  def tree_diff(old_oid, new_oid)
+    key = [old_oid, new_oid]
+    @diffs[key] ||= @repo.database.tree_diff(old_oid, new_oid, @prune)
+  end
+
+  private
+
+  def include_refs(refs)
+    oids = refs.map(&:read_oid).compact
+    oids.each { |oid| handle_revision(oid) }
+  end
+
+  def handle_revision(rev)
+    if @repo.workspace.stat_file(rev)
+      @prune.push(Pathname.new(rev))
+    elsif match = RANGE.match(rev)
+      set_start_point(match[1], false)
+      set_start_point(match[2], true)
+      @walk = true
+    elsif match = EXCLUDE.match(rev)
+      set_start_point(match[1], false)
+      @walk = true
+    else
+      set_start_point(rev, true)
+    end
+  end
+
+  def set_start_point(rev, interesting)
+    rev = Revision::HEAD if rev == ""
+    oid = Revision.new(@repo, rev).resolve(Revision::COMMIT)
+
+    commit = load_commit(oid)
+    enqueue_commit(commit)
+
+    unless interesting
+      @limited = true
+      mark(oid, :uninteresting)
+      mark_parents_uninteresting(commit)
+    end
+
+  rescue Revision::InvalidObject => error
+    raise error unless @missing
+  end
+
+  def enqueue_commit(commit)
+    return unless mark(commit.oid, :seen)
+
+    if @walk
+      index = @queue.find_index { |c| c.date < commit.date }
+      @queue.insert(index || @queue.size, commit)
+    else
+      @queue.push(commit)
+    end
+  end
+
+  def limit_list
+    while still_interesting?
+      commit = @queue.shift
+      add_parents(commit)
+
+      unless marked?(commit.oid, :uninteresting)
+        @output.push(commit)
+      end
+    end
+
+    @queue = @output
+  end
+
+  def still_interesting?
+    return false if @queue.empty?
+
+    oldest_out = @output.last
+    newest_in  = @queue.first
+
+    return true if oldest_out and oldest_out.date <= newest_in.date
+
+    if @queue.any? { |commit| not marked?(commit.oid, :uninteresting) }
+      return true
+    end
+
+    false
+  end
+
+  def add_parents(commit)
+    return unless @walk and mark(commit.oid, :added)
+
+    if marked?(commit.oid, :uninteresting)
+      parents = commit.parents.map { |oid| load_commit(oid) }
+      parents.each { |parent| mark_parents_uninteresting(parent) }
+    else
+      parents = simplify_commit(commit).map { |oid| load_commit(oid) }
+    end
+
+    parents.each { |parent| enqueue_commit(parent) }
+  end
+
+  def mark_parents_uninteresting(commit)
+    queue = commit.parents.clone
+
+    until queue.empty?
+      oid = queue.shift
+
+      while oid
+        break unless mark(oid, :uninteresting)
+
+        parent = @commits[oid]
+        break unless parent
+
+        oid = parent.parents.first
+        queue.concat(parent.parents.drop(1))
+      end
+    end
+  end
+
+  def mark_edges_uninteresting
+    @queue.each do |commit|
+      if marked?(commit.oid, :uninteresting)
+        mark_tree_uninteresting(commit.tree)
+      end
+
+      commit.parents.each do |oid|
+        next unless marked?(oid, :uninteresting)
+
+        parent = load_commit(oid)
+        mark_tree_uninteresting(parent.tree)
+      end
+    end
+  end
+
+  def mark_tree_uninteresting(tree_oid)
+    entry = @repo.database.tree_entry(tree_oid)
+    traverse_tree(entry) { |object| mark(object.oid, :uninteresting) }
+  end
+
+  def simplify_commit(commit)
+    return commit.parents if @prune.empty?
+
+    parents = commit.parents
+    parents = [nil] if parents.empty?
+
+    parents.each do |oid|
+      next unless tree_diff(oid, commit.oid).empty?
+      mark(commit.oid, :treesame)
+      return [*oid]
+    end
+
+    commit.parents
+  end
+
+  def traverse_commits
+    until @queue.empty?
+      commit = @queue.shift
+      add_parents(commit) unless @limited
+
+      next if marked?(commit.oid, :uninteresting)
+      next if marked?(commit.oid, :treesame)
+
+      @pending.push(@repo.database.tree_entry(commit.tree))
+      yield commit
+    end
+  end
+
+  def traverse_pending
+    return unless @objects
+
+    @pending.each do |entry|
+      traverse_tree(entry) do |object|
+        next if marked?(object.oid, :uninteresting)
+        next unless mark(object.oid, :seen)
+
+        yield object
+        true
+      end
+    end
+  end
+
+  def traverse_tree(entry, path = Pathname.new(""))
+    @paths[entry.oid] ||= path
+
+    return unless yield entry
+    return unless entry.tree?
+
+    tree = @repo.database.load(entry.oid)
+
+    tree.each_entry do |name, item|
+      traverse_tree(item, path.join(name)) { |object| yield object }
+    end
+  end
+
+  def load_commit(oid)
+    return nil unless oid
+    @commits[oid] ||= @repo.database.load(oid)
+  end
+
+  def mark(oid, flag)
+    @flags[oid].add?(flag)
+  end
+
+  def marked?(oid, flag)
+    @flags[oid].include?(flag)
+  end
+end