nucop 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f9fc165f5dbcc9624bfd5ed3c1c372f3f81ff325ca44d59990c4db36a2f0da39
+  data.tar.gz: a10769b0dc3d5de55c23442b4d27ea6bedecde3db859b3e679b5583c2b3e9846
+SHA512:
+  metadata.gz: 43218b9441df727be126479a83813cbfc048af1a472f1fc1a5dc365871eaad0cf95bab8b091abf34238243dd3f3843fe0d0408a57e59a17193de288f0e2ed697
+  data.tar.gz: 986be2c74320253d2746d25229fd9ad724f61029e1200d7b447b7373aa83ec813921af6bd3745eff5d0cd92e5f51c69a7176881bde42a2f95526cfc1311bd6ab

data/bin/nucop

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+
+require "nucop"
+require "nucop/cli"
+
+Nucop::CLI.start(ARGV)

data/lib/nucop.rb

@@ -0,0 +1,11 @@
+require "nucop/version"
+
+require "rubocop"
+require "git_diff_parser"
+
+Dir[File.join(__dir__, "nucop/helpers/**/*.rb")].each { |f| require f }
+Dir[File.join(__dir__, "nucop/formatters/**/*.rb")].each { |f| require f }
+Dir[File.join(__dir__, "nucop/cops/**/*.rb")].each { |f| require f }
+
+module Nucop
+end

data/lib/nucop/cli.rb

