rubocop 0.51.0 → 0.52.0

data/lib/rubocop/cop/rails/validation.rb

@@ -29,6 +29,13 @@ module RuboCop
           add_offense(node, location: :selector)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector, 'validates')
+            correct_validate_type(corrector, node)
+          end
+        end
+
         private
 
         def message(node)
@@ -39,13 +46,6 @@ module RuboCop
           WHITELIST[BLACKLIST.index(method.to_sym)]
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, 'validates')
-            correct_validate_type(corrector, node)
-          end
-        end
-
         def correct_validate_type(corrector, node)
           options = node.arguments.find { |arg| !arg.sym_type? }
           validate_type = node.method_name.to_s.split('_')[1]

data/lib/rubocop/cop/security/json_load.rb

@@ -23,7 +23,7 @@ module RuboCop
       #   JSON.parse("{}")
       #
       class JSONLoad < Cop
-        MSG = 'Prefer `JSON.parse` over `JSON.%s`.'.freeze
+        MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'.freeze
 
         def_node_matcher :json_load, <<-PATTERN
           (send (const {nil? cbase} :JSON) ${:load :restore} ...)
@@ -31,7 +31,9 @@ module RuboCop
 
         def on_send(node)
           json_load(node) do |method|
-            add_offense(node, location: :selector, message: format(MSG, method))
+            add_offense(node,
+                        location: :selector,
+                        message: format(MSG, method: method))
           end
         end
 

data/lib/rubocop/cop/security/marshal_load.rb

@@ -19,7 +19,7 @@ module RuboCop
       #   Marshal.load(Marshal.dump({}))
       #
       class MarshalLoad < Cop
