jit 0.0.0 → 1.0.0

data/lib/database/tree.rb

@@ -0,0 +1,77 @@
+class Database
+  class Tree
+
+    ENTRY_FORMAT = "Z*H40"
+    TREE_MODE    = 040000
+
+    attr_accessor :oid, :entries
+
+    def self.parse(scanner)
+      entries = {}
+
+      until scanner.eos?
+        mode = scanner.scan_until(/ /).strip.to_i(8)
+        name = scanner.scan_until(/\0/)[0..-2]
+
+        oid = scanner.peek(20).unpack("H40").first
+        scanner.pos += 20
+
+        entries[name] = Entry.new(oid, mode)
+      end
+
+      Tree.new(entries)
+    end
+
+    def self.build(entries)
+      root = Tree.new
+
+      entries.each do |entry|
+        root.add_entry(entry.parent_directories, entry)
+      end
+
+      root
+    end
+
+    def initialize(entries = {})
+      @entries = entries
+    end
+
+    def each_entry(&block)
+      @entries.each(&block)
+    end
+
+    def add_entry(parents, entry)
+      if parents.empty?
+        @entries[entry.basename] = entry
+      else
+        tree = @entries[parents.first.basename] ||= Tree.new
+        tree.add_entry(parents.drop(1), entry)
+      end
+    end
+
+    def traverse(&block)
+      @entries.each do |name, entry|
+        entry.traverse(&block) if entry.is_a?(Tree)
+      end
+      block.call(self)
+    end
+
+    def mode
+      TREE_MODE
+    end
+
+    def type
+      "tree"
+    end
+
+    def to_s
+      entries = @entries.map do |name, entry|
+        mode = entry.mode.to_s(8)
+        ["#{ mode } #{ name }", entry.oid].pack(ENTRY_FORMAT)
+      end
+
+      entries.join("")
+    end
+
+  end
+end

data/lib/database/tree_diff.rb

@@ -0,0 +1,88 @@
+require "pathname"
+
+class Database
+  class TreeDiff
+
+    attr_reader :changes
+
+    def initialize(database, prune = [])
+      @database = database
+      @changes  = {}
+
+      build_routing_table(prune)
+    end
+
+    def compare_oids(a, b, prefix = Pathname.new(""))
+      return if a == b
+
+      a_entries = a ? oid_to_tree(a).entries : {}
+      b_entries = b ? oid_to_tree(b).entries : {}
+
+      detect_deletions(a_entries, b_entries, prefix)
+      detect_additions(a_entries, b_entries, prefix)
+    end
+
+    private
+
+    def build_routing_table(prune)
+      @routes = {}
+
+      prune.each do |path|
+        table = @routes
+        path.each_filename { |name| table = table[name] ||= {} }
+      end
+    end
+
+    def routes_for_prefix(prefix)
+      prefix.each_filename.reduce(@routes) { |table, name| table[name] || {} }
+    end
+
+    def oid_to_tree(oid)
+      object = @database.load(oid)
+
+      case object
+      when Commit then @database.load(object.tree)
+      when Tree   then object
+      end
+    end
+
+    def detect_deletions(a, b, prefix)
+      routes = routes_for_prefix(prefix)
+
+      a.each do |name, entry|
+        next unless routes.empty? or routes.has_key?(name)
+
+        path  = prefix.join(name)
+        other = b[name]
+
+        next if entry == other
+
+        tree_a, tree_b = [entry, other].map { |e| e&.tree? ? e.oid : nil }
+        compare_oids(tree_a, tree_b, path)
+
+        blobs = [entry, other].map { |e| e&.tree? ? nil : e }
+        @changes[path] = blobs if blobs.any?
+      end
+    end
+
+    def detect_additions(a, b, prefix)
+      routes = routes_for_prefix(prefix)
+
+      b.each do |name, entry|
+        next unless routes.empty? or routes.has_key?(name)
+
+        path  = prefix.join(name)
+        other = a[name]
+
+        next if other
+
+        if entry.tree?
+          compare_oids(nil, entry.oid, path)
+        else
+          @changes[path] = [nil, entry]
+        end
+      end
+    end
+
+  end
+end

data/lib/diff.rb

