rubocop_plus 1.11.0

data/config/group/style.yml

@@ -0,0 +1,91 @@
+# Temporarily disable. This cop has many false positives.
+Style/AccessModifierDeclarations:
+  Enabled: false
+
+# In ruby, you can define modules and classes like this:
+#
+#   = Nested =             = Compact =
+#   class Foo      or      class Foo::Bar
+#     class Bar            end
+#     end
+#   end
+#
+# Style/ClassAndModuleChildren instructs rubocop to prefer 'nested' or 'compact'. The default is 'nested', but Rails typically uses
+# 'compact'. Both are valid and useful strategies and there's no reason to strictly enforce one over the other.
+# See https://github.com/roberts1000/rubocop_plus/issues/24
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+# Style/EmptyMethod checks the formatting of empty methods.  There are two formatting options:
+#
+#   = expanded =      vs      = compact =
+#   def foo                   def foo; end
+#   end
+#
+# rubocop uses the `compact` style by default. rubocop_plus prefers the `expanded` style since it used by Rails and appears to be
+# more common.
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+
+# Frozen strings are a new feature (as of Ruby 2.3) and may become the default in a future version of Ruby. Disable this cop
+# until more is known.
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+# Style/HashSyntax checks how hash are created.  There are many ways to create a hash and they all have valid use cases. This cop has
+# been disabled since it's hard to use a consistent strategy.
+Style/HashSyntax:
+  Enabled: false
+
+# Style/MixinUsage checks that "include" statements do not appear in the global namespace. Some 3rd party files violate this so
+# we'll ignore them.
+Style/MixinUsage:
+  Exclude:
+    - bin/update
+    - bin/setup
+    - spec/dummy/bin/update
+    - spec/dummy/bin/setup
+
+# Style/PreferredHashMethods checks if hash methods like 'has_key?' or 'has_value?' are called, then recommends they be switched
+# to 'key?' and 'value?'. rubocop_plus perfers the use of predicates on method names since they make the code questions more
+# precise. Also, the Naming/PredicateName cop has been disabled in this file and that cop checks for a similar
+# pattern on custom methods. For consistency, the more verbose form (like 'has_key?') is preferred when working with Hashes.
+Style/PreferredHashMethods:
+  EnforcedStyle: verbose
+
+# Style/StringLiterals enforces the use of single quotes around string literals. The major argument for using single quotes is
+# they should be faster than double quotes (which need to be parsed for possible uses of interpolation). Also, they help reveal
+# intention by alerting developers that there is no interpolation in the string. However, there is no performance difference
+# between using single and double quoted strings (https://www.viget.com/articles/just-use-double-quoted-ruby-strings) and
+# we consider any semantic advantages to be not worth the effort. We have disabled this cop and advocate that developers
+# "try" to be consistent within an individual file.
+Style/StringLiterals:
+  Enabled: false
+
+# Style/SingleLineBlockParams requires parameters to have standard names in blocks. rubocop considers the following to be bad:
+#
+#   [1, 2, 3].inject(0) { |sum, a| sum + a }
+#
+# Instead, this is preferred
+#
+#   [1, 2, 3].inject(0) { |acc, elem| acc + elem }
+#
+# "acc" means "acc"umulator and "e" means "elem"ent. Forcing everyone to use the same variable names does standardizes things,
+# but it can decrease readability. Unique variable names which impart meaning are better.
+Style/SingleLineBlockParams:
+  Enabled: false
+
+# Style/StderrPuts suggests using `warn` over `$stderr.puts`. Some 3rd party files violate this so we'll ignore them.
+Style/StderrPuts:
+  Exclude:
+    - bin/yarn
+    - spec/dummy/bin/yarn
+
+# Style/SymbolArray checks if %i or %I are used to create symbol arrays. rubocop recommends
+#
+#   = Good =              = Bad =
+#   %i[foo bar]           [:foo, :bar]
+#
+# The direct symbol form is easier to read and follows Rails.
+Style/SymbolArray:
+  Enabled: false

data/config/rubocop.yml

@@ -0,0 +1,22 @@
+require:
+  - rubocop-performance
+  - rubocop-rails
+  - rubocop-rspec
+
+AllCops:
+  Exclude:  # skip all of the following....
+    - db/schema.rb  # An auto-generated file
+    - spec/dummy/db/schema.rb # An auto-generated file
+    - lib/tasks/cucumber.rake # A 3rd-party auto-generated file
+    - vendor/**/* # Contains 3rd party libs; no need to check code that originated outside the project
+    - node_modules/**/* # Yarn 3rd party dependencies; no need to check code that originated outside the project
+    - client/**/* # It's mostly JavaScript, but it may contain 3rd party that was written outside of the project
+
+inherit_from:
+  - group/layout.yml
+  - group/lint.yml
+  - group/metrics.yml
+  - group/naming.yml
+  - group/rails.yml
+  - group/rspec.yml
+  - group/style.yml

