rubocop 0.47.1 → 0.48.0

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

@@ -8,6 +8,8 @@ module RuboCop
       class SpaceAroundOperators < Cop
         include PrecedingFollowingAlignment
 
+        IRREGULAR_METHODS = %i([] ! []=).freeze
+
         def on_pair(node)
           return unless node.hash_rocket?
 
@@ -25,32 +27,32 @@ module RuboCop
 
         def on_resbody(node)
           return unless node.loc.assoc
+
           _, variable, = *node
 
           check_operator(node.loc.assoc, variable.source_range)
         end
 
         def on_send(node)
-          if node.loc.operator # aref assignment, attribute assignment
+          if node.setter_method?
             on_special_asgn(node)
-          elsif !node.unary_operation? && !called_with_dot?(node)
-            op = node.method_name
-            if operator_with_regular_syntax?(op)
-              _, _, right, = *node
-              check_operator(node.loc.selector, right.source_range)
-            end
+          elsif regular_operator?(node)
+            check_operator(node.loc.selector, node.first_argument.source_range)
           end
         end
 
         def on_binary(node)
-          _, right, = *node
-          return if right.nil?
-          check_operator(node.loc.operator, right.source_range)
+          _, rhs, = *node
+
+          return unless rhs
+
+          check_operator(node.loc.operator, rhs.source_range)
         end
 
         def on_special_asgn(node)
-          return unless node.loc.operator
           _, _, right, = *node
+
+          return unless right
           check_operator(node.loc.operator, right.source_range)
         end
 
@@ -69,12 +71,14 @@ module RuboCop
 
         private
 
-        def called_with_dot?(node)
-          node.loc.dot
+        def regular_operator?(send_node)
+          !send_node.unary_operation? && !send_node.dot? &&
+            operator_with_regular_syntax?(send_node)
         end
 
-        def operator_with_regular_syntax?(op)
-          ![:[], :!, :[]=].include?(op) && operator?(op)
+        def operator_with_regular_syntax?(send_node)
+          send_node.operator_method? &&
+            !IRREGULAR_METHODS.include?(send_node.method_name)
         end
 
         def check_operator(op, right_operand)

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

@@ -15,6 +15,10 @@ module RuboCop
       #   something  x
       #   something   y, z
       #
+      #   @good
+      #   something x
+      #   something y, z
+      #
       class SpaceBeforeFirstArg < Cop
         include PrecedingFollowingAlignment
 
@@ -22,13 +26,14 @@ module RuboCop
               'the first argument.'.freeze
 
         def on_send(node)
-          return unless regular_method_call_with_params?(node)
+          return unless regular_method_call_with_arguments?(node)
           return unless expect_params_after_method_name?(node)
 
-          _receiver, _method_name, *args = *node
-          arg1 = args.first.source_range
-          arg1_with_space = range_with_surrounding_space(arg1, :left)
-          space = range_between(arg1_with_space.begin_pos, arg1.begin_pos)
+          first_arg = node.first_argument.source_range
+          first_arg_with_space = range_with_surrounding_space(first_arg, :left)
+          space = range_between(first_arg_with_space.begin_pos,
+                                first_arg.begin_pos)
+
           add_offense(space, space) if space.length > 1
         end
 
@@ -38,20 +43,18 @@ module RuboCop
 
         private
 
-        def regular_method_call_with_params?(node)
-          _receiver, method_name, *args = *node
-
-          !(args.empty? || operator?(method_name) || node.asgn_method_call?)
+        def regular_method_call_with_arguments?(node)
+          node.arguments? && !node.operator_method? && !node.setter_method?
         end
 
         def expect_params_after_method_name?(node)
-          return false if parentheses?(node)
+          return false if node.parenthesized?
 
-          _receiver, _method_name, *args = *node
-          arg1 = args.first.source_range
+          first_arg = node.first_argument
 
-          arg1.line == node.loc.line &&
-            !(allow_for_alignment? && aligned_with_something?(arg1))
+          same_line?(first_arg, node) &&
+            !(allow_for_alignment? &&
+              aligned_with_something?(first_arg.source_range))
         end
       end
     end

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

@@ -9,7 +9,7 @@ module RuboCop
 
         def specifics
           [
-            [:tLBRACK, :tLBRACK2],
+            %i(tLBRACK tLBRACK2),
             :tRBRACK,
             'square brackets'
           ]

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

