rubocop 0.46.0 → 0.47.0

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

@@ -8,20 +8,28 @@ module RuboCop
       # This cop mirrors a warning in Ruby 2.2.
       #
       # @example
+      #
+      #   # bad
+      #
       #   hash = { food: 'apple', food: 'orange' }
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   hash = { food: 'apple', other_food: 'orange' }
       class DuplicatedKey < Cop
+        include Duplication
+
         MSG = 'Duplicated key in hash literal.'.freeze
 
         def on_hash(node)
-          keys = []
+          keys = node.keys.select(&:recursive_basic_literal?)
+
+          return unless duplicates?(keys)
 
-          hash_pairs = *node
-          hash_pairs.each do |pair|
-            key, _value = *pair
-            if keys.include?(key) && key.recursive_basic_literal?
-              add_offense(key, :expression)
-            end
-            keys << key
+          consecutive_duplicates(keys).each do |key|
+            add_offense(key, :expression)
           end
         end
       end

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

@@ -11,7 +11,16 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   sum = numbers.each_with_object(0) { |e, a| a += e }
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   num = 0
+      #   sum = numbers.each_with_object(num) { |e, a| a += e }
       class EachWithObjectArgument < Cop
         MSG = 'The argument to each_with_object can not be immutable.'.freeze
 

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

@@ -9,18 +9,29 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   if something
       #     ...
       #   else do_this
       #     do_that
       #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if something
+      #     ...
+      #   else
+      #     do_this
+      #     do_that
+      #   end
       class ElseLayout < Cop
-        include IfNode
+        MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'.freeze
 
         def on_if(node)
-          return if ternary?(node)
-          # ignore modifier ops & elsif nodes
-          return unless node.loc.end
+          return if node.ternary? || node.elsif?
 
           check(node)
         end
@@ -28,39 +39,25 @@ module RuboCop
         private
 
         def check(node)
-          return unless node
-          return check_else(node) if else?(node)
+          return unless node.else_branch
 
-          check_if(node) if if?(node)
+          if node.else? && node.loc.else.is?('else')
+            check_else(node)
+          elsif node.if?
+            check(node.else_branch)
+          end
         end
 
         def check_else(node)
-          _cond, _if_branch, else_branch = *node
-          return unless else_branch && else_branch.begin_type?
-
-          first_else_expr = else_branch.children.first
-          return unless first_else_expr.source_range.line == node.loc.else.line
+          else_branch = node.else_branch
 
-          add_offense(first_else_expr, :expression, message)
-        end
+          return unless else_branch.begin_type?
 
-        def check_if(node)
-          _cond, _if_branch, else_branch = *node
-          check(else_branch)
-        end
+          first_else = else_branch.children.first
 
-        def if?(node)
-          node.loc.respond_to?(:keyword) &&
-            %w(if elsif).include?(node.loc.keyword.source)
-        end
-
-        def else?(node)
-          node.loc.respond_to?(:else) && node.loc.else &&
-            node.loc.else.is?('else')
-        end
+          return unless first_else.source_range.line == node.loc.else.line
 
-        def message
-          'Odd `else` layout detected. Did you mean to use `elsif`?'
+          add_offense(first_else, :expression)
         end
       end
     end

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

@@ -4,6 +4,44 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for empty `ensure` blocks
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     do_something
+      #   ensure
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
       class EmptyEnsure < Cop
         MSG = 'Empty `ensure` block detected.'.freeze
 

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

@@ -7,11 +7,21 @@ module RuboCop
       #
       # @example
       #
-      #   @bad
+      #   # bad
+      #
       #   foo = ()
       #   if ()
       #     bar
       #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   foo = (some_expression)
+      #   if (some_expression)
+      #     bar
+      #   end
       class EmptyExpression < Cop
         MSG = 'Avoid empty expressions.'.freeze
 

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

@@ -7,7 +7,15 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   "result is #{}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is #{some_result}"
       class EmptyInterpolation < Cop
         MSG = 'Empty interpolation detected.'.freeze
 

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

@@ -7,33 +7,31 @@ module RuboCop
       #
       # @example
       #
-      #   @bad
+      #   # bad
+      #
       #   case foo
       #   when bar then 1
       #   when baz then # nothing
       #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   case foo
+      #   when bar then 1
+      #   when baz then 2
+      #   end
       class EmptyWhen < Cop
         MSG = 'Avoid `when` branches without a body.'.freeze
 
         def on_case(node)
-          _cond_node, *when_nodes, _else_node = *node
+          node.each_when do |when_node|
+            next if when_node.body
 
