rubocop 0.49.1 → 0.52.0

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `$stderr.puts` can be replaced by
+      # `warn`. The latter has the advantage of easily being disabled by,
+      # e.g. the -W0 interpreter flag, or setting $VERBOSE to nil.
+      #
+      # @example
+      #   # bad
+      #   $stderr.puts('hello')
+      #
+      #   # good
+      #   warn('hello')
+      #
+      class StderrPuts < Cop
+        MSG = 'Use `warn` instead of `$stderr.puts` to allow such output ' \
+              'to be disabled.'.freeze
+
+        def_node_matcher :stderr_puts?, <<-PATTERN
+          (send
+            (gvar #stderr_gvar?) :puts
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless stderr_puts?(node)
+
+          add_offense(node, location: stderr_puts_range(node))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(stderr_puts_range(node), 'warn')
+          end
+        end
+
+        private
+
+        def stderr_gvar?(sym)
+          sym == :$stderr
+        end
+
+        def stderr_puts_range(send)
+          range_between(
+            send.loc.expression.begin_pos,
+            send.loc.selector.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of strings as keys in hashes. The use of
+      # symbols is preferred instead.
+      #
+      # @example
+      #   # bad
+      #   { 'one' => 1, 'two' => 2, 'three' => 3 }
+      #
+      #   # good
+      #   { one: 1, two: 2, three: 3 }
+      class StringHashKeys < Cop
+        MSG = 'Prefer symbols instead of strings as hash keys.'.freeze
+
+        def_node_matcher :string_hash_key?, <<-PATTERN
+          (pair (str _) _)
+        PATTERN
+
+        def on_pair(node)
+          return unless string_hash_key?(node)
+          add_offense(node.key)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            symbol_content = node.str_content.to_sym.inspect
+            corrector.replace(node.source_range, symbol_content)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,28 @@ module RuboCop
   module Cop
     module Style
       # Checks if uses of quotes match the configured preference.
+      #
+      # @example EnforcedStyle: single_quotes (default)
+      #   # bad
+      #   "No special symbols"
+      #   "No string interpolation"
+      #   "Just text"
+      #
+      #   # good
+      #   'No special symbols'
+      #   'No string interpolation'
+      #   'Just text'
+      #   "Wait! What's #{this}!"
+      #
+      # @example EnforcedStyle: double_quotes
+      #   # bad
+      #   'Just some text'
+      #   'No special chars or interpolation'
+      #
+      #   # good
+      #   "Just some text"
+      #   "No special chars or interpolation"
+      #   "Every string in #{project} uses double_quotes"
       class StringLiterals < Cop
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
@@ -24,7 +46,7 @@ module RuboCop
           quote_styles = detect_quote_styles(node)
 
           if quote_styles.size > 1
-            add_offense(node, :expression, MSG_INCONSISTENT)
+            add_offense(node, message: MSG_INCONSISTENT)
           else
             check_multiline_quote_style(node, quote_styles[0])
           end
@@ -76,10 +98,11 @@ module RuboCop
           range = node.source_range
           children = node.children
           if unexpected_single_quotes?(quote)
-            add_offense(node, range) if children.all? { |c| wrong_quotes?(c) }
+            all_children_with_quotes = children.all? { |c| wrong_quotes?(c) }
+            add_offense(node, location: range) if all_children_with_quotes
           elsif unexpected_double_quotes?(quote) &&
                 !accept_child_double_quotes?(children)
-            add_offense(node, range)
+            add_offense(node, location: range)
           end
         end
 

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

@@ -3,7 +3,22 @@
 module RuboCop
   module Cop
     module Style
-      # Checks if uses of quotes match the configured preference.
+      # This cop checks that quotes inside the string interpolation
+      # match the configured preference.
+      #
+      # @example EnforcedStyle: single_quotes (default)
+      #   # bad
+      #   result = "Tests #{success ? "PASS" : "FAIL"}"
+      #
+      #   # good
+      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #
+      # @example EnforcedStyle: double_quotes
+      #   # bad
+      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #
+      #   # good
+      #   result = "Tests #{success ? "PASS" : "FAIL"}"
       class StringLiteralsInInterpolation < Cop
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp

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

@@ -5,21 +5,24 @@ module RuboCop
     module Style
       # This cop enforces the use of consistent method names
       # from the String class.
+      #
+      # @example
+      #   # bad
+      #   'name'.intern
+      #   'var'.unfavored_method
+      #
+      #   # good
+      #   'name'.to_sym
+      #   'var'.preferred_method
       class StringMethods < Cop
         include MethodPreference
 
-        MSG = 'Prefer `%s` over `%s`.'.freeze
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'.freeze
 
         def on_send(node)
           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)
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
@@ -28,6 +31,14 @@ module RuboCop
                               preferred_method(node.method_name))
           end
         end
+
+        private
+
+        def message(node)
+          format(MSG,
+                 prefer: preferred_method(node.method_name),
+                 current: node.method_name)
+        end
       end
     end
   end

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

@@ -19,12 +19,12 @@ module RuboCop
           _name, superclass, _body = *node
           return unless struct_constructor?(superclass)
 
-          add_offense(node, superclass.source_range, MSG)
+          add_offense(node, location: superclass.source_range)
         end
 
         def_node_matcher :struct_constructor?, <<-PATTERN
-           {(send (const nil :Struct) :new ...)
-            (block (send (const nil :Struct) :new ...) ...)}
+           {(send (const nil? :Struct) :new ...)
+            (block (send (const nil? :Struct) :new ...) ...)}
         PATTERN
       end
     end

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

@@ -7,26 +7,21 @@ module RuboCop
       # using the %i() syntax.
       #
       # 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.
+      # projects which do not want to use that syntax.
       #
       # Configuration option: MinSize
       # If set, arrays with fewer elements than this value will not trigger the
       # cop. For example, a `MinSize of `3` will not enforce a style on an array
       # of 2 or fewer elements.
       #
-      # @example
-      #   EnforcedStyle: percent (default)
-      #
+      # @example EnforcedStyle: percent (default)
       #   # good
       #   %i[foo bar baz]
       #
       #   # bad
       #   [:foo, :bar, :baz]
       #
-      # @example
-      #   EnforcedStyle: brackets
-      #
+      # @example EnforcedStyle: brackets
       #   # good
       #   [:foo, :bar, :baz]
       #
@@ -37,9 +32,7 @@ module RuboCop
         include ArraySyntax
         include ConfigurableEnforcedStyle
         include PercentLiteral
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.0
+        include PercentArray
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'.freeze
         ARRAY_MSG = 'Use `[]` for an array of symbols.'.freeze
@@ -50,6 +43,8 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:sym, node)
+            return if symbols_contain_spaces?(node)
+
             check_bracketed_array(node)
           elsif node.percent_literal?(:symbol)
             check_percent_array(node)
