rubocop 0.78.0 → 1.13.0

data/lib/rubocop/cop/style/exponential_notation.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces consistency when using exponential notation
+      # for numbers in the code (eg 1.2e4). Different styles are supported:
+      #
+      # * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive).
+      # * `engineering` which enforces the exponent to be a multiple of 3 and the mantissa
+      #   to be between 0.1 (inclusive) and 10 (exclusive).
+      # * `integral` which enforces the mantissa to always be a whole number without
+      #   trailing zeroes.
+      #
+      # @example EnforcedStyle: scientific (default)
+      #   # Enforces a mantissa between 1 (inclusive) and 10 (exclusive).
+      #
+      #   # bad
+      #   10e6
+      #   0.3e4
+      #   11.7e5
+      #   3.14e0
+      #
+      #   # good
+      #   1e7
+      #   3e3
+      #   1.17e6
+      #   3.14
+      #
+      # @example EnforcedStyle: engineering
+      #   # Enforces using multiple of 3 exponents,
+      #   # mantissa should be between 0.1 (inclusive) and 1000 (exclusive)
+      #
+      #   # bad
+      #   3.2e7
+      #   0.1e5
+      #   12e5
+      #   1232e6
+      #
+      #   # good
+      #   32e6
+      #   10e3
+      #   1.2e6
+      #   1.232e9
+      #
+      # @example EnforcedStyle: integral
+      #   # Enforces the mantissa to have no decimal part and no
+      #   # trailing zeroes.
+      #
+      #   # bad
+      #   3.2e7
+      #   0.1e5
+      #   120e4
+      #
+      #   # good
+      #   32e6
+      #   1e4
+      #   12e5
+      #
+      class ExponentialNotation < Base
+        include ConfigurableEnforcedStyle
+        MESSAGES = {
+          scientific: 'Use a mantissa in [1, 10[.',
+          engineering: 'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.',
+          integral: 'Use an integer as mantissa, without trailing zero.'
+        }.freeze
+
+        def on_float(node)
+          add_offense(node) if offense?(node)
+        end
+
+        private
+
+        def scientific?(node)
+          mantissa, = node.source.split('e')
+          /^-?[1-9](\.\d*[0-9])?$/.match?(mantissa)
+        end
+
+        def engineering?(node)
+          mantissa, exponent = node.source.split('e')
+          return false unless /^-?\d+$/.match?(exponent)
+          return false unless (exponent.to_i % 3).zero?
+          return false if /^-?\d{4}/.match?(mantissa)
+          return false if /^-?0\d/.match?(mantissa)
+          return false if /^-?0.0/.match?(mantissa)
+
+          true
+        end
+
+        def integral(node)
+          mantissa, = node.source.split('e')
+          /^-?[1-9](\d*[1-9])?$/.match?(mantissa)
+        end
+
+        def offense?(node)
+          return false unless node.source['e']
+
+          case style
+          when :scientific
+            !scientific?(node)
+          when :engineering
+            !engineering?(node)
+          when :integral
+            !integral(node)
+          else
+            false
+          end
+        end
+
+        def message(_node)
+          MESSAGES[style]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/float_division.rb

@@ -7,6 +7,9 @@ module RuboCop
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #
+      # This cop is marked as unsafe, because if operand variable is a string object
+      # then `.to_f` will be removed and an error will occur.
+      #
       # @example EnforcedStyle: single_coerce (default)
       #   # bad
       #   a.to_f / b.to_f
@@ -39,24 +42,51 @@ module RuboCop
       #
       #   # good
       #   a.fdiv(b)
-      class FloatDivision < Cop
+      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)
-          add_offense(node) if offense_condition?(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
@@ -77,15 +107,34 @@ module RuboCop
         end
 
         def message(_node)
-          case style
-          when :left_coerce
-            'Prefer using `.to_f` on the left side.'
-          when :right_coerce
-            'Prefer using `.to_f` on the right side.'
-          when :single_coerce
-            'Prefer using `.to_f` on one side only.'
-          when :fdiv
-            'Prefer using `fdiv` for float divisions.'
+          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

data/lib/rubocop/cop/style/for.rb

@@ -38,9 +38,10 @@ module RuboCop
       #     end
       #   end
       #
-      class For < Cop
+      class For < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         EACH_LENGTH = 'each'.length
         PREFER_EACH = 'Prefer `each` over `for`.'
@@ -48,7 +49,8 @@ module RuboCop
 
         def on_for(node)
           if style == :each
-            add_offense(node, message: PREFER_EACH) do
+            add_offense(node, message: PREFER_EACH) do |corrector|
+              ForToEachCorrector.new(node).call(corrector)
               opposite_style_detected
             end
           else
@@ -60,7 +62,8 @@ module RuboCop
           return unless suspect_enumerable?(node)
 
           if style == :for
-            add_offense(node, message: PREFER_FOR) do
+            add_offense(node, message: PREFER_FOR) do |corrector|
+              EachToForCorrector.new(node).call(corrector)
               opposite_style_detected
             end
           else
@@ -68,19 +71,10 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          if style == :each
-            ForToEachCorrector.new(node)
-          else
-            EachToForCorrector.new(node)
-          end
-        end
-
         private
 
         def suspect_enumerable?(node)
-          node.multiline? &&
-            node.send_node.method?(:each) && !node.send_node.arguments?
+          node.multiline? && node.send_node.method?(:each) && !node.send_node.arguments?
         end
       end
     end

data/lib/rubocop/cop/style/format_string.rb

@@ -35,11 +35,14 @@ module RuboCop
       #   # good
       #   puts '%10s' % 'hoge'
       #
-      class FormatString < Cop
+      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} _ _ ...)
@@ -48,6 +51,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method variable_argument?(node)
         def_node_matcher :variable_argument?, <<~PATTERN
           (send {str dstr} :% {send_type? lvar_type?})
         PATTERN
