rubocop 0.34.2 → 0.35.0

data/lib/rubocop/cop/lint/debugger.rb

@@ -7,64 +7,17 @@ module RuboCop
       class Debugger < Cop
         MSG = 'Remove debugger entry point `%s`.'
 
-        # debugger call node
-        #
-        # (send nil :debugger)
-        DEBUGGER_NODE = s(:send, nil, :debugger)
-
-        # byebug call node
-        #
-        # (send nil :byebug)
-        BYEBUG_NODE = s(:send, nil, :byebug)
-
-        # binding.pry node
-        #
-        # (send
-        #   (send nil :binding) :pry)
-        PRY_NODE = s(:send, s(:send, nil, :binding), :pry)
-
-        # binding.remote_pry node
-        #
-        # (send
-        #   (send nil :binding) :remote_pry)
-        REMOTE_PRY_NODE = s(:send, s(:send, nil, :binding), :remote_pry)
-
-        # binding.pry_remote node
-        #
-        # (send
-        #   (send nil :binding) :pry_remote)
-        PRY_REMOTE_NODE = s(:send, s(:send, nil, :binding), :pry_remote)
-
-        # save_and_open_page
-        #
-        # (send nil :save_and_open_page)
-        CAPYBARA_SAVE_PAGE = s(:send, nil, :save_and_open_page)
-
-        # save_and_open_screenshot
-        #
-        # (send nil :save_and_open_screenshot)
-        CAPYBARA_SAVE_OPEN_SCREENSHOT = s(:send, nil, :save_and_open_screenshot)
-
-        # save_screenshot
-        #
-        # (send nil :save_screenshot)
-        CAPYBARA_SAVE_SCREENSHOT = s(:send, nil, :save_screenshot)
-
-        DEBUGGER_NODES = [
-          DEBUGGER_NODE,
-          BYEBUG_NODE,
-          PRY_NODE,
-          REMOTE_PRY_NODE,
-          PRY_REMOTE_NODE,
-          CAPYBARA_SAVE_PAGE,
-          CAPYBARA_SAVE_OPEN_SCREENSHOT,
-          CAPYBARA_SAVE_SCREENSHOT
-        ]
+        def_node_matcher :debugger_call?,
+                         '{(send nil {:debugger :byebug} ...)
+                           (send (send nil :binding)
+                             {:pry :remote_pry :pry_remote} ...)
+                           (send (const nil :Pry) :rescue ...)
+                           (send nil {:save_and_open_page
+                                      :save_and_open_screenshot
+                                      :save_screenshot} ...)}'
 
         def on_send(node)
-          receiver, method_name, *_args = *node
-          node_without_args = self.class.s(:send, receiver, method_name)
-          return unless DEBUGGER_NODES.include? node_without_args
+          return unless debugger_call?(node)
           add_offense(node,
                       :expression,
                       format(MSG, node.loc.expression.source))

data/lib/rubocop/cop/lint/end_alignment.rb

@@ -41,6 +41,10 @@ module RuboCop
         end
 
         def on_case(node)
+          if argument_case?(node)
+            return check_alignment(node.ancestors.first, node)
+          end
+
           check_offset_of_node(node)
         end
 
@@ -57,24 +61,40 @@ module RuboCop
           return unless [:if, :while, :until, :case].include?(rhs.type)
           return if ternary_op?(rhs)
 
-          expr = node.loc.expression
-          if variable_alignment?(expr, rhs, style)
+          check_alignment(node, rhs)
+        end
+
+        def check_alignment(outer_node, inner_node)
+          expr = outer_node.loc.expression
+          if variable_alignment?(expr, inner_node, style)
             range = Parser::Source::Range.new(expr.source_buffer,
                                               expr.begin_pos,
-                                              rhs.loc.keyword.end_pos)
-            offset = rhs.loc.keyword.column - node.loc.expression.column
+                                              inner_node.loc.keyword.end_pos)
+            offset =
+              inner_node.loc.keyword.column - outer_node.loc.expression.column
           else
-            range = rhs.loc.keyword
+            range = inner_node.loc.keyword
             offset = 0
           end
 
-          check_offset(rhs, range.source, offset)
-          ignore_node(rhs) # Don't check again.
+          check_offset(inner_node, range.source, offset)
+          ignore_node(inner_node) # Don't check again.
         end
 
         def autocorrect(node)
