rubocop-rubomatic 1.0.0.pre.rc.1

data/docs/cops/layout/README.adoc

@@ -0,0 +1,7 @@
+= Layout
+
+Layout cops check for stylistic whitespace in your code
+
+== Cops
+
+* xref:./multiline_array_line_breaks/README.adoc[``Layout/MultilineArrayLineBreaks``]

data/docs/cops/layout/multiline_array_line_breaks/README.adoc

@@ -0,0 +1,44 @@
+= ``Layout/MultilineArrayLineBreaks``
+
+== Description
+
+Extends the built-in link:https://docs.rubocop.org/rubocop/1.49/cops_layout.html#layoutmultilinearraylinebreaks[``Layout/MultilineArrayLineBreaks``]
+and adds the ``AllowPercentArray`` option
+
+== Examples
+
+[source,ruby]
+----
+# bad
+%w[
+  1
+  2
+  3
+  4
+]
+
+# good
+%w[
+  1 2
+  3 4
+]
+----
+
+== Configurable Attributes
+
+|===
+|Name |Default value |Configurable values
+
+|AllowMultilineFinalElement
+|false
+|Boolean
+
+|AllowPercentArray
+|false
+|Boolean
+
+|===
+
+== References
+
+* https://github.com/BrandsInsurance/expert-chainsaw/issues/1032

data/docs/cops/style/README.adoc

@@ -0,0 +1,7 @@
+= Style
+
+Style cops check for stylistic consistency of your code
+
+== Cops
+
+* xref:./disallowed_methods/README.adoc[``Style/DisallowedMethods``]

data/docs/cops/style/disallowed_methods/README.adoc

@@ -0,0 +1,28 @@
+= ``Style/DisallowedMethods``
+
+== Description
+
+Certain methods should not be used
+
+== Examples
+
+[source,ruby]
+----
+# Bad (Don't use `tap`)
+tap do
+end
+
+# Bad (Don't use `abort`)
+abort
+
+# Good (Use `raise` instead of `abort`)
+raise
+----
+
+== Configurable Attributes
+
+There are no configurable attributes
+
+== References
+
+* https://github.com/BrandsInsurance/expert-chainsaw/issues/434