@@ -58,41 +62,38 @@ module RuboCop
 
             return if detected_style == style
 
-            add_offense(node, location: :selector,
-                              message: message(detected_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))
+          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(node)
+        def autocorrect(corrector, node)
           return if variable_argument?(node)
 
-          lambda do |corrector|
-            case node.method_name
-            when :%
-              autocorrect_from_percent(corrector, 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
-              case style
-              when :percent
-                autocorrect_to_percent(corrector, node)
-              when :format, :sprintf
-                corrector.replace(node.loc.selector, style.to_s)
-              end
+              corrector.replace(node.loc.selector, style.to_s)
             end
           end
         end
 
-        private
-
         def autocorrect_from_percent(corrector, node)
           percent_rhs = node.first_argument
           args = case percent_rhs.type
@@ -104,7 +105,7 @@ module RuboCop
 
           corrected = "#{style}(#{node.receiver.source}, #{args})"
 
-          corrector.replace(node.loc.expression, corrected)
+          corrector.replace(node, corrected)
         end
 
         def autocorrect_to_percent(corrector, node)
@@ -112,14 +113,19 @@ module RuboCop
           format = format_arg.source
 
           args = if param_args.one?
-                   arg = param_args.last
-
-                   arg.hash_type? ? "{ #{arg.source} }" : arg.source
+                   format_single_parameter(param_args.last)
                  else
                    "[#{param_args.map(&:source).join(', ')}]"
                  end
 
-          corrector.replace(node.loc.expression, "#{format} % #{args}")
+          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

data/lib/rubocop/cop/style/format_string_token.rb

@@ -5,13 +5,14 @@ module RuboCop
     module Style
       # Use a consistent style for named format string tokens.
       #
-      # **Note:**
-      # `unannotated` style cop only works for strings
+      # 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
+      # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
+      # This cop can be customized ignored methods with `IgnoredMethods`.
+      #
       # @example EnforcedStyle: annotated (default)
       #
       #   # bad
@@ -34,30 +35,61 @@ module RuboCop
       #
       #   # bad
       #   format('%<greeting>s', greeting: 'Hello')
-      #   format('%{greeting}', 'Hello')
+      #   format('%{greeting}', greeting: 'Hello')
       #
       #   # good
       #   format('%s', 'Hello')
-      class FormatStringToken < Cop
+      #
+      # 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 IgnoredMethods: [redirect]
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
+      class FormatStringToken < Base
         include ConfigurableEnforcedStyle
+        include IgnoredMethods
 
         def on_str(node)
-          return if node.each_ancestor(:xstr, :regexp).any?
+          return if format_string_token?(node) || use_ignored_method?(node)
 
-          tokens(node) do |detected_style, token_range|
-            if detected_style == style ||
-               unannotated_format?(node, detected_style)
+          detections = collect_detections(node)
+          return if detections.empty?
+          return if allowed_unannotated?(detections)
+
+          detections.each do |detected_style, token_range|
+            if detected_style == style
               correct_style_detected
             else
               style_detected(detected_style)
-              add_offense(node, location: token_range,
-                                message: message(detected_style))
+              add_offense(token_range, message: message(detected_style))
             end
           end
         end
 
         private
 
+        # @!method format_string_in_typical_context?(node)
         def_node_matcher :format_string_in_typical_context?, <<~PATTERN
           {
             ^(send _ {:format :sprintf :printf} %0 ...)
@@ -65,9 +97,16 @@ module RuboCop
           }
         PATTERN
 
+        def format_string_token?(node)
+          !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
+        end
+
+        def use_ignored_method?(node)
+          (parent = node.parent) && parent.send_type? && ignored_method?(parent.method_name)
+        end
+
         def unannotated_format?(node, detected_style)
-          detected_style == :unannotated &&
-            !format_string_in_typical_context?(node)
+          detected_style == :unannotated && !format_string_in_typical_context?(node)
         end
 
         def message(detected_style)
@@ -76,11 +115,11 @@ module RuboCop
 
         # rubocop:disable Style/FormatStringToken
         def message_text(style)
-          case style
-          when :annotated then 'annotated tokens (like `%<foo>s`)'
-          when :template then 'template tokens (like `%{foo}`)'
-          when :unannotated then 'unannotated tokens (like `%s`)'
-          end
+          {
+            annotated: 'annotated tokens (like `%<foo>s`)',
+            template: 'template tokens (like `%{foo}`)',
+            unannotated: 'unannotated tokens (like `%s`)'
+          }[style]
         end
         # rubocop:enable Style/FormatStringToken
 
@@ -107,14 +146,31 @@ module RuboCop
             next if seq.percent?
 
             detected_style = seq.style
-            token = contents.begin.adjust(
-              begin_pos: seq.begin_pos,
-              end_pos:   seq.end_pos
-            )
+            token = contents.begin.adjust(begin_pos: seq.begin_pos, end_pos: seq.end_pos)
 
             yield(detected_style, token)
           end
         end
+
+        def collect_detections(node)
+          detections = []
+          tokens(node) do |detected_style, token_range|
+            unless unannotated_format?(node, detected_style)
+              detections << [detected_style, token_range]
+            end
+          end
+          detections
+        end
+
+        def allowed_unannotated?(detections)
+          return false if detections.size > max_unannotated_placeholders_allowed
+
+          detections.all? { |detected_style,| detected_style == :unannotated }
+        end
+
+        def max_unannotated_placeholders_allowed
+          cop_config['MaxUnannotatedPlaceholdersAllowed']
+        end
       end
     end
   end