@@ -0,0 +1,268 @@
+require "thor"
+require "open3"
+
+RUBOCOP_DEFAULT_CONFIG_FILE = ".rubocop.yml"
+CONFIGURATION_FILEPATH = ".nucop.yml"
+
+module Nucop
+  class CLI < Thor
+    desc "diff_enforced", "run RuboCop on the current diff using only the enforced cops"
+    method_option "commit-spec", default: "origin/master", desc: "the commit used to determine the diff."
+    method_option "auto-correct", type: :boolean, default: false, desc: "runs RuboCop with auto-correct option"
+    method_option "junit_report", type: :string, default: "", desc: "runs RuboCop with junit formatter option"
+    def diff_enforced
+      invoke :diff, nil, options.merge(only: cops_to_enforce.join(","))
+    end
+
+    desc "diff", "run RuboCop on the current diff"
+    method_option "commit-spec", default: "origin/master", desc: "the commit used to determine the diff."
+    method_option "only", desc: "run only specified cop(s) and/or cops in the specified departments"
+    method_option "auto-correct", type: :boolean, default: false, desc: "runs RuboCop with auto-correct option"
+    method_option "ignore", type: :boolean, default: true, desc: "ignores files specified in #{options[:diffignore_file]}"
+    method_option "added-only", type: :boolean, default: false, desc: "runs RuboCop only on files that have been added (not on files that have been modified)"
+    method_option "exit", type: :boolean, default: true, desc: "disable to prevent task from exiting. Used by other Thor tasks when invoking this task, to prevent parent task from exiting"
+    def diff
+      puts "Running on files changed relative to '#{options[:"commit-spec"]}' (specify using the 'commit-spec' option)"
+      diff_filter = options[:"added-only"] ? "A" : "d"
+      diff_base = capture_std_out("git merge-base HEAD #{options[:"commit-spec"]}").chomp
+
+      files, diff_status = Open3.capture2("git diff #{diff_base} --diff-filter=#{diff_filter} --name-only | grep \"\\.rb$\"")
+
+      if diff_status != 0
+        if options[:exit]
+          puts "There are no rb files present in diff. Exiting."
+          exit 0
+        else
+          puts "There are no rb files present in diff."
+          return true
+        end
+      end
+
+      if options[:ignore] && File.exist?(options[:diffignore_file]) && !File.zero?(options[:diffignore_file])
+        files, non_ignored_diff_status = Open3.capture2("grep -v -f #{options[:diffignore_file]}", stdin_data: files)
+
+        if non_ignored_diff_status != 0
+          if options[:exit]
+            puts "There are no non-ignored rb files present in diff. Exiting."
+            exit 0
+          else
+            puts "There are no non-ignored rb files present in diff."
+            return true
+          end
+        end
+      end
+
+      no_violations_detected = invoke :rubocop, [multi_line_to_single_line(files)], options
+
+      exit 1 unless no_violations_detected
+      return true unless options[:exit]
+      exit 0
+    end
+
+    desc "rubocop", "run RuboCop on files provided"
+    method_option "only", desc: "run only specified cop(s) and/or cops in the specified departments"
+    method_option "auto-correct", type: :boolean, default: false, desc: "runs RuboCop with auto-correct option"
+    method_option "exclude-backlog", type: :boolean, default: false, desc: "when true, uses config which excludes violations in the RuboCop backlog"
+    def rubocop(files = nil)
+      print_cops_being_run(options[:only])
+      config_file = options[:"exclude-backlog"] ? RUBOCOP_DEFAULT_CONFIG_FILE : options[:rubocop_todo_config_file]
+      junit_report_path = options[:"junit_report"]
+      junit_report_options = junit_report_path.to_s.empty? ? "" : "--format Nucop::Formatters::JUnitFormatter --out #{junit_report_path} --format progress"
+
+      rubocop_requires = [
+        "--require rubocop-rspec",
+        "--require rubocop-performance",
+        "--require rubocop-rails"
+      ]
+
+      system("bundle exec rubocop --parallel #{rubocop_requires.join(' ')} #{junit_report_options} --force-exclusion --config #{config_file} #{pass_through_option(options, 'auto-correct')} #{pass_through_flag(options, 'only')} #{files}")
+    end
+
+    desc "regen_backlog", "update the RuboCop backlog, disabling offending files and excluding all cops with over 500 violating files."
+    method_option "exclude-limit", type: :numeric, default: 500, desc: "Limit files listed to this limit. Passed to RuboCop"
+    def regen_backlog
+      regenerate_rubocop_todos
+      update_enforced_cops
+    end
+
+    desc "update_enforced", "update the enforced cops list with file with cops that no longer have violations"
+    def update_enforced
+      update_enforced_cops
+    end
+
+    desc "modified_lines", "display RuboCop violations for ONLY modified lines"
+    method_option "commit-spec", default: "master", desc: "the commit used to determine the diff."
+    def modified_lines
+      diff_files, diff_status = Open3.capture2("git diff #{options[:'commit-spec']} --diff-filter=d --name-only | grep \"\\.rb$\"")
+
+      exit 1 unless diff_status.exitstatus.zero?
+
+      command = [
+        "bundle exec rubocop",
+        "--parallel",
+        "--format Nucop::Formatters::GitDiffFormatter",
+        "--config #{options[:rubocop_todo_config_file]}",
+        multi_line_to_single_line(diff_files).to_s
+      ].join(" ")
+
+      # HACK: use ENVVAR to parameterize GitDiffFormatter
+      system({ "RUBOCOP_COMMIT_SPEC" => options[:"commit-spec"] }, command)
+    end
+
+    desc "ready_for_promotion", "display the next n cops with the fewest offenses"
+    method_option "n", type: :numeric, default: 1, desc: "number of cops to display"
+    def ready_for_promotion
+      finder = Helpers::NextCopForPromotion.new(options[:rubocop_todo_file])
+      todo_config = YAML.load_file(options[:rubocop_todo_file])
+
+      puts "The following cop(s) are ready to be promoted to enforced. Good luck!"
+      puts "Remember to run `nucop:regen_backlog` to capture your hard work."
+      puts
+      finder.find(options["n"].to_i).each do |todo|
+        puts "#{todo.name} with #{todo.offenses} offenses:"
+        puts
+
+        files = todo_config.fetch(todo.name, {}).fetch("Exclude", [])
+
+        system("bundle exec rubocop --parallel --config #{options[:rubocop_todo_config_file]} --only #{todo.name} #{files.join(' ')}")
+        puts("*" * 100) if options["n"] > 1
+        puts
+      end
+    end
+
+    private
+
+    # some cops cannot be used with the --only option and will raise an error
+    # this filters them out
+    def cops_to_enforce
+      cops = enforced_cops
+
+      cops.delete("Lint/UnneededCopDisableDirective")
+
+      cops
+    end
+
+    def enforced_cops
+      @enforced_cops ||= YAML.load_file(options[:enforced_cops_file])
+    end
+
+    def capture_std_out(command, error_message = nil, stdin_data = nil)
+      std_out, std_error, status = Open3.capture3(command, stdin_data: stdin_data)
+      print_errors_and_exit(std_error, error_message) unless status.success?
+
+      std_out
+    end
+
+    def print_errors_and_exit(std_error, message = "An error has occurred")
+      warn message
+      puts std_error
+      puts "Exiting"
+      exit 1
+    end
+
+    def print_cops_being_run(only_option)
+      if only_option
+        enforced_cops_count = Helpers::CopCounter.count(enabled_cops, only_option.split(","))
+        puts "Running with a force of #{enforced_cops_count} cops. See '#{options[:enforced_cops_file]}' for more details."
+      else
+        puts "Running all cops (specify using the 'only' option)"
+      end
+    end
+
+    def multi_line_to_single_line(str)
+      str.split(/\n+/).join(" ")
+    end
+
+    def pass_through_flag(options, option)
+      pass_through_option(options, option, true)
+    end
+
+    def pass_through_option(options, option, is_flag_option = false)
+      return nil unless options[option]
+      "--#{option} #{options[option] if is_flag_option}"
+    end
+
+    def files_changed_since(commit_spec)
+      `git diff #{commit_spec} HEAD --name-only`
+        .split("\n")
+        .select { |e| e.end_with?(".rb") }
+    end
+
+    def regenerate_rubocop_todos
+      puts "Regenerating '#{options[:rubocop_todo_file]}'. Please be patient..."
+
+      rubocop_options = [
+        "--auto-gen-config",
+        "--config #{options[:rubocop_todo_config_file]}",
+        "--exclude-limit #{options[:'exclude-limit']}",
+        "--require rubocop-rspec",
+        "--require rubocop-performance",
+        "--require rubocop-rails"
+      ]
+
+      rubocop_command = "DISABLE_SPRING=1 bundle exec rubocop #{rubocop_options.join(' ')}"
+
+      system(rubocop_command)
+
+      # RuboCop wants to inherit from our todos (options[:rubocop_todo_file]) in our backlog configuration file (options[:rubocop_todo_config_file])
+      # However, that means the next time we try to update our backlog, it will NOT include the violations recorded as todo
+      # For now, we ignore any changes in our backlog config
+      system("git checkout #{options[:rubocop_todo_config_file]}")
+    end
+
+    def update_enforced_cops
+      puts "Updating enforced cops list..."
+
+      current_enforced_cops = Helpers::CopSet.new(enforced_cops)
+      cops_without_violations.each do |cop|
+        current_enforced_cops.add_cop(cop)
+      end
+
+      if current_enforced_cops.cop_added?
+        File.open(options[:enforced_cops_file], "w+") do |f|
+          f.write(current_enforced_cops.to_a.sort.to_yaml)
+        end
+        puts "Updated '#{options[:enforced_cops_file]}'!"
+      else
+        puts "No new cops are clear of violations"
+      end
+    end
+
+    def cops_without_violations
+      cops_with_violations = YAML.load_file(options[:rubocop_todo_file]).map(&:first)
+
+      enabled_cops - cops_with_violations
+    end
+
+    def enabled_cops
+      YAML.load(`bundle exec rubocop --parallel --show-cops`).select { |_, config| config["Enabled"] }.map(&:first)
+    end
+
+    # Override Thor's options method to include Nucop's options
+    def options
+      return @_options if defined?(@_options)
+
+      original_options = super
+      @_options = Thor::CoreExt::HashWithIndifferentAccess.new(
+        configuration_options.merge(original_options)
+      )
+    end
+
+    def configuration_options
+      if File.exist?(CONFIGURATION_FILEPATH)
+        default_configuration.merge(YAML.load_file(CONFIGURATION_FILEPATH))
+      else
+        default_configuration
+      end
+    end
+
+    def default_configuration
+      {
+        enforced_cops_file: ".rubocop.enforced.yml",
+        rubocop_todo_file: ".rubocop_todo.yml",
+        rubocop_todo_config_file: ".rubocop.backlog.yml",
+        diffignore_file: ".nucop_diffignore"
+      }
+    end
+  end
+end