-          align(node,
-                style == :variable ? node.each_ancestor(:lvasgn).first : node)
+          align(node, alignment_node(node))
+        end
+
+        def alignment_node(node)
+          return node unless style == :variable
+          return node.ancestors.first if argument_case?(node)
+
+          node.each_ancestor(:lvasgn).first
+        end
+
+        def argument_case?(node)
+          node.case_type? && !node.ancestors.empty? &&
+            node.ancestors.first.send_type?
         end
       end
     end

data/lib/rubocop/cop/lint/eval.rb

@@ -8,9 +8,13 @@ module RuboCop
         MSG = 'The use of `eval` is a serious security risk.'
 
         def on_send(node)
-          receiver, method_name, = *node
+          receiver, method_name, *args = *node
 
-          add_offense(node, :selector) if receiver.nil? && method_name == :eval
+          return unless receiver.nil? &&
+                        method_name == :eval &&
+                        !args.empty? &&
+                        args.first.type != :str
+          add_offense(node, :selector)
         end
       end
     end

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -37,7 +37,10 @@ module RuboCop
               false
             else
               num_of_format_args, num_of_expected_fields = count_matches(node)
-              num_of_expected_fields != num_of_format_args
+
+              num_of_format_args != :unknown &&
+                num_of_expected_fields != :unknown &&
+                num_of_expected_fields != num_of_format_args
             end
           else
             false
@@ -79,22 +82,36 @@ module RuboCop
           args.loc.expression.source[0, 2] == SHOVEL
         end
 
+        def literal?(node)
+          node.int_type? ||
+            node.str_type? ||
+            node.sym_type? ||
+            node.float_type? ||
+            node.dstr_type? ||
+            node.dsym_type?
+        end
+
         def count_matches(node)
           receiver_node, _method_name, *args = *node
 
           if (sprintf?(node) || format?(node)) && !heredoc?(node)
             number_of_args_for_format = (args.size - 1)
             number_of_expected_fields = expected_fields_count(args.first)
-          elsif percent?(node)
-            first_child_argument = args.first
+          elsif percent?(node) && args.first.array_type?
+            number_of_expected_fields = expected_fields_count(receiver_node)
 
+            first_child_argument = args.first
             if first_child_argument.array_type?
               number_of_args_for_format = args.first.child_nodes.size
-              number_of_expected_fields = expected_fields_count(receiver_node)
-            else
+            elsif literal?(first_child_argument)
               number_of_args_for_format = 1
-              number_of_expected_fields = expected_fields_count(receiver_node)
+            else
+              # non-literals might evaluate to an Array, or they might not
+              # so we can't tell just how many format args there will be
+              number_of_args_for_format = :unknown
             end
+          else
+            number_of_args_for_format = number_of_expected_fields = :unknown
           end
 
           [number_of_args_for_format, number_of_expected_fields]
@@ -113,6 +130,7 @@ module RuboCop
         end
 
         def expected_fields_count(node)
+          return :unknown unless node.str_type?
           node
             .loc
             .expression

data/lib/rubocop/cop/lint/literal_in_condition.rb

@@ -20,11 +20,6 @@ module RuboCop
       class LiteralInCondition < Cop
         MSG = 'Literal `%s` appeared in a condition.'
 
-        LITERALS = [:str, :dstr, :int, :float, :array,
-                    :hash, :regexp, :nil, :true, :false]
-
-        BASIC_LITERALS = LITERALS - [:dstr, :array, :hash]
-
         def on_if(node)
           check_for_literal(node)
         end

data/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb

@@ -5,7 +5,8 @@ module RuboCop
     module Lint
       # This cop checks for non-local exit from iterator, without return value.
       # It warns only when satisfies all of these: `return` doesn't have return
-      # value, block followed by method chain, and block have arguments.
+      # value, the block is preceded by a method chain, the block has arguments,
+      # and the method which receives the block is not `define_method`.
       #
       # @example
       #
@@ -42,6 +43,9 @@ module RuboCop
 
             # `return` does not exit to outside of lambda block, this is safe.
             break if lambda?(send_node)
