rubocop 0.42.0 → 0.52.1

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

@@ -1,22 +1,23 @@
-# encoding: utf-8
 # frozen_string_literal: true
+
 module RuboCop
   module Cop
     module Style
       # Check for parentheses around stabby lambda arguments.
       # There are two different styles. Defaults to `require_parentheses`.
       #
-      # @example
-      #   # require_parentheses - bad
+      # @example EnforcedStyle: require_parentheses (default)
+      #   # bad
       #   ->a,b,c { a + b + c }
       #
-      #   # require_parentheses - good
+      #   # good
       #   ->(a,b,c) { a + b + c}
       #
-      #   # require_no_parentheses - bad
+      # @example EnforcedStyle: require_no_parentheses
+      #   # bad
       #   ->(a,b,c) { a + b + c }
       #
-      #   # require_no_parentheses - good
+      #   # good
       #   ->a,b,c { a + b + c}
       class StabbyLambdaParentheses < Cop
         include ConfigurableEnforcedStyle
@@ -24,22 +25,12 @@ module RuboCop
         MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'.freeze
         MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
                          'with parentheses.'.freeze
-        ARROW = '->'.freeze
-
         def on_send(node)
-          return unless arrow_lambda_with_args?(node)
+          return unless stabby_lambda_with_args?(node)
+          return unless redundant_parentheses?(node) ||
+                        missing_parentheses?(node)
 
-          if style == :require_parentheses
-            if parentheses?(node)
-              correct_style_detected
-            else
-              missing_parentheses(node)
-            end
-          elsif parentheses?(node)
-            unwanted_parentheses(node)
-          else
-            correct_style_detected
-          end
+          add_offense(node.parent.arguments)
         end
 
         def autocorrect(node)
@@ -52,21 +43,21 @@ module RuboCop
 
         private
 
-        def missing_parentheses(node)
-          add_offense(node_args(node), :expression, MSG_REQUIRE) do
-            opposite_style_detected
-          end
+        def missing_parentheses?(node)
+          style == :require_parentheses && !parentheses?(node)
         end
 
-        def unwanted_parentheses(node)
-          add_offense(node_args(node), :expression, MSG_NO_REQUIRE) do
-            opposite_style_detected
-          end
+        def redundant_parentheses?(node)
+          style == :require_no_parentheses && parentheses?(node)
+        end
+
+        def message(_node)
+          style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
         end
 
         def missing_parentheses_corrector(node)
           lambda do |corrector|
-            args_loc = node_args(node).source_range
+            args_loc = node.parent.arguments.source_range
 
             corrector.insert_before(args_loc, '(')
             corrector.insert_after(args_loc, ')')
@@ -75,39 +66,19 @@ module RuboCop
 
         def unwanted_parentheses_corrector(node)
           lambda do |corrector|
-            args_loc = node_args(node).loc
+            args_loc = node.parent.arguments.loc
 
             corrector.replace(args_loc.begin, '')
             corrector.remove(args_loc.end)
           end
         end
 
-        def arrow_lambda_with_args?(node)
-          lambda_node?(node) && arrow_form?(node) && args?(node)
-        end
-
-        def lambda_node?(node)
-          receiver, call = *node
-          receiver.nil? && call == :lambda
-        end
-
-        def arrow_form?(node)
-          node.loc.selector.source == ARROW
-        end
-
-        def node_args(node)
-          _call, args, _body = *node.parent
-          args
-        end
-
-        def args?(node)
-          args = node_args(node)
-          args.children.count > 0
+        def stabby_lambda_with_args?(node)
+          node.stabby_lambda? && node.parent.arguments?
         end
 
         def parentheses?(node)
-          args = node_args(node)
-          args.loc.begin
+          node.parent.arguments.loc.begin
         end
       end
     end

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

@@ -1,10 +1,31 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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
@@ -25,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
@@ -33,6 +54,10 @@ module RuboCop
           ignore_node(node)
         end
 
+        def autocorrect(node)
+          StringLiteralCorrector.correct(node, style)
+        end
+
         private
 
         def all_string_literals?(nodes)
@@ -77,10 +102,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
 
@@ -94,7 +120,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_literals_in_interpolation.rb

@@ -1,14 +1,32 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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
 
+        def autocorrect(node)
+          StringLiteralCorrector.correct(node, style)
+        end
+
         private
 
         def message(*)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,26 +5,40 @@ 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)
-          _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, location: :selector)
         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
+
+        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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -20,24 +19,13 @@ 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
 
-        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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,64 +7,60 @@ 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)
+      #   # 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 ArrayMinSize
         include ArraySyntax
+        include ConfigurableEnforcedStyle
+        include PercentLiteral
+        include PercentArray
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'.freeze
         ARRAY_MSG = 'Use `[]` for an array of symbols.'.freeze
 
+        class << self
+          attr_accessor :largest_brackets
+        end
+
         def on_array(node)
           if bracketed_array_of?(:sym, node)
+            return if symbols_contain_spaces?(node)
+
             check_bracketed_array(node)
-          elsif percent_array?(node)
+          elsif node.percent_literal?(:symbol)
             check_percent_array(node)
           end
         end
 
-        def validate_config
-          if 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.'
+        def autocorrect(node)
+          if style == :percent
+            correct_percent(node, 'i')
+          else
+            correct_bracketed(node)
           end
         end
 
         private
 
-        def percent_array?(node)
-          node.loc.begin && node.loc.begin.source =~ /\A%[iI]/
-        end
-
-        def check_bracketed_array(node)
-          return if comments_in_array?(node)
-          return if symbols_contain_spaces?(node)
-
-          style_detected(:brackets)
-          add_offense(node, :expression, PERCENT_MSG) if style == :percent
-        end
-
-        def check_percent_array(node)
-          style_detected(:percent)
-          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
@@ -73,34 +68,13 @@ module RuboCop
           end
         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
+        def correct_bracketed(node)
+          syms = node.children.map { |c| to_symbol_literal(c.value.to_s) }
 
           lambda do |corrector|
-            corrector.replace(node.source_range, corrected)
+            corrector.replace(node.source_range, "[#{syms.join(', ')}]")
           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(' ')})"
-          else
-            "%i(#{syms.join(' ')})"
-          end
-        end
-
-        def bracket_replacement(syms)
-          syms = syms.map { |s| to_symbol_literal(s) }
-          "[#{syms.join(', ')}]"
-        end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -19,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)