@@ -0,0 +1,46 @@
+require_relative "./diff/combined"
+require_relative "./diff/hunk"
+require_relative "./diff/myers"
+
+module Diff
+  SYMBOLS = {
+    :eql => " ",
+    :ins => "+",
+    :del => "-"
+  }
+
+  Line = Struct.new(:number, :text)
+
+  Edit = Struct.new(:type, :a_line, :b_line) do
+    def a_lines
+      [a_line]
+    end
+
+    def to_s
+      line = a_line || b_line
+      SYMBOLS.fetch(type) + line.text
+    end
+  end
+
+  def self.lines(document)
+    document = document.lines if document.is_a?(String)
+    document.map.with_index { |text, i| Line.new(i + 1, text) }
+  end
+
+  def self.diff(a, b)
+    Myers.diff(lines(a), lines(b))
+  end
+
+  def self.diff_hunks(a, b)
+    Hunk.filter(diff(a, b))
+  end
+
+  def self.combined(as, b)
+    diffs = as.map { |a| diff(a, b) }
+    Combined.new(diffs).to_a
+  end
+
+  def self.combined_hunks(as, b)
+    Hunk.filter(combined(as, b))
+  end
+end

data/lib/diff/combined.rb

@@ -0,0 +1,72 @@
+module Diff
+  class Combined
+
+    include Enumerable
+
+    Row = Struct.new(:edits) do
+      def type
+        types = edits.compact.map(&:type)
+        types.include?(:ins) ? :ins : types.first
+      end
+
+      def a_lines
+        edits.map { |edit| edit&.a_line }
+      end
+
+      def b_line
+        edits.first&.b_line
+      end
+
+      def to_s
+        symbols = edits.map { |edit| SYMBOLS.fetch(edit&.type, " ") }
+
+        del  = edits.find { |edit| edit&.type == :del }
+        line = del ? del.a_line : edits.first.b_line
+
+        symbols.join("") + line.text
+      end
+    end
+
+    def initialize(diffs)
+      @diffs = diffs
+    end
+
+    def each
+      @offsets = @diffs.map { 0 }
+
+      loop do
+        @diffs.each_with_index do |diff, i|
+          consume_deletions(diff, i) { |row| yield row }
+        end
+
+        return if complete?
+
+        edits = offset_diffs.map { |offset, diff| diff[offset] }
+        @offsets.map! { |offset| offset + 1 }
+
+        yield Row.new(edits)
+      end
+    end
+
+    private
+
+    def complete?
+      offset_diffs.all? { |offset, diff| offset == diff.size }
+    end
+
+    def offset_diffs
+      @offsets.zip(@diffs)
+    end
+
+    def consume_deletions(diff, i)
+      while @offsets[i] < diff.size and diff[@offsets[i]].type == :del
+        edits = Array.new(@diffs.size)
+        edits[i] = diff[@offsets[i]]
+        @offsets[i] += 1
+
+        yield Row.new(edits)
+      end
+    end
+
+  end
+end

data/lib/diff/hunk.rb

@@ -0,0 +1,64 @@
+module Diff
+
+  HUNK_CONTEXT = 3
+
+  Hunk = Struct.new(:a_starts, :b_start, :edits) do
+    def self.filter(edits)
+      hunks  = []
+      offset = 0
+
+      loop do
+        offset += 1 while edits[offset]&.type == :eql
+        return hunks if offset >= edits.size
+
+        offset -= HUNK_CONTEXT + 1
+
+        a_starts = (offset < 0) ? []  : edits[offset].a_lines.map(&:number)
+        b_start  = (offset < 0) ? nil : edits[offset].b_line.number
+
+        hunks.push(Hunk.new(a_starts, b_start, []))
+        offset = build_hunk(hunks.last, edits, offset)
+      end
+    end
+
+    def self.build_hunk(hunk, edits, offset)
+      counter = -1
+
+      until counter == 0
+        hunk.edits.push(edits[offset]) if offset >= 0 and counter > 0
+
+        offset += 1
+        break if offset >= edits.size
+
+        case edits[offset + HUNK_CONTEXT]&.type
+        when :ins, :del
+          counter = 2 * HUNK_CONTEXT + 1
+        else
+          counter -= 1
+        end
+      end
+
+      offset
+    end
+
+    def header
+      a_lines = edits.map(&:a_lines).transpose
+      offsets = a_lines.map.with_index { |lines, i| format("-", lines, a_starts[i]) }
+
+      offsets.push(format("+", edits.map(&:b_line), b_start))
+      sep = "@" * offsets.size
+
+      [sep, *offsets, sep].join(" ")
+    end
+
+    private
+
+    def format(sign, lines, start)
+      lines = lines.compact
+      start = lines.first&.number || start || 0
+
+      "#{ sign }#{ start },#{ lines.size }"
+    end
+  end
+
+end

