rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks `eval` method usage. `eval` can receive source location
+      # metadata, that are filename and line number. The metadata is used by
+      # backtraces. This cop recommends to pass the metadata to `eval` method.
+      #
+      # @example
+      #   # bad
+      #   eval <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # bad
+      #   C.class_eval <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # good
+      #   eval <<-RUBY, binding, __FILE__, __LINE__ + 1
+      #     def do_something
+      #     end
+      #   RUBY
+      #
+      #   # good
+      #   C.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      #     def do_something
+      #     end
+      #   RUBY
+      class EvalWithLocation < Cop
+        MSG = 'Pass `__FILE__` and `__LINE__` to `eval` method, ' \
+              'as they are used by backtraces.'.freeze
+        MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
+                             'as they are used by backtraces.'.freeze
+
+        def_node_matcher :eval_without_location?, <<-PATTERN
+          {
+            (send nil? :eval ${str dstr})
+            (send nil? :eval ${str dstr} _)
+            (send nil? :eval ${str dstr} _ #special_file_keyword?)
+            (send nil? :eval ${str dstr} _ #special_file_keyword? _)
+
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr})
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr} #special_file_keyword?)
+            (send _ {:class_eval :module_eval :instance_eval}
+              ${str dstr} #special_file_keyword? _)
+          }
+        PATTERN
+
+        def_node_matcher :line_with_offset?, <<-PATTERN
+          {
+            (send #special_line_keyword? %1 (int %2))
+            (send (int %2) %1 #special_line_keyword?)
+          }
+        PATTERN
+
+        def on_send(node)
+          eval_without_location?(node) do |code|
+            if with_lineno?(node)
+              on_with_lineno(node, code)
+            else
+              add_offense(node)
+            end
+          end
+        end
+
+        private
+
+        def special_file_keyword?(node)
+          node.str_type? &&
+            node.source == '__FILE__'
+        end
+
+        def special_line_keyword?(node)
+          node.int_type? &&
+            node.source == '__LINE__'
+        end
+
+        # FIXME: It's a Style/ConditionalAssignment's false positive.
+        # rubocop:disable Style/ConditionalAssignment
+        def with_lineno?(node)
+          if node.method_name == :eval
+            node.arguments.size == 4
+          else
+            node.arguments.size == 3
+          end
+        end
+        # rubocop:enable Style/ConditionalAssignment
+
+        def message_incorrect_line(actual, sign, line_diff)
+          expected =
+            if line_diff.zero?
+              '__LINE__'
+            else
+              "__LINE__ #{sign} #{line_diff}"
+            end
+          format(MSG_INCORRECT_LINE, actual: actual.source, expected: expected)
+        end
+
+        def on_with_lineno(node, code)
+          line_node = node.arguments.last
+          lineno_range = line_node.loc.expression
+          line_diff = string_first_line(code) - lineno_range.first_line
+          if line_diff.zero?
+            add_offense_for_same_line(node, line_node)
+          else
+            add_offense_for_different_line(node, line_node, line_diff)
+          end
+        end
+
+        def string_first_line(str_node)
+          if str_node.heredoc?
+            str_node.loc.heredoc_body.first_line
+          else
+            str_node.loc.expression.first_line
+          end
+        end
+
+        def add_offense_for_same_line(node, line_node)
+          return if special_line_keyword?(line_node)
+          add_offense(
+            node,
+            location: line_node.loc.expression,
+            message: message_incorrect_line(line_node, nil, 0)
+          )
+        end
+
+        def add_offense_for_different_line(node, line_node, line_diff)
+          sign = line_diff > 0 ? :+ : :-
+          return if line_with_offset?(line_node, sign, line_diff.abs)
+          add_offense(
+            node,
+            location: line_node.loc.expression,
+            message: message_incorrect_line(line_node, sign, line_diff.abs)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -1,76 +1,57 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where Fixnum#even? or Fixnum#odd?
+      # This cop checks for places where Integer#even? or Integer#odd?
       # should have been used.
       #
       # @example
       #
       #   # bad
       #   if x % 2 == 0
+      #   end
       #
       #   # good
       #   if x.even?
+      #   end
       class EvenOdd < Cop
-        MSG = 'Replace with `Fixnum#%s?`.'.freeze
+        MSG = 'Replace with `Integer#%<method>s?`.'.freeze
 
-        ZERO = s(:int, 0)
-        ONE = s(:int, 1)
-        TWO = s(:int, 2)
+        def_node_matcher :even_odd_candidate?, <<-PATTERN
+          (send
+            {(send $_ :% (int 2))
+             (begin (send $_ :% (int 2)))}
+            ${:== :!=}
+            (int ${0 1 2}))
+        PATTERN
 
         def on_send(node)
-          offense = offense_type(node)
-          add_offense(node, :expression, format(MSG, offense)) if offense
+          even_odd_candidate?(node) do |_base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
+            add_offense(node, message: format(MSG, method: replacement_method))
+          end
         end
 
         def autocorrect(node)
-          correction = "#{base_number(node)}.#{offense_type(node)}?"
-          ->(corrector) { corrector.replace(node.source_range, correction) }
-        end
-
-        private
+          even_odd_candidate?(node) do |base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
 
-        def base_number(node)
-          receiver, = *node
-          node = expression(receiver)
-          node.children[0].source
+            correction = "#{base_number.source}.#{replacement_method}?"
+            ->(corrector) { corrector.replace(node.source_range, correction) }
+          end
         end
 
-        def offense_type(node)
-          receiver, method, args = *node
-
-          return unless [:==, :!=].include?(method)
-          return unless div_by_2?(receiver)
+        private
 
-          if args == ZERO
+        def replacement_method(arg, method)
+          case arg
+          when 0
             method == :== ? :even : :odd
-          elsif args == ONE
+          when 1
             method == :== ? :odd : :even
           end
         end
-
-        def div_by_2?(node)
-          node = expression(node)
-
-          _receiver, method, args = *node
-
-          method == :% && args == TWO
-        end
-
-        def expression(node)
-          return unless node
-
-          # check for scenarios like (x % 2) == 0
-          if node.type == :begin && node.children.size == 1
-            node = node.children.first
-          end
-
-          return unless node.type == :send
-          node
-        end
       end
     end
   end

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

@@ -1,19 +1,29 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop looks for uses of flip flop operator
+      #
+      # @example
+      #   # bad
+      #   (1..20).each do |x|
+      #     puts x if (x == 5) .. (x == 10)
+      #   end
+      #
+      #   # good
+      #   (1..20).each do |x|
+      #     puts x if (x >= 5) && (x <= 10)
+      #   end
       class FlipFlop < Cop
         MSG = 'Avoid the use of flip flop operators.'.freeze
 
         def on_iflipflop(node)
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def on_eflipflop(node)
-          add_offense(node, :expression)
+          add_offense(node)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -14,7 +13,9 @@ module RuboCop
 
         def on_for(node)
           if style == :each
-            add_offense(node, :keyword, 'Prefer `each` over `for`.') do
+            msg = 'Prefer `each` over `for`.'
+
+            add_offense(node, location: :keyword, message: msg) do
               opposite_style_detected
             end
           else
@@ -23,26 +24,29 @@ module RuboCop
         end
 
         def on_block(node)
-          return if block_length(node).zero?
-
-          method, _args, _body = *node
-          return unless method.type == :send
+          return if node.single_line?
 
-          _receiver, method_name, *args = *method
-          return unless method_name == :each && args.empty?
+          return unless node.send_node.method?(:each) &&
+                        !node.send_node.arguments?
 
           if style == :for
-            end_pos = method.source_range.end_pos
-            range = Parser::Source::Range.new(processed_source.buffer,
-                                              end_pos - EACH_LENGTH,
-                                              end_pos)
-            add_offense(range, range, 'Prefer `for` over `each`.') do
-              opposite_style_detected
-            end
+            incorrect_style_detected(node.send_node)
           else
             correct_style_detected
           end
         end
+
+        private
+
+        def incorrect_style_detected(method)
+          end_pos = method.source_range.end_pos
+          range = range_between(end_pos - EACH_LENGTH, end_pos)
+          msg = 'Prefer `for` over `each`.'
+
+          add_offense(range, location: range, message: msg) do
+            opposite_style_detected
+          end
+        end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -11,65 +10,112 @@ module RuboCop
       # 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 < Cop
         include ConfigurableEnforcedStyle
 
-        def on_send(node)
-          add_offense(node, :selector) if offending_node?(node)
-        end
+        MSG = 'Favor `%<prefer>s` over `%<current>s`.'.freeze
 
-        private
+        def_node_matcher :formatter, <<-PATTERN
+        {
+          (send nil? ${:sprintf :format} _ _ ...)
+          (send {str dstr} $:% ... )
+          (send !nil? $:% {array hash})
+        }
+        PATTERN
 
-        def offending_node?(node)
-          case style
-          when :format
-            sprintf?(node) || percent?(node)
-          when :sprintf
-            format?(node) || percent?(node)
-          when :percent
-            format?(node) || sprintf?(node)
-          end
-        end
-
-        def format_method?(name, node)
-          receiver, method_name, *args = *node
+        def on_send(node)
+          formatter(node) do |selector|
+            detected_style = selector == :% ? :percent : selector
 
-          # commands have no explicit receiver
-          return false unless !receiver && method_name == name
+            return if detected_style == style
 
-          # we do an argument count check to reduce false positives
-          args.size >= 2
+            add_offense(node, location: :selector,
+                              message: message(detected_style))
+          end
         end
 
-        def format?(node)
-          format_method?(:format, node)
+        def message(detected_style)
+          format(MSG,
+                 prefer: method_name(style),
+                 current: method_name(detected_style))
         end
 
-        def sprintf?(node)
-          format_method?(:sprintf, node)
+        def method_name(style_name)
+          style_name == :percent ? 'String#%' : style_name
         end
 
-        def percent?(node)
-          receiver_node, method_name, *arg_nodes = *node
+        def autocorrect(node)
+          lambda do |corrector|
+            _receiver, detected_method = *node
 
-          method_name == :% &&
-            ([:str, :dstr].include?(receiver_node.type) ||
-             arg_nodes[0].type == :array)
+            case detected_method
+            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
         end
 
-        def message(node)
-          _receiver_node, method_name, *_arg_nodes = *node
-
-          preferred =
-            if style == :percent
-              'String#%'
-            else
-              style
-            end
+        private
 
-          method_name = 'String#%' if method_name == :%
+        def autocorrect_from_percent(corrector, node)
+          receiver, _method, args = *node
+          format = receiver.source
+          args = if args.array_type? || args.hash_type?
+                   args.children.map(&:source).join(', ')
+                 else
+                   args.source
+                 end
+          corrected = "#{style}(#{format}, #{args})"
+          corrector.replace(node.loc.expression, corrected)
+        end
 
-          "Favor `#{preferred}` over `#{method_name}`."
+        def autocorrect_to_percent(corrector, node)
+          _nil, _method, format, *args = *node
+          format = format.source
+          args   = if args.one?
+                     arg = args.first
+                     if arg.hash_type?
+                       "{ #{arg.source} }"
+                     else
+                       arg.source
+                     end
+                   else
+                     "[#{args.map(&:source).join(', ')}]"
+                   end
+          corrected = "#{format} % #{args}"
+          corrector.replace(node.loc.expression, corrected)
         end
       end
     end

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

@@ -0,0 +1,163 @@
+# 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:
+      # `sprintf`, `format`, `%`.
+      # The reason is that *unannotated* format is very similar
+      # to encoded URLs or Date/Time formatting strings.
+      #
+      # @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}', 'Hello')
+      #
+      #   # good
+      #   format('%s', 'Hello')
+      class FormatStringToken < Cop
+        include ConfigurableEnforcedStyle
+
+        FIELD_CHARACTERS = Regexp.union(%w[A B E G X a b c d e f g i o p s u x])
+        FORMAT_STRING_METHODS = %i[sprintf format %].freeze
+
+        STYLE_PATTERNS = {
+          annotated: /(?<token>%<[^>]+>#{FIELD_CHARACTERS})/,
+          template: /(?<token>%\{[^\}]+\})/,
+          unannotated: /(?<token>%#{FIELD_CHARACTERS})/
+        }.freeze
+
+        def on_str(node)
+          return if node.each_ancestor(:xstr, :regexp).any?
+
+          tokens(node) do |detected_style, token_range|
+            if detected_style == style ||
+               unannotated_format?(node, detected_style)
+              correct_style_detected
+            else
+              style_detected(detected_style)
+              add_offense(node, location: token_range,
+                                message: message(detected_style))
+            end
+          end
+        end
+
+        private
+
+        def includes_format_methods?(node)
+          root_node = node.ancestors.last
+          return unless root_node
+
+          root_node.descendants.any? do |desc_node|
+            FORMAT_STRING_METHODS.include?(desc_node.method_name)
+          end
+        end
+
+        def unannotated_format?(node, detected_style)
+          detected_style == :unannotated && !includes_format_methods?(node)
+        end
+
+        def message(detected_style)
+          "Prefer #{message_text(style)} over #{message_text(detected_style)}."
+        end
+
+        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
+        end
+
+        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
+            slice_source(
+              source_map.expression,
+              source_map.expression.begin_pos + 1,
+              source_map.expression.end_pos - 1
+            )
+          else
+            source_map.expression
+          end
+        end
+
+        def token_ranges(contents)
+          while (offending_match = match_token(contents))
+            detected_style, *range = *offending_match
+            token, contents = split_token(contents, *range)
+            yield(detected_style, token)
+          end
+        end
+
+        def match_token(source_range)
+          supported_styles.each do |style_name|
+            pattern = STYLE_PATTERNS.fetch(style_name)
+            match = source_range.source.match(pattern)
+            next unless match
+
+            return [style_name, match.begin(:token), match.end(:token)]
+          end
+
+          nil
+        end
+
+        def split_token(source_range, match_begin, match_end)
+          token =
+            slice_source(
+              source_range,
+              source_range.begin_pos + match_begin,
+              source_range.begin_pos + match_end
+            )
+
+          remainder =
+            slice_source(
+              source_range,
+              source_range.begin_pos + match_end,
+              source_range.end_pos
+            )
+
+          [token, remainder]
+        end
+
+        def slice_source(source_range, new_begin, new_end)
+          Parser::Source::Range.new(
+            source_range.source_buffer,
+            new_begin,
+            new_end
+          )
+        end
+      end
+    end
+  end
+end