danger-wcc 0.0.2

data/lib/wcc/github.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Github
+  def labels
+    @github_labels ||=
+      github.api.labels(repo_name)
+  end
+
+  def repo_name
+    github.pr_json['base']['repo']['full_name']
+  end
+
+  def pr_number
+    github.pr_json['number']
+  end
+
+  def add_labels(*new_labels)
+    existing = labels.map(&:name)
+    new_labels.reject { |l| existing.include?(l) }.each do |to_create|
+      github.api.add_label(repo_name, to_create)
+    end
+    github.api.add_labels_to_an_issue(repo_name, pr_number, new_labels)
+  end
+end

data/lib/wcc/jshint.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+class Danger::DangerWCC < Danger::Plugin
+  class Jshint
+    include Utils
+
+    DEFAULT_OPTIONS = {
+      directory: 'app/assets/javascripts'
+    }.freeze
+
+    def initialize(plugin, options = {})
+      @plugin = plugin
+      @options = DEFAULT_OPTIONS.merge(options)
+    end
+
+    def perform
+      return unless Dir.exist?(@options[:directory])
+
+      run('PREFIX=/tmp npm install -g jshint')
+      diff = run_jshint_diff
+
+      # run jshint again to get line numbers
+      jshint_lines = run '/tmp/lib/node_modules/jshint/bin/jshint '\
+        "#{@options[:directory]}"
+      jshint_lines = jshint_lines.lines
+
+      each_addition_in_diff(diff) do |line|
+        add_jshint_warning(jshint_lines[line.line_number.right - 1])
+      end
+    end
+
+    private
+
+    def run_jshint_diff
+      diff =
+        run_and_diff do
+          write_jshintrc
+          run('/tmp/lib/node_modules/jshint/bin/jshint '\
+            "#{@options[:directory]} | sed 's/line [0-9]*, col [0-9]*,//g'")
+        end
+      GitDiff.from_string(diff)
+    end
+
+    def write_jshintrc
+      return if File.exist?('.jshintrc')
+
+      default = File.join(File.dirname(__FILE__), 'default.jshintrc')
+      FileUtils.cp(default, './.jshintrc')
+    end
+
+    def add_jshint_warning(with_line_number)
+      return unless warning = with_line_number.match(
+        /^([^\:]+)\:\s+line\s+(\d+),\s+col\s+\d+,\s+(.+)$/i
+      )
+
+      plugin.warn(warning.captures[2],
+        file: warning.captures[0],
+        line: warning.captures[1].to_i)
+    end
+  end
+end

