jit 0.0.0 → 1.0.0

data/lib/index.rb

@@ -0,0 +1,212 @@
+require "set"
+
+require_relative "./index/checksum"
+require_relative "./index/entry"
+require_relative "./lockfile"
+
+class Index
+  Invalid = Class.new(StandardError)
+
+  HEADER_SIZE   = 12
+  HEADER_FORMAT = "a4N2"
+  SIGNATURE     = "DIRC"
+  VERSION       = 2
+
+  def initialize(pathname)
+    @pathname = pathname
+    @lockfile = Lockfile.new(pathname)
+    clear
+  end
+
+  def clear!
+    clear
+    @changed = true
+  end
+
+  def load_for_update
+    @lockfile.hold_for_update
+    load
+  end
+
+  def load
+    clear
+    file = open_index_file
+
+    if file
+      reader = Checksum.new(file)
+      count = read_header(reader)
+      read_entries(reader, count)
+      reader.verify_checksum
+    end
+  ensure
+    file&.close
+  end
+
+  def write_updates
+    return @lockfile.rollback unless @changed
+
+    writer = Checksum.new(@lockfile)
+
+    header = [SIGNATURE, VERSION, @entries.size].pack(HEADER_FORMAT)
+    writer.write(header)
+    each_entry { |entry| writer.write(entry.to_s) }
+
+    writer.write_checksum
+    @lockfile.commit
+
+    @changed = false
+  end
+
+  def release_lock
+    @lockfile.rollback
+  end
+
+  def add(pathname, oid, stat)
+    (1..3).each { |stage| remove_entry_with_stage(pathname, stage) }
+
+    entry = Entry.create(pathname, oid, stat)
+    discard_conflicts(entry)
+    store_entry(entry)
+    @changed = true
+  end
+
+  def add_from_db(pathname, item)
+    store_entry(Entry.create_from_db(pathname, item, 0))
+    @changed = true
+  end
+
+  def add_conflict_set(pathname, items)
+    remove_entry_with_stage(pathname, 0)
+
+    items.each_with_index do |item, n|
+      next unless item
+      entry = Entry.create_from_db(pathname, item, n + 1)
+      store_entry(entry)
+    end
+    @changed = true
+  end
+
+  def update_entry_stat(entry, stat)
+    entry.update_stat(stat)
+    @changed = true
+  end
+
+  def remove(pathname)
+    @parents[pathname.to_s].each { |child| remove_entry(child) }
+    remove_entry(pathname)
+    @changed = true
+  end
+
+  def each_entry
+    if block_given?
+      @keys.each { |key| yield @entries[key] }
+    else
+      enum_for(:each_entry)
+    end
+  end
+
+  def conflict?
+    @entries.any? { |key, entry| entry.stage > 0 }
+  end
+
+  def conflict_paths
+    paths = Set.new
+    each_entry { |entry| paths.add(entry.path) unless entry.stage == 0 }
+    paths
+  end
+
+  def entry_for_path(path, stage = 0)
+    @entries[[path.to_s, stage]]
+  end
+
+  def child_paths(path)
+    @parents[path.to_s].to_a
+  end
+
+  def tracked_file?(path)
+    (0..3).any? { |stage| @entries.has_key?([path.to_s, stage]) }
+  end
+
+  def tracked_directory?(path)
+    @parents.has_key?(path.to_s)
+  end
+
+  def tracked?(path)
+    tracked_file?(path) or tracked_directory?(path)
+  end
+
+  private
+
+  def clear
+    @entries = {}
+    @keys    = SortedSet.new
+    @parents = Hash.new { |hash, key| hash[key] = Set.new }
+    @changed = false
+  end
+
+  def discard_conflicts(entry)
+    entry.parent_directories.each { |parent| remove_entry(parent) }
+
+    set = @parents.fetch(entry.path, [])
+    set.each { |child| remove_entry(child) }
+  end
+
+  def remove_entry(pathname)
+    (0..3).each { |stage| remove_entry_with_stage(pathname, stage) }
+  end
+
+  def remove_entry_with_stage(pathname, stage)
+    entry = @entries[[pathname.to_s, stage]]
+    return unless entry
+
+    @keys.delete(entry.key)
+    @entries.delete(entry.key)
+
+    entry.parent_directories.each do |dirname|
+      dir = dirname.to_s
+      @parents[dir].delete(entry.path)
+      @parents.delete(dir) if @parents[dir].empty?
+    end
+  end
+
+  def store_entry(entry)
+    @keys.add(entry.key)
+    @entries[entry.key] = entry
+
+    entry.parent_directories.each do |dirname|
+      @parents[dirname.to_s].add(entry.path)
+    end
+  end
+
+  def open_index_file
+    File.open(@pathname, File::RDONLY)
+  rescue Errno::ENOENT
+    nil
+  end
+
+  def read_header(reader)
+    data = reader.read(HEADER_SIZE)
+    signature, version, count = data.unpack(HEADER_FORMAT)
+
+    unless signature == SIGNATURE
+      raise Invalid, "Signature: expected '#{ SIGNATURE }' but found '#{ signature }'"
+    end
+    unless version == VERSION
+      raise Invalid, "Version: expected '#{ VERSION }' but found '#{ version }'"
+    end
+
+    count
+  end
+
+  def read_entries(reader, count)
+    count.times do
+      entry = reader.read(ENTRY_MIN_SIZE)
+
+      until entry.byteslice(-1) == "\0"
+        entry.concat(reader.read(ENTRY_BLOCK))
+      end
+
+      store_entry(Entry.parse(entry))
+    end
+  end
+end