data/lib/diff/myers.rb

@@ -0,0 +1,90 @@
+module Diff
+  class Myers
+
+    def self.diff(a, b)
+      new(a, b).diff
+    end
+
+    def initialize(a, b)
+      @a, @b = a, b
+    end
+
+    def diff
+      diff = []
+
+      backtrack do |prev_x, prev_y, x, y|
+        a_line, b_line = @a[prev_x], @b[prev_y]
+
+        if x == prev_x
+          diff.push(Edit.new(:ins, nil, b_line))
+        elsif y == prev_y
+          diff.push(Edit.new(:del, a_line, nil))
+        else
+          diff.push(Edit.new(:eql, a_line, b_line))
+        end
+      end
+
+      diff.reverse
+    end
+
+    private
+
+    def backtrack
+      x, y = @a.size, @b.size
+
+      shortest_edit.each_with_index.reverse_each do |v, d|
+        k = x - y
+
+        if k == -d or (k != d and v[k - 1] < v[k + 1])
+          prev_k = k + 1
+        else
+          prev_k = k - 1
+        end
+
+        prev_x = v[prev_k]
+        prev_y = prev_x - prev_k
+
+        while x > prev_x and y > prev_y
+          yield x - 1, y - 1, x, y
+          x, y = x - 1, y - 1
+        end
+
+        yield prev_x, prev_y, x, y if d > 0
+
+        x, y = prev_x, prev_y
+      end
+    end
+
+    def shortest_edit
+      n, m = @a.size, @b.size
+      max  = n + m
+
+      v     = Array.new(2 * max + 1)
+      v[1]  = 0
+      trace = []
+
+      (0 .. max).step do |d|
+        trace.push(v.clone)
+
+        (-d .. d).step(2) do |k|
+          if k == -d or (k != d and v[k - 1] < v[k + 1])
+            x = v[k + 1]
+          else
+            x = v[k - 1] + 1
+          end
+
+          y = x - k
+
+          while x < n and y < m and @a[x].text == @b[y].text
+            x, y = x + 1, y + 1
+          end
+
+          v[k] = x
+
+          return trace if x >= n and y >= m
+        end
+      end
+    end
+
+  end
+end

data/lib/editor.rb

@@ -0,0 +1,59 @@
+require "shellwords"
+
+class Editor
+  DEFAULT_EDITOR = "vi"
+
+  def self.edit(path, command)
+    editor = new(path, command)
+    yield editor
+    editor.edit_file
+  end
+
+  def initialize(path, command)
+    @path    = path
+    @command = command || DEFAULT_EDITOR
+    @closed  = false
+  end
+
+  def puts(string)
+    return if @closed
+    file.puts(string)
+  end
+
+  def note(string)
+    return if @closed
+    string.each_line { |line| file.puts("# #{ line }") }
+  end
+
+  def close
+    @closed = true
+  end
+
+  def edit_file
+    file.close
+    editor_argv = Shellwords.shellsplit(@command) + [@path.to_s]
+
+    unless @closed or system(*editor_argv)
+      raise "There was a problem with the editor '#{ @command }'."
+    end
+
+    remove_notes(File.read(@path))
+  end
+
+  private
+
+  def remove_notes(string)
+    lines = string.lines.reject { |line| line.start_with?("#") }
+
+    if lines.all? { |line| /^\s*$/ =~ line }
+      nil
+    else
+      "#{ lines.join("").strip }\n"
+    end
+  end
+
+  def file
+    flags = File::WRONLY | File::CREAT | File::TRUNC
+    @file ||= File.open(@path, flags)
+  end
+end