+            # if a proc is passed to `Module#define_method`, `return` will not
+            # cause a non-local exit error
+            break if define_method?(send_node)
 
             next if args_node.children.empty?
             if chained_send?(send_node)
@@ -64,6 +68,11 @@ module RuboCop
           receiver_node, selector_node = *send_node
           receiver_node.nil? && selector_node == :lambda
         end
+
+        def define_method?(send_node)
+          _receiver, selector = *send_node
+          selector == :define_method
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -14,7 +14,7 @@ module RuboCop
 
         def on_send(node)
           _receiver, method_name, args = *node
-          return if operator?(method_name) || method_name.to_s.end_with?('=')
+          return if operator?(method_name) || node.asgn_method_call?
           return unless args && args.loc.expression.source.start_with?('(')
 
           space_length = spaces_before_left_parenthesis(node)

data/lib/rubocop/cop/lint/space_before_first_arg.rb

@@ -20,7 +20,7 @@ module RuboCop
           _receiver, method_name, *args = *node
           return if args.empty?
           return if operator?(method_name)
-          return if method_name.to_s.end_with?('=')
+          return if node.asgn_method_call?
 
           # Setter calls with parentheses are parsed this way. The parentheses
           # belong to the argument, not the send node.

data/lib/rubocop/cop/lint/unused_block_argument.rb

@@ -16,6 +16,12 @@ module RuboCop
 
         def check_argument(variable)
           return unless variable.block_argument?
+
+          if cop_config['IgnoreEmptyBlocks']
+            _send, _args, body = *variable.scope.node
+            return if body.nil?
+          end
+
           super
         end
 

data/lib/rubocop/cop/lint/unused_method_argument.rb

@@ -15,6 +15,14 @@ module RuboCop
 
         def check_argument(variable)
           return unless variable.method_argument?
+          return if variable.keyword_argument? &&
+                    cop_config['AllowUnusedKeywordArguments']
+
+          if cop_config['IgnoreEmptyMethods']
+            _name, _args, body = *variable.scope.node
+            return if body.nil?
+          end
+
           super
         end
 

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -21,7 +21,7 @@ module RuboCop
           condition = 0
 
           node.each_node do |child|
-            if ASGN_NODES.include?(child.type)
+            if child.assignment?
               assignment += 1
             elsif BRANCH_NODES.include?(child.type)
               branch += 1

data/lib/rubocop/cop/mixin/access_modifier_node.rb

@@ -40,7 +40,7 @@ module RuboCop
       # Returns true when the block node looks like Class or Module.new do ... .
       def class_constructor?(block_node)
         send_node = block_node.children.first
-        receiver_node, method_name, *_ = *send_node
+        receiver_node, method_name, = *send_node
         return false unless method_name == :new
         %w(Class Module).include?(Util.const_name(receiver_node))
       end

data/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -82,7 +82,7 @@ module RuboCop
             corrector.insert_before(range, ' ' * column_delta)
           end
         else
-          remove(range, corrector) if range.source =~ /^[ \t]+$/
+          remove(range, corrector) if range.source =~ /\A[ \t]+\z/
         end
       end
 

data/lib/rubocop/cop/mixin/autocorrect_unless_changing_ast.rb

@@ -5,6 +5,10 @@ module RuboCop
     # This module does auto-correction of nodes that could become grammatically
     # different after the correction. If the code change would alter the
     # abstract syntax tree, it is not done.
+    #
+    # However, if the code change merely introduces extraneous "begin" nodes
+    # which do not change the meaning of the code, it is still accepted.
+    #
     module AutocorrectUnlessChangingAST
       def autocorrect(node)
         current_buffer_src = processed_source.buffer.source
@@ -12,11 +16,12 @@ module RuboCop
         pre = current_buffer_src[0...replaced_range.begin_pos]
         post = current_buffer_src[replaced_range.end_pos..-1]
         new_buffer_src = pre + rewrite_node(node) + post
+        new_processed_src = ProcessedSource.new(new_buffer_src)
 
         # Make the correction only if it doesn't change the AST for the buffer.
-        if processed_source.ast != ProcessedSource.new(new_buffer_src).ast
-          return
-        end
+        return if !new_processed_src.ast ||
+                  (INLINE_BEGIN.process(processed_source.ast) !=
+                   INLINE_BEGIN.process(new_processed_src.ast))
 
         correction(node)
       end
