rubocop 0.49.1 → 0.50.0

data/lib/rubocop/cop/style/symbol_literal.rb

@@ -18,7 +18,7 @@ module RuboCop
         def on_sym(node)
           return unless node.source =~ /\A:["'][A-Za-z_]\w*["']\z/
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/style/symbol_proc.rb

@@ -19,8 +19,8 @@ module RuboCop
         def_node_matcher :symbol_proc?, <<-PATTERN
           (block
             ${(send ...) (super ...) zsuper}
-            $(args (arg _))
-            $(send lvar $_))
+            (args (arg _var))
+            (send (lvar _var) $_))
         PATTERN
 
         def self.autocorrect_incompatible_with
@@ -28,7 +28,7 @@ module RuboCop
         end
 
         def on_block(node)
-          symbol_proc?(node) do |send_or_super, block_args, block_body, method|
+          symbol_proc?(node) do |send_or_super, method|
             block_method_name = resolve_block_method_name(send_or_super)
 
             # TODO: Rails-specific handling that we should probably make
@@ -37,7 +37,6 @@ module RuboCop
             return if proc_node?(send_or_super)
             return if %i[lambda proc].include?(block_method_name)
             return if ignored_method?(block_method_name)
-            return unless can_shorten?(block_args, block_body)
 
             offense(node, method, block_method_name)
           end
@@ -124,20 +123,6 @@ module RuboCop
           ignored_methods.include?(name.to_s)
         end
 
-        def can_shorten?(block_args, block_body)
-          argument_matches_receiver?(block_args, block_body)
-        end
-
-        # TODO: This might be clearer as a node matcher with unification
-        def argument_matches_receiver?(block_args, block_body)
-          receiver, = *block_body
-
-          block_arg_name, = *block_args.children.first
-          receiver_name, = *receiver
-
-          block_arg_name == receiver_name
-        end
-
         def super?(node)
           SUPER_TYPES.include?(node.type)
         end

data/lib/rubocop/cop/style/ternary_parentheses.rb

@@ -54,6 +54,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include SurroundingSpace
 
+        VARIABLE_TYPES = AST::Node::VARIABLES
+        NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
+
         MSG = '%s parentheses for ternary conditions.'.freeze
         MSG_COMPLEX = '%s parentheses for ternary expressions with' \
           ' complex conditions.'.freeze
@@ -61,7 +64,7 @@ module RuboCop
         def on_if(node)
           return unless node.ternary? && !infinite_loop? && offense?(node)
 
-          add_offense(node, node.source_range, message(node))
+          add_offense(node, node.source_range)
         end
 
         private
@@ -102,17 +105,21 @@ module RuboCop
           if condition.begin_type?
             condition.to_a.any? { |x| complex_condition?(x) }
           else
-            non_complex_type?(condition) ? false : true
+            non_complex_expression?(condition) ? false : true
           end
         end
 
         # Anything that is not a variable, constant, or method/.method call
         # will be counted as a complex expression.
-        def non_complex_type?(condition)
-          condition.variable? || condition.const_type? ||
-            (condition.send_type? && !operator?(condition.method_name)) ||
-            condition.defined_type? || condition.yield_type? ||
-            square_brackets?(condition)
+        def non_complex_expression?(condition)
+          NON_COMPLEX_TYPES.include?(condition.type) ||
+            non_complex_send?(condition)
+        end
+
+        def non_complex_send?(node)
+          return false unless node.send_type?
+
+          !node.operator_method? || node.method?(:[])
         end
 
         def message(node)
@@ -165,9 +172,6 @@ module RuboCop
            (send {_ nil} _ $(send nil _)...)}
         PATTERN
 
-        def_node_matcher :square_brackets?,
-                         '(send {(send _recv _msg) str array hash} :[] ...)'
-
         def correct_parenthesized(condition)
           lambda do |corrector|
             corrector.remove(condition.loc.begin)

data/lib/rubocop/cop/style/trailing_underscore_variable.rb

@@ -96,16 +96,35 @@ module RuboCop
 
           return unless first_offense
 
-          end_position =
-            if first_offense.source_range == variables.first.source_range
-              right.source_range.begin_pos
-            else
-              node.loc.operator.begin_pos
-            end
+          if unused_variables_only?(first_offense, variables)
+            return left_side_range(left, right)
+          end
+
+          if Util.parentheses?(left)
+            return range_for_parentheses(first_offense, left)
+          end
+
+          range_between(
+            first_offense.source_range.begin_pos,
+            node.loc.operator.begin_pos
+          )
+        end
+
+        def unused_variables_only?(offense, variables)
+          offense.source_range == variables.first.source_range
+        end
+
+        def left_side_range(left, right)
+          range_between(
+            left.source_range.begin_pos, right.source_range.begin_pos
+          )
+        end
 