data/lib/index/checksum.rb

@@ -0,0 +1,44 @@
+require "digest/sha1"
+
+class Index
+  class Checksum
+
+    EndOfFile = Class.new(StandardError)
+
+    CHECKSUM_SIZE = 20
+
+    def initialize(file)
+      @file   = file
+      @digest = Digest::SHA1.new
+    end
+
+    def write(data)
+      @file.write(data)
+      @digest.update(data)
+    end
+
+    def write_checksum
+      @file.write(@digest.digest)
+    end
+
+    def read(size)
+      data = @file.read(size)
+
+      unless data.bytesize == size
+        raise EndOfFile, "Unexpected end-of-file while reading index"
+      end
+
+      @digest.update(data)
+      data
+    end
+
+    def verify_checksum
+      sum = @file.read(CHECKSUM_SIZE)
+
+      unless sum == @digest.digest
+        raise Invalid, "Checksum does not match value stored on disk"
+      end
+    end
+
+  end
+end

data/lib/index/entry.rb

@@ -0,0 +1,91 @@
+require "pathname"
+
+class Index
+  ENTRY_FORMAT   = "N10H40nZ*"
+  ENTRY_BLOCK    = 8
+  ENTRY_MIN_SIZE = 64
+
+  REGULAR_MODE    = 0100644
+  EXECUTABLE_MODE = 0100755
+  MAX_PATH_SIZE   = 0xfff
+
+  entry_fields = [
+    :ctime, :ctime_nsec,
+    :mtime, :mtime_nsec,
+    :dev, :ino, :mode, :uid, :gid, :size,
+    :oid, :flags, :path
+  ]
+
+  Entry = Struct.new(*entry_fields) do
+    def self.create(pathname, oid, stat)
+      path  = pathname.to_s
+      mode  = mode_for_stat(stat)
+      flags = [path.bytesize, MAX_PATH_SIZE].min
+
+      Entry.new(
+        stat.ctime.to_i, stat.ctime.nsec,
+        stat.mtime.to_i, stat.mtime.nsec,
+        stat.dev, stat.ino, mode, stat.uid, stat.gid, stat.size,
+        oid, flags, path)
+    end
+
+    def self.create_from_db(pathname, item, n)
+      path  = pathname.to_s
+      flags = (n << 12) | [path.bytesize, MAX_PATH_SIZE].min
+
+      Entry.new(0, 0, 0, 0, 0, 0, item.mode, 0, 0, 0, item.oid, flags, path)
+    end
+
+    def self.mode_for_stat(stat)
+      stat.executable? ? EXECUTABLE_MODE : REGULAR_MODE
+    end
+
+    def self.parse(data)
+      Entry.new(*data.unpack(ENTRY_FORMAT))
+    end
+
+    def key
+      [path, stage]
+    end
+
+    def stage
+      (flags >> 12) & 0x3
+    end
+
+    def parent_directories
+      Pathname.new(path).descend.to_a[0..-2]
+    end
+
+    def basename
+      Pathname.new(path).basename
+    end
+
+    def update_stat(stat)
+      self.ctime      = stat.ctime.to_i
+      self.ctime_nsec = stat.ctime.nsec
+      self.mtime      = stat.mtime.to_i
+      self.mtime_nsec = stat.mtime.nsec
+      self.dev        = stat.dev
+      self.ino        = stat.ino
+      self.mode       = Entry.mode_for_stat(stat)
+      self.uid        = stat.uid
+      self.gid        = stat.gid
+      self.size       = stat.size
+    end
+
+    def stat_match?(stat)
+      mode == Entry.mode_for_stat(stat) and (size == 0 or size == stat.size)
+    end
+
+    def times_match?(stat)
+      ctime == stat.ctime.to_i and ctime_nsec == stat.ctime.nsec and
+      mtime == stat.mtime.to_i and mtime_nsec == stat.mtime.nsec
+    end
+
+    def to_s
+      string = to_a.pack(ENTRY_FORMAT)
+      string.concat("\0") until string.bytesize % ENTRY_BLOCK == 0
+      string
+    end
+  end
+end