@@ -28,6 +33,24 @@ module RuboCop
         c = correction(ps.ast)
         Corrector.new(ps.buffer, [c]).rewrite
       end
+
+      # 'begin' nodes with a single child can be removed without changing
+      # the semantics of an AST. Canonicalizing an AST in this way can help
+      # us determine whether it has really changed in a meaningful way, or
+      # not. This means we can auto-correct in cases where we would otherwise
+      # refrain from doing so.
+      #
+      # If any other simplifications can be done to an AST without changing
+      # its meaning, they should be added here (and the class renamed).
+      # This will make autocorrection more powerful across the board.
+      #
+      class InlineBeginNodes < Parser::AST::Processor
+        def on_begin(node)
+          node.children.one? ? node.children[0] : node
+        end
+      end
+
+      INLINE_BEGIN = InlineBeginNodes.new
     end
   end
 end

data/lib/rubocop/cop/mixin/check_assignment.rb

@@ -23,13 +23,12 @@ module RuboCop
       end
 
       def on_send(node)
-        _receiver, method_name, *_, rhs = *node
-
         # we only want to indent relative to the receiver
         # when the method called looks like a setter
-        return unless method_name.to_s.end_with?('=')
+        return unless node.asgn_method_call?
 
         # This will match if, case, begin, blocks, etc.
+        rhs = node.children.last
         check_assignment(node, rhs) if rhs.is_a?(AST::Node)
       end
     end

data/lib/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -5,28 +5,75 @@ module RuboCop
     # Handles `EnforcedStyle` configuration parameters.
     module ConfigurableEnforcedStyle
       def opposite_style_detected
-        self.config_to_allow_offenses ||=
-          { parameter_name => alternative_style.to_s }
-        both_styles_detected if config_to_allow_offenses['Enabled']
+        style_detected(alternative_style)
       end
 
       def correct_style_detected
-        # Enabled:true indicates, later when the opposite style is detected,
-        # that the correct style is used somewhere.
-        self.config_to_allow_offenses ||= { 'Enabled' => true }
-        both_styles_detected if config_to_allow_offenses[parameter_name]
+        style_detected(style)
       end
 
-      def both_styles_detected
-        # Both correct and opposite styles exist.
-        self.config_to_allow_offenses = { 'Enabled' => false }
+      def unexpected_style_detected(unexpected)
+        style_detected(unexpected)
+      end
+
+      def ambiguous_style_detected(*possibilities)
+        style_detected(possibilities)
       end
 
-      def unrecognized_style_detected
-        # All we can do is to disable.
+      def style_detected(detected)
+        # `detected` can be a single style, or an Array of possible styles
+        # (if there is more than one which matches the observed code)
+
+        return if no_acceptable_style?
+
+        if detected.is_a?(Array)
+          detected.map!(&:to_s)
+        else
+          detected = detected.to_s
+        end
+
+        if !detected_style # we haven't observed any specific style yet
+          self.detected_style = detected
+        elsif detected_style.is_a?(Array)
+          self.detected_style &= [*detected]
+        elsif detected.is_a?(Array)
+          no_acceptable_style! unless detected.include?(detected_style)
+        else
+          no_acceptable_style! unless detected_style == detected
+        end
+      end
+
+      def no_acceptable_style?
+        config_to_allow_offenses['Enabled'] == false
+      end
+
+      def no_acceptable_style!
         self.config_to_allow_offenses = { 'Enabled' => false }
       end
 
+      def detected_style
+        config_to_allow_offenses[parameter_name]
+      end
+
+      def detected_style=(style)
+        if style.nil?
+          no_acceptable_style!
+        elsif style.is_a?(Array)
+          if style.empty?
+            no_acceptable_style!
+          elsif style.one?
+            config_to_allow_offenses[parameter_name] = style[0]
+          else
+            config_to_allow_offenses[parameter_name] = style
+          end
+        else
+          config_to_allow_offenses[parameter_name] = style
+        end
+      end
+
+      alias_method :conflicting_styles_detected, :no_acceptable_style!
+      alias_method :unrecognized_style_detected, :no_acceptable_style!
+
       def style
         s = cop_config[parameter_name]
         if cop_config['SupportedStyles'].include?(s)