-          range = range_between(first_offense.source_range.begin_pos,
-                                end_position)
-          range_with_surrounding_space(range, :right)
+        def range_for_parentheses(offense, left)
+          range_between(
+            offense.source_range.begin_pos - 1,
+            left.loc.expression.end_pos - 1
+          )
         end
       end
     end

data/lib/rubocop/cop/style/trivial_accessors.rb

@@ -10,16 +10,11 @@ module RuboCop
 
         def on_def(node)
           return if in_module_or_instance_eval?(node)
-          method_name, args, body = *node
-          on_method_def(node, method_name, args, body)
-        end
+          return if ignore_class_methods? && node.defs_type?
 
-        def on_defs(node)
-          return if in_module_or_instance_eval?(node)
-          return if ignore_class_methods?
-          _scope, method_name, args, body = *node
-          on_method_def(node, method_name, args, body)
+          on_method_def(node)
         end
+        alias on_defs on_def
 
         private
 
@@ -37,10 +32,10 @@ module RuboCop
           false
         end
 
-        def on_method_def(node, method_name, args, body)
-          kind = if trivial_reader?(method_name, args, body)
+        def on_method_def(node)
+          kind = if trivial_reader?(node)
                    'reader'
-                 elsif trivial_writer?(method_name, args, body)
+                 elsif trivial_writer?(node)
                    'writer'
                  end
           return unless kind
@@ -69,61 +64,53 @@ module RuboCop
           Array(whitelist).map(&:to_sym) + [:initialize]
         end
 
-        def predicate?(method_name)
-          method_name[-1] == '?'
-        end
-
         def dsl_writer?(method_name)
           !method_name.to_s.end_with?('=')
         end
 
-        def trivial_reader?(method_name, args, body)
-          looks_like_trivial_reader?(args, body) &&
-            !allowed_method?(method_name, body) &&
-            !allowed_reader?(method_name)
+        def trivial_reader?(node)
+          looks_like_trivial_reader?(node) &&
+            !allowed_method?(node) && !allowed_reader?(node)
         end
 
-        def looks_like_trivial_reader?(args, body)
-          args.children.empty? && body && body.ivar_type?
+        def looks_like_trivial_reader?(node)
+          !node.arguments? && node.body && node.body.ivar_type?
         end
 
-        def trivial_writer?(method_name, args, body)
-          looks_like_trivial_writer?(args, body) &&
-            !allowed_method?(method_name, body) &&
-            !allowed_writer?(method_name)
+        def trivial_writer?(node)
+          looks_like_trivial_writer?(node) &&
+            !allowed_method?(node) && !allowed_writer?(node.method_name)
         end
 
-        def looks_like_trivial_writer?(args, body)
-          args.children.one? &&
-            !%i[restarg blockarg].include?(args.children[0].type) &&
-            body && body.ivasgn_type? &&
-            body.children[1] && body.children[1].lvar_type?
-        end
+        def_node_matcher :looks_like_trivial_writer?, <<-PATTERN
+          {(def    _ (args (arg ...)) (ivasgn _ (lvar _)))
+           (defs _ _ (args (arg ...)) (ivasgn _ (lvar _)))}
+        PATTERN
 
-        def allowed_method?(method_name, body)
-          whitelist.include?(method_name) ||
-            exact_name_match? && !names_match?(method_name, body)
+        def allowed_method?(node)
+          whitelist.include?(node.method_name) ||
+            exact_name_match? && !names_match?(node)
         end
 
         def allowed_writer?(method_name)
           allow_dsl_writers? && dsl_writer?(method_name)
         end
 
-        def allowed_reader?(method_name)
-          allow_predicates? && predicate?(method_name)
+        def allowed_reader?(node)
+          allow_predicates? && node.predicate_method?
         end
 
-        def names_match?(method_name, body)
-          ivar_name, = *body
+        def names_match?(node)
+          ivar_name, = *node.body
 
-          method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..-1]
+          node.method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..-1]
         end
 
-        def trivial_accessor_kind(method_name, args, body)
-          if trivial_writer?(method_name, args, body) &&
-             !dsl_writer?(method_name)
+        def trivial_accessor_kind(node)
+          if trivial_writer?(node) &&
+             !dsl_writer?(node.method_name)
             'writer'
-          elsif trivial_reader?(method_name, args, body)
+          elsif trivial_reader?(node)
             'reader'
           end
         end
@@ -141,31 +128,27 @@ module RuboCop
         end
 
         def autocorrect_instance(node)
