gergich 0.0.1

data/lib/gergich/capture.rb

@@ -0,0 +1,77 @@
+module Gergich
+  module Capture
+    class BaseCapture
+      def self.inherited(subclass)
+        name = subclass.name
+        # borrowed from AS underscore, since we may not have it
+        name.gsub!(/.*::|Capture\z/, "")
+        name.gsub!(/([A-Z\d]+)([A-Z][a-z])/, "\\1_\\2")
+        name.gsub!(/([a-z\d])([A-Z])/, "\\1_\\2")
+        name.tr!("-", "_")
+        name.downcase!
+        Capture.captors[name] = subclass
+      end
+    end
+
+    class << self
+      def run(format, command)
+        captor = load_captor(format)
+
+        exit_code, output = run_command(command)
+        comments = captor.new.run(output.gsub(/\e\[\d+m/m, ""))
+
+        draft = Gergich::Draft.new
+        skip_paths = (ENV["SKIP_PATHS"] || "").split(",")
+        comments.each do |comment|
+          next if skip_paths.any? { |path| comment[:path].start_with?(path) }
+          draft.add_comment comment[:path], comment[:position],
+                            comment[:message], comment[:severity]
+        end
+
+        exit_code
+      end
+
+      def run_command(command)
+        output = ""
+        IO.popen("#{command} 2>&1", "r+") do |io|
+          io.each do |line|
+            puts line
+            output << line
+          end
+        end
+        exit_code = $CHILD_STATUS && $CHILD_STATUS.exitstatus || 0
+
+        [exit_code, output]
+      end
+
+      def load_captor(format)
+        if (match = format.match(/\Acustom:(?<path>.+?):(?<class_name>.+)\z/))
+          load_custom_captor(match[:path], match[:class_name])
+        else
+          captor = captors[format]
+          raise GergichError, "Unrecognized format `#{format}`" unless captor
+          captor
+        end
+      end
+
+      def load_custom_captor(path, class_name)
+        begin
+          require path
+        rescue LoadError
+          raise GergichError, "unable to load custom format from `#{path}`"
+        end
+        begin
+          const_get(class_name)
+        rescue NameError
+          raise GergichError, "unable to find custom format class `#{class_name}`"
+        end
+      end
+
+      def captors
+        @captors ||= {}
+      end
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + "/capture/*.rb"].each { |file| require file }

data/lib/gergich/capture/eslint_capture.rb