data/lib/wcc/plugin.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+require_relative 'github'
+require_relative 'todos'
+require_relative 'rubocop_exceptions'
+require_relative 'commit_lint'
+require_relative 'reek'
+require_relative 'jshint'
+
+class Danger::DangerWCC < Danger::Plugin
+  include Utils
+  include Github
+
+  CHECKS = %i[
+    rubocop_exceptions
+    todos
+    commit_lint
+    reek
+    flay
+    brakeman
+    jshint
+  ].freeze
+
+  # Runs all the included checks in the plugin
+  def all(options = {})
+    to_run = CHECKS.reject { |check_name| options[check_name] == false }
+    raise ArgumentError, 'No Enabled Checks' if to_run.empty?
+
+    to_run.each do |check_name|
+      public_send(check_name, options.fetch(check_name, {}))
+    end
+  end
+
+  # Checks for added TODOs
+  def todos(options = {})
+    logger.info "TODOs: #{options}"
+    Todos.new(self, options).perform
+  end
+
+  # Checks for if Rubocop was disabled in the source
+  def rubocop_exceptions(options = {})
+    logger.info "rubocop_exceptions: #{options}"
+    RubocopExceptions.new(self, options).perform
+  end
+
+  # Lints the commit messages
+  def commit_lint(options = {})
+    logger.info "commit_lint: #{options}"
+    CommitLint.new(self, DEFAULT_COMMIT_LINT_OPTIONS.merge(options)).perform
+  end
+
+  def reek(options = {})
+    logger.info "reek: #{options}"
+    Reek.new(self, options).perform
+  end
+
+  def brakeman(options = {})
+    logger.info "brakeman: #{options}"
+    diff = run_and_diff('bundle exec brakeman -f tabs 2>/dev/null '\
+      '| sed s@`pwd`/@@ | sed -E "s/([0-9]+)//g"')
+    diff = GitDiff.from_string(diff)
+
+    brakeman_lines = run 'bundle exec brakeman -f tabs 2>/dev/null '\
+      '| sed s@`pwd`/@@'
+    brakeman_lines = brakeman_lines.lines
+
+    each_addition_in_diff(diff) do |line|
+      fields = brakeman_lines[line.line_number.right - 1].split("\t")
+
+      add_brakeman_error(fields, fields[0])
+    end
+  end
+
+  def flay(options = {})
+    logger.info "flay: #{options}"
+    flay_results = parse_flay_results
+
+    each_addition_in_diff do |add, _h, file|
+      search = "#{file.b_path}:#{add.line_number.right}"
+      flay_results.each do |warning, lines|
+        other = lines.reject { |l| l == search }
+        next unless other.length < lines.length
+
+        add_flay_warning(warning, other, file, add)
+      end
+    end
+  end
+
+  def jshint(options = {})
+    logger.info "jshint: #{options}"
+    Jshint.new(self, options).perform
+  end
+
+  private
+
+  def parse_flay_results
+    flay = run('bundle exec flay app/**/*.rb lib/**/*.rb')
+    flay_results = {}
+    current = nil
+    flay.lines.each do |flay_line|
+      if m = flay_line.match(/^\d+\)\s+(.+)$/i)
+        current = []
+        flay_results[m.captures[0]] = current
+      elsif current && flay_line =~ /^\s+.+\:\d+\s*$/i
+        current << flay_line.strip!
+      end
+    end
+    flay_results
+  end
+
+  def add_brakeman_error(fields, file)
+    message = "#{fields[2]} #{fields[3]} #{fields[4]} confidence: #{fields[5]}"
+    fail(message, file: file, line: fields[1].to_i)
+  end
+
+  def add_flay_warning(warning, other, file, line)
+    other = other.map { |l| github.html_link(l.gsub(/\:/, '#L')) }
+    message = "#{warning} at:\n  " + other.join("\n  ")
+    warn(message, file: file.b_path, line: line.line_number.right)
+  end
+
+  DEFAULT_COMMIT_LINT_OPTIONS = {
+    warn: :all,
+    disable: %i[subject_period subject_cap],
+    subject_length: { max: 72 }
+  }.freeze
+end

data/lib/wcc/reek.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+class Danger::DangerWCC < Danger::Plugin
+  class Reek
+    include Utils
+
+    def initialize(plugin, options = {})
+      @plugin = plugin
+      @options = options
+    end
+
+    def perform
+      # get the diff of new reek issues
+      diff = run_reek_diff
+
+      # run reek again to get line numbers
+      reek_lines = run 'bundle exec reek --single-line --no-progress --no-color'
+      reek_lines = reek_lines.lines
+
+      each_addition_in_diff(diff) do |line|
+        add_reek_warning(line, reek_lines[line.line_number.right - 1])
+      end
+    end
+
+    private
+
+    def run_reek_diff
+      diff =
+        run_and_diff do
+          write_reek_config
+          run('bundle exec reek --single-line --no-progress '\
+          '--no-color --no-line-numbers')
+        end
+      GitDiff.from_string(diff)
+    end
+
+    def write_reek_config
+      return if File.exist?('.reek')
+      return unless Dir.glob('*.reek').empty?
+
+      default = File.join(File.dirname(__FILE__), 'defaults.reek')
+      FileUtils.cp(default, './')
+    end
+
+    def add_reek_warning(line, with_line_number)
+      return unless warning = line.content.match(/^\+?\s*([^\:]+\:\s+.+)$/i)
+
+      line_info = with_line_number.match(/^\s*([^\:]+)\:(\d+)\:/i)
+      plugin.warn(format_links_as_markdown(warning.captures[0]),
+        file: line_info.captures[0],
+        line: line_info.captures[1].to_i)
+    end
+  end
+end

