rubocop 0.49.1 → 0.52.0

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

@@ -44,7 +44,11 @@ module RuboCop
         def check(node)
           return if node.modifier_form? || node.single_line_condition?
 
-          add_offense(node.condition, :expression, format(MSG, node.keyword))
+          add_offense(node.condition)
+        end
+
+        def message(node)
+          format(MSG, node.parent.keyword)
         end
       end
     end

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

@@ -35,26 +35,33 @@ module RuboCop
       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?, <<-END
-          (send (send nil :binding) :irb ...)
-        END
+        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) || binding_irb?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         private

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

@@ -12,44 +12,41 @@ module RuboCop
       # 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
       #
-      # @example
-      #
-      #   # EnforcedStyleAlignWith: start_of_line (default)
-      #
       #   # good
       #
       #   private def foo
       #   end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: def
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: def
+      #   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)
+          return unless node.def_modifier?
 
-          method_def = node.first_argument
+          method_def = node.each_descendant(:def, :defs).first
           expr = node.source_range
 
           line_start = range_between(expr.begin_pos,
@@ -63,8 +60,6 @@ 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)

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

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

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

@@ -33,9 +33,9 @@ module RuboCop
         def on_case(case_node)
           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
+              next unless repeated_condition?(previous, condition)
+
+              add_offense(condition)
             end
 
             previous.push(when_node.conditions)

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

@@ -20,6 +20,16 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
+      #   def duplicated
+      #     1
+      #   end
+      #
+      #   alias duplicated other_duplicated
+      #
+      # @example
+      #
       #   # good
       #
       #   def duplicated
@@ -43,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)
@@ -60,6 +70,40 @@ module RuboCop
           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)
@@ -81,8 +125,8 @@ module RuboCop
                  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
@@ -92,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

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

@@ -29,7 +29,7 @@ module RuboCop
           return unless duplicates?(keys)
 
           consecutive_duplicates(keys).each do |key|
-            add_offense(key, :expression)
+            add_offense(key)
           end
         end
       end

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

@@ -30,7 +30,7 @@ module RuboCop
           each_with_object?(node) do |arg|
             return unless arg.immutable_literal?
 
-            add_offense(node, :expression)
+            add_offense(node)
           end
         end
       end

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

@@ -12,7 +12,7 @@ module RuboCop
       #   # bad
       #
       #   if something
-      #     ...
+      #     # ...
       #   else do_this
       #     do_that
       #   end
@@ -22,7 +22,7 @@ module RuboCop
       #   # good
       #
       #   if something
-      #     ...
+      #     # ...
       #   else
       #     do_this
       #     do_that
@@ -57,7 +57,7 @@ module RuboCop
 
           return unless first_else.source_range.line == node.loc.else.line
 
-          add_offense(first_else, :expression)
+          add_offense(first_else)
         end
       end
     end

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

@@ -46,7 +46,7 @@ module RuboCop
         MSG = 'Empty `ensure` block detected.'.freeze
 
         def on_ensure(node)
-          add_offense(node, :keyword) unless node.body
+          add_offense(node, location: :keyword) unless node.body
         end
 
         def autocorrect(node)

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

@@ -28,7 +28,7 @@ module RuboCop
         def on_begin(node)
           return unless empty_expression?(node)
 
-          add_offense(node, node.source_range, MSG)
+          add_offense(node, location: node.source_range)
         end
 
         private

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

@@ -21,7 +21,7 @@ module RuboCop
 
         def on_dstr(node)
           node.each_child_node(:begin) do |begin_node|
-            add_offense(begin_node, :expression) if begin_node.children.empty?
+            add_offense(begin_node) if begin_node.children.empty?
           end
         end
 

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

@@ -29,7 +29,7 @@ module RuboCop
           node.each_when do |when_node|
             next if when_node.body
 
-            add_offense(when_node, when_node.source_range, MSG)
+            add_offense(when_node, location: when_node.source_range)
           end
         end
       end

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

@@ -17,34 +17,33 @@ module RuboCop
       # If it's set to `start_of_line`, the `end` shall be aligned with the
       # start of the line where the matching keyword appears.
       #
-      # @example
-      #
+      # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad
       #
       #   variable = if true
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyleAlignWith: keyword (default)
-      #
       #   # good
       #
       #   variable = if true
       #              end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: variable
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: variable
+      #   variable = if true
+      #       end
       #
       #   # good
       #
       #   variable = if true
       #   end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: start_of_line
+      #   variable = if true
+      #       end
       #
       #   # good
       #
@@ -82,6 +81,10 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          align(node, alignment_node(node))
+        end
+
         private
 
         def check_assignment(node, rhs)
@@ -125,10 +128,6 @@ module RuboCop
           check_end_kw_alignment(node, align_with)
         end
 
-        def autocorrect(node)
-          align(node, alignment_node(node))
-        end
-
         def alignment_node(node)
           if style == :keyword
             node

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

@@ -32,7 +32,7 @@ module RuboCop
 
         def on_postexe(node)
           inside_of_method = node.each_ancestor(:def, :defs).count.nonzero?
-          add_offense(node, :keyword) if inside_of_method
+          add_offense(node, location: :keyword) if inside_of_method
         end
       end
     end

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

@@ -34,7 +34,7 @@ module RuboCop
           return unless ensure_body
 
           ensure_body.each_node(:return) do |return_node|
-            add_offense(return_node, :expression)
+            add_offense(return_node)
           end
         end
       end

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

@@ -23,11 +23,11 @@ module RuboCop
 
         def on_float(node)
           value, = *node
-          if value.infinite?
-            add_offense(node, :expression, MSG)
-          elsif value.zero? && node.source =~ /[1-9]/
-            add_offense(node, :expression, MSG)
-          end
+
+          return unless value.infinite? ||
+                        value.zero? && node.source =~ /[1-9]/
+
+          add_offense(node)
         end
       end
     end