@@ -0,0 +1,20 @@
+module Gergich
+  module Capture
+    class EslintCapture < BaseCapture
+      def run(output)
+        # e.g. "  4:21  error  Missing semicolon  semi"
+        error_pattern = /\s\s+(\d+):\d+\s+\w+\s+(.*?)\s+[\w-]+\n/
+        pattern = %r{            # Example:
+          ^([^\n]+)\n            #   jsapp/models/user.js
+          ((#{error_pattern})+)  #     4:21  error  Missing semicolon  semi
+        }mx
+
+        output.scan(pattern).map { |file, errors|
+          errors.scan(error_pattern).map { |line, error|
+            { path: file, message: "[eslint] #{error}", position: line.to_i, severity: "error" }
+          }
+        }.compact.flatten
+      end
+    end
+  end
+end

data/lib/gergich/capture/i18nliner_capture.rb

@@ -0,0 +1,22 @@
+module Gergich
+  module Capture
+    class I18nlinerCapture < BaseCapture
+      def run(output)
+        pattern = %r{ # Example:
+          ^\d+\)\n    #   1)
+          (.*?)\n     #   invalid signature on line 4: <unsupported expression>
+          (.*?)\n     #   jsapp/models/user.js
+        }mx
+
+        output.scan(pattern).map { |error, file|
+          line = 1
+          error.sub!(/ on line (\d+)/) do
+            line = Regexp.last_match[1]
+            ""
+          end
+          { path: file, message: "[i18n] #{error}", position: line.to_i, severity: "error" }
+        }.compact
+      end
+    end
+  end
+end

data/lib/gergich/capture/rubocop_capture.rb

@@ -0,0 +1,19 @@
+module Gergich
+  module Capture
+    class RubocopCapture < BaseCapture
+      def run(output)
+        pattern = %r{                     # Example:
+          ^([^:\n]+):(\d+):\d+:\s(.*?)\n  #   bin/gergich:47:8: C: Prefer double-quoted strings
+          ([^\n]+\n                       #   if ENV['DEBUG']
+           [^^\n]*\^+[^^\n]*\n)?          #          ^^^^^^^
+        }mx
+
+        output.scan(pattern).map { |file, line, error, context|
+          context = "\n\n" + context.gsub(/^/, " ") if context
+          { path: file, message: "[rubocop] #{error}#{context}",
+            position: line.to_i, severity: "error" }
+        }.compact
+      end
+    end
+  end
+end

data/lib/gergich/cli.rb

@@ -0,0 +1,82 @@
+require "shellwords"
+require "English"
+
+$stdout.sync = true
+$stderr.sync = true
+
+def info(text)
+  puts text
+  exit
+end
+
+def script_name
+  $PROGRAM_NAME.sub(%r{.*\/}, "")
+end
+
+def usage(content = nil)
+  "Usage: #{script_name} <command> [<args>...]\n" +
+    (content ? "\n#{content}\n\n" : "") +
+    "Tip: run `#{script_name} help <command>` for more info"
+end
+
+def error(text)
+  $stderr.puts "\e[31mError:\e[0m #{text}"
+  $stderr.puts usage
+  exit 1
+end
+
+def help_command(commands)
+  {
+    action: ->(subcommand = "help") {
+      subcommand_info = commands[subcommand]
+      if !subcommand_info
+        error "Unrecognized command `#{subcommand}`"
+      elsif (help_text = subcommand_info[:help])
+        info help_text.respond_to?(:call) ? help_text.call : help_text
+      else
+        error "No help available for `#{subcommand}`"
+      end
+    },
+    help: -> {
+      indentation = commands.keys.map(&:size).sort.last
+      commands_help = commands
+        .to_a
+        .sort_by(&:first)
+        .map { |key, data|
+          "#{key.ljust(indentation)} - #{data[:summary]}" if data[:summary]
+        }
+        .compact
+      usage(commands_help.join("\n"))
+    }
+  }
+end
+
+def run_command(action)
+  params = action.parameters
+  params.each_with_index do |(type, name), i|
+    error "No <#{name}> specified" if i >= ARGV.size && type == :req
+  end
+  if ARGV.size > params.size
+    extra_args = ARGV[params.size, ARGV.size].map { |a| "`#{Shellwords.escape(a)}`" }
+    error "Extra arg(s) #{extra_args.join(' ')}"
+  end
+  action.call(*ARGV)
+end
+
+def run_app(commands)
+  commands["help"] = help_command(commands)
+  command = ARGV.shift || "help"
+
+  if commands[command]
+    begin
+      action = commands[command][:action]
+      run_command(action)
+    rescue GergichError
+      error $ERROR_INFO.message
+    rescue
+      error "Unhandled exception: #{$ERROR_INFO}\n#{$ERROR_INFO.backtrace.join("\n")}"
+    end
+  else
+    error "Unrecognized command `#{command}`"
+  end
+end

data/lib/gergich/cli/gergich.rb

@@ -0,0 +1,247 @@
+# encoding=utf-8
+
+require_relative "../cli"
+require_relative "../../gergich"
+
+CI_TEST_ARGS = {
+  "comment" => [
+    [
+      { path: "foo.rb", position: 3, severity: "error", message: "ಠ_ಠ" },
+      { path: "/COMMIT_MSG", position: 1, severity: "info", message: "cool story bro" },
+      { path: "/COMMIT_MSG", severity: "info", message: "lol",
+        position: { start_line: 1, start_character: 1, end_line: 1, end_character: 2 } }
+    ].to_json
+  ],
+  "label" => ["Code-Review", 1],
+  "message" => ["this is a test"],
+  "capture" => ["rubocop", "echo #{Shellwords.escape(<<-OUTPUT)}"]
+bin/gergich:47:8: C: Prefer double-quoted strings
+if ENV['DEBUG']
+       ^^^^^^^
+OUTPUT
+}.freeze
+
+def run_ci_test!(all_commands)
+  commands_to_test = all_commands - %w[citest reset publish status]
+  commands_to_test << "status" # put it at the end, so we maximize the stuff it tests
+
+  commands = commands_to_test.map { |command| [command, CI_TEST_ARGS[command] || []] }
+  commands.concat all_commands.map { |command| ["help", [command]] }
+
+  # after running our test commands, reset and publish frd:
+  commands << ["reset"]
+  commands << ["label", ["QA-Review", 1]]
+  commands << ["label", ["Product-Review", 1]]
+  commands << ["label", ["Code-Review", 1]]
+  commands << ["message", ["\`gergich citest\` checks out :thumbsup: :mj:"]]
+  commands << ["publish"]
+
+  commands.each do |command, args = []|
+    arglist = args.map { |arg| Shellwords.escape(arg.to_s) }
+    output = `bin/gergich #{command} #{arglist.join(" ")} 2>&1`
+    unless $CHILD_STATUS.success?
+      error "`gergich citest` failed on step `#{command}`:\n\n#{output.gsub(/^/, '  ')}\n"
+    end
+  end
+end
+
+commands = {}
+
+commands["reset"] = {
+  summary: "Clear out pending comments/labels/messages for this patchset",
+  action: ->() {
+    Gergich::Draft.new.reset!
+  },
+  help: -> {
+    <<-TEXT
+gergich reset
+
+Clear out the draft for this patchset. Useful for testing.
+TEXT
+  }
+}
+
+commands["publish"] = {
+  summary: "Publish the draft for this patchset",
+  action: ->() {
+    if (data = Gergich::Review.new.publish!)
+      puts "Published #{data[:total_comments]} comments, set score to #{data[:score]}"
+    else
+      puts "Nothing to publish"
+    end
+  },
+  help: -> {
+    <<-TEXT
+gergich publish
+
+Publish all draft comments/labels/messages for this patchset. no-op if
+there are none.
+
+The cover message and Code-Review label (e.g. -2) are inferred from the
+comments, but labels and messages may be manually set (via `gergich
+message` and `gergich labels`)
+TEXT
+  }
+}
+
+commands["status"] = {
+  summary: "Show the current draft for this patchset",
+  action: ->() {
+    Gergich::Review.new.status
+  },
+  help: -> {
+    <<-TEXT
+gergich status
+
+Show the current draft for this patchset
+
+Display any labels, cover messages and inline comments that will be set
+as part of this review.
+TEXT
+  }
+}
+
+commands["comment"] = {
+  summary: "Add one or more draft comments to this patchset",
+  action: ->(comment_data) {
+    comment_data = begin
+      JSON.parse(comment_data)
+    rescue JSON::ParserError
+      error("Unable to parse <comment_data> json", "comment")
+    end
+    comment_data = [comment_data] unless comment_data.is_a?(Array)
+
+    draft = Gergich::Draft.new
+    comment_data.each do |comment|
+      draft.add_comment comment["path"],
+                        comment["position"],
+                        comment["message"],
+                        comment["severity"]
+    end
+  },
+  help: ->() {
+    <<-TEXT
+gergich comment <comment_data>
+
+<comment_data> is a JSON object (or array of objects). Each comment object
+should have the following properties:
+  path     - the relative file path, e.g. "app/models/user.rb"
+  position - either a number (line) or an object (range). If an object,
+             must have the following numeric properties:
+               * start_line
+               * start_character
+               * end_line
+               * end_character
+  message  - the text of the comment
+  severity - "info"|"warn"|"error" - this will automatically prefix the
+             comment (e.g. "[ERROR] message here"), and the most severe
+             comment will be used to determine the overall Code-Review
+             score (0, -1, or -2 respectively)
+
+Note that a cover message and Code-Review score will be inferred from the
+most severe comment.
+
+Examples
+    gergich comment '{"path":"foo.rb","position":3,"severity":"error",
+                      "message":"ಠ_ಠ"}'
+    gergich comment '{"path":"bar.rb","severity":"warn",
+                      "position":{"start_line":3,"start_character":5,...},
+                      "message":"¯\\_(ツ)_/¯"}'
+    gergich comment '[{"path":"baz.rb",...}, {...}, {...}]'
+TEXT
+  }
+}
+
+commands["message"] = {
+  summary: "Add a draft cover message to this patchset",
+  action: ->(message) {
+    draft = Gergich::Draft.new
+    draft.add_message message
+  },
+  help: ->() {
+    <<-TEXT
+gergich message <message>
+
+<message> will be appended to existing cover messages (inferred or manually
+added) for this patchset.
+TEXT
+  }
+}
+
+commands["label"] = {
+  summary: "Add a draft label (e.g. Code-Review -1) to this patchset",
+  action: ->(label, score) {
+    Gergich::Draft.new.add_label label, score
+  },
+  help: ->() {
+    <<-TEXT
+gergich label <label> <score>
+
+Add a draft label to this patchset. If the same label is set multiple
+times, the lowest score will win.
+
+<label>  - a valid label (e.g. "Code-Review")
+<score>  - a valid score (e.g. -1)
+TEXT
+  }
+}
+
+commands["capture"] = {
+  summary: "Run a command and translate its output into `gergich comment` calls",
+  action: ->(format, command) {
+    require_relative "../../gergich/capture"
+    exit Gergich::Capture.run(format, command)
+  },
+  help: ->() {
+    <<-TEXT
+gergich capture <format> <command>
+
+For common linting formats, `gergich capture` can be used to automatically
+do `gergich comment` calls so you don't have to wire it up yourself.
+
+<format>        - One of the following:
+                  * rubocop
+                  * eslint
+                  * i18nliner
+                  * custom:<path>:<class_name> - file path and ruby
+                    class_name of a custom formatter.
+
+<command>       - The command to run whose output conforms to <format>
+
+Examples:
+    gergich capture rubocop "bundle exec rubocop"
+
+    gergich capture eslint eslint
+
+    gergich capture i18nliner "rake i18nliner:check"
+
+    gergich capture custom:./gergich/xss:Gergich::XSS "node script/xsslint"
+
+TEXT
+  }
+}
+
+commands["citest"] = {
+  summary: "Do a full gergich test based on the current commit",
+  action: ->() {
+    # automagically test any new command that comes along
+    run_ci_test!(commands.keys)
+  },
+  help: ->() {
+    <<-TEXT
+gergich citest
+
+You shouldn't need to run this locally, it runs on jenkins. It does the
+following:
+
+1. runs all the gergich commands (w/ dummy data)
+2. ensure all `help` commands work
+3. ensures gergich status is correct
+4. resets
+5. posts an actual +1
+6. publishes
+    TEXT
+  }
+}
+
+run_app commands