@@ -48,7 +48,7 @@ module RuboCop
           return if t1.pos.line < t2.pos.line
           return if t2.type == :tCOMMENT # Also indicates there's a line break.
 
-          is_empty_braces = t1.text == '{' && t2.text == '}'
+          is_empty_braces = left_brace?(t1) && right_brace?(t2)
           expect_space    = expect_space?(t1, t2)
 
           if offense?(t1, t2, expect_space)
@@ -59,8 +59,8 @@ module RuboCop
         end
 
         def expect_space?(t1, t2)
-          is_same_braces  = t1.text == t2.text
-          is_empty_braces = t1.text == '{' && t2.text == '}'
+          is_same_braces  = t1.type == t2.type
+          is_empty_braces = left_brace?(t1) && right_brace?(t2)
 
           if is_same_braces && style == :compact
             false

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

@@ -8,7 +8,7 @@ module RuboCop
         include SpaceInside
 
         def specifics
-          [[:tLPAREN, :tLPAREN2], :tRPAREN, 'parentheses']
+          [%i(tLPAREN tLPAREN2), :tRPAREN, 'parentheses']
         end
       end
     end

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

@@ -19,19 +19,19 @@ module RuboCop
           :$0 => [:$PROGRAM_NAME],
           :$! => [:$ERROR_INFO],
           :$@ => [:$ERROR_POSITION],
-          :$; => [:$FIELD_SEPARATOR, :$FS],
-          :$, => [:$OUTPUT_FIELD_SEPARATOR, :$OFS],
-          :$/ => [:$INPUT_RECORD_SEPARATOR, :$RS],
-          :$\ => [:$OUTPUT_RECORD_SEPARATOR, :$ORS],
-          :$. => [:$INPUT_LINE_NUMBER, :$NR],
+          :$; => %i($FIELD_SEPARATOR $FS),
+          :$, => %i($OUTPUT_FIELD_SEPARATOR $OFS),
+          :$/ => %i($INPUT_RECORD_SEPARATOR $RS),
+          :$\ => %i($OUTPUT_RECORD_SEPARATOR $ORS),
+          :$. => %i($INPUT_LINE_NUMBER $NR),
           :$_ => [:$LAST_READ_LINE],
           :$> => [:$DEFAULT_OUTPUT],
           :$< => [:$DEFAULT_INPUT],
-          :$$ => [:$PROCESS_ID, :$PID],
+          :$$ => %i($PROCESS_ID $PID),
           :$? => [:$CHILD_STATUS],
           :$~ => [:$LAST_MATCH_INFO],
           :$= => [:$IGNORECASE],
