gitolemy 0.0.4

data/lib/store.rb

@@ -0,0 +1,96 @@
+require_relative "cache"
+
+module Store
+  def Store.read(set, key)
+    set[key]
+  end
+
+  def Store.write(set, key, value)
+    set[key] = value
+    key
+  end
+
+  def Store.cache(cache_key, new, old)
+    Cache.write(cache_key, new, old)
+  end
+
+  module Commit
+    @@commits = {}
+    def Commit.[](commit_id)
+      ::Store::read(@@commits, commit_id)
+    end
+
+    def Commit.index(commit)
+      ::Store::write(@@commits, commit[:commit_id], commit)
+    end
+
+    def Commit.cache(old={})
+      ::Store::cache("commits", @@commits, Cache.read("commits", {}))
+    end
+  end
+
+  module Line
+    @@lines = {}
+    def Line.[](line_id)
+      ::Store::read(@@lines, line_id)
+    end
+
+    def Line.index(line)
+      ::Store::write(@@lines, line[:line_id], line)
+    end
+
+    def Line.cache()
+      ::Store::cache("lines", @@lines, Cache.read("lines", {}))
+    end
+  end
+
+  module Issue
+    @@issues = {}
+    def Issue.[](issue_id)
+      ::Store::read(@@issues, issue_id)
+    end
+
+    def Issue.index(issue)
+      ::Store::write(@@issues, issue[:issue_id], issue)
+    rescue
+      issue
+    end
+
+    def Issue.cache(old={})
+      ::Store::cache("issues", @@issues, old)
+    end
+  end
+
+  module Bug
+    @@bugs = {}
+    def Bug.[](bug_id)
+      ::Store::read(@@bugs, bug_id)
+    end
+
+    def Bug.index(bug)
+      ::Store::write(@@bugs, bug[:bug_id], bug)
+    rescue
+      bug
+    end
+
+    def Bug.cache(old={})
+      ::Store::cache("bugs", @@bugs, old)
+    end
+  end
+
+
+  module Error
+    @@errors = {}
+    def Error.[](error_id)
+      ::Store::read(@@errors, error_id)
+    end
+
+    def Error.index(error)
+      ::Store::write(@@errors, error[:error_id], error)
+    end
+
+    def Error.cache(old={})
+      ::Store::cache("errors", @@errors, old)
+    end
+  end
+end

data/lib/util.rb

@@ -0,0 +1,10 @@
+def fold_reducer(regex)
+  lambda do |acc, line|
+    if line.match(regex)
+      acc << [line]
+    else
+      acc.last << line
+    end
+    acc
+  end
+end

data/lib/virtual_file.rb

