gitolemy 0.0.4

data/lib/function_trace/python_tracer.rb

@@ -0,0 +1,103 @@
+require "byebug"
+
+class PythonTracer
+  def trace(code)
+    code = strip_comments(code)
+    find_funcs(code)
+      .map { |func| define_func(func, code) }
+  rescue => e
+    byebug
+    []
+  end
+
+  private
+
+  def find_funcs(code)
+    funcs = code.scan(/[ \t]*def\s+[A-Za-z_][A-Za-z0-9_]*.*?\)\:/m)
+
+    funcs = funcs
+      .each_with_index
+      .map do |func, index|
+        name = func.split("(").first.split(" ").last
+
+        [name, func.lines.count] + code
+          .lines
+          .each_with_index
+          .select { |line, line_num| line.match(func.split("(").first) }
+          .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[3]...func[4]]
+    indent = function_code
+      .first[/^\s*/]
+      .size
+
+    close = function_code[func[1]..-1]
+      .each_with_index
+      .select do |line, line_num|
+        line_indent = line[/^\s*/].size
+        line.match(/[^\s]/) && line_indent <= indent
+      end
+      .first
+
+    end_line = close.nil? ? func[4] : func[3] + close.last + func[1]
+    while code.lines[end_line - 1].match(/^\s+$/) do
+      end_line -= 1
+    end
+
+    {
+      name: func.first,
+      start: func[3] + 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.tr("\t", " ")
+  end
+
+  def line_captures()
+    [
+      {
+        regex: /#.*/,
+        type: "LINE COMMENT",
+        start: "#"
+      }
+    ]
+  end
+
+  def block_captures()
+    [
+      {
+        regex: /\/\'''.*?\'''\//m,
+        type: "BLOCK QUOTE",
+        start: "'''",
+        end: "'''"
+      }
+    ]
+  end
+end

data/lib/function_trace/ruby_tracer.rb

@@ -0,0 +1,64 @@
+require "ripper"
+
+class RubyTracer
+  # TODO: Handle other languages...
+  def trace(file)
+    out = Ripper.sexp(file)
+
+    funcs = find_funcs(out.last)
+      .map { |func| define_func(func, file.lines) }
+  rescue
+    []
+  end
+
+  private
+
+  def find_funcs(ast)
+    ast.reduce([]) do |acc, ast|
+      if ast.is_a?(Array)
+        if ast.first == :def
+          acc << ast
+        else
+          ast
+            .select { |tree| tree.is_a?(Array) }
+            .each do |sub_ast|
+              acc << sub_ast if sub_ast.first == :def
+              acc.concat(find_funcs(sub_ast)) if sub_ast.is_a?(Array)
+            end
+        end
+      end
+      acc
+    end
+  end
+
+  def trace_func(ast)
+    ast
+      .reduce([]) do |acc, ast|
+        if ast.is_a?(Array)
+          lines = ast.last
+          if lines.is_a?(Array) && lines.count == 2 && lines.first.is_a?(Integer) && lines.last.is_a?(Integer)
+            acc << lines.first
+          else
+            acc.concat(trace_func(ast))
+          end
+        end
+        acc
+      end
+      .uniq()
+  end
+
+  def define_func(ast, file_lines)
+    name = ast[1][1]
+    lines = trace_func(ast)
+
+    if file_lines[lines.last].strip() == "end"
+      lines << lines.last + 1
+    end
+
+    {
+      name: name,
+      start: lines.first,
+      end: lines.last
+    }
+  end
+end

data/lib/function_trace/tracer.rb

@@ -0,0 +1,44 @@
+require "linguist"
+
+require_relative "ruby_tracer"
+require_relative "c_syntax_tracer"
+require_relative "python_tracer"
+
+class VirtualBlob < Linguist::FileBlob
+  def initialize(path, data)
+    @path = path
+    @data = data
+  end
+
+  def data
+    @data
+  end
+
+  def size
+    @size ||= data.length
+  end
+end
+
+class Tracer
+  def trace(path, code)
+    case recognize(path, code)
+    when "ruby"
+      RubyTracer.new.trace(code)
+    when "php", "javascript"
+      CSyntaxTracer.new.trace(code)
+    when "python"
+      PythonTracer.new.trace(code)
+    else
+      []
+    end
+  end
+
+  private
+
+  def recognize(path, code)
+    Linguist
+      .detect(VirtualBlob.new(path, code))
+      &.name
+      &.downcase
+  end
+end

data/lib/gitolemy.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/**/*.rb"].each {|file| require file }

data/lib/integrations/airbrake_client.rb

@@ -0,0 +1,134 @@
+require "json"
+require "date"
+require "net/http"
+require "active_support/core_ext/hash"
+
+require_relative "../cache"
+require_relative "../store"
+require_relative "error_client"
+
+class AirbrakeClient < ErrorClient
+  PROJECT_ROOT_RGX = /^\[PROJECT_ROOT\]/
+
+  def initialize(config)
+    @key = config["api_key"]
+    @project_id = config["project_id"]
+    @environment = config["environment"]
+    @errors = @key.nil? ? [] : errors()
+    @deploys = @key.nil? ? [] : deploys()
+  end
+
+  private
+
+  def deploys()
+    fetch_deploys()["deploys"]
+      .map do |deploy|
+        {
+          commit_id: deploy["version"].to_sym,
+          environment: deploy["environment"],
+          timestamp: DateTime.parse(deploy["createdAt"])
+        }
+      end
+      .sort_by { |deploy| deploy[:timestamp] }
+      .select { |deploy| deploy[:environment] == @environment }
+  end
+
+  def errors()
+    cached_errors = load_from_cache()
+
+    errors = fetch_groups(cached_errors)["groups"]
+      .flat_map(&method(:select_traces))
+      .reject(&:nil?)
+      .map do |trace|
+        stack_trace = (trace["backtrace"] || [])
+          .reject { |trace| trace["file"].nil? }
+          .map do |trace|
+            file = trace["file"].gsub(PROJECT_ROOT_RGX, "")
+            line = trace["line"]
+            function = trace["function"]
+
+            {
+              file: file,
+              line: line,
+              function: function
+            }
+          end
+
+        {
+          error_id: trace["id"].to_sym,
+          first_time: DateTime.rfc3339(trace["createdAt"]),
+          last_time: DateTime.rfc3339(trace["lastNoticeAt"]),
+          link: "https://airbrake.io/projects/#{@project_id}/groups/#{trace["id"]}",
+          environment: trace["context"]["environment"],
+          type: trace["type"],
+          message: trace["message"],
+          total_occurrences: trace["noticeTotalCount"],
+          stack_trace: stack_trace
+        }
+      end
+      .concat(cached_errors)
+      .select { |error| error[:environment] == @environment }
+      .sort_by { |error| error[:last_time] }
+
+    errors.each { |error| Store::Error::index(error) }
+    Store::Error::cache()
+
+    errors
+  end
+
+  def select_traces(group)
+    notices = fetch_error(group["id"])["notices"]
+    error = notices.first["errors"].first
+    group["backtrace"] = error["backtrace"]
+    group["type"] = error["type"]
+    group["message"] = error["message"]
+    [group]
+  rescue
+    []
+  end
+
+  def fetch_error(group_id)
+    JSON.parse(Net::HTTP.get(
+      URI("https://airbrake.io/api/v4/projects/#{@project_id}/groups/#{group_id}/notices?key=#{@key}")
+    ))
+  end
+
+  def fetch_groups(cached_errors, page=1)
+    errors = {"groups" => [], "count" => 1}
+    while errors["groups"].length < errors["count"] do
+      resp = JSON.parse(Net::HTTP.get(
+        URI("https://airbrake.io/api/v4/projects/#{@project_id}/groups?key=#{@key}&page=#{page}")
+      ))
+
+      errors["count"] = resp["count"]
+
+      while group = resp["groups"].shift() do
+        if cached_errors.detect { |cached_item| cached_item[:error_id] == group["id"].to_sym }
+          return errors
+        else
+          errors["groups"] << group
+        end
+      end
+
+      page += 1
+    end
+    errors
+  rescue
+    errors
+  end
+
+  def fetch_deploys(page=1)
+    deploys = {"deploys" => [], "count" => 1}
+    while deploys["deploys"].length < deploys["count"] do
+      resp = JSON.parse(Net::HTTP.get(
+        URI("https://airbrake.io/api/v4/projects/#{@project_id}/deploys?key=#{@key}&page=#{page}")
+      ))
+
+      deploys["count"] = resp["count"]
+      deploys["deploys"].concat(resp["deploys"])
+
+      page += 1
+    end
+    deploys
+  end
+end

data/lib/integrations/code_climate_client.rb

@@ -0,0 +1,79 @@
+# Consider getting every commit and scoring climate
+
+require "uri"
+require "net/http"
+require "json"
+
+class CodeClimateClient
+  def initialize(config)
+    @api_key = config["api_key"]
+    @org_id = config["org_id"]
+    @repo_id = config["repo_id"]
+  end
+
+  def issues()
+    snapshot = last_snapshot_id()
+    request("repos/#{@repo_id}/snapshots/#{snapshot}/issues")["data"]
+      .reduce({}) do |obj, issue|
+        file = issue.dig("attributes", "location", "path")
+
+        obj[file] ||= {
+          issues: []
+        }
+
+        obj[file][:issues] << {
+          categories: issue.dig("attributes", "categories"),
+          description: issue.dig("attributes", "description"),
+          severity: issue.dig("attributes", "severity"),
+          remediation_points: issue.dig("attributes", "remediation_points"),
+          start_line: issue.dig("attributes", "location", "start_line"),
+          end_line: issue.dig("attributes", "location", "end_line"),
+        }
+
+        obj
+      end
+  end
+
+  def scores()
+    snapshot = last_snapshot_id()
+    request("repos/#{@repo_id}/snapshots/#{snapshot}/files")["data"]
+      .reduce({}) do |obj, file|
+        path = file.dig("attributes", "path")
+        obj[path] ||= {}
+        obj[path][:gpa] ||= file.dig("attributes", "rating")
+        obj
+      end
+  end
+
+  private
+
+  def last_snapshot_id()
+    @last_snapshot_id ||= ref_points()["data"]
+      .map { |ref_point| ref_point["relationships"]["snapshot"] }
+      .select { |snap_shot| snap_shot }
+      .first["data"]["id"]
+  end
+
+  def ref_points()
+    request("repos/#{@repo_id}/ref_points")
+  end
+
+  def request(path)
+    uri = URI.parse("https://api.codeclimate.com/v1/#{path}")
+
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+
+    request = Net::HTTP::Get.new(uri.request_uri)
+    request.initialize_http_header(headers())
+
+    JSON.parse(http.request(request).body)
+  end
+
+  def headers()
+    {
+      "Accept" => "application/vnd.api+json",
+      "Authorization" => "Token token=#{@api_key}"
+    }
+  end
+end

data/lib/integrations/covhura_client.rb

@@ -0,0 +1,38 @@
+require "zlib"
+require "json"
+require "active_support/core_ext/object"
+
+class CovhuraClient
+  ROOT_PATH = Dir.pwd
+
+  def initialize(config)
+  end
+
+  def get_report(commit_id, app_files)
+    filename = File.join(Dir.pwd, ".gitolemy", "coverage", "#{commit_id}.covhura.json.gz")
+    return {} if not File.exist?(filename)
+
+    coverage = JSON.parse(Zlib::GzipReader.open(filename) { |gz| gz.read })
+
+    root_path = coverage_root_path(coverage.keys, app_files)
+    coverage.reduce({}) do |acc, (file_path, file_coverage)|
+      begin
+      acc[file_path.sub(root_path, "")] = file_coverage
+      acc
+      rescue => e
+      byebug
+      1
+      end
+    end
+  end
+
+  private
+
+  def coverage_root_path(coverage_files, app_files)
+    coverage_files.each do |coverage_file|
+      match = app_files.detect { |app_file| coverage_file.include?(app_file) }
+      return coverage_file.sub(match, "") if match
+    end
+    return nil
+  end
+end