@@ -66,29 +61,6 @@ module RuboCop
 
         private
 
-        def check_bracketed_array(node)
-          return if comments_in_array?(node) ||
-                    symbols_contain_spaces?(node) ||
-                    below_array_length?(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 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
-        end
-
         def symbols_contain_spaces?(node)
           node.children.any? do |sym|
             content, = *sym
@@ -97,7 +69,7 @@ module RuboCop
         end
 
         def correct_bracketed(node)
-          syms = node.children.map { |c| to_symbol_literal(c.children[0].to_s) }
+          syms = node.children.map { |c| to_symbol_literal(c.value.to_s) }
 
           lambda do |corrector|
             corrector.replace(node.source_range, "[#{syms.join(', ')}]")

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

@@ -12,15 +12,16 @@ module RuboCop
       #   # good
       #   something.map(&:upcase)
       class SymbolProc < Cop
-        MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'.freeze
+        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` ' \
+              'instead of a block.'.freeze
         SUPER_TYPES = %i[super zsuper].freeze
 
-        def_node_matcher :proc_node?, '(send (const nil :Proc) :new)'
+        def_node_matcher :proc_node?, '(send (const nil? :Proc) :new)'
         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 +29,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 +38,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
@@ -72,10 +72,10 @@ module RuboCop
           range = range_between(block_start, block_end)
 
           add_offense(node,
-                      range,
-                      format(MSG,
-                             method_name,
-                             block_method_name))
+                      location: range,
+                      message: format(MSG,
+                                      method: method_name,
+                                      block_method: block_method_name))
         end
 
         def autocorrect_method(corrector, node, args, method_name)
@@ -102,7 +102,7 @@ module RuboCop
         def block_range_with_space(node)
           block_range = range_between(begin_pos_for_replacement(node),
                                       node.loc.end.end_pos)
-          range_with_surrounding_space(block_range, :left)
+          range_with_surrounding_space(range: block_range, side: :left)
         end
 
         def begin_pos_for_replacement(node)
@@ -124,20 +124,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

@@ -8,44 +8,35 @@ module RuboCop
       # parentheses using `EnforcedStyle`. Omission is only enforced when
       # removing the parentheses won't cause a different behavior.
       #
-      # @example
-      #
-      #   EnforcedStyle: require_no_parentheses (default)
-      #
-      #   @bad
+      # @example EnforcedStyle: require_no_parentheses (default)
+      #   # bad
       #   foo = (bar?) ? a : b
       #   foo = (bar.baz?) ? a : b
       #   foo = (bar && baz) ? a : b
       #
-      #   @good
+      #   # good
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = bar && baz ? a : b
       #
-      # @example
-      #
-      #   EnforcedStyle: require_parentheses
-      #
-      #   @bad
+      # @example EnforcedStyle: require_parentheses
+      #   # bad
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = bar && baz ? a : b
       #
-      #   @good
+      #   # good
       #   foo = (bar?) ? a : b
       #   foo = (bar.baz?) ? a : b
       #   foo = (bar && baz) ? a : b
       #
-      # @example
-      #
-      #   EnforcedStyle: require_parentheses_when_complex
-      #
-      #   @bad
+      # @example EnforcedStyle: require_parentheses_when_complex
+      #   # bad
       #   foo = (bar?) ? a : b
       #   foo = (bar.baz?) ? a : b
       #   foo = bar && baz ? a : b
       #
-      #   @good
+      #   # good
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = (bar && baz) ? a : b
@@ -54,14 +45,31 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include SurroundingSpace
 
-        MSG = '%s parentheses for ternary conditions.'.freeze
-        MSG_COMPLEX = '%s parentheses for ternary expressions with' \
+        VARIABLE_TYPES = AST::Node::VARIABLES
+        NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
+
+        MSG = '%<command>s parentheses for ternary conditions.'.freeze
+        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with' \
           ' complex conditions.'.freeze
 
         def on_if(node)
           return unless node.ternary? && !infinite_loop? && offense?(node)
 
-          add_offense(node, node.source_range, message(node))
+          add_offense(node, location: node.source_range)
+        end
+
+        def autocorrect(node)
+          condition = node.condition
+
+          return nil if parenthesized?(condition) &&
+                        (safe_assignment?(condition) ||
+                        unsafe_autocorrect?(condition))
+
+          if parenthesized?(condition)
+            correct_parenthesized(condition)
+          else
+            correct_unparenthesized(condition)
+          end
         end
 
         private
@@ -82,46 +90,36 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          condition = node.condition
-
-          return nil if parenthesized?(condition) &&
-                        (safe_assignment?(condition) ||
-                        unsafe_autocorrect?(condition))
-
-          if parenthesized?(condition)
-            correct_parenthesized(condition)
-          else
-            correct_unparenthesized(condition)
-          end
-        end
-
         # If the condition is parenthesized we recurse and check for any
         # complex expressions within it.
         def complex_condition?(condition)
           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)
           if require_parentheses_when_complex?
-            omit = parenthesized?(node.condition) ? 'Only use' : 'Use'
-            format(MSG_COMPLEX, omit)
+            command = parenthesized?(node.condition) ? 'Only use' : 'Use'
+            format(MSG_COMPLEX, command: command)
           else
-            verb = require_parentheses? ? 'Use' : 'Omit'
-            format(MSG, verb)
+            command = require_parentheses? ? 'Use' : 'Omit'
+            format(MSG, command: command)
           end
         end
 
@@ -162,12 +160,9 @@ module RuboCop
 
         def_node_matcher :method_call_argument, <<-PATTERN
           {(:defined? $...)
-           (send {_ nil} _ $(send nil _)...)}
+           (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)
@@ -191,8 +186,8 @@ module RuboCop
 
         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)
+          last_token = processed_source.tokens[index]
+          last_token.space_after?
         end
       end
     end