fablicop 1.10.1 → 1.10.2

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/message_annotator.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Message Annotator class annotates a basic offense message
+    # based on params passed into initializer.
+    #
+    # @see #initialize
+    #
+    # @example
+    #   RuboCop::Cop::MessageAnnotator.new(
+    #     config, cop_name, cop_config, @options
+    #   ).annotate('message')
+    #  #=> 'Cop/CopName: message (http://example.org/styleguide)'
+    class MessageAnnotator
+      attr_reader :options, :config, :cop_name, :cop_config
+
+      @style_guide_urls = {}
+
+      class << self
+        attr_reader :style_guide_urls
+      end
+
+      # @param config [RuboCop::Config] Check configs for all cops
+      #   @note Message Annotator specifically checks the
+      #     following config options for_all_cops
+      #     :StyleGuideBaseURL [String] URL for styleguide
+      #     :DisplayStyleGuide [Boolean] Include styleguide and reference URLs
+      #     :ExtraDetails [Boolean] Include cop details
+      #     :DisplayCopNames [Boolean] Include cop name
+      #
+      # @param [String] cop_name for specific cop name
+      # @param [Hash] cop_config configs for specific cop, from config#for_cop
+      # @option cop_config [String] :StyleGuide Extension of base styleguide URL
+      # @option cop_config [String] :Reference Full reference URL
+      # @option cop_config [String] :Details
+      #
+      # @param [Hash, nil] options optional
+      # @option options [Boolean] :display_style_guide
+      #   Include style guide and reference URLs
+      # @option options [Boolean] :extra_details
+      #   Include cop specific details
+      # @option options [Boolean] :debug
+      #   Include debug output
+      # @option options [Boolean] :display_cop_names
+      #   Include cop name
+      def initialize(config, cop_name, cop_config, options)
+        @config = config
+        @cop_name = cop_name
+        @cop_config = cop_config || {}
+        @options = options
+      end
+
+      # Returns the annotated message,
+      # based on params passed into initializer
+      #
+      # @return [String] annotated message
+      def annotate(message)
+        message = "#{cop_name}: #{message}" if display_cop_names?
+        message += " #{details}" if extra_details? && details
+        if display_style_guide?
+          links = urls.join(', ')
+          message = "#{message} (#{links})"
+        end
+        message
+      end
+
+      def urls
+        [style_guide_url, *reference_urls].compact
+      end
+
+      private
+
+      def style_guide_url
+        url = cop_config['StyleGuide']
+        return nil if url.nil? || url.empty?
+
+        self.class.style_guide_urls[url] ||= begin
+          base_url = style_guide_base_url
+          if base_url.nil? || base_url.empty?
+            url
+          else
+            URI.join(base_url, url).to_s
+          end
+        end
+      end
+
+      # Returns the base style guide URL from AllCops or the specific department
+      #
+      # @return [String] style guide URL
+      def style_guide_base_url
+        department_name = cop_name.split('/')[0..-2].join('/')
+
+        config.for_department(department_name)['StyleGuideBaseURL'] ||
+          config.for_all_cops['StyleGuideBaseURL']
+      end
+
+      def display_style_guide?
+        (options[:display_style_guide] || config.for_all_cops['DisplayStyleGuide']) && !urls.empty?
+      end
+
+      def reference_urls
+        urls = Array(cop_config['Reference'])
+        urls.nil? || urls.empty? ? nil : urls.reject(&:empty?)
+      end
+
+      def extra_details?
+        options[:extra_details] || config.for_all_cops['ExtraDetails']
+      end
+
+      def debug?
+        options[:debug]
+      end
+
+      def display_cop_names?
+        return true if debug?
+        return false if options[:display_cop_names] == false
+        return true if options[:display_cop_names]
+        return false if options[:format] == 'json'
+
+        config.for_all_cops['DisplayCopNames']
+      end
+
+      def details
+        details = cop_config && cop_config['Details']
+        details.nil? || details.empty? ? nil : details
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/metrics/abc_size.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks that the ABC size of methods is not higher than the
+      # configured maximum. The ABC size is based on assignments, branches
+      # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
+      # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
+      #
+      # Interpreting ABC size:
+      #
+      # * <= 17 satisfactory
+      # * 18..30 unsatisfactory
+      # * > 30 dangerous
+      #
+      # You can have repeated "attributes" calls count as a single "branch".
+      # For this purpose, attributes are any method with no argument; no attempt
+      # is meant to distinguish actual `attr_reader` from other methods.
+      #
+      # @example CountRepeatedAttributes: false (default is true)
+      #
+      #    # `model` and `current_user`, referenced 3 times each,
+      #    # are each counted as only 1 branch each if
+      #    # `CountRepeatedAttributes` is set to 'false'
+      #
+      #    def search
+      #      @posts = model.active.visible_by(current_user)
+      #                .search(params[:q])
+      #      @posts = model.some_process(@posts, current_user)
+      #      @posts = model.another_process(@posts, current_user)
+      #
+      #      render 'pages/search/page'
+      #    end
+      #
+      # This cop also takes into account `AllowedMethods` (defaults to `[]`)
+      # And `AllowedPatterns` (defaults to `[]`)
+      #
+      class AbcSize < Base
+        include MethodComplexity
+
+        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+              '[%<abc_vector>s %<complexity>.4g/%<max>.4g]'
+
+        private
+
+        def complexity(node)
+          Utils::AbcSizeCalculator.calculate(
+            node,
+            discount_repeated_attributes: !cop_config['CountRepeatedAttributes']
+          )
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/metrics/block_length.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks if the length of a block exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      # The cop can be configured to ignore blocks passed to certain methods.
+      #
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
+      # will be counted as one line regardless of its actual size.
+      #
+      #
+      # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
+      # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
+      # instead. By default, there are no methods to allowed.
+      #
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      #
+      #   something do
+      #     array = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     msg = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
+      #
+      # NOTE: This cop does not apply for `Struct` definitions.
+      class BlockLength < Base
+        include CodeLength
+        include AllowedMethods
+        include AllowedPattern
+
+        LABEL = 'Block'
+
+        def on_block(node)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+          return if method_receiver_excluded?(node)
+          return if node.class_constructor?
+
+          check_code_length(node)
+        end
+        alias on_numblock on_block
+
+        private
+
+        def method_receiver_excluded?(node)
+          node_receiver = node.receiver&.source&.gsub(/\s+/, '')
+          node_method = String(node.method_name)
+
+          allowed_methods.any? do |config|
+            next unless config.is_a?(String)
+
+            receiver, method = config.split('.')
+
+            unless method
+              method = receiver
+              receiver = node_receiver
+            end
+
+            method == node_method && receiver == node_receiver
+          end
+        end
+
+        def cop_label
+          LABEL
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/metrics/block_nesting.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks for excessive nesting of conditional and looping
+      # constructs.
+      #
+      # You can configure if blocks are considered using the `CountBlocks`
+      # option. When set to `false` (the default) blocks are not counted
+      # towards the nesting level. Set to `true` to count blocks as well.
+      #
+      # The maximum level of nesting allowed is configurable.
+      class BlockNesting < Base
+        NESTING_BLOCKS = %i[case case_match if while while_post until until_post for resbody].freeze
+
+        exclude_limit 'Max'
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          max = cop_config['Max']
+          check_nesting_level(processed_source.ast, max, 0)
+        end
+
+        private
+
+        def check_nesting_level(node, max, current_level)
+          if consider_node?(node)
+            current_level += 1 unless node.if_type? && node.elsif?
+            if current_level > max
+              self.max = current_level
+              unless part_of_ignored_node?(node)
+                add_offense(node, message: message(max)) { ignore_node(node) }
+              end
+            end
+          end
+
+          node.each_child_node do |child_node|
+            check_nesting_level(child_node, max, current_level)
+          end
+        end
+
+        def consider_node?(node)
+          return true if NESTING_BLOCKS.include?(node.type)
+
+          count_blocks? && (node.block_type? || node.numblock_type?)
+        end
+
+        def message(max)
+          "Avoid more than #{max} levels of block nesting."
+        end
+
+        def count_blocks?
+          cop_config['CountBlocks']
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/metrics/class_length.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks if the length of a class exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      #
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
+      # will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      #
+      #   class Foo
+      #     ARRAY = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     HASH = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     MSG = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
+      #
+      #
+      # NOTE: This cop also applies for `Struct` definitions.
+      class ClassLength < Base
+        include CodeLength
+
+        def on_class(node)
+          check_code_length(node)
+        end
+        alias on_sclass on_class
+
+        def on_casgn(node)
+          parent = node.parent
+
+          if parent&.assignment?
+            block_node = parent.children[1]
+          elsif parent&.parent&.masgn_type?
+            block_node = parent.parent.children[1]
+          else
+            _scope, _name, block_node = *node
+          end
+
+          return unless block_node.respond_to?(:class_definition?) && block_node.class_definition?
+
+          check_code_length(block_node)
+        end
+
+        private
+
+        def message(length, max_length)
+          format('Class has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/metrics/collection_literal_length.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks for literals with extremely many entries. This is indicative of
+      # configuration or data that may be better extracted somewhere else, like
+      # a database, fetched from an API, or read from a non-code file (CSV,
+      # JSON, YAML, etc.).
+      #
+      # @example
+      #   # bad
+      #   # Huge Array literal
+      #   [1, 2, '...', 999_999_999]
+      #
+      #   # bad
+      #   # Huge Hash literal
+      #   { 1 => 1, 2 => 2, '...' => '...', 999_999_999 => 999_999_999}
+      #
+      #   # bad
+      #   # Huge Set "literal"
+      #   Set[1, 2, '...', 999_999_999]
+      #
+      #   # good
+      #   # Reasonably sized Array literal
+      #   [1, 2, '...', 10]
+      #
+      #   # good
+      #   # Reading huge Array from external data source
+      #   # File.readlines('numbers.txt', chomp: true).map!(&:to_i)
+      #
+      #   # good
+      #   # Reasonably sized Hash literal
+      #   { 1 => 1, 2 => 2, '...' => '...', 10 => 10}
+      #
+      #   # good
+      #   # Reading huge Hash from external data source
+      #   CSV.foreach('numbers.csv', headers: true).each_with_object({}) do |row, hash|
+      #     hash[row["key"].to_i] = row["value"].to_i
+      #   end
+      #
+      #   # good
+      #   # Reasonably sized Set "literal"
+      #   Set[1, 2, '...', 10]
+      #
+      #   # good
+      #   # Reading huge Set from external data source
+      #   SomeFramework.config_for(:something)[:numbers].to_set
+      #
+      class CollectionLiteralLength < Base
+        MSG = 'Avoid hard coding large quantities of data in code. ' \
+              'Prefer reading the data from an external source.'
+        RESTRICT_ON_SEND = [:[]].freeze
+
+        def on_array(node)
+          add_offense(node) if node.children.length >= collection_threshold
+        end
+        alias on_hash on_array
+
+        def on_index(node)
+          add_offense(node) if node.arguments.length >= collection_threshold
+        end
+
+        def on_send(node)
+          on_index(node) if node.method?(:[])
+        end
+
+        private
+
+        def collection_threshold
+          cop_config.fetch('LengthThreshold', Float::INFINITY)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/metrics/cyclomatic_complexity.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks that the cyclomatic complexity of methods is not higher
+      # than the configured maximum. The cyclomatic complexity is the number of
+      # linearly independent paths through a method. The algorithm counts
+      # decision points and adds one.
+      #
+      # An if statement (or unless or ?:) increases the complexity by one. An
+      # else branch does not, since it doesn't add a decision point. The &&
+      # operator (or keyword and) can be converted to a nested if statement,
+      # and ||/or is shorthand for a sequence of ifs, so they also add one.
+      # Loops can be said to have an exit condition, so they add one.
+      # Blocks that are calls to builtin iteration methods
+      # (e.g. `ary.map{...}) also add one, others are ignored.
+      #
+      #   def each_child_node(*types)               # count begins: 1
+      #     unless block_given?                     # unless: +1
+      #       return to_enum(__method__, *types)
+      #
+      #     children.each do |child|                # each{}: +1
+      #       next unless child.is_a?(Node)         # unless: +1
+      #
+      #       yield child if types.empty? ||        # if: +1, ||: +1
+      #                      types.include?(child.type)
+      #     end
+      #
+      #     self
+      #   end                                       # total: 6
+      class CyclomaticComplexity < Base
+        include MethodComplexity
+        include Utils::IteratingBlock
+
+        MSG = 'Cyclomatic complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
+        COUNTED_NODES = %i[if while until for csend block block_pass
+                           rescue when in_pattern and or or_asgn and_asgn].freeze
+
+        private
+
+        def complexity_score_for(node)
+          return 0 if iterating_block?(node) == false
+          return 0 if node.csend_type? && discount_for_repeated_csend?(node)
+
+          1
+        end
+
+        def count_block?(block)
+          KNOWN_ITERATING_METHODS.include? block.method_name
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/metrics/method_length.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks if the length of a method exceeds some maximum value.
+      # Comment lines can optionally be allowed.
+      # The maximum allowed length is configurable.
+      #
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
+      # will be counted as one line regardless of its actual size.
+      #
+      # NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
+      # deprecated and only kept for backwards compatibility.
+      # Please use `AllowedMethods` and `AllowedPatterns` instead.
+      # By default, there are no methods to allowed.
+      #
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      #
+      #   def m
+      #     array = [       # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {        # +3
+      #       key: 'value'
+      #     }
+      #
+      #     <<~HEREDOC      # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(            # +1
+      #       1,
+      #       2
+      #     )
+      #   end               # 6 points
+      #
+      class MethodLength < Base
+        include CodeLength
+        include AllowedMethods
+        include AllowedPattern
+
+        LABEL = 'Method'
+
+        def on_def(node)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+
+          check_code_length(node)
+        end
+        alias on_defs on_def
+
+        def on_block(node)
+          return unless node.send_node.method?(:define_method)
+
+          check_code_length(node)
+        end
+        alias on_numblock on_block
+
+        private
+
+        def cop_label
+          LABEL
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/metrics/module_length.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks if the length of a module exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      #
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
+      # will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      #
+      #   module M
+      #     ARRAY = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     HASH = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     MSG = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
+      #
+      class ModuleLength < Base
+        include CodeLength
+
+        def on_module(node)
+          check_code_length(node)
+        end
+
+        def on_casgn(node)
+          module_definition?(node) { check_code_length(node) }
+        end
+
+        private
+
+        # @!method module_definition?(node)
+        def_node_matcher :module_definition?, <<~PATTERN
+          (casgn nil? _ ({block numblock} (send (const {nil? cbase} :Module) :new) ...))
+        PATTERN
+
+        def message(length, max_length)
+          format('Module has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        end
+      end
+    end
+  end
+end