-          when_nodes.each do |when_node|
-            check_when(when_node)
+            add_offense(when_node, when_node.source_range, MSG)
           end
         end
-
-        private
-
-        def check_when(when_node)
-          return unless empty_when_body?(when_node)
-
-          add_offense(when_node, when_node.source_range, MSG)
-        end
-
-        def empty_when_body?(when_node)
-          !when_node.to_a.last
-        end
       end
     end
   end

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

@@ -5,8 +5,8 @@ module RuboCop
     module Lint
       # This cop checks whether the end keywords are aligned properly.
       #
-      # Three modes are supported through the `AlignWith` configuration
-      # parameter:
+      # Three modes are supported through the `EnforcedStyleAlignWith`
+      # configuration parameter:
       #
       # If it's set to `keyword` (which is the default), the `end`
       # shall be aligned with the start of the keyword (if, class, etc.).
@@ -18,22 +18,41 @@ module RuboCop
       # start of the line where the matching keyword appears.
       #
       # @example
-      #   @good
-      #   # keyword style
+      #
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: keyword (default)
+      #
+      #   # good
+      #
       #   variable = if true
       #              end
       #
-      #   # variable style
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: variable
+      #
+      #   # good
+      #
       #   variable = if true
       #   end
       #
-      #   # start_of_line style
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: start_of_line
+      #
+      #   # good
+      #
       #   puts(if true
       #   end)
       class EndAlignment < Cop
         include CheckAssignment
         include EndKeywordAlignment
-        include IfNode
 
         def on_class(node)
           check_other_alignment(node)
@@ -44,7 +63,7 @@ module RuboCop
         end
 
         def on_if(node)
-          check_other_alignment(node) unless ternary?(node)
+          check_other_alignment(node) unless node.ternary?
         end
 
         def on_while(node)
@@ -56,8 +75,11 @@ module RuboCop
         end
 
         def on_case(node)
-          return check_asgn_alignment(node.parent, node) if argument_case?(node)
-          check_other_alignment(node)
+          if node.argument?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
         end
 
         private
@@ -67,29 +89,31 @@ module RuboCop
           # assignment, we let rhs be the receiver of those method calls before
           # we check if it's an if/unless/while/until.
           return unless (rhs = first_part_of_call_chain(rhs))
-          return unless [:if, :while, :until, :case].include?(rhs.type)
-          return if ternary?(rhs)
+          return unless CONDITIONAL_NODES.include?(rhs.type)
+          return if rhs.if_type? && rhs.ternary?
 
           check_asgn_alignment(node, rhs)
         end
 
         def check_asgn_alignment(outer_node, inner_node)
-          expr = outer_node.source_range
-
           align_with = {
             keyword: inner_node.loc.keyword,
-            start_of_line: start_line_range(outer_node)
+            start_of_line: start_line_range(outer_node),
+            variable: asgn_variable_align_with(outer_node, inner_node)
           }
 
-          align_with[:variable] =
-            if !line_break_before_keyword?(expr, inner_node)
-              range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
-            else
-              inner_node.loc.keyword
-            end
-
           check_end_kw_alignment(inner_node, align_with)
-          ignore_node(inner_node) # Don't check again.
+          ignore_node(inner_node)
+        end
+
+        def asgn_variable_align_with(outer_node, inner_node)
+          expr = outer_node.source_range
+
+          if !line_break_before_keyword?(expr, inner_node)
+            range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
+          else
+            inner_node.loc.keyword
+          end
         end
 
         def check_other_alignment(node)
@@ -109,7 +133,7 @@ module RuboCop
           if style == :keyword
             node
           elsif style == :variable
-            return node.parent if argument_case?(node)
+            return node.parent if node.case_type? && node.argument?
             # Fall back to 'keyword' style if this node is not on the RHS
             # of an assignment
             node.ancestors.find(&:assignment?) || node
@@ -118,10 +142,6 @@ module RuboCop
           end
         end
 
-        def argument_case?(node)
-          node.case_type? && node.parent && node.parent.send_type?
-        end
-
         def start_line_range(node)
           expr   = node.source_range
           buffer = expr.source_buffer

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

@@ -4,6 +4,29 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for END blocks in method definitions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     END { do_something }
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     at_exit { do_something }
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # outside defs
+      #   END { do_something }
       class EndInMethod < Cop
         MSG = '`END` found in method definition. Use `at_exit` instead.'.freeze
 

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

@@ -4,6 +4,27 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for *return* from an *ensure* block.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #     return
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
       class EnsureReturn < Cop
         MSG = 'Do not return from an `ensure` block.'.freeze