@@ -0,0 +1,218 @@
+require "active_support/core_ext/object"
+require "date"
+
+require_relative "loggr"
+require_relative "line"
+require_relative "function_trace/tracer"
+require_relative "virtual_function"
+
+class VirtualFile
+
+  attr_reader :lines
+  attr_reader :path
+  attr_reader :file_id
+  attr_reader :issues
+  attr_reader :commits
+  attr_reader :business_value
+
+  def initialize(file_path, diff=nil)
+    @path = file_path
+    @file_id = nil
+    @previous_file_id = nil
+    @touched_at_times = []
+    @commits = []
+    @issues = []
+    @bugs = []
+    @lines = []
+    @functions = []
+    @business_value = 0
+    @is_binary = diff.blank? ? false : diff.operation == :binary
+  end
+
+  def self.from_json(file_id, json)
+    file = VirtualFile.new(json["path"])
+    touched_at_times = (json["touched_at_times"] || []).map { |time| DateTime.rfc3339(time) }
+    lines = (json["lines"] || []).map { |line| line.deep_symbolize_keys }
+    functions = (json["functions"] || []).map { |function| function.deep_symbolize_keys }
+
+    file.instance_variable_set(:@file_id, file_id)
+    file.instance_variable_set(:@previous_file_id, json["previous_file_id"])
+    file.instance_variable_set(:@touched_at_times, touched_at_times)
+    file.instance_variable_set(:@lines, lines)
+    file.instance_variable_set(:@functions, functions)
+    file.instance_variable_set(:@commits, json["commits"] || [])
+    file.instance_variable_set(:@issues, json["issues"] || [])
+    file.instance_variable_set(:@bugs, json["bugs"] || [])
+    file.instance_variable_set(:@business_value, json["business_value"] || 0)
+    file.instance_variable_set(:@is_binary, false)
+    file
+  end
+
+  def touch(commit, file_diff)
+    @path = file_diff.b_file_name
+    @file_id = file_diff.b_file_id if not file_diff.b_file_id.nil?
+    @previous_file_id = file_diff.a_file_id
+    @touched_at_times << commit.date
+    @commits << commit.id
+    @issues << commit.issue_id if commit.issue_id.present?
+    @bugs << commit.bug_id if commit.bug_id.present?
+    @business_value += diff_business_value(commit, file_diff)
+  end
+
+  def save()
+    @functions = Tracer
+      .new
+      .trace(@path, as_text())
+      .map { |function| VirtualFunction.new(function, @path, @lines) }
+
+    Cache::write_object(@file_id, as_json())
+  end
+
+  def apply_file_diff!(commit, file_diff)
+    touch(commit, file_diff)
+    return if binary?
+
+    context = file_diff.diffs
+      .reduce(new_context(commit), &method(:apply_diff))
+
+    new_lines = context[:new_lines]
+
+    unchanged_lines = @lines[context[:position]..-1]
+    new_lines.concat(unchanged_lines) if unchanged_lines
+
+    @lines = new_lines
+  end
+
+  def binary?
+    @is_binary
+  end
+
+  def plain_text
+    @lines.map { |line| line[:text] }
+  end
+
+  def created_at
+    @touched_at_times.first
+  end
+
+  def last_updated_at
+    @touched_at_times.last
+  end
+
+  def change_line!(line_change, line_number)
+    @lines[line_number] = Line::change!(line_change, @lines[line_number])
+  end
+
+  def move_line!(line_movement, line_number)
+    line = @lines[line_number]
+    if line_movement[:text].strip() != line[:text].strip()
+      # TODO: raise reconstruction error.
+      Loggr.instance.warn("MISMATCH: #{line[:text]} VS #{line_movement[:text]}")
+    else
+      @lines[line_number] = Line::move!(line_movement, line)
+    end
+  end
+
+  def merge_coverage!(file_coverage)
+    @lines.each_with_index do |line, index|
+      line[:coverage] = file_coverage.dig("lines", (index + 1).to_s, "hits")
+    end
+  end
+
+  def merge_error!(error, trace, depth)
+    line = @lines[trace[:line] - 1]
+    Line::merge_error!(line, error, depth)
+  end
+
+  def as_json()
+    {
+      path: @path,
+      previous_file_id: @previous_file_id,
+      lines: @lines,
+      functions: @functions.map { |function| function.as_json() },
+      commits: @commits,
+      issues: @issues,
+      business_value: @business_value,
+      bugs: @bugs
+    }
+  end
+
+  def revisions_total()
+    @lines
+      .map { |line| line[:revisions].count }
+      .reduce(0, &:+)
+  end
+
+  def errors_total()
+    @lines
+      .map do |line|
+        line[:revisions].flat_map { |revision| revision[:errors] }.count +
+          line[:errors].count
+      end
+      .reduce(0, &:+)
+  end
+
+  def buggy_lines_total()
+    @lines
+      .map do |line|
+        line[:revisions].flat_map { |revision| revision[:bugs] }.count +
+          line[:bugs].count
+      end
+      .reduce(0, &:+)
+  end
+
+  def covered_lines
+    @lines
+      .select { |line| line[:coverage] != nil && line[:coverage] > 0 }
+      .count
+  end
+
+  def uncovered_lines
+    @lines
+      .select { |line| line[:coverage] == 0 }
+      .count
+  end
+
+  private
+
+  def as_text()
+    @lines
+      .map { |line| line[:text] }
+      .join("\n")
+  end
+
+  def apply_diff(acc, diff)
+    delete_start = diff.delete_start
+    delete_count = diff.delete_count
+    copy_end = delete_count == 0 ?
+      delete_start :
+      delete_start - 1
+
+    new_lines = diff.insertions
+      .each_with_index
+      .map do |line, index|
+        line_num = diff.insert_start + index
+        Line::new_line(line, @path, line_num, acc[:commit])
+      end
+    unchanged_lines = acc[:existing_lines][acc[:position]...copy_end]
+
+    acc[:new_lines].concat(unchanged_lines) if unchanged_lines
+    acc[:position] = copy_end + delete_count
+
+    acc[:new_lines].concat(new_lines)
+    acc
+  end
+
+  def diff_business_value(commit, file_diff)
+    (file_diff.changes_total / commit.changes_total.to_f) * commit.business_value
+  end
+
+  def new_context(commit)
+    {
+      position: 0,
+      new_lines: [],
+      existing_lines: @lines,
+      commit: commit
+    }
+  end
+end

data/lib/virtual_file_system.rb