-          :$* => [:$ARGV, :ARGV],
+          :$* => %i($ARGV ARGV),
           :$& => [:$MATCH],
           :$` => [:$PREMATCH],
           :$' => [:$POSTMATCH],
@@ -51,12 +51,12 @@ module RuboCop
         PERL_VARS.each { |_, v| v.freeze }.freeze
 
         # Anything *not* in this set is provided by the English library.
-        NON_ENGLISH_VARS = Set.new([
-                                     :$LOAD_PATH,
-                                     :$LOADED_FEATURES,
-                                     :$PROGRAM_NAME,
-                                     :ARGV
-                                   ]).freeze
+        NON_ENGLISH_VARS = Set.new(%i(
+                                     $LOAD_PATH
+                                     $LOADED_FEATURES
+                                     $PROGRAM_NAME
+                                     ARGV
+                                   )).freeze
 
         def on_gvar(node)
           global_var, = *node
@@ -126,7 +126,7 @@ module RuboCop
           parent_type = node.parent && node.parent.type
           preferred_name = preferred_names(global_var).first
 
-          unless [:dstr, :xstr, :regexp].include?(parent_type)
+          unless %i(dstr xstr regexp).include?(parent_type)
             return preferred_name.to_s
           end
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module RuboCop
   module Cop
     module Style
@@ -87,7 +88,7 @@ module RuboCop
 
         def lambda_node?(node)
           receiver, call = *node
-          receiver.nil? && call == :lambda
+          !receiver && call == :lambda
         end
 
         def arrow_form?(node)

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

@@ -93,7 +93,7 @@ module RuboCop
 
         def accept_child_double_quotes?(nodes)
           nodes.any? do |n|
-            n.dstr_type? || double_quotes_acceptable?(n.str_content)
+            n.dstr_type? || double_quotes_required?(n.source)
           end
         end
       end

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

@@ -11,16 +11,21 @@ module RuboCop
         MSG = 'Prefer `%s` over `%s`.'.freeze
 
         def on_send(node)
-          _receiver, method_name, *_args = *node
-          return unless preferred_methods[method_name]
-          add_offense(node, :selector,
-                      format(MSG, preferred_method(method_name), method_name))
+          return unless preferred_method(node.method_name)
+
+          add_offense(node, :selector)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, preferred_method(node.method_name), node.method_name)
         end
 
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.loc.selector,
-                              preferred_method(node.loc.selector.source))
+                              preferred_method(node.method_name))
           end
         end
       end

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

@@ -22,21 +22,10 @@ module RuboCop
           add_offense(node, superclass.source_range, MSG)
         end
 
-        private
-
-        def struct_constructor?(node)
-          return false unless node
-
-          send_node = node.block_type? ? node.children.first : node
-          return false unless send_node.send_type?
-
-          receiver, method_name = *send_node
-
-          receiver &&
-            receiver.const_type? &&
-            receiver.children.last == :Struct &&
-            method_name == :new
-        end
+        def_node_matcher :struct_constructor?, <<-PATTERN
+           {(send (const nil :Struct) :new ...)
+            (block (send (const nil :Struct) :new ...) ...)}
+        PATTERN
       end
     end
   end

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

@@ -9,9 +9,31 @@ module RuboCop
       # Alternatively, it checks for symbol arrays using the %i() syntax on
       # projects which do not want to use that syntax, perhaps because they
       # support a version of Ruby lower than 2.0.
+      #
+      # @example
+      #   EnforcedStyle: percent (default)
+      #
+      #   # good
+      #   %i[foo bar baz]
+      #
+      #   # bad
+      #   [:foo, :bar, :baz]
+      #
+      # @example
+      #   EnforcedStyle: brackets
+      #
+      #   # good
+      #   [:foo, :bar, :baz]
+      #
+      #   # bad
+      #   %i[foo bar baz]
       class SymbolArray < Cop
         include ConfigurableEnforcedStyle
         include ArraySyntax
+        include PercentLiteral
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.0
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'.freeze
         ARRAY_MSG = 'Use `[]` for an array of symbols.'.freeze
@@ -24,19 +46,6 @@ module RuboCop
           end
         end
 
-        def validate_config
-          return unless style == :percent && target_ruby_version < 2.0
-
-          raise ValidationError, 'The default `percent` style for the ' \
-                                '`Style/SymbolArray` cop is only compatible' \
-                                ' with Ruby 2.0 and up, but the target Ruby' \
-                                " version for your project is 1.9.\nPlease " \
-                                'either disable this cop, configure it to ' \
-                                'use `array` style, or adjust the ' \
-                                '`TargetRubyVersion` parameter in your ' \
-                                'configuration.'
-        end
-
         private
 
         def check_bracketed_array(node)
@@ -69,32 +78,19 @@ module RuboCop
         end
 
         def autocorrect(node)
-          syms = node.children.map { |c| c.children[0].to_s }
-          corrected = if style == :percent
-                        percent_replacement(syms)
-                      else
-                        bracket_replacement(syms)
-                      end
-
-          lambda do |corrector|
-            corrector.replace(node.source_range, corrected)
-          end
-        end
-
-        def percent_replacement(syms)
-          escape = syms.any? { |s| needs_escaping?(s) }
-          syms = syms.map { |s| escape_string(s) } if escape
-          syms = syms.map { |s| s.gsub(/\)/, '\\)') }
-          if escape
-            "%I(#{syms.join(' ')})"
+          if style == :percent
+            correct_percent(node, 'i')
           else
-            "%i(#{syms.join(' ')})"
+            correct_bracketed(node)
           end
         end
 
-        def bracket_replacement(syms)
-          syms = syms.map { |s| to_symbol_literal(s) }
-          "[#{syms.join(', ')}]"
+        def correct_bracketed(node)
+          syms = node.children.map { |c| to_symbol_literal(c.children[0].to_s) }
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "[#{syms.join(', ')}]")
+          end
         end
       end
     end

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

@@ -13,7 +13,7 @@ module RuboCop
       #   something.map(&:upcase)
       class SymbolProc < Cop
         MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'.freeze
-        SUPER_TYPES = [:super, :zsuper].freeze
+        SUPER_TYPES = %i(super zsuper).freeze
 
         def_node_matcher :proc_node?, '(send (const nil :Proc) :new)'
         def_node_matcher :symbol_proc?, <<-PATTERN
@@ -31,7 +31,7 @@ module RuboCop
             # configurable - https://github.com/bbatsov/rubocop/issues/1485
             # we should ignore lambdas & procs
             return if proc_node?(send_or_super)
-            return if [:lambda, :proc].include?(block_method_name)
+            return if %i(lambda proc).include?(block_method_name)
             return if ignored_method?(block_method_name)
             return unless can_shorten?(block_args, block_body)
 

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

@@ -13,7 +13,7 @@ module RuboCop
       #
       #   @bad
       #   foo = (bar?) ? a : b
-      #   foo = (bar.baz) ? a : b
+      #   foo = (bar.baz?) ? a : b
       #   foo = (bar && baz) ? a : b
       #
       #   @good
@@ -32,7 +32,7 @@ module RuboCop
       #
       #   @good
       #   foo = (bar?) ? a : b
-      #   foo = (bar.baz) ? a : b
+      #   foo = (bar.baz?) ? a : b
       #   foo = (bar && baz) ? a : b
       #
       # @example
@@ -46,11 +46,12 @@ module RuboCop
       #
       #   @good
       #   foo = bar? ? a : b
-      #   foo = bar.baz ? a : b
+      #   foo = bar.baz? ? a : b
       #   foo = (bar && baz) ? a : b
       class TernaryParentheses < Cop
         include SafeAssignment
         include ConfigurableEnforcedStyle
+        include SurroundingSpace
 
         MSG = '%s parentheses for ternary conditions.'.freeze
         MSG_COMPLEX = '%s parentheses for ternary expressions with' \
@@ -87,14 +88,10 @@ module RuboCop
                         (safe_assignment?(condition) ||
                         unsafe_autocorrect?(condition))
 
-          lambda do |corrector|
-            if parenthesized?(condition)
-              corrector.remove(condition.loc.begin)
-              corrector.remove(condition.loc.end)
-            else
-              corrector.insert_before(condition.source_range, '(')
-              corrector.insert_after(condition.source_range, ')')
-            end
+          if parenthesized?(condition)
+            correct_parenthesized(condition)
+          else
+            correct_unparenthesized(condition)
           end
         end
 
@@ -113,7 +110,8 @@ module RuboCop
         def non_complex_type?(condition)
           condition.variable? || condition.const_type? ||
             (condition.send_type? && !operator?(condition.method_name)) ||
-            condition.defined_type?
+            condition.defined_type? || condition.yield_type? ||
+            square_brackets?(condition)
         end
 
         def message(node)
@@ -135,7 +133,7 @@ module RuboCop
         end
 
         def redundant_parentheses_enabled?
-          @config.for_cop('RedundantParentheses')['Enabled']
+          @config.for_cop('Style/RedundantParentheses').fetch('Enabled')
         end
 
         def parenthesized?(node)
@@ -165,6 +163,36 @@ module RuboCop
           {(:defined? $...)
            (send {(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)
+            corrector.remove(condition.loc.end)
+
+            # Ruby allows no space between the question mark and parentheses.
+            # If we remove the parentheses, we need to add a space or we'll
+            # generate invalid code.
+            unless whitespace_after?(condition)
+              corrector.insert_after(condition.loc.end, ' ')
+            end
+          end
+        end
+
+        def correct_unparenthesized(condition)
+          lambda do |corrector|
+            corrector.insert_before(condition.source_range, '(')
+            corrector.insert_after(condition.source_range, ')')
+          end
+        end
+
+        def whitespace_after?(node)
+          index = index_of_last_token(node)
+          last_token, next_token = processed_source.tokens[index, 2]
+          space_between?(last_token, next_token)
+        end
       end
     end
   end