-          method_name, args, body = *node
-          unless names_match?(method_name, body) &&
-                 !predicate?(method_name) &&
-                 (kind = trivial_accessor_kind(method_name, args, body))
-            return
-          end
+          kind = trivial_accessor_kind(node)
+
+          return unless names_match?(node) && !node.predicate_method? && kind
 
           lambda do |corrector|
-            corrector.replace(node.source_range, accessor(kind, method_name))
+            corrector.replace(node.source_range,
+                              accessor(kind, node.method_name))
           end
         end
 
         def autocorrect_class(node)
-          _, method_name, args, body = *node
-          unless names_match?(method_name, body) &&
-                 (kind = trivial_accessor_kind(method_name, args, body))
-            return
-          end
+          kind = trivial_accessor_kind(node)
+
+          return unless names_match?(node) && kind
 
           lambda do |corrector|
             indent = ' ' * node.loc.column
             corrector.replace(
               node.source_range,
               ['class << self',
-               "#{indent}  #{accessor(kind, method_name)}",
+               "#{indent}  #{accessor(kind, node.method_name)}",
                "#{indent}end"].join("\n")
             )
           end

data/lib/rubocop/cop/style/unless_else.rb

@@ -11,7 +11,7 @@ module RuboCop
         def on_if(node)
           return unless node.unless? && node.else?
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/style/unneeded_capital_w.rb

@@ -19,7 +19,7 @@ module RuboCop
         def on_percent_literal(node)
           return if requires_interpolation?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def requires_interpolation?(node)

data/lib/rubocop/cop/style/unneeded_interpolation.rb

@@ -25,7 +25,7 @@ module RuboCop
         end
 
         def on_dstr(node)
-          add_offense(node, :expression, MSG) if single_interpolation?(node)
+          add_offense(node) if single_interpolation?(node)
         end
 
         private

data/lib/rubocop/cop/style/unneeded_percent_q.rb

@@ -35,7 +35,7 @@ module RuboCop
           return unless start_with_percent_q_variant?(node)
           return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def interpolated_quotes?(node)

data/lib/rubocop/cop/style/variable_interpolation.rb

@@ -5,9 +5,11 @@ module RuboCop
     module Style
       # This cop checks for variable interpolation (like "#@ivar").
       class VariableInterpolation < Cop
+        # rubocop:disable Lint/InterpolationCheck
         MSG = 'Replace interpolated variable `%s` ' \
               'with expression `#{%s}`.'.freeze
 
+        # rubocop:enable Lint/InterpolationCheck
         def on_dstr(node)
           check_for_interpolation(node)
         end
@@ -23,12 +25,15 @@ module RuboCop
         private
 
         def check_for_interpolation(node)
-          var_nodes(node.children).each do |v|
-            var = v.source
-            add_offense(v, :expression, format(MSG, var, var))
+          var_nodes(node.children).each do |var_node|
+            add_offense(var_node)
           end
         end
 
+        def message(node)
+          format(MSG, node.source, node.source)
+        end
+
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.source_range, "{#{node.source}}")

data/lib/rubocop/cop/style/word_array.rb

@@ -35,6 +35,7 @@ module RuboCop
         include ArrayMinSize
         include ArraySyntax
         include ConfigurableEnforcedStyle
+        include PercentArray
         include PercentLiteral
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'.freeze
@@ -47,12 +48,16 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:str, node)
+            return if complex_content?(node.values)
+
             check_bracketed_array(node)
           elsif node.percent_literal?(:string)
             check_percent_array(node)
           end
         end
 
+        private
+
         def autocorrect(node)
           if style == :percent
             correct_percent(node, 'w')
@@ -61,33 +66,11 @@ module RuboCop
           end
         end
 
-        private
-
         def check_bracketed_array(node)
-          return if complex_content?(node.values) ||
-                    comments_in_array?(node) ||
-                    below_array_length?(node)
+          return if allowed_bracket_array?(node)
 
           array_style_detected(:brackets, node.values.size)
-          add_offense(node, :expression, PERCENT_MSG) if style == :percent
-        end
-
-        def check_percent_array(node)
-          array_style_detected(:percent, node.values.size)
-          add_offense(node, :expression, ARRAY_MSG) if style == :brackets
-        end
-
-        def percent_syntax?(node)
-          node.loc.begin && node.loc.begin.source =~ /\A%[wW]/
-        end
-
-        def comments_in_array?(node)
-          comments = processed_source.comments
-          array_range = node.source_range.to_a
-
-          comments.any? do |comment|
-            !(comment.loc.expression.to_a & array_range).empty?
-          end
+          add_offense(node) if style == :percent
         end
 
         def complex_content?(strings)