rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,34 +6,51 @@ 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
       # `def` keyword.
       #
-      # @example
+      # @example EnforcedStyleAlignWith: start_of_line (default)
+      #   # bad
+      #
+      #   private def foo
+      #               end
+      #
+      #   # good
       #
       #   private def foo
       #   end
+      #
+      # @example EnforcedStyleAlignWith: def
+      #   # bad
+      #
+      #   private def foo
+      #               end
+      #
+      #   # good
+      #
+      #   private def foo
+      #           end
       class DefEndAlignment < Cop
-        include OnMethodDef
         include EndKeywordAlignment
 
         MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
 
-        def on_method_def(node, _method_name, _args, _body)
+        def on_def(node)
           check_end_kw_in_node(node)
         end
+        alias on_defs on_def
 
         def on_send(node)
-          return unless modifier_and_def_on_same_line?(node)
-          _, _, method_def = *node
+          return unless node.def_modifier?
+
+          method_def = node.each_descendant(:def, :defs).first
           expr = node.source_range
 
-          line_start = Parser::Source::Range.new(expr.source_buffer,
-                                                 expr.begin_pos,
-                                                 method_def.loc.keyword.end_pos)
+          line_start = range_between(expr.begin_pos,
+                                     method_def.loc.keyword.end_pos)
           align_with = {
             def: method_def.loc.keyword,
             start_of_line: line_start
@@ -44,13 +60,11 @@ module RuboCop
           ignore_node(method_def) # Don't check the same `end` again.
         end
 
-        private
-
         def autocorrect(node)
           if style == :start_of_line && node.parent && node.parent.send_type?
-            align(node, node.parent)
+            AlignmentCorrector.align_end(processed_source, node, node.parent)
           else
-            align(node, node)
+            AlignmentCorrector.align_end(processed_source, node, node)
           end
         end
       end

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

@@ -1,16 +1,27 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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
 
@@ -36,10 +47,10 @@ module RuboCop
 
         def on_send(node)
           check(node) do |data|
-            add_offense(node, :selector,
-                        format(MSG,
-                               deprecated_method(data),
-                               replacement_method(data)))
+            message = format(MSG, deprecated_method(data),
+                             replacement_method(data))
+
+            add_offense(node, location: :selector, message: message)
           end
         end
 
@@ -55,11 +66,9 @@ module RuboCop
         private
 
         def check(node)
-          receiver, method_name, *_args = *node
-
           DEPRECATED_METHODS_OBJECT.each do |data|
-            next unless data.class_nodes.include?(receiver)
-            next unless method_name == data.deprecated_method
+            next unless data.class_nodes.include?(node.receiver)
+            next unless node.method?(data.deprecated_method)
             yield data
           end
         end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated conditions
+      # used in case 'when' expressions.
+      #
+      # @example
+      #
+      #   # 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)
+          case_node.when_branches.each_with_object([]) do |when_node, previous|
+            when_node.each_condition do |condition|
+              next unless repeated_condition?(previous, condition)
+
+              add_offense(condition)
+            end
+
+            previous.push(when_node.conditions)
+          end
+        end
+
+        private
+
+        def repeated_condition?(previous, condition)
+          previous.any? { |c| c.include?(condition) }
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,12 +7,36 @@ module RuboCop
       # definitions.
       #
       # @example
-      #   @bad
+      #
+      #   # bad
+      #
+      #   def duplicated
+      #     1
+      #   end
+      #
+      #   def duplicated
+      #     2
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
       #   def duplicated
       #     1
       #   end
       #
+      #   alias duplicated other_duplicated
+      #
+      # @example
+      #
+      #   # good
+      #
       #   def duplicated
+      #     1
+      #   end
+      #
+      #   def other_duplicated
       #     2
       #   end
       class DuplicateMethods < Cop
@@ -30,8 +53,8 @@ module RuboCop
           return if node.ancestors.any?(&:if_type?)
           return if possible_dsl?(node)
 
-          return unless (scope = node.parent_module_name)
-          found_instance_method(node, scope)
+          name, = *node
+          found_instance_method(node, name)
         end
 
         def on_defs(node)
@@ -41,25 +64,69 @@ module RuboCop
           receiver, name, = *node
           if receiver.const_type?
             _, const_name = *receiver
-            if (qualified = lookup_constant(node, const_name))
-              found_method(node, "#{qualified}.#{name}")
-            end
+            check_const_receiver(node, name, const_name)
           elsif receiver.self_type?
-            if (enclosing = node.parent_module_name)
-              found_method(node, "#{enclosing}.#{name}")
-            end
+            check_self_receiver(node, name)
+          end
+        end
+
+        def_node_matcher :method_alias?, <<-PATTERN
+          (alias (sym $_name) sym)
+        PATTERN
+
+        def on_alias(node)
+          return unless (name = method_alias?(node))
+          return if node.ancestors.any?(&:if_type?)
+          return if possible_dsl?(node)
+
+          found_instance_method(node, name)
+        end
+
+        def_node_matcher :alias_method?, <<-PATTERN
+          (send nil? :alias_method (sym $_name) _)
+        PATTERN
+
+        def_node_matcher :attr?, <<-PATTERN
+          (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
+        PATTERN
+
+        def_node_matcher :sym_name, '(sym $_name)'
+
+        def on_send(node)
+          if (name = alias_method?(node))
+            return unless name
+            return if node.ancestors.any?(&:if_type?)
+            return if possible_dsl?(node)
+
+            found_instance_method(node, name)
+          elsif (attr = attr?(node))
+            on_attr(node, *attr)
           end
         end
 
         private
 
+        def check_const_receiver(node, name, const_name)
+          qualified = lookup_constant(node, const_name)
+          return unless qualified
+
+          found_method(node, "#{qualified}.#{name}")
+        end
+
+        def check_self_receiver(node, name)
+          enclosing = node.parent_module_name
+          return unless enclosing
+
+          found_method(node, "#{enclosing}.#{name}")
+        end
+
         def message_for_dup(node, method_name)
           format(MSG, method_name, @definitions[method_name],
                  source_location(node))
         end
 
-        def found_instance_method(node, scope)
-          name, = *node
+        def found_instance_method(node, name)
+          return unless (scope = node.parent_module_name)
           if scope =~ /\A#<Class:(.*)>\Z/
             found_method(node, "#{Regexp.last_match(1)}.#{name}")
           else
@@ -69,12 +136,38 @@ module RuboCop
 
         def found_method(node, method_name)
           if @definitions.key?(method_name)
-            add_offense(node, :keyword, message_for_dup(node, method_name))
+            loc = node.send_type? ? node.loc.selector : node.loc.keyword
+            message = message_for_dup(node, method_name)
+
+            add_offense(node, location: loc, message: message)
           else
             @definitions[method_name] = source_location(node)
           end
         end
 
+        def on_attr(node, attr_name, args)
+          case attr_name
+          when :attr
+            writable = args.size == 2 && args.last.true_type?
+            found_attr(node, [args.first], readable: true, writable: writable)
+          when :attr_reader
+            found_attr(node, args, readable: true)
+          when :attr_writer
+            found_attr(node, args, writable: true)
+          when :attr_accessor
+            found_attr(node, args, readable: true, writable: true)
+          end
+        end
+
+        def found_attr(node, args, readable: false, writable: false)
+          args.each do |arg|
+            name = sym_name(arg)
+            next unless name
+            found_instance_method(node, name) if readable
+            found_instance_method(node, "#{name}=") if writable
+          end
+        end
+
         def lookup_constant(node, const_name)
           # this method is quite imperfect and can be fooled
           # to do much better, we would need to do global analysis of the whole
@@ -120,7 +213,8 @@ module RuboCop
 
         def source_location(node)
           range = node.location.expression
-          "#{range.source_buffer.name}:#{range.line}"
+          path = smart_path(range.source_buffer.name)
+          "#{path}:#{range.line}"
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,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)
           end
         end
       end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -12,17 +11,27 @@ 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
 
+        def_node_matcher :each_with_object?, '(send _ :each_with_object $_)'
+
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return unless method_name == :each_with_object
-          return unless args.length == 1
+          each_with_object?(node) do |arg|
+            return unless arg.immutable_literal?
 
-          arg = args.first
-          add_offense(node, :expression) if arg.immutable_literal?
+            add_offense(node)
+          end
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,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
@@ -29,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.type == :begin
-
-          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)
         end
       end
     end

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

