jit 0.0.0 → 1.0.0

data/lib/merge/diff3.rb

@@ -0,0 +1,156 @@
+require_relative "../diff"
+
+module Merge
+  class Diff3
+
+    Clean = Struct.new(:lines) do
+      def to_s(*)
+        lines.join("")
+      end
+    end
+
+    Conflict = Struct.new(:o_lines, :a_lines, :b_lines) do
+      def to_s(a_name = nil, b_name = nil)
+        text = ""
+        separator(text, "<", a_name)
+        a_lines.each { |line| text.concat(line) }
+        separator(text, "=")
+        b_lines.each { |line| text.concat(line) }
+        separator(text, ">", b_name)
+        text
+      end
+
+      def separator(text, char, name = nil)
+        text.concat(char * 7)
+        text.concat(" #{ name }") if name
+        text.concat("\n")
+      end
+    end
+
+    Result = Struct.new(:chunks) do
+      def clean?
+        chunks.none? { |chunk| chunk.is_a?(Conflict) }
+      end
+
+      def to_s(a_name = nil, b_name = nil)
+        chunks.map { |chunk| chunk.to_s(a_name, b_name) }.join("")
+      end
+    end
+
+    def self.merge(o, a, b)
+      o = o.lines if o.is_a?(String)
+      a = a.lines if a.is_a?(String)
+      b = b.lines if b.is_a?(String)
+
+      new(o, a, b).merge
+    end
+
+    def initialize(o, a, b)
+      @o, @a, @b = o, a, b
+    end
+
+    def merge
+      setup
+      generate_chunks
+      Result.new(@chunks)
+    end
+
+    def setup
+      @chunks = []
+      @line_o = @line_a = @line_b = 0
+
+      @match_a = match_set(@a)
+      @match_b = match_set(@b)
+    end
+
+    def match_set(file)
+      matches = {}
+
+      Diff.diff(@o, file).each do |edit|
+        next unless edit.type == :eql
+        matches[edit.a_line.number] = edit.b_line.number
+      end
+
+      matches
+    end
+
+    def generate_chunks
+      loop do
+        i = find_next_mismatch
+
+        if i == 1
+          o, a, b = find_next_match
+
+          if a and b
+            emit_chunk(o, a, b)
+          else
+            emit_final_chunk
+            return
+          end
+
+        elsif i
+          emit_chunk(@line_o + i, @line_a + i, @line_b + i)
+
+        else
+          emit_final_chunk
+          return
+        end
+      end
+    end
+
+    def find_next_mismatch
+      i = 1
+      while in_bounds?(i) and
+            match?(@match_a, @line_a, i) and
+            match?(@match_b, @line_b, i)
+        i += 1
+      end
+      in_bounds?(i) ? i : nil
+    end
+
+    def in_bounds?(i)
+      @line_o + i <= @o.size or
+      @line_a + i <= @a.size or
+      @line_b + i <= @b.size
+    end
+
+    def match?(matches, offset, i)
+      matches[@line_o + i] == offset + i
+    end
+
+    def find_next_match
+      o = @line_o + 1
+      until o > @o.size or (@match_a.has_key?(o) and @match_b.has_key?(o))
+        o += 1
+      end
+      [o, @match_a[o], @match_b[o]]
+    end
+
+    def emit_chunk(o, a, b)
+      write_chunk(
+        @o[@line_o ... o - 1],
+        @a[@line_a ... a - 1],
+        @b[@line_b ... b - 1])
+
+      @line_o, @line_a, @line_b = o - 1, a - 1, b - 1
+    end
+
+    def emit_final_chunk
+      write_chunk(
+        @o[@line_o .. -1],
+        @a[@line_a .. -1],
+        @b[@line_b .. -1])
+    end
+
+    def write_chunk(o, a, b)
+      if a == o or a == b
+        @chunks.push(Clean.new(b))
+      elsif b == o
+        @chunks.push(Clean.new(a))
+      else
+        @chunks.push(Conflict.new(o, a, b))
+      end
+    end
+
+  end
+end

data/lib/merge/inputs.rb

@@ -0,0 +1,42 @@
+require_relative "./bases"
+require_relative "../revision"
+
+module Merge
+  class Inputs
+
+    ATTRS = [ :left_name, :right_name,
+              :left_oid, :right_oid,
+              :base_oids ]
+
+    attr_reader(*ATTRS)
+
+    def initialize(repository, left_name, right_name)
+      @repo       = repository
+      @left_name  = left_name
+      @right_name = right_name
+
+      @left_oid  = resolve_rev(@left_name)
+      @right_oid = resolve_rev(@right_name)
+
+      common     = Bases.new(@repo.database, @left_oid, @right_oid)
+      @base_oids = common.find
+    end
+
+    def already_merged?
+      @base_oids == [@right_oid]
+    end
+
+    def fast_forward?
+      @base_oids == [@left_oid]
+    end
+
+    private
+
+    def resolve_rev(rev)
+      Revision.new(@repo, rev).resolve(Revision::COMMIT)
+    end
+
+  end
+
+  CherryPick = Struct.new(*Inputs::ATTRS)
+end