@@ -0,0 +1,78 @@
+require_relative "virtual_tree"
+require_relative "virtual_file"
+require_relative "cache"
+require_relative "store"
+require "active_support/core_ext/module/delegation"
+
+class VirtualFileSystem
+
+  attr_reader :root
+
+  def initialize()
+    @root = VirtualTree.new({path: ""}, {})
+  end
+
+  def [](file_name)
+    @root.get_file(file_name)
+  end
+
+  def file_for_diff(commit, diff)
+    if diff.operation == :move
+      @root.move_file(diff.a_file_name, diff.b_file_name)
+    elsif diff.operation == :delete
+      @root.delete_file(diff.a_file_name)
+    else
+      file_name = diff.b_file_name
+      file = @root.get_file(file_name)
+      file = @root.set_file(file_name, VirtualFile.new(file_name, diff)) if file.nil?
+      file
+    end
+  end
+
+  def load!(commits, meta)
+    commit = commits.first
+    return commits if commit.nil? || commit.cached_files.nil?
+    commit.cached_trees.each do |tree_object|
+      tree_id = tree_object[:object_id]
+      cached_tree = Cache.read_object(tree_id)
+      @root.add_tree(VirtualTree.from_json(cached_tree))
+    end
+    commit.cached_files.each do |file_object|
+      file_id = file_object[:object_id]
+      cached_file = Cache.read_object(file_id)
+      if not cached_file.nil?
+        @root.set_file(file_object[:path], VirtualFile.from_json(file_id, cached_file))
+      end
+    end
+    sync_meta!(commit, meta)
+    commits
+  end
+
+  def touch_tree(diff_tree, commit)
+    @root.touch(diff_tree, commit)
+  end
+
+  def save(commit)
+    prune(commit)
+    @root.save(commit)
+  end
+
+  def file_paths
+    root
+      .all_files()
+      .map { |file| file.path }
+  end
+
+  private
+
+  def prune(commit)
+    commit
+      .trees
+      .reverse()
+      .each { |diff_tree| @root.prune(diff_tree, commit) }
+  end
+
+  def sync_meta!(commit, meta)
+    meta[:errors] && meta[:errors].sync!(commit)
+  end
+end

data/lib/virtual_function.rb

@@ -0,0 +1,38 @@
+class VirtualFunction
+  def initialize(function, file, lines)
+    @name = function[:name]
+    @file = file
+    @start = function[:start]
+    @end = function[:end]
+    @lines = lines[(@start - 1)..@end]
+  end
+
+  def as_json()
+    commits = {}
+    issues = {}
+    errors = {}
+    bugs = {}
+    score = 0
+
+    @lines.each do |line|
+      commits[line[:commit]] = true
+      line[:revisions].each { |revision| commits[revision[:commit]] = true }
+      line[:issues].each { |issue| issues[issue] = true }
+      line[:errors].each { |error| errors[error] = true }
+      line[:bugs].each { |bug| bugs[bug] = true }
+      score += Line.score(line)
+    end
+
+    {
+      name: @name,
+      file: @file,
+      start: @start,
+      end: @end,
+      bugs: bugs.keys,
+      commits: commits.keys,
+      issues: issues.keys,
+      errors: errors.keys,
+      score: score
+    }
+  end
+end

data/lib/virtual_tree.rb

