rubocop 0.51.0 → 0.52.0

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

@@ -5,6 +5,16 @@ module RuboCop
     module Style
       # This cop checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
+      #
+      # @example
+      #   # bad
+      #   foo = 1; bar = 2;
+      #   baz = 3;
+      #
+      #   # good
+      #   foo = 1
+      #   bar = 2
+      #   baz = 3
       class Semicolon < Cop
         MSG = 'Do not use semicolons to terminate expressions.'.freeze
 
@@ -36,6 +46,11 @@ module RuboCop
           end
         end
 
+        def autocorrect(range)
+          return unless range
+          ->(corrector) { corrector.remove(range) }
+        end
+
         private
 
         def check_for_line_terminator_or_opener
@@ -44,13 +59,13 @@ module RuboCop
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.pos.column if tokens.last.type == :tSEMI
-            yield line, tokens.first.pos.column if tokens.first.type == :tSEMI
+            yield line, tokens.last.column if tokens.last.semicolon?
+            yield line, tokens.first.column if tokens.first.semicolon?
           end
         end
 
         def tokens_for_lines
-          @processed_source.tokens.group_by { |token| token.pos.line }
+          @processed_source.tokens.group_by(&:line)
         end
 
         def convention_on(line, column, autocorrect)
@@ -59,11 +74,6 @@ module RuboCop
           # on the same line
           add_offense(autocorrect ? range : nil, location: range)
         end
-
-        def autocorrect(range)
-          return unless range
-          ->(corrector) { corrector.remove(range) }
-        end
       end
     end
   end

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

@@ -4,6 +4,15 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for the use of the send method.
+      #
+      # @example
+      #   # bad
+      #   Foo.send(:bar)
+      #   quuz.send(:fred)
+      #
+      #   # good
+      #   Foo.__send__(:bar)
+      #   quuz.public_send(:fred)
       class Send < Cop
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
               '`send`.'.freeze

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

@@ -4,6 +4,106 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for uses of `fail` and `raise`.
+      #
+      # @example EnforcedStyle: only_raise (default)
+      #   # The `only_raise` style enforces the sole use of `raise`.
+      #   # bad
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.fail
+      #
+      #   # good
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.raise
+      #
+      # @example EnforcedStyle: only_fail
+      #   # The `only_fail` style enforces the sole use of `fail`.
+      #   # bad
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.raise
+      #
+      #   # good
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.fail
+      #
+      # @example EnforcedStyle: semantic
+      #   # The `semantic` style enforces the use of `fail` to signal an
+      #   # exception, then will use `raise` to trigger an offense after
+      #   # it has been rescued.
+      #   # bad
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     # Error thrown
+      #   rescue Exception
+      #     fail
+      #   end
+      #
+      #   Kernel.fail
+      #   Kernel.raise
+      #
+      #   # good
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     raise 'Preferably with descriptive message'
+      #   end
+      #
+      #   explicit_receiver.fail
+      #   explicit_receiver.raise
       class SignalException < Cop
         include ConfigurableEnforcedStyle
 

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

@@ -9,7 +9,7 @@ module RuboCop
       # For instance one can configure `reduce`(`inject`) to use |a, e| as
       # parameters.
       class SingleLineBlockParams < Cop
-        MSG = 'Name `%s` block params `|%s|`.'.freeze
+        MSG = 'Name `%<method>s` block params `|%<params>s|`.'.freeze
 
         def on_block(node)
           return unless node.single_line?
@@ -28,7 +28,7 @@ module RuboCop
           method_name = node.parent.send_node.method_name
           arguments   = target_args(method_name).join(', ')
 
-          format(MSG, method_name, arguments)
+          format(MSG, method: method_name, params: arguments)
         end
 
         def eligible_arguments?(node)

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

@@ -3,8 +3,20 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for single-line method definitions.
-      # It can optionally accept single-line methods with no body.
+      # This cop checks for single-line method definitions that contain a body.
+      # It will accept single-line methods with no body.
+      #
+      # @example
+      #   # bad
+      #   def some_method; body end
+      #   def link_to(url); {:name => url}; end
+      #   def @table.columns; super; end
+      #
+      #   # good
+      #   def no_op; end
+      #   def self.resource_class=(klass); end
+      #   def @table.columns; end
+      #
       class SingleLineMethods < Cop
         include AutocorrectAlignment
 