-        MSG = 'Avoid using `Marshal.%s`.'.freeze
+        MSG = 'Avoid using `Marshal.%<method>s`.'.freeze
 
         def_node_matcher :marshal_load, <<-PATTERN
           (send (const {nil? cbase} :Marshal) ${:load :restore}
@@ -28,7 +28,9 @@ module RuboCop
 
         def on_send(node)
           marshal_load(node) do |method|
-            add_offense(node, location: :selector, message: format(MSG, method))
+            add_offense(node,
+                        location: :selector,
+                        message: format(MSG, method: method))
           end
         end
       end

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

@@ -7,38 +7,35 @@ module RuboCop
       # depending on configuration.
       # It also flags uses of `alias :symbol` rather than `alias bareword`.
       #
-      # @example
-      #
-      #   # EnforcedStyle: prefer_alias
+      # @example EnforcedStyle: prefer_alias (default)
+      #   # bad
+      #   alias_method :bar, :foo
+      #   alias :bar :foo
       #
       #   # good
       #   alias bar foo
       #
+      # @example EnforcedStyle: prefer_alias_method
       #   # bad
-      #   alias_method :bar, :foo
       #   alias :bar :foo
-      #
-      # @example
-      #
-      #   # EnforcedStyle: prefer_alias_method
+      #   alias bar foo
       #
       #   # good
       #   alias_method :bar, :foo
-      #
-      #   # bad
-      #   alias bar foo
       class Alias < Cop
         include ConfigurableEnforcedStyle
 
         MSG_ALIAS = 'Use `alias_method` instead of `alias`.'.freeze
-        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %s.'.freeze
-        MSG_SYMBOL_ARGS  = 'Use `alias %s` instead of `alias %s`.'.freeze
+        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` ' \
+                           '%<current>s.'.freeze
+        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of ' \
+                           '`alias %<current>s`.'.freeze
 
         def on_send(node)
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)
 
-          msg = format(MSG_ALIAS_METHOD, lexical_scope_type(node))
+          msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
           add_offense(node, location: :selector, message: msg)
         end
 
@@ -52,6 +49,16 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          if node.send_type?
+            correct_alias_method_to_alias(node)
+          elsif scope_type(node) == :dynamic || style == :prefer_alias_method
+            correct_alias_to_alias_method(node)
+          else
+            correct_alias_with_symbol_args(node)
+          end
+        end
+
         private
 
         def alias_keyword_possible?(node)
@@ -63,22 +70,13 @@ module RuboCop
             node.children.none?(&:gvar_type?)
         end
 
-        def autocorrect(node)
-          if node.send_type?
-            correct_alias_method_to_alias(node)
-          elsif scope_type(node) == :dynamic || style == :prefer_alias_method
-            correct_alias_to_alias_method(node)
-          else
-            correct_alias_with_symbol_args(node)
-          end
-        end
-
         def add_offense_for_args(node)
           existing_args  = node.children.map(&:source).join(' ')
           preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
           arg_ranges     = node.children.map(&:source_range)
-          msg            = format(MSG_SYMBOL_ARGS, preferred_args,
-                                  existing_args)
+          msg            = format(MSG_SYMBOL_ARGS,
+                                  prefer: preferred_args,
+                                  current: existing_args)
           add_offense(node, location: arg_ranges.reduce(&:join), message: msg)
         end
 

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

@@ -7,33 +7,39 @@ module RuboCop
       # `|| instead`. It can be configured to check only in conditions, or in
       # all contexts.
       #
-      # @example
+      # @example EnforcedStyle: always (default)
+      #   # bad
+      #   foo.save and return
       #
-      #   # EnforcedStyle: always (default)
+      #   # bad
+      #   if foo and bar
+      #   end
       #
       #   # good
       #   foo.save && return
+      #
+      #   # good
       #   if foo && bar
+      #   end
       #
+      # @example EnforcedStyle: conditionals
       #   # bad
-      #   foo.save and return
       #   if foo and bar
-      #
-      # @example
-      #
-      #   # EnforcedStyle: conditionals
+      #   end
       #
       #   # good
       #   foo.save && return
+      #
+      #   # good
       #   foo.save and return
-      #   if foo && bar
       #
-      #   # bad
-      #   if foo and bar
+      #   # good
+      #   if foo && bar
+      #   end
       class AndOr < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
         def on_and(node)
           process_logical_operator(node) if style == :always
@@ -48,6 +54,22 @@ module RuboCop
         alias on_until      on_if
         alias on_until_post on_if
 
+        def autocorrect(node)
+          lambda do |corrector|
+            node.each_child_node do |expr|
+              if expr.send_type?
+                correct_send(expr, corrector)
+              elsif expr.return_type?
+                correct_other(expr, corrector)
+              elsif expr.assignment?
+                correct_other(expr, corrector)
+              end
+            end
+
+            corrector.replace(node.loc.operator, node.alternate_operator)
+          end
+        end
+
         private
 
         def on_conditionals(node)
@@ -63,23 +85,7 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, node.alternate_operator, node.operator)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            node.each_child_node do |expr|
-              if expr.send_type?
-                correct_send(expr, corrector)
-              elsif expr.return_type?
-                correct_other(expr, corrector)
-              elsif expr.assignment?
-                correct_other(expr, corrector)
-              end
-            end
-
-            corrector.replace(node.loc.operator, node.alternate_operator)
-          end
+          format(MSG, prefer: node.alternate_operator, current: node.operator)
         end
 
         def correct_send(node, corrector)

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

@@ -8,6 +8,15 @@ module RuboCop
       # Not all cases can reliably checked, due to Ruby's dynamic
       # types, so we consider only cases when the first argument is an
       # array literal or the second is a string literal.
+      #
+      # @example
+      #
+      #   # bad
+      #   %w(foo bar baz) * ","
+      #
+      #   # good
+      #   %w(foo bar bax).join(",")
+      #
       class ArrayJoin < Cop
         MSG = 'Favor `Array#join` over `Array#*`.'.freeze
 

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

@@ -1,18 +1,28 @@
 # frozen_string_literal: true
 
+# rubocop:disable Style/AsciiComments
+
 module RuboCop
   module Cop
     module Style
       # This cop checks for non-ascii (non-English) characters
-      # in comments.
+      # in comments. You could set an array of allowed non-ascii chars in
+      # AllowedChars attribute (empty by default).
+      #
+      # @example
+      #   # bad
+      #   # Translates from English to 日本語。
+      #
+      #   # good
+      #   # Translates from English to Japanese
       class AsciiComments < Cop
         MSG = 'Use only ascii symbols in comments.'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            unless comment.text.ascii_only?
-              add_offense(comment, location: first_offense_range(comment))
-            end
+            next if comment.text.ascii_only?
+            next if only_allowed_non_ascii_chars?(comment.text)
+            add_offense(comment, location: first_offense_range(comment))
           end
         end
 
@@ -32,7 +42,17 @@ module RuboCop
         def first_non_ascii_chars(string)
           string.match(/[^[:ascii:]]+/).to_s
         end
+
+        def only_allowed_non_ascii_chars?(string)
+          non_ascii = string.scan(/[^[:ascii:]]/)
+          (non_ascii - allowed_non_ascii_chars).empty?
+        end
+
+        def allowed_non_ascii_chars
+          cop_config['AllowedChars'] || []
+        end
       end
     end
   end
 end
+# rubocop:enable Style/AsciiComments

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

@@ -4,8 +4,18 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for uses of Module#attr.
+      #
+      # @example
+      #   # bad - creates a single attribute accessor (deprecated in Ruby 1.9)
+      #   attr :something, true
+      #   attr :one, :two, :three # behaves as attr_reader
+      #
+      #   # good
+      #   attr_accessor :something
+      #   attr_reader :one, :two, :three
+      #
       class Attr < Cop
-        MSG = 'Do not use `attr`. Use `%s` instead.'.freeze
+        MSG = 'Do not use `attr`. Use `%<replacement>s` instead.'.freeze
 
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
@@ -13,8 +23,6 @@ module RuboCop
           add_offense(node, location: :selector)
         end
 
-        private
-
         def autocorrect(node)
           attr_name, setter = *node.arguments
 
@@ -31,8 +39,10 @@ module RuboCop
           end
         end
 
+        private
+
         def message(node)
-          format(MSG, replacement_method(node))
+          format(MSG, replacement: replacement_method(node))
         end
 
         def replacement_method(node)

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

@@ -14,10 +14,10 @@ module RuboCop
       #
       #   # good
       #   File.open('file') do |f|
-      #     ...
+      #     # ...
       #   end
       class AutoResourceCleanup < Cop
-        MSG = 'Use the block version of `%s.%s`.'.freeze
+        MSG = 'Use the block version of `%<class>s.%<method>s`.'.freeze
 
         TARGET_METHODS = {
           File: :open
@@ -33,7 +33,9 @@ module RuboCop
             next if node.block_argument?
 
             add_offense(node,
-                        message: format(MSG, target_class, target_method))
+                        message: format(MSG,
+                                        class: target_class,
+                                        method: target_method))
           end
         end
       end

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

@@ -4,10 +4,29 @@ module RuboCop
   module Cop
     module Style
       # This cop checks if usage of %() or %Q() matches configuration.
+      #
+      # @example EnforcedStyle: bare_percent (default)
+      #   # bad
+      #   %Q(He said: "#{greeting}")
+      #   %q{She said: 'Hi'}
+      #
+      #   # good
+      #   %(He said: "#{greeting}")
+      #   %{She said: 'Hi'}
+      #
+      # @example EnforcedStyle: percent_q
+      #   # bad
+      #   %|He said: "#{greeting}"|
+      #   %/She said: 'Hi'/
+      #
+      #   # good
+      #   %Q|He said: "#{greeting}"|
+      #   %q/She said: 'Hi'/
+      #
       class BarePercentLiterals < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use `%%%s` instead of `%%%s`.'.freeze
+        MSG = 'Use `%%%<good>s` instead of `%%%<bad>s`.'.freeze
 
         def on_dstr(node)
           check(node)
@@ -17,6 +36,14 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          src = node.loc.begin.source
+          replacement = src.start_with?('%Q') ? '%' : '%Q'
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, src.sub(/%Q?/, replacement))
+          end
+        end
+
         private
 
         def check(node)
@@ -41,15 +68,9 @@ module RuboCop
         end
 
         def add_offense_for_wrong_style(node, good, bad)
-          add_offense(node, location: :begin, message: format(MSG, good, bad))
-        end
-
-        def autocorrect(node)
-          src = node.loc.begin.source
-          replacement = src.start_with?('%Q') ? '%' : '%Q'
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, src.sub(/%Q?/, replacement))
-          end
+          add_offense(node, location: :begin, message: format(MSG,
+                                                              good: good,
+                                                              bad: bad))
         end
       end
     end