gitolemy 0.0.4

data/lib/diff.rb

@@ -0,0 +1,65 @@
+require "active_support/core_ext/string"
+
+class Diff
+
+  attr_accessor :insertions
+  attr_accessor :deletions
+  attr_accessor :delete_start
+  attr_accessor :delete_count
+  attr_accessor :insert_start
+  attr_accessor :insert_count
+
+  def initialize(attrs={})
+    attrs.each do |key, val|
+      instance_variable_set("@#{key}".to_sym, val)
+    end
+  end
+
+  private
+
+  class << self
+    def from_git(diff_lines)
+      Diff.new(parse_diff(diff_lines))
+    end
+
+    def parse_diff(diff_lines)
+      stats = diff_lines
+        .first
+        .split("@@")[1]
+        .split(" ")
+
+      delete = stats.first.split(",")
+      add = stats.last.split(",")
+
+      delete_start = delete.first[1..-1].to_i
+      delete_count = delete.length > 1 ? delete.last.to_i : 1
+      add_start = add.first[1..-1].to_i
+      add_count = add.length > 1 ? add.last.to_i : 1
+
+      diffs = diff_lines[1..-1]
+      patch = {
+        insertions: [],
+        deletions: [],
+        delete_start: delete_start,
+        delete_count: delete_count,
+        insert_start: add_start,
+        insert_count: add_count
+      }
+
+      diffs.reduce(patch, &method(:fold_lines_standard))
+    end
+
+    def fold_lines_standard(acc, diff_line)
+      diff = diff_line
+      line = diff_line[1..-1]
+
+      if diff.first == "+"
+        acc[:insertions] << line
+      elsif diff.first == "-"
+        acc[:deletions] << line
+      end
+
+      acc
+    end
+  end
+end

data/lib/file_diff.rb

@@ -0,0 +1,98 @@
+require_relative "util"
+require_relative "diff"
+
+class FileDiff
+  DIFF_REGEX = /^@@ -\d+(,\d+)? \+\d+(,\d+)? @@/
+  FILE_INDEX_REGEX = /index [0-9a-f]{7,40}/
+  BINARY_REGEX = /^Binary files \/dev\/null and/
+  DELETION_REGEX = /\[-.*?-\]/
+  INSERTION_REGEX = /\{\+.*?\+\}/
+  DIFF_STAT_REGEX = /^\d+\t\d+\t/
+  DELETE_REGEX = /$\[-.*?-\]$/
+  DELETE_OP_REGEX = /^deleted file/
+
+  attr_accessor :operation
+  attr_accessor :a_file_name
+  attr_accessor :b_file_name
+  attr_accessor :a_file_id
+  attr_accessor :b_file_id
+  attr_accessor :diffs
+  attr_accessor :insertions_total
+  attr_accessor :deletions_total
+  attr_accessor :changes_total
+
+  def initialize(attrs={})
+    attrs.each do |key, val|
+      instance_variable_set("@#{key}".to_sym, val)
+    end
+  end
+
+  class << self
+    def from_git(file_diff_lines)
+      FileDiff.new(parse_file_diff(file_diff_lines))
+    end
+
+    # TODO: Handle different file modes like new, move, and delete.
+    def parse_file_diff(file_diff_lines)
+      file_names = file_diff_lines
+        .first
+        .sub("diff --git a/", "")
+        .split(" b/")
+
+      a_file_name = file_names.first.strip()
+      b_file_name = file_names.last.strip()
+
+      file_index = file_diff_lines
+        .each_index
+        .detect { |i| file_diff_lines[i].match(FILE_INDEX_REGEX) }
+
+      if file_index.nil?
+        a_file_id = nil
+        b_file_id = nil
+      else
+        a_file_id, b_file_id = file_diff_lines[file_index]
+          .sub("index ", "")
+          .split(" ")
+          .first
+          .split("..")
+      end
+
+      if file_diff_lines.last.match(BINARY_REGEX)
+        operation = :binary
+      elsif (a_file_name != b_file_name)
+        operation = :move
+      elsif (file_diff_lines[1].match(DELETE_OP_REGEX))
+        operation = :delete
+      else
+        operation = :change
+      end
+
+      diff_index = file_diff_lines
+        .each_index
+        .detect { |i| file_diff_lines[i].match(DIFF_REGEX) }
+
+      if diff_index.nil?
+        diffs = []
+      else
+        diffs = file_diff_lines[diff_index..-1]
+          .reduce([], &fold_reducer(DIFF_REGEX))
+          .flat_map { |diff_lines| Diff.from_git(diff_lines) }
+      end
+
+      insertions = diffs.map { |diff| diff.insert_count }.reduce(0, :+)
+      deletions = diffs.map { |diff| diff.delete_count }.reduce(0, :+)
+
+      {
+        operation: operation,
+        a_file_name: a_file_name,
+        b_file_name: b_file_name,
+        a_file_id: a_file_id,
+        b_file_id: b_file_id,
+        diffs: diffs,
+        insertions_total: insertions,
+        deletions_total: deletions,
+        changes_total: insertions + deletions
+      }
+    end
+  end
+end

