rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for ambiguous block association with method
+      # when param passed without parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_method a { |val| puts val }
+      #
+      # @example
+      #
+      #   # good
+      #   # With parentheses, there's no ambiguity.
+      #   some_method(a) { |val| puts val }
+      #
+      #   # good
+      #   # Operator methods require no disambiguation
+      #   foo == bar { |b| b.baz }
+      #
+      #   # good
+      #   # Lambda arguments require no disambiguation
+      #   foo = ->(bar) { bar.baz }
+      class AmbiguousBlockAssociation < Cop
+        MSG = 'Parenthesize the param `%s` to make sure that the block will be'\
+              ' associated with the `%s` method call.'.freeze
+
+        def on_send(node)
+          return if !node.arguments? || node.parenthesized? ||
+                    node.last_argument.lambda? || allowed_method?(node)
+
+          return unless ambiguous_block_association?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def ambiguous_block_association?(send_node)
+          send_node.last_argument.block_type? &&
+            !send_node.last_argument.send_node.arguments?
+        end
+
+        def allowed_method?(node)
+          node.assignment? || node.operator_method? || node.method?(:[])
+        end
+
+        def message(send_node)
+          block_param = send_node.last_argument
+
+          format(MSG, block_param.source, block_param.send_node.source)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,14 +7,19 @@ module RuboCop
       # method invocation without parentheses.
       #
       # @example
-      #   array = [1, 2, 3]
+      #
+      #   # bad
       #
       #   # The `*` is interpreted as a splat operator but it could possibly be
-      #   # a `*` method invocation (i.e. `do_something.*(array)`).
-      #   do_something *array
+      #   # a `*` method invocation (i.e. `do_something.*(some_array)`).
+      #   do_something *some_array
+      #
+      # @example
+      #
+      #   # good
       #
       #   # With parentheses, there's no ambiguity.
-      #   do_something(*array)
+      #   do_something(*some_array)
       class AmbiguousOperator < Cop
         include ParserDiagnostic
 
@@ -29,10 +33,10 @@ module RuboCop
           hash[:operator] = key
         end
 
-        MSG_FORMAT = 'Ambiguous %{actual} operator. Parenthesize the method ' \
-                     "arguments if it's surely a %{actual} operator, or add " \
-                     'a whitespace to the right of the `%{operator}` if it ' \
-                     'should be a %{possible}.'.freeze
+        MSG_FORMAT = 'Ambiguous %<actual>s operator. Parenthesize the method ' \
+                     "arguments if it's surely a %<actual>s operator, or add " \
+                     'a whitespace to the right of the `%<operator>s` if it ' \
+                     'should be a %<possible>s.'.freeze
 
         private
 

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,11 +7,18 @@ module RuboCop
       # a method invocation without parentheses.
       #
       # @example
+      #
+      #   # bad
+      #
       #   # This is interpreted as a method invocation with a regexp literal,
       #   # but it could possibly be `/` method invocations.
       #   # (i.e. `do_something./(pattern)./(i)`)
       #   do_something /pattern/i
       #
+      # @example
+      #
+      #   # good
+      #
       #   # With parentheses, there's no ambiguity.
       #   do_something(/pattern/i)
       class AmbiguousRegexpLiteral < Cop

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,10 +5,32 @@ module RuboCop
     module Lint
       # This cop checks for assignments in the conditions of
       # if/while/until.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   if some_var = true
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if some_var == true
+      #     do_something
+      #   end
       class AssignmentInCondition < Cop
         include SafeAssignment
 
-        MSG = 'Assignment in condition - you probably meant to use `==`.'.freeze
+        MSG_WITH_SAFE_ASSIGNMENT_ALLOWED =
+          'Use `==` if you meant to do a comparison or wrap the expression ' \
+          'in parentheses to indicate you meant to assign in a ' \
+          'condition.'.freeze
+        MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
+          'Use `==` if you meant to do a comparison or move the assignment ' \
+          'up out of the condition.'.freeze
         ASGN_TYPES = [:begin, *EQUALS_ASGN_NODES, :send].freeze
 
         def on_if(node)
@@ -26,37 +47,46 @@ module RuboCop
 
         private
 