@@ -18,12 +30,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        private
-
-        def allow_empty?
-          cop_config['AllowIfMethodIsEmpty']
-        end
-
         def autocorrect(node)
           body = node.body
 
@@ -39,6 +45,12 @@ module RuboCop
           end
         end
 
+        private
+
+        def allow_empty?
+          cop_config['AllowIfMethodIsEmpty']
+        end
+
         def end_of_line_comment(line)
           processed_source.comments.find { |c| c.loc.line == line }
         end

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

@@ -7,11 +7,12 @@ module RuboCop
       class SpecialGlobalVars < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_BOTH = 'Prefer `%s` from the stdlib \'English\' module ' \
-        '(don\'t forget to require it), or `%s` over `%s`.'.freeze
-        MSG_ENGLISH = 'Prefer `%s` from the stdlib \'English\' module ' \
-        '(don\'t forget to require it) over `%s`.'.freeze
-        MSG_REGULAR = 'Prefer `%s` over `%s`.'.freeze
+        MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
+        'module (don\'t forget to require it), or `%<regular>s` over ' \
+        '`%<global>s`.'.freeze
+        MSG_ENGLISH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
+        'module (don\'t forget to require it) over `%<global>s`.'.freeze
+        MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'.freeze
 
         ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
           :$: => [:$LOAD_PATH],
@@ -77,7 +78,9 @@ module RuboCop
           if style == :use_english_names
             format_english_message(global_var)
           else
-            format(MSG_REGULAR, preferred_names(global_var).first, global_var)
+            format(MSG_REGULAR,
+                   prefer: preferred_names(global_var).first,
+                   global: global_var)
           end
         end
 
@@ -104,14 +107,16 @@ module RuboCop
           format_message(english, regular, global_var)
         end
 
-        def format_message(english, regular, global_var)
+        def format_message(english, regular, global)
           if !regular.empty? && !english.empty?
-            format(MSG_BOTH, format_list(english), format_list(regular),
-                   global_var)
+            format(MSG_BOTH,
+                   prefer: format_list(english),
+                   regular: format_list(regular),
+                   global: global)
           elsif !regular.empty?
-            format(MSG_REGULAR, format_list(regular), global_var)
+            format(MSG_REGULAR, prefer: format_list(regular), global: global)
           elsif !english.empty?
-            format(MSG_ENGLISH, format_list(english), global_var)
+            format(MSG_ENGLISH, prefer: format_list(english), global: global)
           else
             raise 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
           end

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

@@ -6,17 +6,18 @@ module RuboCop
       # 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,8 +25,6 @@ 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 stabby_lambda_with_args?(node)
           return unless redundant_parentheses?(node) ||
@@ -75,11 +74,7 @@ module RuboCop
         end
 
         def stabby_lambda_with_args?(node)
-          node.command?(:lambda) && arrow_form?(node) && node.parent.arguments?
-        end
-
-        def arrow_form?(node)
-          node.loc.selector.source == ARROW
+          node.stabby_lambda? && node.parent.arguments?
         end
 
         def parentheses?(node)

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # This cop identifies places where `$stderr.puts`
-      # can be replaced by `warn`.
+      # 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
@@ -14,7 +15,8 @@ module RuboCop
       #   warn('hello')
       #
       class StderrPuts < Cop
-        MSG = 'Use `warn` instead of `$stderr.puts`.'.freeze
+        MSG = 'Use `warn` instead of `$stderr.puts` to allow such output ' \
+              'to be disabled.'.freeze
 
         def_node_matcher :stderr_puts?, <<-PATTERN
           (send

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

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

@@ -6,20 +6,14 @@ module RuboCop
       # This cop checks that quotes inside the string interpolation
       # match the configured preference.
       #
-      # @example
-      #
-      #   # EnforcedStyle: single_quotes
-      #
+      # @example EnforcedStyle: single_quotes (default)
       #   # bad
       #   result = "Tests #{success ? "PASS" : "FAIL"}"
       #
       #   # good
       #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
       #
-      # @example
-      #
-      #   # EnforcedStyle: double_quotes
-      #
+      # @example EnforcedStyle: double_quotes
       #   # bad
       #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
       #