data/lib/file_helper.rb

@@ -0,0 +1,58 @@
+require "byebug"
+
+require_relative "loggr"
+
+module FileHelper
+  def fdiff_stat(diff)
+    "@@ -#{diff.delete_start},#{diff.delete_count} +#{diff.insert_start},#{diff.insert_count} @@"
+  end
+
+  def print_context(lines, from, to=nil)
+    if to.nil?
+      to = from + 3
+      from -= 4
+    end
+    (from...to).each do |i|
+      line = lines[i]
+      line = "nil" if line.nil?
+      puts "#{i + 1}: #{line}"
+    end
+    nil
+  end
+
+  def compare(commit, file_name, lines, context=nil, diff=nil)
+    if diff.nil?
+      Loggr.instance.info("COMPARE COMMIT: #{commit.id}")
+    else
+      Loggr.instance.info("COMPARE fdiff: #{fdiff_stat(diff)}")
+    end
+
+    real_file = `git show #{commit.id}:#{file_name}`
+      .encode("UTF-8", invalid: :replace)
+      .lines
+      .map(&:chomp)
+
+    return if real_file.length == 0
+    if real_file.length != lines.length && diff.nil?
+      puts "FILE SIZE MISMATCH:"
+      puts "REAL: #{real_file.length}"
+      puts "RECONSTRUCT: #{lines.length}"
+      byebug
+      1
+    end
+
+    lines
+      .each_with_index
+      .map do |line, line_number|
+        if real_file[line_number] != line.gsub(/\r$/, "")
+          puts "MISMATCH: #{commit.id}:#{file_name}"
+          puts "REAL:"
+          print_context(real_file, line_number)
+          puts "RECONSTRUCT"
+          print_context(lines, line_number)
+          byebug
+          1
+        end
+      end
+  end
+end

data/lib/file_manager.rb

@@ -0,0 +1,116 @@
+require "active_support/core_ext/hash"
+
+require_relative "virtual_file_system"
+require_relative "file_helper"
+require_relative "loggr"
+require_relative "store"
+
+class FileManager
+  include FileHelper
+
+  attr_reader :vfs
+
+  def initialize(branch)
+    @branch = branch
+    @vfs = VirtualFileSystem.new()
+  end
+
+  def apply!(commits, meta)
+    vfs.load!(commits, meta)
+      .each do |commit|
+        # TODO: Won't work for first commit...
+        coverage = meta[:coverage].get_report(commit.id, @vfs.file_paths)
+        errors = meta[:errors]&.get_errors!(commit) || []
+        apply_commit!(commit, errors, coverage)
+        Cache.index_commit(@branch, commit.id)
+      end
+  end
+
+  private
+
+  def apply_commit!(commit, errors, coverage)
+    Loggr.instance.info("APPLY COMMIT: #{commit.id}")
+
+    movements = extract_changes(commit.movements)
+    changes = extract_changes(commit.changes)
+
+    commit.trees.each { |diff_tree| @vfs.touch_tree(diff_tree, commit) }
+
+    files = commit
+      .file_diffs
+      .map { |file_name, file_diff| apply_file_diff!(commit, file_diff) }
+
+    changes.each(&method(:merge_change!))
+    movements.each(&method(:merge_movement!))
+
+    merge_coverage!(coverage) if not coverage.nil?
+    errors.each { |error| apply_error!(error) }
+
+    @vfs.save(commit)
+    files.each(&:save)
+  end
+
+  def apply_file_diff!(commit, file_diff)
+    file = @vfs.file_for_diff(commit, file_diff)
+    file.apply_file_diff!(commit, file_diff)
+    compare(commit, file.path, file.plain_text(), nil, nil) if compare?(file)
+    file
+  end
+
+  def apply_error!(error)
+    error[:stack_trace].each_with_index do |trace, i|
+      file = trace_file(trace[:file])
+      if file.nil?
+        Loggr.instance.error("Trace Not Found: #{trace[:file]}:#{trace[:line]} - #{trace[:message]}")
+      else
+        file.merge_error!(error, trace, i) if not file.nil?
+      end
+    end
+  rescue
+    Loggr.instance.error("CANNOT APPLLY ERROR: #{error[:error_id]}")
+  end
+
+  def extract_changes(changes)
+    changes.reduce({}) do |acc, (dest_file, changes)|
+      changes.each do |dest_line, change|
+        acc[dest_file] ||= {}
+        acc[dest_file][dest_line] = @vfs[change[:from]].lines[change[:line]]
+      end
+      acc
+    end
+  end
+
+  def merge_change!(file, file_line_changes)
+    file_line_changes.each do |(line_number, line_change)|
+      @vfs[file].change_line!(line_change, line_number)
+    end
+  end
+
+  def merge_movement!(file, file_line_movements)
+    file_line_movements.each do |(line_number, line_movement)|
+      @vfs[file].move_line!(line_movement, line_number)
+    end
+  end
+
+  # TODO: Technically, file lines aren't covered. Lines at commits are.
+  #    1: To avoid ambiguity, maybe only view trees by commit.
+  def merge_coverage!(coverage)
+    coverage.each do |file, file_coverage|
+      begin
+        @vfs[file].merge_coverage!(file_coverage)
+        @vfs[file].save()
+      rescue => ex
+        Loggr.instance.error("Coverage File Not Found: #{file}")
+      end
+    end
+  end
+
+  def trace_file(trace_file)
+    match = @vfs.file_paths.detect { |app_file| trace_file.include?(app_file) }
+    match.nil? ? nil : @vfs[match]
+  end
+
+  def compare?(file)
+    ENV["GITOLEMY_COMPARE"] == "true" && !file.binary?
+  end
+end