@@ -1,17 +1,58 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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
 
         def on_ensure(node)
-          _body, ensure_body = *node
+          add_offense(node, location: :keyword) unless node.body
+        end
 
-          add_offense(node, :keyword) unless ensure_body
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.keyword)
+          end
         end
       end
     end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of empty expressions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   foo = ()
+      #   if ()
+      #     bar
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   foo = (some_expression)
+      #   if (some_expression)
+      #     bar
+      #   end
+      class EmptyExpression < Cop
+        MSG = 'Avoid empty expressions.'.freeze
+
+        def on_begin(node)
+          return unless empty_expression?(node)
+
+          add_offense(node, location: node.source_range)
+        end
+
+        private
+
+        def empty_expression?(begin_node)
+          begin_node.children.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,13 +7,27 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   "result is #{}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is #{some_result}"
       class EmptyInterpolation < Cop
         MSG = 'Empty interpolation detected.'.freeze
 
         def on_dstr(node)
-          node.children.select { |n| n.type == :begin }.each do |begin_node|
-            add_offense(begin_node, :expression) if begin_node.children.empty?
+          node.each_child_node(:begin) do |begin_node|
+            add_offense(begin_node) if begin_node.children.empty?
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |collector|
+            collector.remove(node.loc.expression)
           end
         end
       end