data/lib/wcc/rubocop_exceptions.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+class Danger::DangerWCC < Danger::Plugin
+  class RubocopExceptions
+    include Utils
+
+    DISABLE_REGEX = /^(?:\+\s)?.*\#\s*rubocop\:disable\s+(\S+)/i
+    ENABLE_REGEX = /^(?:\+\s)?\s*\#\s*rubocop\:enable\s+(\S+)/i
+    COMMENT_LINE_REGEX = /^(?:\+\s)?\s*\#\s*(.+)$/i
+
+    def initialize(plugin, options = {})
+      @plugin = plugin
+      @options = options
+    end
+
+    def perform
+      find_new_exceptions.each do |e|
+        message = build_message(e)
+        severity = message_severity(e)
+        issue(message,
+          severity: severity, file: e[:file], line: e[:disabled_at])
+      end
+    end
+
+    private
+
+    def build_message(e)
+      message = "Rubocop rule #{e[:rule]} disabled in"\
+                  " #{plugin.github.html_link(e[:file])}"
+      message +=
+        if !e[:context_lines].empty?
+          "  explanation:\n\t> " + e[:context_lines].join("\n\t> ")
+        else
+          "  \nPlease provide an explanation why this rule was disabled."
+        end
+      unless e[:reenabled]
+        message += "\n\nThe rule was not reenabled!\n"\
+          'Please add a `rubocop:enable` comment so the rule is disabled '\
+          'for the minimal scope.'
+      end
+      message
+    end
+
+    def message_severity(e)
+      if !e[:reenabled]
+        'fail'
+      elsif e[:context_lines].empty?
+        'warn'
+      else
+        'message'
+      end
+    end
+
+    def find_new_exceptions
+      find_in_diff(DISABLE_REGEX) do |m, line, hunk, file, _diff|
+        make_violation(File.read(file.b_path), hunk, line, m.captures[0])
+          .merge!(file: file.b_path)
+      end
+    end
+
+    def make_violation(file_contents, hunk, line, rule)
+      reenable_line_offset = find_reenable(file_contents,
+        line.line_number.right,
+        rule)
+
+      {
+        rule: rule,
+        disabled_at: line.line_number.right,
+        reenabled: !reenable_line_offset.nil?,
+        context_lines: find_context(hunk.lines.drop(hunk.lines.index(line)))
+      }
+    end
+
+    def find_context(diff_lines)
+      # search for all non-`rubocop:` comment lines immediately
+      # preceding this disable which were added by this hunk
+      diff_lines
+        .drop_while { |l| rubocop_line?(l) }
+        .take_while { |l| l.addition? && l.content =~ COMMENT_LINE_REGEX }
+        .map { |l| l.content.match(COMMENT_LINE_REGEX).captures[0] }
+    end
+
+    def find_reenable(file_contents, line_number, rule)
+      # search for the reenabling of this line
+      length_to_end = file_contents.lines.length - line_number
+      file_contents.lines[line_number, length_to_end]
+        .find_index do |l|
+          m = l.match(ENABLE_REGEX)
+          !m.nil? && rule.casecmp(m.captures[0]) == 0
+        end
+    end
+
+    def rubocop_line?(l)
+      l.content =~ DISABLE_REGEX || l.content =~ ENABLE_REGEX
+    end
+  end
+end

data/lib/wcc/todos.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+class Danger::DangerWCC < Danger::Plugin
+  class Todos
+    include Utils
+
+    TODO_REGEX = /^\+.*\#.*TODO:?/i
+    LINK_REGEX = /\#.*(https?\:\/\/\S+)/i
+
+    def initialize(plugin, options = {})
+      @plugin = plugin
+      @options = options
+    end
+
+    def perform
+      find_new_todos.each do |result|
+        issue_message(result)
+      end
+    end
+
+    private
+
+    def issue_message(result)
+      if result[:link]
+        plugin.message "TODO added in #{result[:file_link]} "\
+          "referencing [#{result[:link]}](#{result[:link]})",
+          file: result[:file], line: result[:line]
+      else
+        plugin.warn "TODO added in #{result[:file_link]} - "\
+          'is there a card associated with that?',
+          file: result[:file], line: result[:line]
+      end
+    end
+
+    def find_new_todos
+      find_in_diff(TODO_REGEX) do |_m, line, _hunk, file, _diff|
+        make_violation(file, line)
+      end
+    end
+
+    def make_violation(file, todo_line)
+      link_line_number, link = find_link_in_context(file, todo_line)
+
+      {
+        link: link,
+        file: file.b_path,
+        file_link: @plugin.github.html_link(file.b_path),
+        line: max(link_line_number, todo_line.line_number.right),
+        warn: link.nil?
+      }
+    end
+
+    def grab_context_lines(file, line_number)
+      contents = File.read(file.b_path)
+      # grab the line and the lines immediately before and after it
+      contents.lines[max(line_number - 2, 0)..line_number]
+    end
+
+    def find_link_in_context(file, line)
+      context = grab_context_lines(file, line.line_number.right)
+      context.each_with_index do |l, i|
+        if m = l.match(LINK_REGEX)
+          # line at index 0 in the context array is (line.line_number.right - 1)
+          return [line.line_number.right - 1 + i, m.captures[0]]
+        end
+      end
+      nil
+    end
+
+    def max(a, b)
+      return a if b.nil?
+      return b if a.nil?
+      a > b ? a : b
+    end
+  end
+end