study_line 0.2.7 → 0.2.8

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      # Checks for methods with too many parameters.
-      #
-      # The maximum number of parameters is configurable.
-      # Keyword arguments can optionally be excluded from the total count,
-      # as they add less complexity than positional or optional parameters.
-      #
-      # Any number of arguments for `initialize` method inside a block of
-      # `Struct.new` and `Data.define` like this is always allowed:
-      #
-      # [source,ruby]
-      # ----
-      # Struct.new(:one, :two, :three, :four, :five, keyword_init: true) do
-      #   def initialize(one:, two:, three:, four:, five:)
-      #   end
-      # end
-      # ----
-      #
-      # This is because checking the number of arguments of the `initialize` method
-      # does not make sense.
-      #
-      # NOTE: Explicit block argument `&block` is not counted to prevent
-      # erroneous change that is avoided by making block argument implicit.
-      #
-      # @example Max: 3
-      #   # good
-      #   def foo(a, b, c = 1)
-      #   end
-      #
-      # @example Max: 2
-      #   # bad
-      #   def foo(a, b, c = 1)
-      #   end
-      #
-      # @example CountKeywordArgs: true (default)
-      #   # counts keyword args towards the maximum
-      #
-      #   # bad (assuming Max is 3)
-      #   def foo(a, b, c, d: 1)
-      #   end
-      #
-      #   # good (assuming Max is 3)
-      #   def foo(a, b, c: 1)
-      #   end
-      #
-      # @example CountKeywordArgs: false
-      #   # don't count keyword args towards the maximum
-      #
-      #   # good (assuming Max is 3)
-      #   def foo(a, b, c, d: 1)
-      #   end
-      #
-      # This cop also checks for the maximum number of optional parameters.
-      # This can be configured using the `MaxOptionalParameters` config option.
-      #
-      # @example MaxOptionalParameters: 3 (default)
-      #   # good
-      #   def foo(a = 1, b = 2, c = 3)
-      #   end
-      #
-      # @example MaxOptionalParameters: 2
-      #   # bad
-      #   def foo(a = 1, b = 2, c = 3)
-      #   end
-      #
-      class ParameterLists < Base
-        exclude_limit 'Max'
-        exclude_limit 'MaxOptionalParameters'
-
-        MSG = 'Avoid parameter lists longer than %<max>d parameters. [%<count>d/%<max>d]'
-        OPTIONAL_PARAMETERS_MSG = 'Method has too many optional parameters. [%<count>d/%<max>d]'
-
-        NAMED_KEYWORD_TYPES = %i[kwoptarg kwarg].freeze
-        private_constant :NAMED_KEYWORD_TYPES
-
-        # @!method struct_new_or_data_define_block?(node)
-        def_node_matcher :struct_new_or_data_define_block?, <<~PATTERN
-          (block
-            {
-              (send (const {nil? cbase} :Struct) :new ...)
-              (send (const {nil? cbase} :Data) :define ...)
-            }
-            (args) ...)
-        PATTERN
-
-        def on_def(node)
-          optargs = node.arguments.select(&:optarg_type?)
-          return if optargs.count <= max_optional_parameters
-
-          message = format(
-            OPTIONAL_PARAMETERS_MSG,
-            max: max_optional_parameters,
-            count: optargs.count
-          )
-
-          add_offense(node, message: message) { self.max_optional_parameters = optargs.count }
-        end
-        alias on_defs on_def
-
-        def on_args(node)
-          parent = node.parent
-          return if parent.method?(:initialize) && struct_new_or_data_define_block?(parent.parent)
-
-          count = args_count(node)
-          return unless count > max_params
-
-          return if argument_to_lambda_or_proc?(node)
-
-          add_offense(node, message: format(MSG, max: max_params, count: args_count(node))) do
-            self.max = count
-          end
-        end
-
-        private
-
-        # @!method argument_to_lambda_or_proc?(node)
-        def_node_matcher :argument_to_lambda_or_proc?, <<~PATTERN
-          ^lambda_or_proc?
-        PATTERN
-
-        def args_count(node)
-          if count_keyword_args?
-            node.children.count { |a| !a.blockarg_type? }
-          else
-            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) && !a.blockarg_type? }
-          end
-        end
-
-        def max_params
-          cop_config['Max']
-        end
-
-        def max_optional_parameters
-          cop_config['MaxOptionalParameters']
-        end
-
-        def count_keyword_args?
-          cop_config['CountKeywordArgs']
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      # Tries to produce a complexity score that's a measure of the
-      # complexity the reader experiences when looking at a method. For that
-      # reason it considers `when` nodes as something that doesn't add as much
-      # complexity as an `if` or a `&&`. Except if it's one of those special
-      # `case`/`when` constructs where there's no expression after `case`. Then
-      # the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when`
-      # nodes count. In contrast to the CyclomaticComplexity cop, this cop
-      # considers `else` nodes as adding complexity.
-      #
-      # @example
-      #
-      #   def my_method                   # 1
-      #     if cond                       # 1
-      #       case var                    # 2 (0.8 + 4 * 0.2, rounded)
-      #       when 1 then func_one
-      #       when 2 then func_two
-      #       when 3 then func_three
-      #       when 4..10 then func_other
-      #       end
-      #     else                          # 1
-      #       do_something until a && b   # 2
-      #     end                           # ===
-      #   end                             # 7 complexity points
-      class PerceivedComplexity < CyclomaticComplexity
-        MSG = 'Perceived complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
-
-        COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze
-
-        private
-
-        def complexity_score_for(node)
-          case node.type
-          when :case
-            # If cond is nil, that means each when has an expression that
-            # evaluates to true or false. It's just an alternative to
-            # if/elsif/elsif... so the when nodes count.
-            nb_branches = node.when_branches.length + (node.else_branch ? 1 : 0)
-            if node.condition.nil?
-              nb_branches
-            else
-              # Otherwise, the case node gets 0.8 complexity points and each
-              # when gets 0.2.
-              ((nb_branches * 0.2) + 0.8).round
-            end
-          when :if
-            node.else? && !node.elsif? ? 2 : 1
-          else
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      module Utils
-        # > ABC is .. a software size metric .. computed by counting the number
-        # > of assignments, branches and conditions for a section of code.
-        # > http://c2.com/cgi/wiki?AbcMetric
-        #
-        # We separate the *calculator* from the *cop* so that the calculation,
-        # the formula itself, is easier to test.
-        class AbcSizeCalculator
-          include IteratingBlock
-          include RepeatedCsendDiscount
-          prepend RepeatedAttributeDiscount
-
-          # > Branch -- an explicit forward program branch out of scope -- a
-          # > function call, class method call ..
-          # > http://c2.com/cgi/wiki?AbcMetric
-          BRANCH_NODES = %i[send csend yield].freeze
-
-          # > Condition -- a logical/Boolean test, == != <= >= < > else case
-          # > default try catch ? and unary conditionals.
-          # > http://c2.com/cgi/wiki?AbcMetric
-          CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
-
-          private_constant :BRANCH_NODES, :CONDITION_NODES
-
-          def self.calculate(node, discount_repeated_attributes: false)
-            new(node, discount_repeated_attributes: discount_repeated_attributes).calculate
-          end
-
-          def initialize(node)
-            @assignment = 0
-            @branch = 0
-            @condition = 0
-            @node = node
-            reset_repeated_csend
-          end
-
-          def calculate
-            visit_depth_last(@node) { |child| calculate_node(child) }
-
-            [
-              Math.sqrt((@assignment**2) + (@branch**2) + (@condition**2)).round(2),
-              "<#{@assignment}, #{@branch}, #{@condition}>"
-            ]
-          end
-
-          def evaluate_branch_nodes(node)
-            if node.comparison_method?
-              @condition += 1
-            else
-              @branch += 1
-              @condition += 1 if node.csend_type? && !discount_for_repeated_csend?(node)
-            end
-          end
-
-          def evaluate_condition_node(node)
-            @condition += 1 if else_branch?(node)
-            @condition += 1
-          end
-
-          def else_branch?(node)
-            %i[case if].include?(node.type) && node.else? && node.loc.else.is?('else')
-          end
-
-          private
-
-          def visit_depth_last(node, &block)
-            node.each_child_node { |child| visit_depth_last(child, &block) }
-            yield node
-          end
-
-          def calculate_node(node)
-            @assignment += 1 if assignment?(node)
-
-            if branch?(node)
-              evaluate_branch_nodes(node)
-            elsif condition?(node)
-              evaluate_condition_node(node)
-            end
-          end
-
-          def assignment?(node)
-            return compound_assignment(node) if node.masgn_type? || node.shorthand_asgn?
-
-            node.for_type? ||
-              (node.respond_to?(:setter_method?) && node.setter_method?) ||
-              simple_assignment?(node) ||
-              argument?(node)
-          end
-
-          def compound_assignment(node)
-            # Methods setter cannot be detected for multiple assignments
-            # and shorthand assigns, so we'll count them here instead
-            children = node.masgn_type? ? node.children[0].children : node.children
-
-            will_be_miscounted = children.count do |child|
-              child.respond_to?(:setter_method?) && !child.setter_method?
-            end
-            @assignment += will_be_miscounted
-
-            false
-          end
-
-          def simple_assignment?(node)
-            if !node.equals_asgn?
-              false
-            elsif node.lvasgn_type?
-              reset_on_lvasgn(node)
-              capturing_variable?(node.children.first)
-            else
-              true
-            end
-          end
-
-          def capturing_variable?(name)
-            name && !name.start_with?('_')
-          end
-
-          def branch?(node)
-            BRANCH_NODES.include?(node.type)
-          end
-
-          def argument?(node)
-            node.argument_type? && capturing_variable?(node.children.first)
-          end
-
-          def condition?(node)
-            return false if iterating_block?(node) == false
-
-            CONDITION_NODES.include?(node.type)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      module Utils
-        # Helps to calculate code length for the provided node.
-        class CodeLengthCalculator
-          extend NodePattern::Macros
-          include Util
-
-          FOLDABLE_TYPES = %i[array hash heredoc send csend].freeze
-          CLASSLIKE_TYPES = %i[class module].freeze
-          private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
-
-          def initialize(node, processed_source, count_comments: false, foldable_types: [])
-            @node = node
-            @processed_source = processed_source
-            @count_comments = count_comments
-            @foldable_checks = build_foldable_checks(foldable_types)
-            @foldable_types = normalize_foldable_types(foldable_types)
-          end
-
-          def calculate
-            length = code_length(@node)
-            return length if @foldable_types.empty?
-
-            each_top_level_descendant(@node, @foldable_types) do |descendant|
-              next unless foldable_node?(descendant)
-
-              descendant_length = code_length(descendant)
-              length = length - descendant_length + 1
-              # Subtract length of opening and closing brace if method argument omits hash braces.
-              length -= omit_length(descendant) if descendant.hash_type? && !descendant.braces?
-            end
-
-            length
-          end
-
-          private
-
-          def build_foldable_checks(types) # rubocop:disable Metrics/MethodLength
-            types.map do |type|
-              case type
-              when :array
-                ->(node) { node.array_type? }
-              when :hash
-                ->(node) { node.hash_type? }
-              when :heredoc
-                ->(node) { heredoc_node?(node) }
-              when :method_call
-                ->(node) { node.call_type? }
-              else
-                raise ArgumentError, "Unknown foldable type: #{type.inspect}. " \
-                                     "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
-              end
-            end
-          end
-
-          def normalize_foldable_types(types)
-            types.push(:str, :dstr) if types.delete(:heredoc)
-            types.push(:send, :csend) if types.delete(:method_call)
-            types
-          end
-
-          def code_length(node) # rubocop:disable Metrics/MethodLength
-            if classlike_node?(node)
-              classlike_code_length(node)
-            elsif heredoc_node?(node)
-              heredoc_length(node)
-            else
-              body = extract_body(node)
-              return 0 unless body
-
-              source =
-                if node_with_heredoc?(body)
-                  source_from_node_with_heredoc(body)
-                else
-                  body.source.lines
-                end
-
-              source.count { |line| !irrelevant_line?(line) }
-            end
-          end
-
-          def heredoc_node?(node)
-            node.respond_to?(:heredoc?) && node.heredoc?
-          end
-
-          def classlike_code_length(node)
-            return 0 if namespace_module?(node)
-
-            body_line_numbers = line_range(node).to_a[1...-1]
-
-            target_line_numbers = body_line_numbers -
-                                  line_numbers_of_inner_nodes(node, :module, :class)
-
-            target_line_numbers.reduce(0) do |length, line_number|
-              source_line = @processed_source[line_number]
-              next length if irrelevant_line?(source_line)
-
-              length + 1
-            end
-          end
-
-          def namespace_module?(node)
-            classlike_node?(node.body)
-          end
-
-          def line_numbers_of_inner_nodes(node, *types)
-            line_numbers = Set.new
-
-            node.each_descendant(*types) do |inner_node|
-              line_range = line_range(inner_node)
-              line_numbers.merge(line_range)
-            end
-
-            line_numbers.to_a
-          end
-
-          def heredoc_length(node)
-            lines = node.loc.heredoc_body.source.lines
-            lines.count { |line| !irrelevant_line?(line) } + 2
-          end
-
-          def each_top_level_descendant(node, types, &block)
-            node.each_child_node do |child|
-              next if classlike_node?(child)
-
-              if types.include?(child.type)
-                yield child
-              else
-                each_top_level_descendant(child, types, &block)
-              end
-            end
-          end
-
-          def classlike_node?(node)
-            CLASSLIKE_TYPES.include?(node&.type)
-          end
-
-          def foldable_node?(node)
-            @foldable_checks.any? { |check| check.call(node) }
-          end
-
-          def extract_body(node)
-            case node.type
-            when :class, :module, :sclass, :block, :numblock, :def, :defs
-              node.body
-            when :casgn
-              _scope, _name, value = *node
-              extract_body(value)
-            else
-              node
-            end
-          end
-
-          # Returns true for lines that shall not be included in the count.
-          def irrelevant_line?(source_line)
-            source_line.blank? || (!count_comments? && comment_line?(source_line))
-          end
-
-          def count_comments?
-            @count_comments
-          end
-
-          def omit_length(descendant)
-            parent = descendant.parent
-            return 0 if another_args?(parent)
-            return 0 unless parenthesized?(parent)
-
-            [
-              parent.loc.begin.end_pos != descendant.source_range.begin_pos,
-              parent.loc.end.begin_pos != descendant.source_range.end_pos
-            ].count(true)
-          end
-
-          def parenthesized?(node)
-            node.call_type? && node.parenthesized?
-          end
-
-          def another_args?(node)
-            node.call_type? && node.arguments.count > 1
-          end
-
-          def node_with_heredoc?(node)
-            node.each_descendant(:str, :dstr).any? { |descendant| heredoc_node?(descendant) }
-          end
-
-          def source_from_node_with_heredoc(node)
-            last_line = -1
-            node.each_descendant do |descendant|
-              next unless descendant.source
-
-              descendant_last_line =
-                if heredoc_node?(descendant)
-                  descendant.loc.heredoc_end.line
-                else
-                  descendant.last_line
-                end
-
-              last_line = [last_line, descendant_last_line].max
-            end
-            @processed_source[(node.first_line - 1)..(last_line - 1)]
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/metrics/utils/iterating_block.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Metrics
-      module Utils
-        # Used to identify iterating blocks like `.map{}` and `.map(&:...)`
-        module IteratingBlock
-          enumerable = %i[
-            all? any? chain chunk chunk_while collect collect_concat count cycle
-            detect drop drop_while each each_cons each_entry each_slice
-            each_with_index each_with_object entries filter filter_map find
-            find_all find_index flat_map grep grep_v group_by inject lazy map
-            max max_by min min_by minmax minmax_by none? one? partition reduce
-            reject reverse_each select slice_after slice_before slice_when sort
-            sort_by sum take take_while tally to_h uniq zip
-          ]
-
-          enumerator = %i[with_index with_object]
-
-          array = %i[
-            bsearch bsearch_index collect! combination d_permutation delete_if
-            each_index keep_if map! permutation product reject! repeat
-            repeated_combination select! sort sort! sort_by sort_by
-          ]
-
-          hash = %i[
-            each_key each_pair each_value fetch fetch_values has_key? merge
-            merge! transform_keys transform_keys! transform_values
-            transform_values!
-          ]
-
-          KNOWN_ITERATING_METHODS = (Set.new(enumerable) + enumerator + array + hash).freeze
-
-          # Returns the name of the method called with a block
-          # if node is a block node, or a block-pass node.
-          def block_method_name(node)
-            case node.type
-            when :block
-              node.method_name
-            when :block_pass
-              node.parent.method_name
-            end
-          end
-
-          # Returns true iff name is a known iterating type (e.g. :each, :transform_values)
-          def iterating_method?(name)
-            KNOWN_ITERATING_METHODS.include? name
-          end
-
-          # Returns nil if node is neither a block node or a block-pass node.
-          # Otherwise returns true/false if method call is a known iterating call
-          def iterating_block?(node)
-            name = block_method_name(node)
-            name && iterating_method?(name)
-          end
-        end
-      end
-    end
-  end
-end