data/lib/merge/resolve.rb

@@ -0,0 +1,178 @@
+require_relative "./diff3"
+
+module Merge
+  class Resolve
+
+    def initialize(repository, inputs)
+      @repo   = repository
+      @inputs = inputs
+
+      @on_progress = nil
+    end
+
+    def on_progress(&block)
+      @on_progress = block
+    end
+
+    def execute
+      prepare_tree_diffs
+
+      migration = @repo.migration(@clean_diff)
+      migration.apply_changes
+
+      add_conflicts_to_index
+      write_untracked_files
+    end
+
+    private
+
+    def prepare_tree_diffs
+      base_oid    = @inputs.base_oids.first
+      @left_diff  = @repo.database.tree_diff(base_oid, @inputs.left_oid)
+      @right_diff = @repo.database.tree_diff(base_oid, @inputs.right_oid)
+      @clean_diff = {}
+      @conflicts  = {}
+      @untracked  = {}
+
+      @right_diff.each do |path, (old_item, new_item)|
+        file_dir_conflict(path, @left_diff, @inputs.left_name) if new_item
+        same_path_conflict(path, old_item, new_item)
+      end
+
+      @left_diff.each do |path, (_, new_item)|
+        file_dir_conflict(path, @right_diff, @inputs.right_name) if new_item
+      end
+    end
+
+    def same_path_conflict(path, base, right)
+      return if @conflicts[path]
+
+      unless @left_diff.has_key?(path)
+        @clean_diff[path] = [base, right]
+        return
+      end
+
+      left = @left_diff[path][1]
+      return if left == right
+
+      log "Auto-merging #{ path }" if left and right
+
+      oid_ok, oid = merge_blobs(base&.oid, left&.oid, right&.oid)
+      mode_ok, mode = merge_modes(base&.mode, left&.mode, right&.mode)
+
+      @clean_diff[path] = [left, Database::Entry.new(oid, mode)]
+      return if oid_ok and mode_ok
+
+      @conflicts[path] = [base, left, right]
+      log_conflict(path)
+    end
+
+    def merge_blobs(base_oid, left_oid, right_oid)
+      result = merge3(base_oid, left_oid, right_oid)
+      return result if result
+
+      oids  = [base_oid, left_oid, right_oid]
+      blobs = oids.map { |oid| oid ? @repo.database.load(oid).data : "" }
+      merge = Diff3.merge(*blobs)
+
+      data = merge.to_s(@inputs.left_name, @inputs.right_name)
+      blob = Database::Blob.new(data)
+      @repo.database.store(blob)
+
+      [merge.clean?, blob.oid]
+    end
+
+    def merge_modes(base_mode, left_mode, right_mode)
+      merge3(base_mode, left_mode, right_mode) || [false, left_mode]
+    end
+
+    def merge3(base, left, right)
+      return [false, right] unless left
+      return [false, left] unless right
+
+      if left == base or left == right
+        [true, right]
+      elsif right == base
+        [true, left]
+      end
+    end
+
+    def file_dir_conflict(path, diff, name)
+      path.dirname.ascend do |parent|
+        old_item, new_item = diff[parent]
+        next unless new_item
+
+        @conflicts[parent] = case name
+          when @inputs.left_name  then [old_item, new_item, nil]
+          when @inputs.right_name then [old_item, nil, new_item]
+        end
+
+        @clean_diff.delete(parent)
+        rename = "#{ parent }~#{ name }"
+        @untracked[rename] = new_item
+
+        log "Adding #{ path }" unless diff[path]
+        log_conflict(parent, rename)
+      end
+    end
+
+    def add_conflicts_to_index
+      @conflicts.each do |path, items|
+        @repo.index.add_conflict_set(path, items)
+      end
+    end
+
+    def write_untracked_files
+      @untracked.each do |path, item|
+        blob = @repo.database.load(item.oid)
+        @repo.workspace.write_file(path, blob.data)
+      end
+    end
+
+    def log(message)
+      @on_progress&.call(message)
+    end
+
+    def log_conflict(path, rename = nil)
+      base, left, right = @conflicts[path]
+
+      if left and right
+        log_left_right_conflict(path)
+      elsif base and (left or right)
+        log_modify_delete_conflict(path, rename)
+      else
+        log_file_directory_conflict(path, rename)
+      end
+    end
+
+    def log_left_right_conflict(path)
+      type = @conflicts[path][0] ? "content" : "add/add"
+      log "CONFLICT (#{ type }): Merge conflict in #{ path }"
+    end
+
+    def log_modify_delete_conflict(path, rename)
+      deleted, modified = log_branch_names(path)
+
+      rename = rename ? " at #{ rename }" : ""
+
+      log "CONFLICT (modify/delete): #{ path } " +
+          "deleted in #{ deleted } and modified in #{ modified }. " +
+          "Version #{ modified } of #{ path } left in tree#{ rename }."
+    end
+
+    def log_file_directory_conflict(path, rename)
+      type = @conflicts[path][1] ? "file/directory" : "directory/file"
+      branch, _ = log_branch_names(path)
+
+      log "CONFLICT (#{ type }): There is a directory " +
+          "with name #{ path } in #{ branch }. " +
+          "Adding #{ path } as #{ rename }"
+    end
+
+    def log_branch_names(path)
+      a, b = @inputs.left_name, @inputs.right_name
+      @conflicts[path][1] ? [b, a] : [a, b]
+    end
+
+  end
+end

