rubocop 0.49.1 → 0.50.0

data/lib/rubocop/cop/layout/space_before_comment.rb

@@ -5,6 +5,13 @@ module RuboCop
     module Layout
       # This cop checks for missing space between a token and a comment on the
       # same line.
+      #
+      # @example
+      #   # bad
+      #   1 + 1# this operation does ...
+      #
+      #   # good
+      #   1 + 1 # this operation does ...
       class SpaceBeforeComment < Cop
         MSG = 'Put a space before an end-of-line comment.'.freeze
 

data/lib/rubocop/cop/layout/space_before_semicolon.rb

@@ -4,6 +4,13 @@ module RuboCop
   module Cop
     module Layout
       # Checks for semicolon (;) preceded by space.
+      #
+      # @example
+      #   # bad
+      #   x = 1 ; y = 2
+      #
+      #   # good
+      #   x = 1; y = 2
       class SpaceBeforeSemicolon < Cop
         include SpaceBeforePunctuation
 

data/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb

@@ -26,7 +26,7 @@ module RuboCop
 
         def on_percent_literal(node)
           each_unnecessary_space_match(node) do |range|
-            add_offense(node, range, MSG)
+            add_offense(node, range)
           end
         end
 

data/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb

@@ -50,7 +50,7 @@ module RuboCop
           return unless node.single_line?
 
           regex_matches(node) do |match_range|
-            add_offense(node, match_range, MSG)
+            add_offense(node, match_range)
           end
         end
 

data/lib/rubocop/cop/layout/space_inside_range_literal.rb

@@ -40,7 +40,7 @@ module RuboCop
 
           return unless expression =~ /(\s#{escaped_op})|(#{escaped_op}\s)/
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/layout/space_inside_string_interpolation.rb

@@ -18,8 +18,8 @@ module RuboCop
         SPACE_MSG = 'Missing space around string interpolation detected.'.freeze
 
         def on_dstr(node)
-          each_style_violation(node) do |final_node, msg|
-            add_offense(final_node, :expression, msg)
+          each_style_violation(node) do |final_node|
+            add_offense(final_node)
           end
         end
 
@@ -31,13 +31,17 @@ module RuboCop
             next unless final_node
 
             if style == :no_space && space_on_any_side?(final_node)
-              yield final_node, NO_SPACE_MSG
+              yield final_node
             elsif style == :space && !space_on_each_side?(final_node)
-              yield final_node, SPACE_MSG
+              yield final_node
             end
           end
         end
 
+        def message(_node)
+          style == :no_space ? NO_SPACE_MSG : SPACE_MSG
+        end
+
         def space_on_any_side?(node)
           interp = node.source_range
           interp_with_surrounding_space = range_with_surrounding_space(interp)

data/lib/rubocop/cop/layout/tab.rb

@@ -22,7 +22,7 @@ module RuboCop
                                  index + 1,
                                  (spaces.length)...(match.end(0)))
 
-            add_offense(range, range, MSG)
+            add_offense(range, range)
           end
         end
 

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

@@ -36,7 +36,7 @@ module RuboCop
           last_param = node.last_argument.children.first
           return unless method_as_param?(last_param)
 
-          add_offense(node, :expression, message(node.last_argument))
+          add_offense(node)
         end
 
         private
@@ -53,7 +53,9 @@ module RuboCop
           param && param.send_type? && !param.arguments?
         end
 
-        def message(param)
+        def message(node)
+          param = node.last_argument
+
           format(MSG, param.source, param.children.first.source)
         end
 

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

@@ -24,7 +24,13 @@ module RuboCop
       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)
@@ -41,6 +47,14 @@ 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)
           return if node.condition.block_type?
 

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

@@ -93,14 +93,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.loc.line != node.loc.line &&
+            !parent.masgn_type?
         end
 
         def check_block_alignment(start_node, block_node)

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, :expression, format(MSG, node.source[1..-1]))
+        end
+      end
+    end
+  end
+end

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 (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 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

@@ -37,19 +37,19 @@ module RuboCop
       #   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,

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,36 @@ 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
+            add_offense(node, loc, message_for_dup(node, method_name))
           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