data/exe/rubo

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+# This script runs rubocop with some default output specifications.  Output is written to a 'rubocop/' folder into the root
+# of an application.  This script can be invoked by running the following commands in the root of a ruby gem, rails engine
+# or rails application:
+#
+# EXECUTION
+#
+# rubo      # Run rubocop with the defaults.
+# rubo -h   # View the help file to see more options.
+#
+# EXIT STATUS
+#
+# See the bottom of the file for exit status codes and their meaning.
+
+lib = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "cri"
+require 'commands/rubo'
+require "commands/rubo/utils/cri_platform_monkey_patch"
+
+# rubocop:disable Metrics/BlockLength
+command = Cri::Command.define do
+  # name        'rubo'
+  usage       'rubo [options]'
+  # aliases     :ds, :stuff
+  # summary     'foo'
+  description 'rubo is an executable installed by the rubocop_plus gem.  It invokes rubocop with a custom set of ' \
+    "rules.  The following status codes are returned:\n\n" \
+    "STATUS CODES\n\n" \
+    "0 - rubocop ran and results were written to the 'rubocop' folder........\n" \
+    "1 - the project root does not contain a .rubocop.yml file...............\n" \
+    "2 - the .rubocop.yml file does not have the correct content.............\n" \
+    "3 - the 'rubocop' command cound not be found (likely due to missing gem)\n" \
+    "4 - the output from the 'rubo' command is missing or corrupt............\n"
+
+  flag :h, :help, 'show help for this command' do |_value, cmd|
+    puts cmd.help
+    exit 0
+  end
+
+  flag :i, :init, "(re)initialize your project with starting files; this will overwrite existing files" do |_value, cmd|
+    RubocopPlus::Commands::Rubo.new({ validate: true }, {}, cmd).initialize_project
+    exit 0
+  end
+
+  # This option is helpful when we're printing results to places that don't support the terminal colors (like the Jenkins
+  # console output).  It also helps other tools parse the results of a successful run since the output doesn't contain extra
+  # numeric characters.
+  flag nil, "no-color", "do not colorize the output"
+
+  # This method should return a proper exit status if there are errors determining the rubocop version.
+  flag nil, "rubocop-version", 'return the version of rubocop' do |_value, cmd|
+    rubo = RubocopPlus::Commands::Rubo.new({ validate: true }, {}, cmd)
+    rubo.check_if_rubocop_command_exists!
+    puts rubo.rubocop_version_name
+    exit 0
+  end
+
+  # This method should return a proper exit status if there are errors determining the total violations count.
+  flag :t, "total-violations", 'write the total violations' do |_value, cmd|
+    rubo = RubocopPlus::Commands::Rubo.new({ total_violations: true }, {}, cmd)
+    rubo.check_if_total_violations_count_still_present_and_valid!
+    puts rubo.total_violations_count
+    exit 0
+  end
+
+  # This method should return a proper exit status if there are validation errors.
+  flag nil, :validate, "make sure rubocop is runnable" do |_value, cmd|
+    RubocopPlus::Commands::Rubo.new({ validate: true }, {}, cmd).validate_pre_run!
+    puts "Everything looks great!"
+    exit 0
+  end
+
+  flag :v, :version, 'return the version of rubo' do |_value, _cmd|
+    require 'rubocop_plus/version'
+    puts RubocopPlus::VERSION
+    exit 0
+  end
+
+  run do |options, args, cmd|
+    RubocopPlus::Commands::Rubo.new(options, args, cmd).run
+  end
+end
+# rubocop:enable Metrics/BlockLength
+
+begin
+  command.run(ARGV)
+  exit 0
+# Raised when an application fails to include a .rubocop.yml file.
+rescue RubocopPlus::Commands::MissingYml => e
+  warn e.message
+  exit 1
+# Raised when a project has a .rubocop.yml file, but it doesn't contain the correct content to work with this gem.
+rescue RubocopPlus::Commands::IncorrectYml => e
+  warn e.message
+  exit 2
+# Raised when the needed version of the rubocop executable is not installed (like because the rubocop gem is not installed).
+rescue RubocopPlus::Commands::NoRubocopCommand => e
+  warn e.message
+  exit 3
+# Raised when there are issues with the output generated by rubo.
+rescue RubocopPlus::Commands::BadOutput, RubocopPlus::Commands::OutputMissing => e
+  warn e.message
+  exit 4
+end

data/lib/commands/rubo.rb