@@ -0,0 +1,233 @@
+require "active_support/core_ext/object"
+
+require_relative "cache"
+
+class VirtualTree
+  attr_reader :path
+  attr_reader :tree_id
+  attr_reader :previous_tree_id
+  attr_reader :issues
+  attr_reader :commits
+  attr_reader :files
+  attr_reader :trees
+
+  def initialize(diff_tree, commit)
+    @path = diff_tree[:path]
+    @tree_id = nil
+    @previous_tree_id = nil
+    @commits = []
+    @issues = []
+    @files = {}
+    @trees = {}
+  end
+
+  def self.from_json(tree_json)
+    new_tree = VirtualTree.new({path: tree_json["path"]}, {})
+    new_tree.instance_variable_set(:@commits, tree_json["commits"])
+    new_tree.instance_variable_set(:@issues, tree_json["issues"])
+    new_tree.instance_variable_set(:@tree_id, tree_json["tree_id"])
+    new_tree.instance_variable_set(:@previous_tree_id, tree_json["previous_tree_id"])
+    new_tree
+  end
+
+  def get_file(file_path)
+    file_subtree(file_path).files[file_path]
+  end
+
+  def set_file(file_path, file)
+    file_subtree(file_path).files[file_path] = file
+  end
+
+  def delete_file(file_path)
+    file_subtree(file_path)
+      .files
+      .delete(file_path)
+  end
+
+  def move_file(a_file_name, b_file_name)
+    file = get_file(a_file_name)
+    delete_file(a_file_name)
+    set_file(b_file_name, file)
+  end
+
+  # TODO: What happens when a tree moves??
+  def touch(diff_tree, commit)
+    if @path == diff_tree[:path]
+      @previous_tree_id = diff_tree[:a_tree_id]
+      @tree_id = diff_tree[:b_tree_id]
+      @commits << commit.id
+      @issues << commit.issue_id if commit.issue_id.present?
+    else
+      find_or_create_subtree!(diff_tree, commit).touch(diff_tree, commit)
+    end
+  end
+
+  def prune(diff_tree, commit)
+    return if diff_tree[:operation] != :delete
+
+    tree_name = tree_name(diff_tree[:path])
+    subtree(file_tree_path(diff_tree[:path]))
+      .trees
+      .delete(tree_name)
+  end
+
+  def all_files()
+    @trees
+      .values
+      .flat_map { |tree| tree.all_files() }
+      .concat(@files.values)
+  end
+
+  # TODO: Figure out how to save only when something changes.
+  def save(commit)
+    trees_json = @trees
+      .values
+      .map { |tree| tree.save(commit) }
+
+    json = trees_json
+      .reduce(as_json()) do |acc, tree_json|
+        [
+            :lines,
+            :covered_lines,
+            :uncovered_lines,
+            :changes,
+            :errors,
+            :buggy_lines,
+            :business_value
+          ].each do |key|
+            acc[key] += tree_json[key]
+          end
+
+        acc
+      end
+
+    relevant_lines = json[:covered_lines] + json[:uncovered_lines]
+    json[:coverage_percent] = relevant_lines > 0 ?
+      (json[:covered_lines] / relevant_lines.to_f * 100).round :
+      0
+
+    json[:trees] = trees_json.map(&method(:slim_tree_json))
+
+    tree_id = @tree_id.present? ? @tree_id : commit.id
+    Cache.write_object(tree_id, json)
+
+    json
+  end
+
+  def add_tree(tree)
+    tree_name = tree_name(tree.path)
+    subtree = subtree(tree.path)
+    if subtree.path == tree.path
+      Loggr.instance.warn("Cannot add pre-existing tree: #{tree.path}")
+    else
+      subtree.trees[tree_name] = tree
+    end
+  end
+
+  def as_json()
+    stats = @files
+      .values
+      .reduce(new_context()) do |acc, file|
+        acc[:business_value] += file.business_value
+        acc[:lines] += file.lines.count
+        acc[:covered_lines] += file.covered_lines
+        acc[:uncovered_lines] += file.uncovered_lines
+        acc[:buggy_lines] += file.buggy_lines_total
+        acc[:changes] += file.revisions_total
+        acc[:errors] += file.errors_total
+        acc
+      end
+
+    {
+      path: @path,
+      tree_id: @tree_id,
+      previous_tree_id: @previous_tree_id,
+      issues: @issues,
+      commits: @commits,
+      files: @files.values.map(&method(:file_json))
+    }.merge(stats)
+  end
+
+  private
+
+  def subtree(path)
+    dirs = path.split(File::SEPARATOR)
+    subtree = self
+    while dirs.length > 0
+      path = dirs.shift()
+      subtree = subtree.trees[path] if subtree.trees.has_key?(path)
+    end
+    subtree
+  end
+
+  def file_tree_path(file_path)
+    file_path
+      .split(File::SEPARATOR)[0..-2]
+      .join(File::SEPARATOR)
+  end
+
+  def tree_name(tree_path)
+    tree_path
+      .split(File::SEPARATOR)
+      .last
+  end
+
+  def file_subtree(file_path)
+    subtree(file_tree_path(file_path))
+  end
+
+  def find_or_create_subtree!(diff_tree, commit)
+    subtree = subtree(diff_tree[:path])
+    if subtree.path != diff_tree[:path]
+      subtree_path = diff_tree[:path]
+        .split(File::SEPARATOR)
+        .last
+      subtree.trees[subtree_path] = subtree = VirtualTree.new(diff_tree, commit)
+    end
+    subtree
+  end
+
+  def slim_tree_json(tree_json)
+    {
+      path: tree_json[:path],
+      tree_id: tree_json[:tree_id],
+      commits: tree_json[:commits].length,
+      issues: tree_json[:commits].length,
+      business_value: tree_json[:business_value],
+      lines: tree_json[:lines],
+      changes: tree_json[:changes],
+      errors: tree_json[:errors],
+      buggy_lines: tree_json[:buggy_lines],
+      covered_lines: tree_json[:covered_lines],
+      uncovered_lines: tree_json[:uncovered_lines]
+    }
+  end
+
+  def file_json(file)
+    {
+      path: file.path,
+      file_id: file.file_id,
+      commits: file.commits.length,
+      issues: file.issues.length,
+      business_value: file.business_value,
+      lines: file.lines.count,
+      changes: file.revisions_total,
+      errors: file.errors_total,
+      buggy_lines: file.buggy_lines_total,
+      covered_lines: file.covered_lines,
+      uncovered_lines: file.uncovered_lines
+    }
+  end
+
+  def new_context()
+    {
+      business_value: 0,
+      lines: 0,
+      changes: 0,
+      errors: 0,
+      buggy_lines: 0,
+      covered_lines: 0,
+      uncovered_lines: 0
+    }
+  end
+end