data/lib/pack.rb

@@ -0,0 +1,45 @@
+require_relative "./pack/reader"
+require_relative "./pack/writer"
+require_relative "./pack/stream"
+require_relative "./pack/indexer"
+require_relative "./pack/unpacker"
+
+module Pack
+  HEADER_SIZE   = 12
+  HEADER_FORMAT = "a4N2"
+  SIGNATURE     = "PACK"
+  VERSION       = 2
+
+  GIT_MAX_COPY    = 0x10000
+  MAX_COPY_SIZE   = 0xffffff
+  MAX_INSERT_SIZE = 0x7f
+
+  IDX_SIGNATURE  = 0xff744f63
+  IDX_MAX_OFFSET = 0x80000000
+
+  COMMIT = 1
+  TREE   = 2
+  BLOB   = 3
+
+  OFS_DELTA = 6
+  REF_DELTA = 7
+
+  TYPE_CODES = {
+    "commit" => COMMIT,
+    "tree"   => TREE,
+    "blob"   => BLOB
+  }
+
+  InvalidPack = Class.new(StandardError)
+
+  Record = Struct.new(:type, :data) do
+    attr_accessor :oid
+
+    def to_s
+      data
+    end
+  end
+
+  OfsDelta = Struct.new(:base_ofs, :delta_data)
+  RefDelta = Struct.new(:base_oid, :delta_data)
+end

data/lib/pack/compressor.rb

@@ -0,0 +1,83 @@
+require_relative "./delta"
+require_relative "./window"
+
+module Pack
+  class Compressor
+
+    OBJECT_SIZE = 50..0x20000000
+    MAX_DEPTH   = 50
+    WINDOW_SIZE = 8
+
+    def initialize(database, progress)
+      @database = database
+      @window   = Window.new(WINDOW_SIZE)
+      @progress = progress
+      @objects  = []
+    end
+
+    def add(entry)
+      return unless OBJECT_SIZE.include?(entry.size)
+      @objects.push(entry)
+    end
+
+    def build_deltas
+      @progress&.start("Compressing objects", @objects.size)
+
+      @objects.sort! { |a, b| b.sort_key <=> a.sort_key }
+
+      @objects.each do |entry|
+        build_delta(entry)
+        @progress&.tick
+      end
+      @progress&.stop
+    end
+
+    private
+
+    def build_delta(entry)
+      object = @database.load_raw(entry.oid)
+      target = @window.add(entry, object.data)
+
+      @window.each { |source| try_delta(source, target) }
+    end
+
+    def try_delta(source, target)
+      return unless source.type == target.type
+      return unless source.depth < MAX_DEPTH
+
+      max_size = max_size_heuristic(source, target)
+      return unless compatible_sizes?(source, target, max_size)
+
+      delta = Delta.new(source, target)
+      size  = target.entry.packed_size
+
+      return if delta.size > max_size
+      return if delta.size == size and delta.base.depth + 1 >= target.depth
+
+      target.entry.assign_delta(delta)
+    end
+
+    def max_size_heuristic(source, target)
+      if target.delta
+        max_size  = target.delta.size
+        ref_depth = target.depth
+      else
+        max_size  = target.size / 2 - 20
+        ref_depth = 1
+      end
+
+      max_size * (MAX_DEPTH - source.depth) / (MAX_DEPTH + 1 - ref_depth)
+    end
+
+    def compatible_sizes?(source, target, max_size)
+      size_diff = [target.size - source.size, 0].max
+
+      return false if max_size == 0
+      return false if size_diff >= max_size
+      return false if target.size < source.size / 32
+
+      true
+    end
+
+  end
+end