@@ -0,0 +1,102 @@
+require "rubocop_plus"
+
+require_relative "rubo/utils/which"
+require_relative "rubo/helpers/misc"
+require_relative "rubo/helpers/output"
+require_relative "rubo/helpers/validations"
+
+require_relative "rubo/errors/missing_yml"
+require_relative "rubo/errors/incorrect_yml"
+require_relative "rubo/errors/no_rubocop_command"
+require_relative "rubo/errors/bad_output"
+require_relative "rubo/errors/output_missing"
+
+module RubocopPlus
+  module Commands
+    # The main class for the rubo command.  When rubo is invoked on the command line, this class is initiated and the 'run'
+    # method is called.
+    class Rubo < Cri::CommandRunner
+      def run
+        prepare_options
+        validate_pre_run!
+        write_starting_message
+        delete_rubocop_folder
+        invoke_rubocop
+        generate_total_violations_file
+        validate_post_run!
+        write_results_message
+      end
+
+      # Perform all of the checks to make sure rubo can actually run.  This method is called by the 'run' method when
+      # 'rubo' is called.  It's also called with 'rubo --validate' is called.
+      def validate_pre_run!
+        check_if_yml_present!
+        check_if_yml_has_correct_content!
+        check_if_rubocop_command_exists!
+      end
+
+      def validate_post_run!
+        check_if_results_exist!
+      end
+
+      def initialize_project
+        backup_rubocop_yml_if_present
+        template_path = File.expand_path('../templates/.rubocop.yml', __dir__)
+        FileUtils.cp(template_path, ".rubocop.yml")
+        puts ".rubocop.yml created"
+      end
+
+      # Execute rubocop with a tailored set of output files.  Rails checks are activated in the default config/rubocop.yml file
+      # so we do not explicitly activate them there.
+      def invoke_rubocop
+        cmd = is_in_gemfile_dot_lock? ? "bundle exec rubocop" : "rubocop"
+        # Make sure we always use the specific version of rubocop.  Without this line, the latest version of rubocop
+        # will be used if a user installs a version that is newer than what we want to use.
+        cmd += " _#{RubocopPlus::RUBOCOP_VERSION}_"
+        cmd += " --format simple --out #{style_issues_text_file_name}"
+        cmd += " --format html --out #{style_issues_html_file_name}"
+        cmd += " --format offenses --out #{style_counts_text_file_name}"
+        cmd += checkstyle_options
+        system cmd
+      end
+
+      # Generates the XML reports necessary to use the Checkstyle Plugin on Jenkins.  It is only needed for the CI so return an
+      # empty string unless the --checkstyle option is present.
+      def checkstyle_options
+        return "" unless options[:checkstyle]
+
+        cmd = " --require rubocop/formatter/checkstyle_formatter"
+        cmd += " --format RuboCop::Formatter::CheckstyleFormatter"
+        cmd + " --out #{output_folder_name}/checkstyle.xml"
+      end
+
+      # While using SublimeText with the SFTP plugin, we noticed the SFTP plugin would not automatically download newer versions
+      # of the generated rubocop files at times.  Rubocop should overwrite the files, but we goahead and explicity delete the
+      # folder in the hopes that will help resolve the file syncing issues for editors (we're not 100% sure this helps).
+      def delete_rubocop_folder
+        FileUtils.remove_dir(output_folder_name, true)
+      end
+
+      private
+
+      def backup_rubocop_yml_if_present
+        return unless File.file?(".rubocop.yml")
+
+        FileUtils.mv(".rubocop.yml", ".rubocop.yml.bak")
+        puts ".rubocop.yml renamed to .rubocop.yml.bak"
+      end
+
+      # The cri doesn't do a good job of preparing the options.  Instead of having symbols like :"no-color", :no_color is better.
+      def prepare_options
+        normalize_options
+        String.allow_color = !options[:no_color]
+      end
+
+      def normalize_options
+        no_color = options.delete(:"no-color")
+        options[:no_color] = no_color.nil? ? false : no_color
+        options[:checkstyle] = false unless options.has_key?(:checkstyle)
+      end
+    end
+  end
+end

data/lib/commands/rubo/errors/bad_output.rb

@@ -0,0 +1,18 @@
+module RubocopPlus
+  module Commands
+    # When the rubo command runs rubocop, it tells rubocop to output to a specific set of files.  If those files aren't
+    # created, (or don't have the expected format), rubo will raise a BadOutput error.
+    class BadOutput < StandardError
+      def initialize(msg="")
+        @details = msg
+        super
+      end
+
+      def message
+        "Error\n\n" \
+        "  The output in the rubocop folder does not look correct.  This implies rubo wasn't able to run 'rubocop'\n" \
+        "  for some reason: #{@details}.\n\n".rubo_red
+      end
+    end
+  end
+end

data/lib/commands/rubo/errors/incorrect_yml.rb

