rubocop-brands_insurance 0.0.2.pre.rc.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b78dfa9d49167cd428caa869e3233539739bf0609ca423c95206d437d0a30491
+  data.tar.gz: edd592a746d2ea5396a5585ce01dd504698fba5767f55ae5f238ce0ae9541468
+SHA512:
+  metadata.gz: 9576f39c77c22ac92247b9f3fe45e8a48298570c6c125bee83cc45aa0d4367ccd37410ddd5b975202a69ef664d75d4bd1252f42d26266b4874d1db7d20cb32cc
+  data.tar.gz: fd679b7562290fc20b46c61d7d4cd29d0d7bd0ae7b818e25398aa35c019cca50d55c658a99ad88085ef9808b3c589bbcb9fc393577b9af8b33286d0a7bd19699

data/README.adoc

@@ -0,0 +1,50 @@
+= Rubocop::BrandsInsurance
+
+Gem for custom rubocop rules for BrandsInsurance
+
+Welcome to your new gem!
+In this directory, you'll find the files you need to be able to package up your Ruby library into a gem.
+Put your Ruby code in the file ``lib/rubocop/brands_insurance``.
+To experiment with that code, run
+``bin/console`` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem 'rubocop-brands_insurance', require: false
+----
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rubocop-brands_insurance
+
+== Usage
+
+Add ``BrandsInsurance/*`` cops to your ``.rubocop.yml`` config file
+
+[source,yaml]
+----
+BrandsInsurance/Style/DisallowedMethods:
+  Enabled: true
+----
+
+== Departments
+
+* xref:./docs/cops/style/README.adoc[``Style``]
+
+== Contributing
+
+See xref:./CONTRIBUTING.adoc[CONTRIBUTING] for how to add your own rule
+
+== Changelog
+
+See xref:./CHANGELOG.adoc[CHANGELOG] see see changes

data/config/default.yml

@@ -0,0 +1,4 @@
+BrandsInsurance/Style/DisallowedMethods:
+  Description: 'Disallows the usage of `#abort` and `#tap` methods'
+  Enabled: pending
+  VersionAdded: '<<next>>'

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/brands_insurance/inject.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# The original code is from https://github.com/rubocop/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
+# See https://github.com/rubocop/rubocop-rspec/blob/master/MIT-LICENSE.md
+module RuboCop
+  module BrandsInsurance
+    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+    # bit of our configuration.
+    module Inject
+      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/brands_insurance/version.rb

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

data/lib/rubocop/brands_insurance.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'brands_insurance/version'
+require 'yaml'
+
+module RuboCop
+  module BrandsInsurance
+    class Error < StandardError; end
+    # Your code goes here...
+    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/cop/brands_insurance/generator/cop_readme_injector.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module BrandsInsurance
+      class Generator
+        class CopReadmeInjector < DeptReadmeInjector
+          TEMPLATE =
+            '* xref:./%<cop_folder>s/README.adoc[``%<department>s/%<cop>s``]'
+
+          # :nodoc:
+          def initialize(badge:, **kwargs)
+            super(badge: badge, **kwargs)
+
+            @cop = badge.cop_name
+          end
+
+          private
+
+            attr_reader :cop
+
+            def new_readme_entry
+              format(TEMPLATE, {
+                department_folder: snake_case(department),
+                cop_folder: snake_case(cop),
+                department: department,
+                cop: cop
+              })
+            end
+
+            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
+
+            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/brands_insurance/generator/dept_readme_injector.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module BrandsInsurance
+      class Generator
+        class DeptReadmeInjector
+          TEMPLATE = '* xref:./docs/cops/%<department_folder>s/README.adoc[``%<department>s``]'
+
+          # :nodoc:
+          def initialize(readme_file_path:, badge:, department:)
+            @readme_file_path = readme_file_path
+            @badge = badge
+            @department = department
+            @output = output
+          end
+
+          # :nodoc:
+          def inject
+            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
+
+            attr_reader :readme_file_path, :badge, :department, :output
+
+            def readme_entries
+              @readme_entries ||= File.readlines(readme_file_path)
+            end
+
+            def new_readme_entry
+              format(TEMPLATE, {
+                department_folder: snake_case(department),
+                department: department
+              })
+            end
+
+            def find_target_line
+              readme_entries.find.with_index do |line, index|
+                return index if line_is_good?(line)
+              end
+
+              return nil
+            end
+
+            def line_is_good?(line)
+              matches = line.match(target_regex)
+              return false if matches.nil?
+
+              department < line.match(target_regex)[:department]
+            end
+
+            def target_regex
+              %r{\* xref:\./docs/cops/[a-z_]+/README\.adoc\[``(?<department>[a-zA-Z_]+)``\]}
+            end
+
+            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/brands_insurance/generator.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require_relative './generator/dept_readme_injector'
+require_relative './generator/cop_readme_injector'
+
+module RuboCop
+  module Cop
+    module BrandsInsurance
+      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>s
+                class %<cop_name>s < 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>s has been added into ' \
+          '%<readme_file_path>s.'
+
+        DEPT_README_TEMPLATE = <<~ADOC
+          = %<department>s
+
+          Describe the department here
+
+          == Cops
+
+        ADOC
+        COP_README_TEMPLATE = <<~ADOC
+          = ``%<department>s/%<cop_name>s``
+
+          == 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
+
+        def initialize(name, output: $stdout)
+          name = ['BrandsInsurance', name].join('/') unless name.start_with?('BrandsInsurance/')
+
+          unless name.count('/') == 2
+            raise(
+              [
+                'You must provide a single department under BrandsInsurance i.e. BrandsInsurance/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
+
+        def write_dept_readme
+          return if File.exists?(dept_docs_path)
+
+          write_unless_file_exists(dept_docs_path, generated_dept_docs)
+        end
+
+        def write_cop_readme
+          write_unless_file_exists(docs_path, generated_cop_docs)
+        end
+
+        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 do
+            output.puts(format(README_ADDED_MESSAGE, readme_file_path: readme_file_path, dept_vs_cop: 'department'))
+          end
+        end
+
+        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 do
+            output.puts(format(README_ADDED_MESSAGE, readme_file_path: readme_file_path, dept_vs_cop: 'cop'))
+          end
+        end
+
+        private
+
+          def department
+            badge.department_name.gsub('BrandsInsurance/', '')
+          end
+
+          def generated_dept_docs
+            generate_readme(DEPT_README_TEMPLATE)
+          end
+
+          def generated_cop_docs
+            generate_readme(COP_README_TEMPLATE)
+          end
+
+          def generate_readme(template)
+            format(template, {
+              department: department,
+              cop_name: badge.cop_name,
+              cop_folder: snake_case(badge.cop_name.to_s)
+            })
+          end
+
+          def dept_docs_path
+            File.join(
+              'docs',
+              'cops',
+              snake_case(department),
+              'README.adoc'
+            )
+          end
+
+          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/brands_insurance/style/disallowed_methods.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module BrandsInsurance
+      module Style
+        # @example EnforcedStyle: foo
+        #   # Description of the `foo` style.
+        #
+        #   # bad
+        #   abort
+        #
+        #   # bad
+        #   abort(args)
+        #
+        #   # bad
+        #   tap {}
+        #
+        #   # bad
+        #   tap do
+        #   end
+        #
+        #   # good
+        #   raise
+        #
+        #   # good
+        #   raise(args)
+        #
+        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`'
+          }
+
+          # `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
+
+          # :nodoc:
+          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/brands_insurance_cops.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'brands_insurance/style/disallowed_methods'

data/lib/rubocop-brands_insurance.rb

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

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-brands_insurance
+version: !ruby/object:Gem::Version
+  version: 0.0.2.pre.rc.1
+platform: ruby
+authors:
+- Brands Insurance
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.43'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.43'
+description: 
+email:
+- documents@brandsinsurance.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.adoc
+- config/default.yml
+- docs/cops/style/README.adoc
+- docs/cops/style/disallowed_methods/README.adoc
+- lib/rubocop-brands_insurance.rb
+- lib/rubocop/brands_insurance.rb
+- lib/rubocop/brands_insurance/inject.rb
+- lib/rubocop/brands_insurance/version.rb
+- lib/rubocop/cop/brands_insurance/generator.rb
+- lib/rubocop/cop/brands_insurance/generator/cop_readme_injector.rb
+- lib/rubocop/cop/brands_insurance/generator/dept_readme_injector.rb
+- lib/rubocop/cop/brands_insurance/style/disallowed_methods.rb
+- lib/rubocop/cop/brands_insurance_cops.rb
+homepage: https://github.com/BrandsInsurance/expert-chainsaw/
+licenses: []
+metadata:
+  homepage_uri: https://github.com/BrandsInsurance/expert-chainsaw/
+  source_code_uri: https://github.com/BrandsInsurance/expert-chainsaw/plugins/rubocop/brandsinsurance
+  changelog_uri: https://github.com/BrandsInsurance/expert-chainsaw/plugins/rubocop/brandsinsurance/CHANGELOG.adoc
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.2.15
+signing_key: 
+specification_version: 4
+summary: Custom cops for BrandsInsurance
+test_files: []