fablicop 1.10.1 → 1.10.3

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/float_division.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for division with integers coerced to floats.
+      # It is recommended to either always use `fdiv` or coerce one side only.
+      # This cop also provides other options for code consistency.
+      #
+      # @safety
+      #   This cop is unsafe, because if the operand variable is a string object
+      #   then `.to_f` will be removed and an error will occur.
+      #
+      #   [source,ruby]
+      #   ----
+      #   a = '1.2'
+      #   b = '3.4'
+      #   a.to_f / b.to_f # Both `to_f` calls are required here
+      #   ----
+      #
+      # @example EnforcedStyle: single_coerce (default)
+      #   # bad
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.to_f / b
+      #   a / b.to_f
+      #
+      # @example EnforcedStyle: left_coerce
+      #   # bad
+      #   a / b.to_f
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.to_f / b
+      #
+      # @example EnforcedStyle: right_coerce
+      #   # bad
+      #   a.to_f / b
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a / b.to_f
+      #
+      # @example EnforcedStyle: fdiv
+      #   # bad
+      #   a / b.to_f
+      #   a.to_f / b
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.fdiv(b)
+      class FloatDivision < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MESSAGES = {
+          left_coerce: 'Prefer using `.to_f` on the left side.',
+          right_coerce: 'Prefer using `.to_f` on the right side.',
+          single_coerce: 'Prefer using `.to_f` on one side only.',
+          fdiv: 'Prefer using `fdiv` for float divisions.'
+        }.freeze
+
+        RESTRICT_ON_SEND = %i[/].freeze
+
+        # @!method right_coerce?(node)
+        def_node_matcher :right_coerce?, <<~PATTERN
+          (send _ :/ (send _ :to_f))
+        PATTERN
+        # @!method left_coerce?(node)
+        def_node_matcher :left_coerce?, <<~PATTERN
+          (send (send _ :to_f) :/ _)
+        PATTERN
+        # @!method both_coerce?(node)
+        def_node_matcher :both_coerce?, <<~PATTERN
+          (send (send _ :to_f) :/ (send _ :to_f))
+        PATTERN
+        # @!method any_coerce?(node)
+        def_node_matcher :any_coerce?, <<~PATTERN
+          {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
+        PATTERN
+
+        def on_send(node)
+          return unless offense_condition?(node)
+
+          add_offense(node) do |corrector|
+            case style
+            when :left_coerce, :single_coerce
+              add_to_f_method(corrector, node.receiver)
+              remove_to_f_method(corrector, node.first_argument)
+            when :right_coerce
+              remove_to_f_method(corrector, node.receiver)
+              add_to_f_method(corrector, node.first_argument)
+            when :fdiv
+              correct_from_slash_to_fdiv(corrector, node, node.receiver, node.first_argument)
+            end
+          end
+        end
+
+        private
+
+        def offense_condition?(node)
+          case style
+          when :left_coerce
+            right_coerce?(node)
+          when :right_coerce
+            left_coerce?(node)
+          when :single_coerce
+            both_coerce?(node)
+          when :fdiv
+            any_coerce?(node)
+          else
+            false
+          end
+        end
+
+        def message(_node)
+          MESSAGES[style]
+        end
+
+        def add_to_f_method(corrector, node)
+          corrector.insert_after(node, '.to_f') unless node.send_type? && node.method?(:to_f)
+        end
+
+        def remove_to_f_method(corrector, send_node)
+          corrector.remove(send_node.loc.dot)
+          corrector.remove(send_node.loc.selector)
+        end
+
+        def correct_from_slash_to_fdiv(corrector, node, receiver, argument)
+          receiver_source = extract_receiver_source(receiver)
+          argument_source = extract_receiver_source(argument)
+
+          if argument.respond_to?(:parenthesized?) && !argument.parenthesized?
+            argument_source = "(#{argument_source})"
+          end
+
+          corrector.replace(node, "#{receiver_source}.fdiv#{argument_source}")
+        end
+
+        def extract_receiver_source(node)
+          if node.send_type? && node.method?(:to_f)
+            node.receiver.source
+          else
+            node.source
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/for.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of the `for` keyword or `each` method. The
+      # preferred alternative is set in the EnforcedStyle configuration
+      # parameter. An `each` call with a block on a single line is always
+      # allowed.
+      #
+      # @example EnforcedStyle: each (default)
+      #   # bad
+      #   def foo
+      #     for n in [1, 2, 3] do
+      #       puts n
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     [1, 2, 3].each do |n|
+      #       puts n
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: for
+      #   # bad
+      #   def foo
+      #     [1, 2, 3].each do |n|
+      #       puts n
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     for n in [1, 2, 3] do
+      #       puts n
+      #     end
+      #   end
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because the scope of
+      #   variables is different between `each` and `for`.
+      #
+      class For < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        EACH_LENGTH = 'each'.length
+        PREFER_EACH = 'Prefer `each` over `for`.'
+        PREFER_FOR = 'Prefer `for` over `each`.'
+
+        def on_for(node)
+          if style == :each
+            add_offense(node, message: PREFER_EACH) do |corrector|
+              ForToEachCorrector.new(node).call(corrector)
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def on_block(node)
+          return unless suspect_enumerable?(node)
+
+          if style == :for
+            add_offense(node, message: PREFER_FOR) do |corrector|
+              EachToForCorrector.new(node).call(corrector)
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def suspect_enumerable?(node)
+          node.multiline? && node.send_node.method?(:each) && !node.send_node.arguments?
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/format_string.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of a single string formatting utility.
+      # Valid options include Kernel#format, Kernel#sprintf and String#%.
+      #
+      # The detection of String#% cannot be implemented in a reliable
+      # manner for all cases, so only two scenarios are considered -
+      # if the first argument is a string literal and if the second
+      # argument is an array literal.
+      #
+      # @example EnforcedStyle: format (default)
+      #   # bad
+      #   puts sprintf('%10s', 'hoge')
+      #   puts '%10s' % 'hoge'
+      #
+      #   # good
+      #   puts format('%10s', 'hoge')
+      #
+      # @example EnforcedStyle: sprintf
+      #   # bad
+      #   puts format('%10s', 'hoge')
+      #   puts '%10s' % 'hoge'
+      #
+      #   # good
+      #   puts sprintf('%10s', 'hoge')
+      #
+      # @example EnforcedStyle: percent
+      #   # bad
+      #   puts format('%10s', 'hoge')
+      #   puts sprintf('%10s', 'hoge')
+      #
+      #   # good
+      #   puts '%10s' % 'hoge'
+      #
+      class FormatString < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Favor `%<prefer>s` over `%<current>s`.'
+        RESTRICT_ON_SEND = %i[format sprintf %].freeze
+
+        # @!method formatter(node)
+        def_node_matcher :formatter, <<~PATTERN
+          {
+            (send nil? ${:sprintf :format} _ _ ...)
+            (send {str dstr} $:% ... )
+            (send !nil? $:% {array hash})
+          }
+        PATTERN
+
+        # @!method variable_argument?(node)
+        def_node_matcher :variable_argument?, <<~PATTERN
+          (send {str dstr} :% {send_type? lvar_type?})
+        PATTERN
+
+        def on_send(node)
+          formatter(node) do |selector|
+            detected_style = selector == :% ? :percent : selector
+
+            return if detected_style == style
+
+            add_offense(node.loc.selector, message: message(detected_style)) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def message(detected_style)
+          format(MSG, prefer: method_name(style), current: method_name(detected_style))
+        end
+
+        def method_name(style_name)
+          style_name == :percent ? 'String#%' : style_name
+        end
+
+        def autocorrect(corrector, node)
+          return if variable_argument?(node)
+
+          case node.method_name
+          when :%
+            autocorrect_from_percent(corrector, node)
+          when :format, :sprintf
+            case style
+            when :percent
+              autocorrect_to_percent(corrector, node)
+            when :format, :sprintf
+              corrector.replace(node.loc.selector, style.to_s)
+            end
+          end
+        end
+
+        def autocorrect_from_percent(corrector, node)
+          percent_rhs = node.first_argument
+          args = case percent_rhs.type
+                 when :array, :hash
+                   percent_rhs.children.map(&:source).join(', ')
+                 else
+                   percent_rhs.source
+                 end
+
+          corrected = "#{style}(#{node.receiver.source}, #{args})"
+
+          corrector.replace(node, corrected)
+        end
+
+        def autocorrect_to_percent(corrector, node)
+          format_arg, *param_args = node.arguments
+          format = format_arg.source
+
+          args = if param_args.one?
+                   format_single_parameter(param_args.last)
+                 else
+                   "[#{param_args.map(&:source).join(', ')}]"
+                 end
+
+          corrector.replace(node, "#{format} % #{args}")
+        end
+
+        def format_single_parameter(arg)
+          source = arg.source
+          return "{ #{source} }" if arg.hash_type?
+
+          arg.send_type? && arg.operator_method? && !arg.parenthesized? ? "(#{source})" : source
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/format_string_token.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use a consistent style for named format string tokens.
+      #
+      # NOTE: `unannotated` style cop only works for strings
+      # which are passed as arguments to those methods:
+      # `printf`, `sprintf`, `format`, `%`.
+      # The reason is that _unannotated_ format is very similar
+      # to encoded URLs or Date/Time formatting strings.
+      #
+      # This cop can be customized allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
+      #
+      # @example EnforcedStyle: annotated (default)
+      #
+      #   # bad
+      #   format('%{greeting}', greeting: 'Hello')
+      #   format('%s', 'Hello')
+      #
+      #   # good
+      #   format('%<greeting>s', greeting: 'Hello')
+      #
+      # @example EnforcedStyle: template
+      #
+      #   # bad
+      #   format('%<greeting>s', greeting: 'Hello')
+      #   format('%s', 'Hello')
+      #
+      #   # good
+      #   format('%{greeting}', greeting: 'Hello')
+      #
+      # @example EnforcedStyle: unannotated
+      #
+      #   # bad
+      #   format('%<greeting>s', greeting: 'Hello')
+      #   format('%{greeting}', greeting: 'Hello')
+      #
+      #   # good
+      #   format('%s', 'Hello')
+      #
+      # It is allowed to contain unannotated token
+      # if the number of them is less than or equals to
+      # `MaxUnannotatedPlaceholdersAllowed`.
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 0
+      #
+      #   # bad
+      #   format('%06d', 10)
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%<number>06d', number: 10)
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 1 (default)
+      #
+      #   # bad
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%06d', 10)
+      #
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedMethods: [redirect]
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: ['redirect']
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
+      class FormatStringToken < Base
+        include ConfigurableEnforcedStyle
+        include AllowedMethods
+        include AllowedPattern
+        extend AutoCorrector
+
+        def on_str(node)
+          return if format_string_token?(node) || use_allowed_method?(node)
+
+          detections = collect_detections(node)
+          return if detections.empty?
+          return if allowed_unannotated?(detections)
+
+          detections.each do |detected_sequence, token_range|
+            check_sequence(detected_sequence, token_range)
+          end
+        end
+
+        private
+
+        # @!method format_string_in_typical_context?(node)
+        def_node_matcher :format_string_in_typical_context?, <<~PATTERN
+          {
+            ^(send _ {:format :sprintf :printf} %0 ...)
+            ^(send %0 :% _)
+          }
+        PATTERN
+
+        def format_string_token?(node)
+          !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
+        end
+
+        def use_allowed_method?(node)
+          send_parent = node.each_ancestor(:send).first
+          send_parent &&
+            (allowed_method?(send_parent.method_name) ||
+            matches_allowed_pattern?(send_parent.method_name))
+        end
+
+        def check_sequence(detected_sequence, token_range)
+          if detected_sequence.style == style
+            correct_style_detected
+          elsif correctable_sequence?(detected_sequence.type)
+            style_detected(detected_sequence.style)
+            add_offense(token_range, message: message(detected_sequence.style)) do |corrector|
+              autocorrect_sequence(corrector, detected_sequence, token_range)
+            end
+          end
+        end
+
+        def correctable_sequence?(detected_type)
+          detected_type == 's' || style == :annotated || style == :unannotated
+        end
+
+        def autocorrect_sequence(corrector, detected_sequence, token_range)
+          return if style == :unannotated
+
+          name = detected_sequence.name
+          return if name.nil?
+
+          flags = detected_sequence.flags
+          width = detected_sequence.width
+          precision = detected_sequence.precision
+          type = detected_sequence.style == :template ? 's' : detected_sequence.type
+          correction = case style
+                       when :annotated then "%<#{name}>#{flags}#{width}#{precision}#{type}"
+                       when :template then "%#{flags}#{width}#{precision}{#{name}}"
+                       end
+          corrector.replace(token_range, correction)
+        end
+
+        def unannotated_format?(node, detected_style)
+          detected_style == :unannotated && !format_string_in_typical_context?(node)
+        end
+
+        def message(detected_style)
+          "Prefer #{message_text(style)} over #{message_text(detected_style)}."
+        end
+
+        # rubocop:disable Style/FormatStringToken
+        def message_text(style)
+          {
+            annotated: 'annotated tokens (like `%<foo>s`)',
+            template: 'template tokens (like `%{foo}`)',
+            unannotated: 'unannotated tokens (like `%s`)'
+          }[style]
+        end
+        # rubocop:enable Style/FormatStringToken
+
+        def tokens(str_node, &block)
+          return if str_node.source == '__FILE__'
+
+          token_ranges(str_contents(str_node.loc), &block)
+        end
+
+        def str_contents(source_map)
+          if source_map.is_a?(Parser::Source::Map::Heredoc)
+            source_map.heredoc_body
+          elsif source_map.begin
+            source_map.expression.adjust(begin_pos: +1, end_pos: -1)
+          else
+            source_map.expression
+          end
+        end
+
+        def token_ranges(contents)
+          format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
+
+          format_string.format_sequences.each do |detected_sequence|
+            next if detected_sequence.percent?
+
+            token = contents.begin.adjust(begin_pos: detected_sequence.begin_pos,
+                                          end_pos: detected_sequence.end_pos)
+
+            yield(detected_sequence, token)
+          end
+        end
+
+        def collect_detections(node)
+          detections = []
+          tokens(node) do |detected_sequence, token_range|
+            unless unannotated_format?(node, detected_sequence.style)
+              detections << [detected_sequence, token_range]
+            end
+          end
+          detections
+        end
+
+        def allowed_unannotated?(detections)
+          return false unless detections.all? do |detected_sequence,|
+                                detected_sequence.style == :unannotated
+                              end
+          return true if detections.size <= max_unannotated_placeholders_allowed
+
+          detections.any? { |detected_sequence,| !correctable_sequence?(detected_sequence.type) }
+        end
+
+        def max_unannotated_placeholders_allowed
+          cop_config['MaxUnannotatedPlaceholdersAllowed']
+        end
+      end
+    end
+  end
+end