data/lib/function_trace/c_syntax_tracer.rb

@@ -0,0 +1,111 @@
+class CSyntaxTracer
+  def trace(code)
+    code = strip_comments(code)
+    find_funcs(code)
+      .map { |func| define_func(func, code) }
+  rescue
+    []
+  end
+
+  private
+
+  def find_funcs(code)
+    funcs = code.scan(/[a-zA-Z \t]*function\s+[A-Za-z_][A-Za-z0-9_]*/)
+    funcs += code.scan(/[a-zA-Z0-9_. \t]*\s*=\s*function/)
+
+    funcs = funcs
+      .each_with_index
+      .map do |func, index|
+        if func.match(/[a-zA-Z0-9_]*\s+=/)
+          name = func
+            .split("=")
+            .last(2)
+            .first
+            .split(/[ \t.]/)
+            .last
+        else
+          name = func.split(" ").last
+        end
+
+        [name] + code
+          .lines
+          .each_with_index
+          .select { |line, line_num| line.match(func) }
+          .first
+      end
+
+    funcs
+      .each_with_index
+      .map do |func, index|
+        if funcs.count > index + 2
+          func << funcs[index + 1].last
+        else
+          func << code.lines.count
+        end
+        func
+      end
+  end
+
+  def define_func(func, code)
+    function_code = code.lines[func[2]...func[3]]
+    indent = function_code
+      .first
+      .match(/^\s*/)[0]
+
+    close = function_code
+      .each_with_index
+      .select { |line, line_num| line.match(Regexp.compile("^#{indent}}")) }
+      .first
+
+    close ||= function_code
+      .each_with_index
+      .map { |line, line_num| [line.match(/}/), line_num] }
+      .select { |line| line.first }
+      .reverse
+      .first
+
+    end_line = close.nil? ? func[3] : func[2] + close.last + 1
+
+    {
+      name: func.first,
+      start: func[2] + 1,
+      end: end_line
+    }
+  end
+
+  def strip_comments(code)
+    block_captures.each do |block_capture|
+      matches = code.scan(block_capture[:regex])
+      matches.each do |match|
+        code = code.gsub(match, "#{block_capture[:start]} #{block_capture[:type]}" + "\n" * (match.lines.count - 1) + block_capture[:end])
+      end
+    end
+
+    line_captures.each do |line_capture|
+      code = code.gsub(line_capture[:regex], "#{line_capture[:start]} #{line_capture[:type]}")
+    end
+
+    code
+  end
+
+  def line_captures()
+    [
+      {
+        regex: /\/\/.*/,
+        type: "LINE COMMENT",
+        start: "//"
+      }
+    ]
+  end
+
+  def block_captures()
+    [
+      {
+        regex: /\/\*.*?\*\//m,
+        type: "BLOCK QUOTE",
+        start: "/*",
+        end: "*/"
+      }
+    ]
+  end
+end