data/lib/rubocop/cop/rubomatic/generator/cop_readme_injector.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rubomatic
+      class Generator
+        class CopReadmeInjector < DeptReadmeInjector
+          TEMPLATE =
+            '* xref:./%{cop_folder}/README.adoc[``%{department}/%{cop}``]'
+
+          # :nodoc:
+          def initialize(badge:, **kwargs)
+            super(badge: badge, **kwargs)
+
+            @cop = badge.cop_name
+          end
+
+          private
+
+            # @return [String]
+            attr_reader :cop
+
+            # @see super
+            def new_readme_entry
+              format(TEMPLATE, {
+                department_folder: snake_case(department),
+                cop_folder: snake_case(cop),
+                department: department,
+                cop: cop
+              })
+            end
+
+            # @see super
+            def line_is_good?(line)
+              return true if super
+
+              matches = line.match(target_regex)
+              return false if matches.nil?
+
+              department == matches[:department] && cop < matches[:cop]
+            end
+
+            # @see super
+            def target_regex
+              %r{\* xref:\./docs/cops/[a-z_]+/[a-z_]+/README\.adoc\[``(?<department>[a-zA-Z_]+)/(?<cop>[a-zA-Z_]+)``\]}
+            end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rubomatic/generator/dept_readme_injector.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rubomatic
+      class Generator
+        class DeptReadmeInjector
+          TEMPLATE = '* xref:./docs/cops/%{department_folder}/README.adoc[``%{department}``]'
+
+          # :nodoc:
+          def initialize(readme_file_path:, badge:, department:)
+            @readme_file_path = readme_file_path
+            @badge = badge
+            @department = department
+            @output = output
+          end
+
+          # Performs the actual string injection into the file
+          # modified version of `inject` from RuboCop::Cop::Generator::ConfigurationInjector
+          # Named `inject_string` becuase rubocop thought when called it was `Array#inject`
+          #
+          # @return [void]
+          #
+          def inject_string
+            target_line = find_target_line
+
+            if target_line
+              readme_entries.insert(target_line, "#{new_readme_entry}\n")
+            else
+              readme_entries.push(new_readme_entry)
+            end
+
+            File.write(readme_file_path, readme_entries.join(''))
+
+            yield if block_given?
+          end
+
+          private
+
+            # @return [String]
+            attr_reader :readme_file_path
+            # @return [RuboCop::Cop::Badge]
+            attr_reader :badge
+            # @return [String]
+            attr_reader :department
+            # @return [*] Default $stdout
+            attr_reader :output
+
+            # Lines in <department>/README.adoc
+            #
+            # @return [Array<String>]
+            #
+            def readme_entries
+              @readme_entries ||= File.readlines(readme_file_path)
+            end
+
+            # Modified version from Rubocop::Cop::Generator::ConfigurationInjector
+            #
+            # @return [String]
+            #
+            def new_readme_entry
+              format(TEMPLATE, {
+                department_folder: snake_case(department),
+                department: department
+              })
+            end
+
+            # Modified version from Rubocop::Cop::Generator::ConfigurationInjector
+            #
+            # @return [Integer, Nil]
+            #
+            def find_target_line
+              readme_entries.find.with_index do |line, index|
+                return index if line_is_good?(line)
+              end
+
+              return nil
+            end
+
+            # Determines if the given line is the same type we're trying to add and if it's alphabetically before
+            #
+            # @return [Boolean]
+            #
+            def line_is_good?(line)
+              matches = line.match(target_regex)
+              return false if matches.nil?
+
+              department < line.match(target_regex)[:department]
+            end
+
+            # Regex to look for in the readme
+            #
+            # @return [Regexp]
+            #
+            def target_regex
+              %r{\* xref:\./docs/cops/[a-z_]+/README\.adoc\[``(?<department>[a-zA-Z_]+)``\]}
+            end
+
+            # Copied from Rubocop::Cop::Generator
+            #
+            # @return [String]
+            #
+            def snake_case(camel_case_string)
+              camel_case_string
+                .gsub('RSpec', 'Rspec')
+                .gsub(%r{([^A-Z/])([A-Z]+)}, '\1_\2')
+                .gsub(%r{([A-Z])([A-Z][^A-Z\d/]+)}, '\1_\2')
+                .downcase
+            end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rubomatic/generator.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require_relative './generator/dept_readme_injector'
+
+require_relative './generator/cop_readme_injector'
+
+module RuboCop
+  module Cop
+    module Rubomatic
+      class Generator
+        COP_DOC = <<~RUBY
+          # TODO: Write cop description and example of bad / good code. For every
+          # `SupportedStyle` and unique configuration, there needs to be examples.
+          # Examples must have valid Ruby syntax. Do not use upticks.
+          #
+          # @safety
+          #   Delete this section if the cop is not unsafe (`Safe: false` or
+          #   `SafeAutoCorrect: false`), or use it to explain how the cop is
+          #   unsafe.
+          #
+          # @example EnforcedStyle: bar (default)
+          #   # Description of the `bar` style.
+          #
+          #   # bad
+          #   bad_bar_method
+          #
+          #   # bad
+          #   bad_bar_method(args)
+          #
+          #   # good
+          #   good_bar_method
+          #
+          #   # good
+          #   good_bar_method(args)
+          #
+          # @example EnforcedStyle: foo
+          #   # Description of the `foo` style.
+          #
+          #   # bad
+          #   bad_foo_method
+          #
+          #   # bad
+          #   bad_foo_method(args)
+          #
+          #   # good
+          #   good_foo_method
+          #
+          #   # good
+          #   good_foo_method(args)
+          #
+        RUBY
+        SOURCE_TEMPLATE = <<~RUBY
+          # frozen_string_literal: true
+
+          module RuboCop
+            module Cop
+              module %{department}
+                class %{cop_name} < Base
+                  # TODO: Implement the cop in here.
+                  #
+                  # In many cases, you can use a node matcher for matching node pattern.
+                  # See https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern.rb
+                  #
+                  # For example
+                  MSG = 'Use `#good_method` instead of `#bad_method`.'
+
+                  # TODO: Don't call `on_send` unless the method name is in this list
+                  # If you don't need `on_send` in the cop you created, remove it.
+                  RESTRICT_ON_SEND = %%i[bad_method].freeze
+
+                  # @!method bad_method?(node)
+                  def_node_matcher :bad_method?, <<~PATTERN
+                    (send nil? :bad_method ...)
+                  PATTERN
+
+                  def on_send(node)
+                    return unless bad_method?(node)
+
+                    add_offense(node)
+                  end
+                end
+              end
+            end
+          end
+        RUBY
+        README_ADDED_MESSAGE = '[modify] A link for the %{dept_vs_cop} has been added into %{readme_file_path}.'
+
+        DEPT_README_TEMPLATE = <<~ADOC
+          = %{department}
+
+          Describe the department here
+
+          == Cops
+
+        ADOC
+        COP_README_TEMPLATE = <<~ADOC
+          = ``%{department}/%{cop_name}``
+
+          == Description
+
+          Add a description here
+
+          == Examples
+
+          [source,ruby]
+          ----
+          # Bad
+          # Add a bad example here
+
+          # Good
+          # Add a good example here
+          ----
+
+          == Configurable Attributes
+
+          |===
+          |Name |Default value |Configurable values
+
+          |Max
+          |120
+          |Integer
+
+          |===
+
+          == References
+
+          https://github.com/BrandsInsurance/expert-chainsaw/issues
+        ADOC
+
+        # :nodoc:
+        def initialize(name, output: $stdout)
+          name = ['Rubomatic', name].join('/') unless name.start_with?('Rubomatic/')
+
+          unless name.count('/') == 2
+            raise(
+              [
+                'You must provide a single department under Rubomatic i.e. Rubomatic/Department/CopName',
+                'or Department/CopName'
+              ].join(' ')
+            )
+          end
+
+          @base_gen = RuboCop::Cop::Generator.new(name, output: output)
+        end
+
+        # Calls methods in the base class
+        #
+        # @return [*]
+        #
+        def method_missing(...)
+          @base_gen.__send__(...)
+        end
+
+        # `self` responds to `method_name` if `@base_gen` does
+        #
+        def respond_to_missing?(method_name, include_private = false)
+          @base_gen.respond_to?(method_name, include_private)
+        end
+
+        # Creates the department readme if it doesn't exist
+        # Modified version of `wirte_source` from RuboCop::Cop::Generator
+        #
+        # @return [void]
+        #
+        def write_dept_readme
+          return if File.exist?(dept_docs_path)
+
+          write_unless_file_exists(dept_docs_path, generated_dept_docs)
+        end
+
+        # Creates the cop readme if it doesn't exist
+        # Modified version of `wirte_source` from RuboCop::Cop::Generator
+        #
+        # @return [void]
+        #
+        def write_cop_readme
+          write_unless_file_exists(docs_path, generated_cop_docs)
+        end
+
+        # Injects the, possibly new, department readme link into the base readme
+        # Modified version of `inject_config` from RuboCop::Cop::Generator
+        #
+        # @return [void]
+        #
+        def inject_dept_readme(readme_file_path: 'README.adoc')
+          # Add this dept to base readme if not already there
+          injector = DeptReadmeInjector.new(
+            readme_file_path: readme_file_path,
+            badge: badge,
+            department: department
+          )
+
+          injector.inject_string do
+            output.puts(format(README_ADDED_MESSAGE, readme_file_path: readme_file_path, dept_vs_cop: 'department'))
+          end
+        end
+
+        # Injects the new cop readme link into the department readme
+        # Modified version of `inject_config` from RuboCop::Cop::Generator
+        #
+        # @return [void]
+        #
+        def inject_cop_readme(readme_file_path: dept_docs_path)
+          # Add this cop to the dept readme
+          injector = CopReadmeInjector.new(
+            readme_file_path: readme_file_path,
+            badge: badge,
+            department: department
+          )
+
+          injector.inject_string do
+            output.puts(format(README_ADDED_MESSAGE, readme_file_path: readme_file_path, dept_vs_cop: 'cop'))
+          end
+        end
+
+        private
+
+          # The rubocop department without the Rubomatic prefix
+          #
+          # @return [String]
+          #
+          def department
+            badge.department_name.gsub('Rubomatic/', '')
+          end
+
+          # Modified version of `generated_source` from Rubocop::Cop::Generator
+          #
+          # @return [String]
+          #
+          def generated_dept_docs
+            generate_readme(DEPT_README_TEMPLATE)
+          end
+
+          # Modified version of `generated_source` from Rubocop::Cop::Generator
+          #
+          # @return [String]
+          #
+          def generated_cop_docs
+            generate_readme(COP_README_TEMPLATE)
+          end
+
+          # Modified version from Rubocop::Cop::Generator
+          #
+          # @return [String]
+          #
+          def generate_readme(template)
+            format(template, {
+              department: department,
+              cop_name: badge.cop_name,
+              cop_folder: snake_case(badge.cop_name.to_s)
+            })
+          end
+
+          # Path to <department>/README.adoc
+          #
+          # @return [String]
+          #
+          def dept_docs_path
+            File.join(
+              'docs',
+              'cops',
+              snake_case(department),
+              'README.adoc'
+            )
+          end
+
+          # Path to <department>/<cop>/README.adoc
+          #
+          # @return [String]
+          #
+          def docs_path
+            File.join(
+              'docs',
+              'cops',
+              snake_case(department),
+              snake_case(badge.cop_name.to_s),
+              'README.adoc'
+            )
+          end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rubomatic/layout/multiline_array_line_breaks.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rubomatic
+      module Layout
+        class MultilineArrayLineBreaks < RuboCop::Cop::Layout::MultilineArrayLineBreaks
+          # @see super
+          def on_array(node)
+            return if allowed_percent_array?(node)
+
+            super
+          end
+
+          private
+
+            # Check conig option
+            #
+            # @return [Boolean]
+            #
+            def allowed_percent_array?(node)
+              cop_config.fetch('AllowPercentArray', true) && node.percent_literal?
+            end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rubomatic/style/disallowed_methods.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rubomatic
+      module Style
+        class DisallowedMethods < RuboCop::Cop::Base
+          # In many cases, you can use a node matcher for matching node pattern.
+          # See https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern.rb
+          #
+          # For example
+          MESSAGES = {
+            abort: 'Use `#raise` instead of `#abort`.',
+            tap: 'Do not use `#tap`'
+          }.freeze
+
+          # `on_send` will only be called if the method name is in this list
+          RESTRICT_ON_SEND = %i[abort tap].freeze
+
+          # @!method using_abort?(node)
+          def_node_matcher :using_abort?, <<~PATTERN
+            (send nil? :abort ...)
+          PATTERN
+
+          # @!method using_tap?(node)
+          def_node_matcher :using_tap?, <<~PATTERN
+            (send nil? :tap ...)
+          PATTERN
+
+          # The main logic method of the cop
+          #
+          # @return [void]
+          #
+          def on_send(node)
+            message =
+              if using_abort?(node)
+                :abort
+              elsif using_tap?(node)
+                :tap
+              end
+
+            return if message.nil?
+
+            add_offense(node, message: MESSAGES.fetch(message))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rubomatic_cops.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'rubomatic/layout/multiline_array_line_breaks'
+require_relative 'rubomatic/style/disallowed_methods'