data/lib/nucop/cops/explicit_factory_bot_usage.rb

@@ -0,0 +1,43 @@
+module Nucop
+  # This cop looks for usages of `FactoryGirl.create`, etc.
+  # See FactoryBotHelper::FACTORY_BOT_METHODS constant for a complete list.
+  #
+  # The factory methods listed are included everywhere, so referencing the constant should rarely be necessary.
+  #
+  # @example
+  #
+  #   # bad
+  #
+  #   job = FactoryGirl.create(:job, project: project)
+  #   FactoryGirl.build(:project, code: "Super Project")
+  #
+  #   # good
+  #
+  #   job = create(:job, project: project)
+  #   build(:project, code: "Super Project")
+  class ExplicitFactoryBotUsage < ::RuboCop::Cop::Cop
+    include Helpers::FilePathHelper
+
+    MSG = "Do not explicitly use `%<constant>s` to build objects. The factory method `%<method>s` is globally available."
+
+    def_node_matcher :explicit_factory_bot_usage, <<~PATTERN
+      (send (const nil? {:FactoryGirl :FactoryBot}) {#{Helpers::FactoryBotHelper.factory_bot_methods_pattern}} ...)
+    PATTERN
+
+    def on_send(node)
+      explicit_factory_bot_usage(node) do
+        add_offense(node, location: :expression, message: format(MSG, constant: node.receiver.const_name, method: node.method_name))
+      end
+    end
+
+    def relevant_file?(file)
+      acceptance_or_spec_file?(file) && super
+    end
+
+    def autocorrect(node)
+      ->(corrector) do
+        corrector.replace(node.source_range, node.source.sub(/(?:FactoryGirl|FactoryBot)[.]/, ""))
+      end
+    end
+  end
+end

data/lib/nucop/cops/no_core_method_overrides.rb

@@ -0,0 +1,31 @@
+module Nucop
+  # This cop looks for core method overrides
+  #
+  # @example
+  #
+  #   # bad
+  #
+  #   def blank?
+  #     # ...
+  #   end
+  #
+  #   # good
+  #
+  #   def anything_other_than_blank?
+  #     # ...
+  #   end
+  #
+  class NoCoreMethodOverrides < ::RuboCop::Cop::Cop
+    MSG = "Core method overridden".freeze
+
+    def_node_matcher :core_methods, <<~PATTERN
+      (def ${:present? :blank? :empty?} ...)
+    PATTERN
+
+    def on_def(node)
+      core_methods(node) do |method|
+        add_offense(node, location: :expression, message: format(MSG, method: method))
+      end
+    end
+  end
+end

data/lib/nucop/cops/no_wip_specs.rb

@@ -0,0 +1,35 @@
+module Nucop
+  # This cop looks for WIP specs
+  #
+  # @example
+  #
+  #   # bad
+  #
+  #   it "tests some stuff", :wip do
+  #     # ...
+  #   end
+  #
+  #   # good
+  #
+  #   it "tests some stuff" do
+  #     # ...
+  #   end
+  #
+  class NoWipSpecs < ::RuboCop::Cop::Cop
+    MSG = "WIP spec found".freeze
+
+    def_node_matcher :wip_it_specs_present?, <<~PATTERN
+      (send nil? :it ... (sym :wip))
+    PATTERN
+
+    def_node_matcher :wip_describe_specs_present?, <<~PATTERN
+      (send nil? :describe ... (sym :wip))
+    PATTERN
+
+    def on_send(node)
+      return unless wip_it_specs_present?(node) || wip_describe_specs_present?(node)
+
+      add_offense(node)
+    end
+  end
+end

data/lib/nucop/cops/ordered_hash.rb

@@ -0,0 +1,42 @@
+module Nucop
+  # This cop looks for usages of `ActiveSupport::OrderedHash`
+  #
+  # Hashes in Ruby (since 1.9) enumerate their keys in the order they are
+  # inserted:
+  #
+  # "Hashes enumerate their values in the order that the corresponding keys were inserted."
+  # http://ruby-doc.org/core-2.1.6/Hash.html
+  #
+  # @example
+  #
+  #   # bad
+  #
+  #   hash = ActiveSupport::OrderedHash.new
+  #
+  #   # good
+  #
+  #   hash = {}
+  class OrderedHash < ::RuboCop::Cop::Cop
+    MSG = "Ruby hashes after 1.9 enumerate keys in order of insertion"
+
+    def_node_matcher :ordered_hash_usage, <<~PATTERN
+      (send (const (const nil? :ActiveSupport) :OrderedHash) :new)
+    PATTERN
+
+    def on_send(node)
+      ordered_hash_usage(node) do
+        add_offense(
+          node,
+          location: :expression,
+          message: MSG
+        )
+      end
+    end
+
+    def autocorrect(node)
+      ->(corrector) do
+        corrector.replace(node.source_range, "{}")
+      end
+    end
+  end
+end

data/lib/nucop/cops/release_toggles_use_symbols.rb

@@ -0,0 +1,43 @@
+module Nucop
+  # This cop checks that a symbol is used when using a Release Toggle name
+  #
+  # @example
+  #
+  #   # bad
+  #
+  #   release_toggle_enabled?("move_out_of_wip_autocomplete")
+  #   release_toggle_enabled_for_any_site?("versioned_production_specification_ui")
+  #   ReleaseToggles.enabled?("test_toggle", site_id: current_user.site_id)
+  #   ReleaseToggles.disabled?("test_toggl"e, site_id: current_user.site_id)
+  #   ReleaseToggles.enable("test_toggle", site_id: current_user.site_id)
+  #   ReleaseToggles.disable!("test_toggle", site_id: current_user.site_id)
+  #
+  #   # good
+  #
+  #   release_toggle_enabled?(:move_out_of_wip_autocomplete)
+  #
+  class ReleaseTogglesUseSymbols < ::RuboCop::Cop::Cop
+    MSG = "Use a symbol when refering to a Release Toggle's by name".freeze
+
+    def_node_matcher :test_helper?, <<~PATTERN
+      (send nil? {:release_toggle_enabled? :release_toggle_enabled_for_any_site?} (str _))
+    PATTERN
+
+    def_node_matcher :release_toggles_public_api_method?, <<~PATTERN
+      (send (const nil? :ReleaseToggles) {:enabled? :disabled? :enable :disable :enable! :disable!} (str _) ...)
+    PATTERN
+
+    def on_send(node)
+      test_helper?(node) { add_offense(node, message: MSG, location: node.children[2].loc.expression) }
+      release_toggles_public_api_method?(node) { add_offense(node, message: MSG, location: node.children[2].loc.expression) }
+    end
+
+    def autocorrect(node)
+      ->(corrector) do
+        toggle_name = node.children[2].value
+
+        corrector.replace(node.children[2].source_range, ":#{toggle_name}")
+      end
+    end
+  end
+end

data/lib/nucop/cops/shadowing_factory_bot_creation_methods.rb

@@ -0,0 +1,37 @@
+module Nucop
+  # This cop looks for defined methods in spec files that would shadow methods defined in FactoryBot::Syntax::Methods.
+  # See FactoryBotHelper::FACTORY_BOT_METHODS constant for a complete list.
+  #
+  # @example
+  #
+  #   # bad
+  #
+  #   def create(args)
+  #     ...
+  #   end
+  #
+  #   # good
+  #
+  #   def create_transfer_pallet(args)
+  #     ...
+  #   end
+  class ShadowingFactoryBotCreationMethods < ::RuboCop::Cop::Cop
+    include Helpers::FilePathHelper
+
+    MSG = "Method `%<method>s` shadows a FactoryBot method. Please rename it to be more specific."
+
+    def_node_matcher :factory_bot_methods, <<~PATTERN
+      (def ${#{Helpers::FactoryBotHelper.factory_bot_methods_pattern}} ...)
+    PATTERN
+
+    def on_def(node)
+      factory_bot_methods(node) do |method|
+        add_offense(node, location: :expression, message: format(MSG, method: method))
+      end
+    end
+
+    def relevant_file?(file)
+      acceptance_or_spec_file?(file) && super
+    end
+  end
+end

data/lib/nucop/formatters/git_diff_formatter.rb

@@ -0,0 +1,52 @@
+module Nucop
+  module Formatters
+    class GitDiffFormatter < RuboCop::Formatter::ProgressFormatter
+      def initialize(output, options = {})
+        super
+
+        populate_history_from_git
+        @offenses_per_file = {}
+      end
+
+      def file_finished(file, offenses)
+        return unless file_touched?(file)
+
+        offenses_in_changes = offenses_from_git_history(file, offenses)
+        @offenses_per_file[file] = offenses_in_changes.size
+
+        # modify parent Formatter to print what we want
+        @offenses_for_files[file] = offenses_in_changes if offenses_in_changes.any?
+        report_file_as_mark(offenses_in_changes)
+      end
+
+      def finished(_inspected_files)
+        @total_offense_count = @offenses_per_file.values.reduce(0, :+)
+        @total_correction_count = 0
+
+        super
+      end
+
+      private
+
+      def populate_history_from_git
+        commit_spec = ENV["RUBOCOP_COMMIT_SPEC"] || "master"
+
+        diff = `git --no-pager diff #{commit_spec}`
+
+        @git_history = ::GitDiffParser.parse(diff).each_with_object({}) do |patch, acc|
+          next if patch.changed_line_numbers.empty?
+
+          acc[File.expand_path(patch.file)] = patch.changed_line_numbers
+        end
+      end
+
+      def file_touched?(file)
+        @git_history.key?(file)
+      end
+
+      def offenses_from_git_history(file, offenses)
+        offenses.select { |offense| @git_history[file].include?(offense.line) }
+      end
+    end
+  end
+end

data/lib/nucop/formatters/junit_formatter.rb

@@ -0,0 +1,45 @@
+require "rexml/document"
+
+module Nucop
+  module Formatters
+    class JUnitFormatter < ::RuboCop::Formatter::BaseFormatter
+      # This gives all cops - we really want all _enabled_ cops, but
+      # that is difficult to obtain - no access to config object here.
+      COPS = RuboCop::Cop::Cop.all
+
+      def started(_target_file)
+        @document = REXML::Document.new.tap do |d|
+          d << REXML::XMLDecl.new
+        end
+        @testsuites = REXML::Element.new("testsuites", @document)
+        @testsuite = REXML::Element.new("testsuite", @testsuites).tap do |el|
+          el.add_attributes("name" => "rubocop")
+        end
+      end
+
+      def file_finished(file, offences)
+        # One test case per cop per file
+        COPS.each do |cop|
+          cop_offences = offences.select { |offence| offence.cop_name == cop.cop_name }
+          unless cop_offences.empty?
+            REXML::Element.new("testcase", @testsuite).tap do |f|
+              f.attributes["classname"] = file.gsub(/\.rb\Z/, "").gsub("#{Dir.pwd}/", "").tr("/", ".")
+              f.attributes["name"]      = "Rubocop: #{cop.cop_name}"
+              f.attributes["file"]      = cop.cop_name
+              cop_offences.each do |offence|
+                REXML::Element.new("failure", f).tap do |e|
+                  e.add_text("#{offence.message}\n\n")
+                  e.add_text(offence.location.to_s.sub("/usr/src/app/", ""))
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def finished(_inspected_files)
+        @document.write(output, 2)
+      end
+    end
+  end
+end

data/lib/nucop/helpers/cop_counter.rb

@@ -0,0 +1,51 @@
+# class to count the number of cops from a list of RuboCop "only" options
+# i.e. it accounts for whole "Departments"
+#
+# Examaples:
+# "Style/Blah" is 1 cops
+# "Layout" may represent 70 cops
+module Nucop
+  module Helpers
+    class CopCounter
+      def self.count(all_cops, cops_or_departments)
+        new(all_cops).count(cops_or_departments)
+      end
+
+      def initialize(cops)
+        @cops_by_department = group_by_department(cops)
+      end
+
+      def count(cops_or_departments)
+        cops_or_departments
+          .map do |cop_or_department|
+          if department?(cop_or_department)
+            @cops_by_department.fetch(cop_or_department, []).length
+          else
+            1
+          end
+        end
+          .reduce(0, &:+)
+      end
+
+      private
+
+      def group_by_department(cop_names)
+        cop_names.group_by do |cop_name|
+          if department?(cop_name)
+            raise "Expected fully-qualified cops by name (i.e. Department/Cop). Got: #{cop_name}"
+          end
+
+          department(cop_name)
+        end
+      end
+
+      def department?(cop_name)
+        !cop_name.include?("/")
+      end
+
+      def department(cop_name)
+        cop_name.split("/").first
+      end
+    end
+  end
+end

data/lib/nucop/helpers/cop_set.rb

@@ -0,0 +1,48 @@
+require "set"
+
+module Nucop
+  module Helpers
+    class CopSet
+      def initialize(initial_cops = [])
+        @cops = Set.new
+
+        add_cops(initial_cops)
+
+        @new_cop_added = false
+      end
+
+      def add_cops(cops)
+        cops.each(&method(:add_cop))
+      end
+
+      # add a single cop to the set
+      # if a cops department is already included,
+      # the cop is not added (it is part of the department already)
+      def add_cop(cop)
+        department = find_department(cop)
+
+        return if department && @cops.include?(department)
+        return if @cops.include?(cop)
+
+        @cops << cop
+        @new_cop_added = true
+      end
+
+      def to_a
+        @cops.to_a
+      end
+
+      def cop_added?
+        @new_cop_added
+      end
+
+      private
+
+      def find_department(cop)
+        return unless cop.include?("/")
+
+        cop.split("/").first
+      end
+    end
+  end
+end

data/lib/nucop/helpers/factory_bot_helper.rb

@@ -0,0 +1,30 @@
+module Nucop
+  module Helpers
+    module FactoryBotHelper
+      extend self
+
+      FACTORY_BOT_METHODS = [
+        :build,
+        :build_list,
+        :build_pair,
+
+        :create,
+        :create_list,
+        :create_pair,
+
+        :build_stubbed,
+        :build_stubbed_list,
+        :build_stubbed_pair,
+
+        :attributes_for,
+        :attributes_for_list,
+        :attributes_for_pair
+      ]
+      private_constant :FACTORY_BOT_METHODS
+
+      def factory_bot_methods_pattern
+        FACTORY_BOT_METHODS.map(&:inspect).join(" ")
+      end
+    end
+  end
+end

data/lib/nucop/helpers/file_path_helper.rb

@@ -0,0 +1,13 @@
+module Nucop
+  module Helpers
+    module FilePathHelper
+      def acceptance_or_spec_file?(filepath)
+        Pathname.new(filepath).fnmatch?(File.join("**", "{spec,acceptance}", "**"), File::FNM_EXTGLOB)
+      end
+
+      def support_file?(filepath)
+        Pathname.new(filepath).fnmatch?(File.join("**", "support", "**"), File::FNM_EXTGLOB)
+      end
+    end
+  end
+end

data/lib/nucop/helpers/next_cop_for_promotion.rb

@@ -0,0 +1,54 @@
+module Nucop
+  module Helpers
+    class NextCopForPromotion
+      Todo = Struct.new(:name, :offenses)
+
+      def initialize(todo_filepath)
+        @todo_filepath = todo_filepath
+        extract_todos
+        sort_todos_by_offense_count
+      end
+
+      def find(how_many = 5)
+        @todos.take(how_many)
+      end
+
+      private
+
+      def extract_todos
+        @todos =
+          extract_offense_counts_and_names
+            .each_slice(2)
+            .map { |count, name| Todo.new(name, count.to_i) }
+      end
+
+      def extract_offense_counts_and_names
+        data = []
+
+        each_line do |line|
+          if (count_match = line.match(/Offense count: (\d+)/))
+            data << count_match.captures.first
+          end
+
+          if (name_match = line.match(/^(\w+[\/]\w+):$/))
+            data << name_match.captures.first
+          end
+        end
+
+        data
+      end
+
+      def each_line
+        File.open(@todo_filepath, "r") do |file|
+          file.each_line do |line|
+            yield line
+          end
+        end
+      end
+
+      def sort_todos_by_offense_count
+        @todos.sort! { |i, j| i.offenses <=> j.offenses }
+      end
+    end
+  end
+end

data/lib/nucop/version.rb

@@ -0,0 +1,3 @@
+module Nucop
+  VERSION = "0.1.2"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require "bundler/setup"
+require "nucop"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with(:rspec) do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: nucop
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Jason Schweier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 13.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 13.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: git_diff_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.75.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.75.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.36.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.36.0
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+description: 
+email:
+- jasons@nulogy.com
+executables:
+- nucop
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/nucop
+- lib/nucop.rb
+- lib/nucop/cli.rb
+- lib/nucop/cops/explicit_factory_bot_usage.rb
+- lib/nucop/cops/no_core_method_overrides.rb
+- lib/nucop/cops/no_wip_specs.rb
+- lib/nucop/cops/ordered_hash.rb
+- lib/nucop/cops/release_toggles_use_symbols.rb
+- lib/nucop/cops/shadowing_factory_bot_creation_methods.rb
+- lib/nucop/formatters/git_diff_formatter.rb
+- lib/nucop/formatters/junit_formatter.rb
+- lib/nucop/helpers/cop_counter.rb
+- lib/nucop/helpers/cop_set.rb
+- lib/nucop/helpers/factory_bot_helper.rb
+- lib/nucop/helpers/file_path_helper.rb
+- lib/nucop/helpers/next_cop_for_promotion.rb
+- lib/nucop/version.rb
+- spec/spec_helper.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Nulogy's implementation of RuboCop, including custom cops and additional
+  tooling.
+test_files:
+- spec/spec_helper.rb