rubocop 0.49.1 → 0.52.0

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

@@ -8,13 +8,22 @@ 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
 
         def_node_matcher :join_candidate?, '(send $array :* $str)'
 
         def on_send(node)
-          join_candidate?(node) { add_offense(node, :selector) }
+          join_candidate?(node) { add_offense(node, location: :selector) }
         end
 
         def autocorrect(node)

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, 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,17 +4,25 @@ 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?
 
-          add_offense(node, :selector)
+          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

@@ -13,11 +13,11 @@ module RuboCop
       #   f = File.open('file')
       #
       #   # good
-      #   f = File.open('file') do
-      #     ...
+      #   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
@@ -32,8 +32,10 @@ module RuboCop
             next if node.parent && node.parent.block_type?
             next if node.block_argument?
 
-            add_offense(node, :expression,
-                        format(MSG, target_class, target_method))
+            add_offense(node,
+                        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, :begin, 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

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

@@ -8,7 +8,7 @@ module RuboCop
         MSG = 'Avoid the use of `BEGIN` blocks.'.freeze
 
         def on_preexe(node)
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
       end
     end

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

@@ -4,6 +4,18 @@ module RuboCop
   module Cop
     module Style
       # This cop looks for uses of block comments (=begin...=end).
+      #
+      # @example
+      #   # bad
+      #   =begin
+      #   Multiple lines
+      #   of comments...
+      #   =end
+      #
+      #   # good
+      #   # Multiple lines
+      #   # of comments...
+      #
       class BlockComments < Cop
         MSG = 'Do not use block comments.'.freeze
         BEGIN_LENGTH = "=begin\n".length
@@ -11,12 +23,12 @@ module RuboCop
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            add_offense(comment, :expression) if comment.document?
+            next unless comment.document?
+
+            add_offense(comment)
           end
         end
 
-        private
-
         def autocorrect(comment)
           eq_begin, eq_end, contents = parts(comment)
 
@@ -33,6 +45,8 @@ module RuboCop
           end
         end
 
+        private
+
         def parts(comment)
           expr = comment.loc.expression
           eq_begin = expr.resize(BEGIN_LENGTH)

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

@@ -5,6 +5,72 @@ module RuboCop
     module Style
       # Check for uses of braces or do/end around single line or
       # multi-line blocks.
+      #
+      # @example EnforcedStyle: line_count_based (default)
+      #   # bad - single line block
+      #   items.each do |item| item / 5 end
+      #
+      #   # good - single line block
+      #   items.each { |item| item / 5 }
+      #
+      #   # bad - multi-line block
+      #   things.map { |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   }
+      #
+      #   # good - multi-line block
+      #   things.map do |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   end
+      #
+      # @example EnforcedStyle: semantic
+      #   # Prefer `do...end` over `{...}` for procedural blocks.
+      #
+      #   # return value is used/assigned
+      #   # bad
+      #   foo = map do |x|
+      #     x
+      #   end
+      #   puts (map do |x|
+      #     x
+      #   end)
+      #
+      #   # return value is not used out of scope
+      #   # good
+      #   map do |x|
+      #     x
+      #   end
+      #
+      #   # Prefer `{...}` over `do...end` for functional blocks.
+      #
+      #   # return value is not used out of scope
+      #   # bad
+      #   each { |x|
+      #     x
+      #   }
+      #
+      #   # return value is used/assigned
+      #   # good
+      #   foo = map { |x|
+      #     x
+      #   }
+      #   map { |x|
+      #     x
+      #   }.inspect
+      #
+      # @example EnforcedStyle: braces_for_chaining
+      #   # bad
+      #   words.each do |word|
+      #     word.flip.flop
+      #   end.join("-")
+      #
+      #   # good
+      #   words.each { |word|
+      #     word.flip.flop
+      #   }.join("-")
+      #
       class BlockDelimiters < Cop
         include ConfigurableEnforcedStyle
 
@@ -25,13 +91,23 @@ module RuboCop
         def on_block(node)
           return if ignored_node?(node)
 
-          add_offense(node, :begin) unless proper_block_style?(node)
+          add_offense(node, location: :begin) unless proper_block_style?(node)
+        end
+
+        def autocorrect(node)
+          return if correction_would_break_code?(node)
+
+          if node.braces?
+            replace_braces_with_do_end(node.loc)
+          else
+            replace_do_end_with_braces(node.loc)
+          end
         end
 
         private
 
         def line_count_based_message(node)
-          if block_length(node) > 0
+          if node.multiline?
             'Avoid using `{...}` for multi-line blocks.'
           else
             'Prefer `{...}` over `do...end` for single-line blocks.'
@@ -49,7 +125,7 @@ module RuboCop
         end
 
         def braces_for_chaining_message(node)
-          if block_length(node) > 0
+          if node.multiline?
             if return_value_chaining?(node)
               'Prefer `{...}` over `do...end` for multi-line chained blocks.'
             else
@@ -68,16 +144,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          return if correction_would_break_code?(node)
-
-          if node.braces?
-            replace_braces_with_do_end(node.loc)
-          else
-            replace_do_end_with_braces(node.loc)
-          end
-        end
-
         def replace_braces_with_do_end(loc)
           b = loc.begin
           e = loc.end
@@ -111,6 +177,7 @@ module RuboCop
           range.source_buffer.source[range.begin_pos + length, 1] =~ /\s/
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
           when :block
@@ -126,8 +193,8 @@ module RuboCop
           when :pair
             node.each_child_node { |child| get_blocks(child, &block) }
           end
-          nil
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def proper_block_style?(node)
           return true if ignored_method?(node.method_name)
@@ -154,10 +221,9 @@ module RuboCop
         end
 
         def braces_for_chaining_style?(node)
-          block_length = block_length(node)
           block_begin = node.loc.begin.source
 
-          block_begin == if block_length > 0
+          block_begin == if node.multiline?
                            (return_value_chaining?(node) ? '{' : 'do')
                          else
                            '{'

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

@@ -5,33 +5,33 @@ module RuboCop
     module Style
       # This cop checks for braces around the last parameter in a method call
       # if the last parameter is a hash.
-      # It supports 3 styles:
+      # It supports `braces`, `no_braces` and `context_dependent` styles.
       #
-      # * The `braces` style enforces braces around all method
-      # parameters that are hashes.
+      # @example EnforcedStyle: braces
+      #   # The `braces` style enforces braces around all method
+      #   # parameters that are hashes.
       #
-      # @example
       #   # bad
       #   some_method(x, y, a: 1, b: 2)
       #
       #   # good
       #   some_method(x, y, {a: 1, b: 2})
       #
-      # * The `no_braces` style checks that the last parameter doesn't
-      # have braces around it.
+      # @example EnforcedStyle: no_braces (default)
+      #   # The `no_braces` style checks that the last parameter doesn't
+      #   # have braces around it.
       #
-      # @example
       #   # bad
       #   some_method(x, y, {a: 1, b: 2})
       #
       #   # good
       #   some_method(x, y, a: 1, b: 2)
       #
-      # * The `context_dependent` style checks that the last parameter
-      # doesn't have braces around it, but requires braces if the
-      # second to last parameter is also a hash literal.
+      # @example EnforcedStyle: context_dependent
+      #   # The `context_dependent` style checks that the last parameter
+      #   # doesn't have braces around it, but requires braces if the
+      #   # second to last parameter is also a hash literal.
       #
-      # @example
       #   # bad
       #   some_method(x, y, {a: 1, b: 2})
       #   some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)
@@ -42,7 +42,7 @@ module RuboCop
       class BracesAroundHashParameters < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = '%s curly braces around a hash parameter.'.freeze
+        MSG = '%<type>s curly braces around a hash parameter.'.freeze
 
         def on_send(node)
           return if node.assignment_method? || node.operator_method?
@@ -53,6 +53,24 @@ module RuboCop
           check(node.last_argument, node.arguments)
         end
 
+        # We let AutocorrectUnlessChangingAST#autocorrect work with the send
+        # node, because that context is needed. When parsing the code to see if
+        # the AST has changed, a braceless hash would not be parsed as a hash
+        # otherwise.
+        def autocorrect(send_node)
+          hash_node = send_node.last_argument
+
+          lambda do |corrector|
+            if hash_node.braces?
+              remove_braces_with_whitespace(corrector,
+                                            hash_node,
+                                            extra_space(hash_node))
+            else
+              add_braces(corrector, hash_node)
+            end
+          end
+        end
+
         private
 
         def check(arg, args)
@@ -78,28 +96,37 @@ module RuboCop
         end
 
         def add_arg_offense(arg, type)
-          add_offense(arg.parent, arg.source_range,
-                      format(MSG, type.to_s.capitalize))
+          add_offense(arg.parent, location: arg.source_range,
+                                  message: format(MSG,
+                                                  type: type.to_s.capitalize))
         end
 
-        # We let AutocorrectUnlessChangingAST#autocorrect work with the send
-        # node, because that context is needed. When parsing the code to see if
-        # the AST has changed, a braceless hash would not be parsed as a hash
-        # otherwise.
-        def autocorrect(send_node)
-          hash_node = send_node.last_argument
+        def extra_space(hash_node)
+          {
+            newlines: extra_left_space?(hash_node) &&
+              extra_right_space?(hash_node),
+            left: extra_left_space?(hash_node),
+            right: extra_right_space?(hash_node)
+          }
+        end
 
-          lambda do |corrector|
-            if hash_node.braces?
-              remove_braces_with_whitespace(corrector, hash_node)
-            else
-              add_braces(corrector, hash_node)
-            end
+        def extra_left_space?(hash_node)
+          @extra_left_space ||= begin
+            top_line = hash_node.source_range.source_line
+            top_line.delete(' ') == '{'
+          end
+        end
+
+        def extra_right_space?(hash_node)
+          @extra_right_space ||= begin
+            bottom_line_number = hash_node.source_range.last_line
+            bottom_line = processed_source.lines[bottom_line_number - 1]
+            bottom_line.delete(' ') == '}'
           end
         end
 
-        def remove_braces_with_whitespace(corrector, node)
-          right_brace_and_space = right_brace_and_space(node.loc.end)
+        def remove_braces_with_whitespace(corrector, node, space)
+          right_brace_and_space = right_brace_and_space(node.loc.end, space)
 
           if comment_on_line?(right_brace_and_space.line)
             # Removing a line break between a comment and the closing
@@ -107,15 +134,24 @@ module RuboCop
             # braces in that case.
             remove_braces(corrector, node)
           else
-            left_brace_and_space = range_with_surrounding_space(node.loc.begin,
-                                                                :right)
+            left_brace_and_space =
+              range_with_surrounding_space(range: node.loc.begin,
+                                           side: :right,
+                                           newlines: space[:newlines],
+                                           whitespace: space[:left])
             corrector.remove(left_brace_and_space)
             corrector.remove(right_brace_and_space)
           end
         end
 
-        def right_brace_and_space(loc_end)
-          brace_and_space = range_with_surrounding_space(loc_end, :left)
+        def right_brace_and_space(loc_end, space)
+          brace_and_space =
+            range_with_surrounding_space(
+              range: loc_end,
+              side: :left,
+              newlines: space[:newlines],
+              whitespace: space[:right]
+            )
           range_with_surrounding_comma(brace_and_space, :left)
         end