+        def message(_node)
+          if safe_assignment_allowed?
+            MSG_WITH_SAFE_ASSIGNMENT_ALLOWED
+          else
+            MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED
+          end
+        end
+
         def check(node)
-          condition, = *node
-
-          # assignments inside blocks are not what we're looking for
-          return if condition.type == :block
-          traverse_node(condition, ASGN_TYPES) do |asgn_node|
-            if asgn_node.type == :send
-              _receiver, method_name, *_args = *asgn_node
-              next :skip_children if method_name !~ /=\z/
-            end
-
-            # skip safe assignment nodes if safe assignment is allowed
-            if safe_assignment_allowed? && safe_assignment?(asgn_node)
-              next :skip_children
-            end
-
-            # assignment nodes from shorthand ops like ||= don't have operator
-            if asgn_node.type != :begin && asgn_node.loc.operator
-              add_offense(asgn_node, :operator)
-            end
+          return if node.condition.block_type?
+
+          traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
+            next :skip_children if skip_children?(asgn_node)
+            next if allowed_construct?(asgn_node)
+
+            add_offense(asgn_node, location: :operator)
           end
         end
 
+        def allowed_construct?(asgn_node)
+          asgn_node.begin_type? || conditional_assignment?(asgn_node)
+        end
+
+        def conditional_assignment?(asgn_node)
+          !asgn_node.loc.operator
+        end
+
+        def skip_children?(asgn_node)
+          (asgn_node.send_type? && asgn_node.method_name !~ /=\z/) ||
+            empty_condition?(asgn_node) ||
+            (safe_assignment_allowed? && safe_assignment?(asgn_node))
+        end
+
         # each_node/visit_descendants_with_types with :skip_children
         def traverse_node(node, types, &block)
           result = yield node if types.include?(node.type)
-          # return to skip all descendant nodes
+
           return if result == :skip_children
-          node.children.each do |child|
-            traverse_node(child, types, &block) if child.is_a?(Node)
-          end
+
+          node.each_child_node { |child| traverse_node(child, types, &block) }
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,8 +6,8 @@ module RuboCop
       # This cop checks whether the end keywords are aligned properly for do
       # end blocks.
       #
-      # Three modes are supported through the `AlignWith` configuration
-      # parameter:
+      # Three modes are supported through the `EnforcedStyleAlignWith`
+      # configuration parameter:
       #
       # `start_of_block` : the `end` shall be aligned with the
       # start of the line where the `do` appeared.
@@ -19,20 +18,45 @@ module RuboCop
       # `either` (which is the default) : the `end` is allowed to be in either
       # location. The autofixer will default to `start_of_line`.
       #
-      # @example
+      # @example EnforcedStyleAlignWith: either (default)
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      #   # good
       #
-      #   # either
       #   variable = lambda do |i|
       #     i
       #   end
       #
-      #   # start_of_block
+      # @example EnforcedStyleAlignWith: start_of_block
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      #   # good
+      #
       #   foo.bar
       #     .each do
       #        baz
       #      end
       #
-      #   # start_of_line
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      #   # good
+      #
       #   foo.bar
       #     .each do
       #        baz
@@ -55,8 +79,21 @@ module RuboCop
           check_block_alignment(start_for_block_node(node), node)
         end
 
-        def parameter_name
-          'AlignWith'
+        def style_parameter_name
+          'EnforcedStyleAlignWith'
+        end
+
+        def autocorrect(node)
+          ancestor_node = start_for_block_node(node)
+          start_col = compute_start_col(ancestor_node, node)
+          loc_end = node.loc.end
+          delta = start_col - loc_end.column
+
+          if delta > 0
+            add_space_before(loc_end, delta)
+          elsif delta < 0
+            remove_space_before(loc_end.begin_pos, -delta)
+          end
         end
 
         private
@@ -72,14 +109,23 @@ module RuboCop
         end
 
         def block_end_align_target(node)
-          while (parent = node.parent)
-            break if !parent || !parent.loc
-            break if parent.loc.line != node.loc.line && !parent.masgn_type?
-            break unless block_end_align_target?(parent, node)
-            node = parent
+          lineage = [node, *node.ancestors]
+
+          target = lineage.each_cons(2) do |current, parent|
+            break current if end_align_target?(current, parent)
           end
 
