rubocop 0.46.0 → 0.47.0

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

@@ -7,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
 

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

@@ -7,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

@@ -5,6 +5,22 @@ 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
 
@@ -26,11 +42,9 @@ module RuboCop
         private
 
         def check(node)
-          condition, = *node
+          return if node.condition.block_type?
 
-          return if condition.block_type?
-
-          traverse_node(condition, ASGN_TYPES) do |asgn_node|
+          traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
 

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

@@ -6,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.
@@ -20,18 +20,40 @@ module RuboCop
       #
       # @example
       #
-      #   # either
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: either (default)
+      #
+      #   # good
+      #
       #   variable = lambda do |i|
       #     i
       #   end
       #
-      #   # start_of_block
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: start_of_block
+      #
+      #   # good
+      #
       #   foo.bar
       #     .each do
       #        baz
       #      end
       #
-      #   # start_of_line
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: start_of_line
+      #
+      #   # good
+      #
       #   foo.bar
       #     .each do
       #        baz
@@ -54,8 +76,8 @@ module RuboCop
           check_block_alignment(start_for_block_node(node), node)
         end
 
-        def parameter_name
-          'AlignWith'
+        def style_parameter_name
+          'EnforcedStyleAlignWith'
         end
 
         private
@@ -93,10 +115,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

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

@@ -9,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

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

@@ -8,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
@@ -32,21 +42,9 @@ 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
-
-        def message(keyword)
-          "Place the condition on the same line as `#{keyword}`."
-        end
+          return if node.modifier_form? || node.single_line_condition?
 
-        def on_different_line?(keyword_line, cond_line)
-          keyword_line != cond_line
+          add_offense(node.condition, :expression, format(MSG, node.keyword))
         end
       end
     end

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

@@ -4,6 +4,34 @@ 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
 

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks whether the end keywords of method definitions are
       # aligned properly.
       #
-      # Two modes are supported through the AlignWith configuration
+      # Two modes are supported through the EnforcedStyleAlignWith configuration
       # parameter. If it's set to `start_of_line` (which is the default), the
       # `end` shall be aligned with the start of the line where the `def`
       # keyword is. If it's set to `def`, the `end` shall be aligned with the
@@ -14,8 +14,28 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
+      #   private def foo
+      #               end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: start_of_line (default)
+      #
+      #   # good
+      #
       #   private def foo
       #   end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: def
+      #
+      #   # good
+      #
+      #   private def foo
+      #           end
       class DefEndAlignment < Cop
         include OnMethodDef
         include EndKeywordAlignment

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

@@ -4,12 +4,24 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for uses of the deprecated class method usages.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   File.exists?(some_path)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   File.exist?(some_path)
       class DeprecatedClassMethods < Cop
         # Inner class to DeprecatedClassMethods.
         # This class exists to add abstraction and clean naming to the
         # objects that are going to be operated on.
         class DeprecatedClassMethod
-          include RuboCop::Sexp
+          include RuboCop::AST::Sexp
 
           attr_reader :class_constant, :deprecated_method, :replacement_method
 

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

@@ -8,40 +8,44 @@ module RuboCop
       #
       # @example
       #
-      #    # bad
-      #    case x
-      #    when 'first'
-      #      do_something
-      #    when 'first'
-      #      do_something_else
-      #    end
+      #   # bad
       #
+      #   case x
+      #   when 'first'
+      #     do_something
+      #   when 'first'
+      #     do_something_else
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   case x
+      #   when 'first
+      #     do_something
+      #   when 'second'
+      #     do_something_else
+      #   end
       class DuplicateCaseCondition < Cop
         MSG = 'Duplicate `when` condition detected.'.freeze
 
         def on_case(case_node)
-          _condition, *whens, _else = *case_node
-          conditions_seen = []
-
-          whens.each do |when_node|
-            conditions = when_conditions(when_node)
-            conditions.each do |cond|
-              if repeated_condition?(conditions_seen, cond)
-                add_offense(case_node, cond.loc.expression, MSG)
+          case_node.when_branches.each_with_object([]) do |when_node, previous|
+            when_node.each_condition do |condition|
+              if repeated_condition?(previous, condition)
+                add_offense(condition, :expression, MSG)
               end
             end
-            conditions_seen.push(conditions)
+
+            previous.push(when_node.conditions)
           end
         end
 
         private
 
-        def when_conditions(when_node)
-          when_node.to_a[0...-1]
-        end
-
-        def repeated_condition?(conditions_seen, condition)
-          conditions_seen.any? { |x| x.include?(condition) }
+        def repeated_condition?(previous, condition)
+          previous.any? { |c| c.include?(condition) }
         end
       end
     end

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

@@ -7,7 +7,9 @@ module RuboCop
       # definitions.
       #
       # @example
-      #   @bad
+      #
+      #   # bad
+      #
       #   def duplicated
       #     1
       #   end
@@ -15,6 +17,18 @@ module RuboCop
       #   def duplicated
       #     2
       #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def duplicated
+      #     1
+      #   end
+      #
+      #   def other_duplicated
+      #     2
+      #   end
       class DuplicateMethods < Cop
         MSG = 'Method `%s` is defined at both %s and %s.'.freeze