data/lib/rubocop/rubomatic/inject.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Rubomatic
+    module Inject
+      # This was a generated method from https://github.com/rubocop/rubocop-extension-generator
+      #
+      def self.defaults!
+        path = CONFIG_DEFAULT.to_s
+        hash = ConfigLoader.__send__(:load_yaml_configuration, path)
+        config = Config.new(hash, path).tap(&:make_excludes_absolute)
+
+        puts("configuration from #{path}") if ConfigLoader.debug?
+
+        config = ConfigLoader.merge_with_default(config, path)
+
+        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop/rubomatic/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Rubomatic
+    VERSION = '1.0.0-rc.1'
+  end
+end

data/lib/rubocop/rubomatic.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'rubomatic/version'
+require 'yaml'
+
+module RuboCop
+  module Rubomatic
+    class Error < StandardError
+    end
+
+    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
+    CONFIG = ::YAML.safe_load(CONFIG_DEFAULT.read).freeze
+
+    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+  end
+end

data/lib/rubocop-rubomatic.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+require_relative 'rubocop/cop/rubomatic/generator'
+require_relative 'rubocop/rubomatic'
+require_relative 'rubocop/rubomatic/inject'
+require_relative 'rubocop/rubomatic/version'
+
+RuboCop::Rubomatic::Inject.defaults!
+
+require_relative 'rubocop/cop/rubomatic_cops'