-          node
+          target || lineage.last
+        end
+
+        def end_align_target?(node, parent)
+          disqualified_parent?(parent, node) ||
+            !block_end_align_target?(parent, node)
+        end
+
+        def disqualified_parent?(parent, node)
+          parent && parent.loc && parent.first_line != node.first_line &&
+            !parent.masgn_type?
         end
 
         def check_block_alignment(start_node, block_node)
@@ -94,10 +140,19 @@ module RuboCop
             compute_do_source_line_column(block_node, end_loc)
           return unless do_source_line_column
 
-          offense(block_node, start_loc, end_loc, do_source_line_column)
+          register_offense(
+            block_node,
+            start_loc,
+            end_loc,
+            do_source_line_column
+          )
         end
 
-        def offense(block_node, start_loc, end_loc, do_source_line_column)
+        def register_offense(block_node,
+                             start_loc,
+                             end_loc,
+                             do_source_line_column)
+
           error_source_line_column = if style == :start_of_block
                                        do_source_line_column
                                      else
@@ -107,7 +162,7 @@ module RuboCop
           message = format_message(start_loc, end_loc, do_source_line_column,
                                    error_source_line_column)
 
-          add_offense(block_node, end_loc, message)
+          add_offense(block_node, location: end_loc, message: message)
         end
 
         def format_message(start_loc, end_loc, do_source_line_column,
@@ -172,26 +227,12 @@ module RuboCop
           (ancestor_node || node).source_range.column
         end
 
-        def autocorrect(node)
-          ancestor_node = start_for_block_node(node)
-          start_col = compute_start_col(ancestor_node, node)
-          loc_end = node.loc.end
-          delta = start_col - loc_end.column
-
-          if delta > 0
-            add_space_before(loc_end, delta)
-          elsif delta < 0
-            source = node.source_range.source_buffer
-            remove_space_before(loc_end.begin_pos, -delta, source)
-          end
-        end
-
         def add_space_before(loc, delta)
           ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
         end
 
-        def remove_space_before(end_pos, delta, source)
-          range = Parser::Source::Range.new(source, end_pos - delta, end_pos)
+        def remove_space_before(end_pos, delta)
+          range = range_between(end_pos - delta, end_pos)
           ->(corrector) { corrector.remove(range) }
         end
       end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `:true` and `:false` symbols.
+      # In most cases it would be a typo.
+      #
+      # @example
+      #
+      #   # bad
+      #   :true
+      #
+      #   # good
+      #   true
+      #
+      # @example
+      #
+      #   # bad
+      #   :false
+      #
+      #   # good
+      #   false
+      class BooleanSymbol < Cop
+        MSG = 'Symbol with a boolean name - ' \
+              'you probably meant to use `%s`.'.freeze
+
+        def_node_matcher :boolean_symbol?, '(sym {:true :false})'
+
+        def on_sym(node)
+          return unless boolean_symbol?(node)
+
+          add_offense(node, message: format(MSG, node.value))
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,27 +9,41 @@ module RuboCop
       # This cop mirrors a warning produced by MRI since 2.2.
       #
       # @example
+      #
       #   # bad
+      #
       #   def bake(pie: pie)
       #     pie.heat_up
       #   end
       #
+      # @example
+      #
       #   # good
+      #
       #   def bake(pie:)
       #     pie.refrigerate
       #   end
       #
+      # @example
+      #
       #   # good
+      #
       #   def bake(pie: self.pie)
       #     pie.feed_to(user)
       #   end
       #
+      # @example
+      #
       #   # bad
+      #
       #   def cook(dry_ingredients = dry_ingredients)
       #     dry_ingredients.reduce(&:+)
       #   end
       #
+      # @example
+      #
       #   # good
+      #
       #   def cook(dry_ingredients = self.dry_ingredients)
       #     dry_ingredients.combine
       #   end
@@ -48,21 +61,10 @@ module RuboCop
         private
 
         def check_for_circular_argument_references(arg_name, arg_value)
-          case arg_value.type
-          when :send
-            # Ruby 2.0 will have type send every time, and "send nil" if it is
-            # calling itself with a specified "self" receiver
-            receiver, name = *arg_value
-            return unless name == arg_name && receiver.nil?
-          when :lvar
-            # Ruby 2.2.2 will have type lvar if it is calling its own method
-            # without a specified "self"
-            return unless arg_value.to_a == [arg_name]
-          else
-            return
-          end
+          return unless arg_value.lvar_type?
+          return unless arg_value.to_a == [arg_name]
 
-          add_offense(arg_value, :expression, format(MSG, arg_name))
+          add_offense(arg_value, message: format(MSG, arg_name))
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,15 +8,25 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   if
       #     some_condition
       #     do_something
       #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if some_condition
+      #     do_something
+      #   end
       class ConditionPosition < Cop
-        include IfNode
+        MSG = 'Place the condition on the same line as `%s`.'.freeze
 
         def on_if(node)
-          return if ternary?(node)
+          return if node.ternary?
 
           check(node)
         end
@@ -33,21 +42,13 @@ module RuboCop
         private
 
         def check(node)
-          return if !node.loc.keyword.is?('elsif') && node.loc.end.nil?
-
-          condition, = *node
-          return unless on_different_line?(node.loc.keyword.line,
-                                           condition.source_range.line)
-
-          add_offense(condition, :expression, message(node.loc.keyword.source))
-        end
+          return if node.modifier_form? || node.single_line_condition?
 
-        def message(keyword)
-          "Place the condition on the same line as `#{keyword}`."
+          add_offense(node.condition)
         end
 
-        def on_different_line?(keyword_line, cond_line)
-          keyword_line != cond_line
+        def message(node)
+          format(MSG, node.parent.keyword)
         end
       end
     end

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

@@ -1,43 +1,77 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks for calls to debugger or pry.
+      #
+      # @example
+      #
+      #   # bad (ok during development)
+      #
+      #   # using pry
+      #   def some_method
+      #     binding.pry
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # bad (ok during development)
+      #
+      #   # using byebug
+      #   def some_method
+      #     byebug
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   end
       class Debugger < Cop
         MSG = 'Remove debugger entry point `%s`.'.freeze
 
-        def_node_matcher :debugger_call?, <<-END
-          {(send nil {:debugger :byebug} ...)
-           (send (send nil :binding)
+        def_node_matcher :kernel?, <<-PATTERN
+          {
+            (const nil? :Kernel)
+            (const (cbase) :Kernel)
+          }
+        PATTERN
+
+        def_node_matcher :debugger_call?, <<-PATTERN
+          {(send {nil? #kernel?} {:debugger :byebug} ...)
+           (send (send {#kernel? nil?} :binding)
              {:pry :remote_pry :pry_remote} ...)
-           (send (const nil :Pry) :rescue ...)
-           (send nil {:save_and_open_page
+           (send (const {nil? (cbase)} :Pry) :rescue ...)
+           (send nil? {:save_and_open_page
                       :save_and_open_screenshot
                       :save_screenshot} ...)}
-        END
+        PATTERN
+
+        def_node_matcher :binding_irb_call?, <<-PATTERN
+          (send (send {#kernel? nil?} :binding) :irb ...)
+        PATTERN
 
-        def_node_matcher :pry_rescue?, '(send (const nil :Pry) :rescue ...)'
+        def_node_matcher :pry_rescue?, '(send (const nil? :Pry) :rescue ...)'
 
         def on_send(node)
-          return unless debugger_call?(node)
-          add_offense(node, :expression, format(MSG, node.source))
+          return unless debugger_call?(node) || binding_irb?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, node.source)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if pry_rescue?(node)
-              block = node.parent
-              body  = block.children[2] # (block <send> <parameters> <body>)
-              corrector.replace(block.source_range, body.source)
-            else
-              range = node.source_range
-              range = range_with_surrounding_space(range, :left, false)
-              range = range_with_surrounding_space(range, :right, true)
-              corrector.remove(range)
-            end
-          end
+        def binding_irb?(node)
+          target_ruby_version >= 2.4 && binding_irb_call?(node)
         end
       end
     end