data/lib/lockfile.rb

@@ -0,0 +1,55 @@
+class Lockfile
+  LockDenied    = Class.new(StandardError)
+  MissingParent = Class.new(StandardError)
+  NoPermission  = Class.new(StandardError)
+  StaleLock     = Class.new(StandardError)
+
+  def initialize(path)
+    @file_path = path
+    @lock_path = path.sub_ext(".lock")
+
+    @lock = nil
+  end
+
+  def hold_for_update
+    unless @lock
+      flags = File::RDWR | File::CREAT | File::EXCL
+      @lock = File.open(@lock_path, flags)
+    end
+  rescue Errno::EEXIST
+    raise LockDenied, "Unable to create '#{ @lock_path }': File exists."
+  rescue Errno::ENOENT => error
+    raise MissingParent, error.message
+  rescue Errno::EACCES => error
+    raise NoPermission, error.message
+  end
+
+  def write(string)
+    raise_on_stale_lock
+    @lock.write(string)
+  end
+
+  def commit
+    raise_on_stale_lock
+
+    @lock.close
+    File.rename(@lock_path, @file_path)
+    @lock = nil
+  end
+
+  def rollback
+    raise_on_stale_lock
+
+    @lock.close
+    File.unlink(@lock_path)
+    @lock = nil
+  end
+
+  private
+
+  def raise_on_stale_lock
+    unless @lock
+      raise StaleLock, "Not holding lock on file: #{ @lock_path }"
+    end
+  end
+end

data/lib/merge/bases.rb

@@ -0,0 +1,38 @@
+require "set"
+require_relative "./common_ancestors"
+
+module Merge
+  class Bases
+
+    def initialize(database, one, two)
+      @database = database
+      @common   = CommonAncestors.new(@database, one, [two])
+    end
+
+    def find
+      @commits = @common.find
+      return @commits if @commits.size <= 1
+
+      @redundant = Set.new
+      @commits.each { |commit| filter_commit(commit) }
+      @commits - @redundant.to_a
+    end
+
+    private
+
+    def filter_commit(commit)
+      return if @redundant.include?(commit)
+
+      others = @commits - [commit, *@redundant]
+      common = CommonAncestors.new(@database, commit, others)
+
+      common.find
+
+      @redundant.add(commit) if common.marked?(commit, :parent2)
+
+      others.select! { |oid| common.marked?(oid, :parent1) }
+      @redundant.merge(others)
+    end
+
+  end
+end

data/lib/merge/common_ancestors.rb

@@ -0,0 +1,77 @@
+require "set"
+
+module Merge
+  class CommonAncestors
+
+    BOTH_PARENTS = Set.new([:parent1, :parent2])
+
+    def initialize(database, one, twos)
+      @database = database
+      @flags    = Hash.new { |hash, oid| hash[oid] = Set.new }
+      @queue    = []
+      @results  = []
+
+      insert_by_date(@queue, @database.load(one))
+      @flags[one].add(:parent1)
+
+      twos.each do |two|
+        insert_by_date(@queue, @database.load(two))
+        @flags[two].add(:parent2)
+      end
+    end
+
+    def find
+      process_queue until all_stale?
+      @results.map(&:oid).reject { |oid| marked?(oid, :stale) }
+    end
+
+    def marked?(oid, flag)
+      @flags[oid].include?(flag)
+    end
+
+    def counts
+      ones, twos = 0, 0
+
+      @flags.each do |oid, flags|
+        next unless flags.size == 1
+        ones += 1 if flags.include?(:parent1)
+        twos += 1 if flags.include?(:parent2)
+      end
+
+      [ones, twos]
+    end
+
+    private
+
+    def all_stale?
+      @queue.all? { |commit| marked?(commit.oid, :stale) }
+    end
+
+    def process_queue
+      commit = @queue.shift
+      flags  = @flags[commit.oid]
+
+      if flags == BOTH_PARENTS
+        flags.add(:result)
+        insert_by_date(@results, commit)
+        add_parents(commit, flags + [:stale])
+      else
+        add_parents(commit, flags)
+      end
+    end
+
+    def add_parents(commit, flags)
+      commit.parents.each do |parent|
+        next if @flags[parent].superset?(flags)
+
+        @flags[parent].merge(flags)
+        insert_by_date(@queue, @database.load(parent))
+      end
+    end
+
+    def insert_by_date(list, commit)
+      index = list.find_index { |c| c.date < commit.date }
+      list.insert(index || list.size, commit)
+    end
+  end
+end