rubocop-gusto 10.0.0

data/lib/rubocop/cop/gusto/use_paint_not_colorize.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Requires the use of the `paint` gem for terminal color methods on strings
+      #
+      # @example
+      #
+      #   # bad
+      #   "string".cyan
+      #   "string".red
+      #   "string".green
+      #   str = "hello"
+      #   str.cyan
+      #   "string".colorize(:blue)
+      #   "string".colorize(:color => :blue)
+      #   "string".colorize(:color => :blue, :background => :red)
+      #   "string".blue.on_red
+      #   "string".colorize(:blue).on_red
+      #   "string".blue.underline
+      #
+      #   # good
+      #   "string"
+      #
+      #   # if color is needed, use `paint` gem
+      #   Paint["string", :cyan]
+      #   Paint["string", :red]
+      #   Paint["string", :green]
+      #   Paint[str, :cyan]
+      #   Paint["string", :blue]
+      #   Paint["string", :blue, :red]
+      #
+      class UsePaintNotColorize < Base
+        extend AutoCorrector
+
+        # Common terminal color methods that should be prevented
+        COLOR_METHODS = Set.new(
+          %i(
+            black
+            red
+            green
+            yellow
+            blue
+            magenta
+            cyan
+            white
+            light_black
+            light_red
+            light_green
+            light_yellow
+            light_blue
+            light_magenta
+            light_cyan
+            light_white
+            colorize
+            on_black
+            on_red
+            on_green
+            on_yellow
+            on_blue
+            on_magenta
+            on_cyan
+            on_white
+            on_light_black
+            on_light_red
+            on_light_green
+            on_light_yellow
+            on_light_blue
+            on_light_magenta
+            on_light_cyan
+            on_light_white
+            bold
+            italic
+            underline
+            blink
+            swap
+            hide
+            uncolorize
+          )
+        ).freeze
+
+        # Style modifiers that are applied as additional options in Paint
+        STYLE_MODIFIERS = Set.new(
+          %i(
+            bold
+            italic
+            underline
+            blink
+            swap
+            hide
+          )
+        ).freeze
+
+        MSG = 'Use Paint instead of colorize for terminal colors.'
+        PROHIBITED_CLASS = 'String'
+        RESTRICT_ON_SEND = COLOR_METHODS
+
+        def on_send(node)
+          return unless node.receiver
+          return unless string_or_colorized_receiver?(node.receiver)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, correction(node))
+          end
+        end
+
+        def on_csend(node)
+          return unless string_or_colorized_receiver?(node.receiver)
+
+          add_offense(node) # no autocorrection for safe navigation due to chained calls
+        end
+
+        private
+
+        def string_or_colorized_receiver?(node)
+          string_receiver?(node) || colorized_string?(node)
+        end
+
+        def string_receiver?(node)
+          node.type?(:str, :dstr) || node.variable?
+        end
+
+        def colorized_string?(node)
+          node.send_type? &&
+            node.receiver.is_a?(RuboCop::AST::Node) &&
+            string_or_colorized_receiver?(node.receiver)
+        end
+
+        def correction(node)
+          # Find the original string and all color/style operations in the chain
+          original_string, color_ops = extract_string_and_operations(node)
+
+          foreground = nil
+          background = nil
+          styles = []
+
+          # Process all the operations to build the Paint parameters
+          color_ops.each do |op|
+            method_name = op[:method]
+            args = op[:args]
+
+            if method_name == :colorize
+              if args.length == 1 && args.first.sym_type?
+                # Single symbol argument, like colorize(:red)
+                foreground = ":#{args.first.value}"
+              elsif args.length == 1 && args.first.hash_type?
+                # Hash argument, like colorize(color: :red, background: :blue)
+                args.first.pairs.each do |pair|
+                  break unless pair.value.sym_type? # can't handle non-symbol arguments
+
+                  key = pair.key.value
+                  value = ":#{pair.value.value}"
+
+                  case key
+                  when :color
+                    foreground = value
+                  when :background
+                    background = value
+                  when :mode
+                    styles << value
+                  else
+                    break # unknown key, skip the rest of the hash
+                  end
+                end
+              else
+                # if the argument is not a symbol or hash, we can't handle it
+                break
+              end
+            elsif method_name == :uncolorize
+              # If uncolorize is called, convert to Paint.unpaint
+              return "Paint.unpaint(#{original_string.source})"
+            elsif method_name.start_with?('on_')
+              # Background color
+              color_name = method_name.to_s.delete_prefix('on_')
+              background = ":#{color_name}"
+            elsif STYLE_MODIFIERS.include?(method_name)
+              # Style modifier
+              styles << ":#{method_name}"
+            elsif method_name.start_with?('light_')
+              # Light/bright foreground color
+              color = method_name.to_s.delete_prefix('light_')
+              foreground = ":bright, :#{color}"
+            else
+              # Regular foreground color
+              foreground = ":#{method_name}"
+            end
+          end
+
+          return unless foreground || background || styles.any?
+
+          # Build the Paint call
+          build_paint_call(original_string, foreground, background, styles)
+        end
+
+        def extract_string_and_operations(node)
+          operations = []
+          current = node
+
+          # Find the deepest operation in the chain
+          while current.send_type? && COLOR_METHODS.include?(current.method_name)
+            operations.unshift(
+              {
+                method: current.method_name,
+                args: current.arguments,
+              }
+            )
+
+            current = current.receiver
+          end
+
+          # The earliest receiver is the original string
+          [current, operations]
+        end
+
+        def build_paint_call(string_node, foreground, background, styles)
+          # Use string_content for string nodes, or source for variables and other expressions
+          string_expr = string_node.source
+
+          params = [string_expr]
+
+          # Add nil as a placeholder for foreground if we only have a background
+          if background && !foreground
+            params << 'nil'
+          elsif foreground
+            params << foreground
+          end
+
+          # Add background if present
+          params << background if background
+
+          # Add any style modifiers
+          params.concat(styles) unless styles.empty?
+
+          "Paint[#{params.join(', ')}]"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/vcr_recordings.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Requires VCR to be set to not record in tests.
+      #
+      # @example
+      #   # bad
+      #   vcr: {record: :all}
+      #
+      #   # good
+      #   vcr: {record: :none}
+      #
+      # @see https://github.com/vcr/vcr
+      #
+      class VcrRecordings < Base
+        extend AutoCorrector
+
+        MSG = 'VCR should be set to not record in tests. Please use vcr: {record: :none}.'
+
+        # @!method vcr_recording?(node)
+        def_node_matcher :vcr_recording?, <<~PATTERN
+          (pair (sym :record) (sym $_))
+        PATTERN
+
+        def on_pair(node)
+          return unless vcr_setting?(node)
+          return unless recording_enabled?(node.key.children.first, node.value.children.first)
+
+          add_offense(node) do |corrector|
+            replacement = node.source.sub(/: :\w*/, ': :none')
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def vcr_setting?(node)
+          node.parent.parent.source.include?('vcr')
+        end
+
+        def recording_enabled?(option, value)
+          option == :record && value != :none
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/assignment_first.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Check for assignment as the first action in a cop hook.
+      #
+      # @example
+      #   # bad
+      #   def on_send(node)
+      #     foo = 1
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def on_send(node)
+      #     do_something
+      #     foo = 1
+      #   end
+      #
+      class AssignmentFirst < Base
+        HOOKS = %i(
+          on_def
+          on_defs
+          on_send
+          on_csend
+          on_const
+          on_int
+          on_class
+          on_module
+          on_block
+          on_begin
+          on_kwbegin
+          after_int
+          after_def
+          after_send
+          after_csend
+          after_class
+          after_module
+        ).to_set.freeze
+        MSG = 'Avoid placing an assignment as the first action in `%{hook}`.'
+
+        def on_def(node)
+          return unless HOOKS.include?(node.method_name)
+          return unless node.body
+
+          # Look through a begin node, e.g. look inside parentheses
+          first_child = node.body.begin_type? ? node.body.children.first : node.body
+          return unless first_child&.assignment?
+
+          add_offense(first_child, message: format(MSG, hook: node.method_name))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/require_restrict_on_send.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Check for missing `RESTRICT_ON_SEND`.
+      #
+      # @example
+      #   # bad
+      #   class FooCop
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooCop
+      #     RESTRICT_ON_SEND = %i[bad_method].freeze
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      # NOTE: This works for us because we do not write cops that investigate every send node.
+      # Upstream Rubocop chose not to implement this as there are many cops in Core that investigate every node.
+      class RequireRestrictOnSend < Base
+        MSG = 'Missing `RESTRICT_ON_SEND` declaration when using `on_send` or `after_send`.'
+
+        # @!method defined_send_callback?(node)
+        def_node_search :defined_send_callback?, <<~PATTERN
+          {
+            (def {:on_send :after_send} ...)
+            (alias (sym {:on_send :after_send}) _source ...)
+            (send nil? :alias_method {(sym {:on_send :after_send}) (str {"on_send" "after_send"})} _source ...)
+          }
+        PATTERN
+
+        # @!method restrict_on_send?(node)
+        def_node_search :restrict_on_send?, <<~PATTERN
+          (casgn nil? :RESTRICT_ON_SEND ...)
+        PATTERN
+
+        # from: https://github.com/rubocop/rubocop/blob/e78790e3c9e82f8e605009673a8d2eac40b18c4c/lib/rubocop/cop/internal_affairs/undefined_config.rb#L25
+        # @!method cop_class_def(node)
+        def_node_matcher :cop_class_def, <<~PATTERN
+          (class _
+            (const {nil? (const nil? :Cop) (const (const {cbase nil?} :RuboCop) :Cop)}
+              {:Base :Cop}) ...)
+        PATTERN
+
+        def on_class(node)
+          return if restrict_on_send?(node) # requirement met
+
+          return unless defined_send_callback?(node)
+          return unless cop_class_def(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gusto/cli.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'rubocop/gusto/config_yml'
+require 'rubocop/gusto/init'
+
+module RuboCop
+  module Gusto
+    class Cli < Thor
+      register(Init, 'init', 'init', 'Initialize rubocop-gusto and update .rubocop.yml')
+
+      desc 'sort [RUBOCOP_YML_PATH]', 'Sort the cops in a .rubocop.yml file (default: .rubocop.yml)'
+      method_option :output, type: :string, default: nil, desc: 'The path to the output file'
+      def sort(rubocop_yml_path = '.rubocop.yml')
+        say "Sorting #{rubocop_yml_path}..."
+        output_path = options[:output] || rubocop_yml_path
+        ConfigYml.load_file(rubocop_yml_path).sort!.write(output_path)
+        say "Done! #{output_path} sorted."
+      end
+    end
+  end
+end

data/lib/rubocop/gusto/config_yml.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  module Gusto
+    # A class for reading and writing a .rubocop.yml file.
+    #
+    # You may rightly ask why we don't just use the standard library's YAML.load_file
+    # and YAML.dump. Simple, we want to preserve the comments.
+    class ConfigYml
+      COMMENT_REGEX = /\A\s*#.*\z/
+      COP_HEADER_REGEX = /\A[A-Z0-9][A-Za-z0-9\/:]+:(\s*#.*)?\z/
+      KEY_REGEX = /\A\w[\w\/]+:(\s*#.*)?\z/i # case insensitive
+      PREAMBLE_KEYS = %w(inherit_mode inherit_gem inherit_from plugins require).freeze
+      INDENT_REGEX = /\A(  |- )/
+
+      # @param [String] file_path the path to the .rubocop.yml file
+      def self.load_file(file_path = '.rubocop.yml')
+        new(File.readlines(file_path))
+      rescue Errno::ENOENT
+        new([])
+      end
+
+      attr_reader :preamble, :cops
+
+      # @param [Array<String>] lines the lines of the .rubocop.yml file
+      def initialize(lines)
+        @preamble, @cops = chunk_blocks(lines).partition do |block|
+          block.none? { |line| line.rstrip.match?(COP_HEADER_REGEX) }
+        end
+      end
+
+      # Find if there's already an inherit_gem section and add the gem to it if needed
+      def add_inherit_gem(gem_name, *config_paths)
+        update_section_data('inherit_gem') do |data|
+          data ||= {}
+          data[gem_name.to_s] = config_paths.flatten
+          data
+        end
+      end
+
+      # Add a plugin to the plugins section or create it if it doesn't exist
+      def add_plugin(plugins)
+        update_section_data('plugins') do |data|
+          data ||= []
+          data.concat(plugins).uniq
+        end
+      end
+
+      def update_section_data(section_name, &)
+        # Look for an existing section in the preamble
+        section = preamble.find { |chunk| chunk_name(chunk) == section_name }
+
+        if section
+          comments = section.select { |line| line.match?(COMMENT_REGEX) }
+          data = YAML.load(section.join)[section_name.to_s] # it can be present and nil
+        else
+          comments = []
+          data = nil
+        end
+
+        data = yield data
+
+        section_lines = YAML.dump({ section_name.to_s => data }).lines.drop(1) # drop the ---
+        section_lines.map! { |line| line.sub(/\A(\s*)-/, '\1  -') } # prefer indented lists
+        section_lines.insert(0, *comments) # add the comments back in at the top
+        section_lines << "\n" # ensure there's a trailing newline
+
+        section ? section.replace(section_lines) : preamble.unshift(section_lines)
+
+        self
+      end
+
+      def sort!
+        # Sort the preamble chunks by our preferred order, falling back to key name
+        preamble.sort_by! do |chunk|
+          key = chunk_name(chunk)
+          PREAMBLE_KEYS.index(key)&.to_s || key
+        end
+
+        # Sort the cops by their key name, putting comments at the top
+        cops.sort_by! { |cop| chunk_name(cop) || 'AAAAA/Comment?' }
+
+        self
+      end
+
+      def empty?
+        cops.empty? && preamble.empty?
+      end
+
+      def lines
+        combined = (preamble + cops).flatten
+        combined.pop # there's always one empty newline because of how we parse
+        combined
+      end
+
+      def to_s
+        lines.join
+      end
+
+      def write(file_path)
+        File.write(file_path, to_s)
+      end
+
+      private
+
+      # Return the name of a chunk by finding the root key
+      def chunk_name(chunk)
+        # Try to find a line that exactly matches KEY_REGEX
+        # Use rstrip, not strip, to preserve indentation
+        name_line = chunk.find { |line| line.rstrip.match?(KEY_REGEX) }
+        name_line&.rstrip&.delete_suffix(':')
+      end
+
+      # Splits the lines into blocks whenever we drop from indented to unindented
+      def chunk_blocks(lines)
+        # slice whenever we drop from indented to unindented
+        chunks = lines.slice_when do |prev, line|
+          prev.match?(INDENT_REGEX) && !prev.strip.empty? && !line.match?(INDENT_REGEX)
+        end
+
+        # Process each chunk to remove leading newlines and add 1 trailing newline
+        chunks.filter_map do |chunk|
+          # Remove leading and trailing empty lines
+          chunk.shift while chunk.first.to_s.strip.empty?
+          chunk.pop while chunk.last.to_s.strip.empty?
+
+          # Ensure each chunk ends with a blank newline
+          chunk << "\n"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gusto/init.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'yaml'
+require 'rubocop/gusto/config_yml'
+
+module RuboCop
+  module Gusto
+    class Init < Thor::Group
+      include Thor::Actions
+
+      PLUGINS = %w(rubocop-gusto rubocop-rspec rubocop-performance rubocop-rake rubocop-rails).freeze
+
+      class_option :rubocop_yml, type: :string, default: '.rubocop.yml'
+
+      def self.source_root
+        File.expand_path('templates', __dir__)
+      end
+
+      def add_dependencies
+        if rails?
+          # we don't want rubocop-rails to be a dependency of the gem so that we can use this in non-rails gems
+          run 'bundle show rubocop-rails >/dev/null || bundle add rubocop-rails --group development', capture: true
+        end
+
+        run 'bundle binstub rubocop', capture: true
+      end
+
+      def copy_config_files
+        config = ConfigYml.load_file(options[:rubocop_yml])
+
+        if config.empty?
+          template 'rubocop.yml', options[:rubocop_yml]
+          config = ConfigYml.load_file(options[:rubocop_yml])
+        end
+
+        if rails?
+          config.add_inherit_gem('rubocop-gusto', 'config/default.yml', 'config/rails.yml')
+          config.add_plugin(PLUGINS)
+        else
+          config.add_inherit_gem('rubocop-gusto', 'config/default.yml')
+          config.add_plugin(PLUGINS - %w(rubocop-rails))
+        end
+
+        config.sort!
+        config.write(options[:rubocop_yml])
+        say_status 'update', options[:rubocop_yml]
+
+        create_file('.rubocop_todo.yml', skip: true)
+      end
+
+      private
+
+      def rails?
+        File.exist?('config/application.rb')
+      end
+    end
+  end
+end

data/lib/rubocop/gusto/plugin.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module Gusto
+    # A plugin that integrates Gusto's standard RuboCop cops and rules.
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-gusto',
+          version: RuboCop::Gusto::VERSION,
+          homepage: 'https://github.com/Gusto/rubocop-gusto',
+          description: "A collection of Gusto's standard RuboCop cops and rules."
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        project_root = Pathname.new(__dir__).join('../../..')
+
+        LintRoller::Rules.new(type: :path, config_format: :rubocop, value: project_root.join('config', 'default.yml'))
+      end
+    end
+  end
+end

data/lib/rubocop/gusto/templates/rubocop.yml

@@ -0,0 +1,25 @@
+inherit_from: .rubocop_todo.yml
+
+inherit_mode:
+  merge:
+    - Include
+
+inherit_gem:
+  rubocop-gusto:
+    - config/default.yml
+
+plugins:
+  - rubocop-gusto
+  - rubocop-rspec
+  - rubocop-performance
+  - rubocop-rake
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.2
+
+Layout/LineLength:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false

data/lib/rubocop/gusto/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Gusto
+    VERSION = '10.0.0'
+  end
+end

data/lib/rubocop/gusto.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'gusto/version'
+
+module RuboCop
+  # RuboCop Gusto project namespace.
+  module Gusto
+  end
+end