@@ -0,0 +1,16 @@
+module RubocopPlus
+  module Commands
+    # The rubo command performs some sanity checking to make sure the current application is using a well defined
+    # .rubocop.yml.  It problems are found, an IncorrectYml error is raised.
+    class IncorrectYml < StandardError
+      def message
+        "\n" \
+        "  The .rubocop.yml file does not appear to have the correct configuration to read from the\n" \
+        "  rubocop_plus gem.  To correct the problem:\n" \
+        "    1. Rename your existing .rubocop.yml to .rubocop.yml.bak\n" \
+        "    2. Run the installer to generate a fresh .rubocop.yml\n" \
+        "       rubo --init\n\n".rubo_red
+      end
+    end
+  end
+end

data/lib/commands/rubo/errors/missing_yml.rb

@@ -0,0 +1,12 @@
+module RubocopPlus
+  module Commands
+    # The rubo command performs some sanity checking to make sure the current application is using a well defined
+    # .rubocop.yml.  If the .rubocop.yml file is missing, a MissingYml error is raised.
+    class MissingYml < StandardError
+      def message
+        "\n  The application does not have a .rubocop.yml file.  Run the installer to generate one:\n" \
+        "    rubo --init\n\n".rubo_red
+      end
+    end
+  end
+end

data/lib/commands/rubo/errors/no_rubocop_command.rb

@@ -0,0 +1,14 @@
+module RubocopPlus
+  module Commands
+    # The rubo command will check to make sure the `rubocop` command exists.  When users install rubocop_plus, rubocop_plus
+    # will automatically install a version of rubocop.  Users may delete rubocop at a later time.  If rubocop isn't available
+    # on the system, NoRubocopCommand will be raised.
+    class NoRubocopCommand < StandardError
+      def message
+        "\n" \
+        "  The 'rubocop' command is not available.  Is the rubocop gem installed?  Verify by executing\n" \
+        "  'gem list rubocop'.  If rubocop is not listed, reinstall rubocop_plus.\n\n".rubo_red
+      end
+    end
+  end
+end

data/lib/commands/rubo/errors/output_missing.rb

@@ -0,0 +1,16 @@
+module RubocopPlus
+  module Commands
+    # The rubo command will generate some custom output files.  If those files don't get created properly, rubo will raise
+    # OutputMissing.
+    class OutputMissing < StandardError
+      def initialize(msg="")
+        @message = msg
+        super
+      end
+
+      def message
+        @message.rubo_red
+      end
+    end
+  end
+end

data/lib/commands/rubo/helpers/misc.rb

@@ -0,0 +1,68 @@
+module RubocopPlus
+  module Commands
+    # Miscellaneous helpers are grouped in this file.
+    class Rubo < Cri::CommandRunner
+      def rubocop_yml_present?
+        File.file?(".rubocop.yml")
+      end
+
+      # The Gemfile.lock is auto generated when the 'bundle' command is run.  It doesn't contain superfluous comments or any
+      # references to a gem unless the gem is being used.  However, many terms like 'rails' is used in multiple gem name so
+      # we need to be smart about checking boundaries.  Each gem line in Gemfile.lock always starts with a couple spaces,
+      # followed by the gem name, followed by a single space or newline chracter.
+      def is_in_gemfile_dot_lock?
+        return false unless File.exist?("Gemfile.lock")
+
+        # Match logic
+        #   ^               - match from beginning of string
+        #   \s*             - match 0-N white space characters
+        #   rubocop_plus    - match the gem_name exactly once
+        #   \s              - match one white space character (it will always be a space or a \n)
+        File.foreach("Gemfile.lock") { |line| return true if line =~ /^\s*rubocop_plus\s/ }
+        false
+      end
+
+      def installed_version_of_gem
+        Gem::Version.new(RubocopPlus::VERSION)
+      end
+
+      def rubocop_version_name
+        Gem::Version.new(RubocopPlus::RUBOCOP_VERSION)
+      end
+
+      def output_folder_name
+        "rubocop"
+      end
+
+      def style_issues_text_file_name
+        "#{output_folder_name}/style-issues.txt"
+      end
+
+      def style_issues_html_file_name
+        "#{output_folder_name}/style-issues.html"
+      end
+
+      def style_counts_text_file_name
+        "#{output_folder_name}/style-counts.txt"
+      end
+
+      def total_violations_count_text_file_name
+        "#{output_folder_name}/total-violations-count.txt"
+      end
+
+      # Perform some sanity checks to make sure .rubocop.yml has expected content.
+      def rubocop_yml_has_correct_content?
+        # If we're running from inside the rubocop_plus folder, ignore this check.
+        return true if Dir.pwd.include?("rubocop_plus")
+
+        text = File.read(".rubocop.yml")
+        text.include?("inherit_gem:") && text.include?("rubocop_plus:")
+      end
+
+      def rubocop_command_exists?
+        path = Which('rubocop')
+        !(path.nil? || path.empty?)
+      end
+    end
+  end
+end