rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,21 +8,26 @@ 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 on_send(node)
-          receiver_node, method_name, *arg_nodes = *node
-          return unless receiver_node && receiver_node.type == :array &&
-                        method_name == :* && arg_nodes[0].type == :str
+        def_node_matcher :join_candidate?, '(send $array :* $str)'
 
-          add_offense(node, :selector)
+        def on_send(node)
+          join_candidate?(node) { add_offense(node, location: :selector) }
         end
 
         def autocorrect(node)
-          receiver_node, _method_name, *arg_nodes = *node
-          array = receiver_node.source
-          join_arg = arg_nodes[0].source
+          array, join_arg = join_candidate?(node).map(&:source)
 
           lambda do |corrector|
             corrector.replace(node.source_range, "#{array}.join(#{join_arg})")

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

@@ -1,19 +1,28 @@
-# encoding: utf-8
 # 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
 
@@ -27,14 +36,23 @@ module RuboCop
                            comment.text.index(first_offense)
           end_position   = start_position + first_offense.length
 
-          Parser::Source::Range.new(comment.loc.expression.source_buffer,
-                                    start_position, end_position)
+          range_between(start_position, end_position)
         end
 
         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

@@ -1,40 +1,53 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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 `%<replacement>s` instead.'.freeze
+
         def on_send(node)
-          return unless node.command?(:attr)
-          _receiver, _method_name, *args = *node
-          msg = "Do not use `attr`. Use `#{replacement_method(node)}` instead."
+          return unless node.command?(:attr) && node.arguments?
 
-          add_offense(node, :selector, msg) if args.any?
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
-          _receiver, _method_name, attr_name, setter = *node
+          attr_name, setter = *node.arguments
+
           node_expr = node.source_range
           attr_expr = attr_name.source_range
 
           if setter && (setter.true_type? || setter.false_type?)
-            remove = Parser::Source::Range.new(node_expr.source_buffer,
-                                               attr_expr.end_pos,
-                                               node_expr.end_pos)
+            remove = range_between(attr_expr.end_pos, node_expr.end_pos)
           end
 
           lambda do |corrector|
             corrector.replace(node.loc.selector, replacement_method(node))
-            corrector.replace(remove, '') if remove
+            corrector.remove(remove) if remove
           end
         end
 
         private
 
+        def message(node)
+          format(MSG, replacement: replacement_method(node))
+        end
+
         def replacement_method(node)
-          _receiver, _method_name, _attr_name, setter = *node
+          setter = node.last_argument
+
           if setter && (setter.true_type? || setter.false_type?)
             setter.true_type? ? 'attr_accessor' : 'attr_reader'
           else

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -14,32 +13,38 @@ 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]
-        ].freeze
+        TARGET_METHODS = {
+          File: :open
+        }.freeze
 
         def on_send(node)
-          receiver_node, method_name, *arg_nodes = *node
-
-          TARGET_METHODS.each do |(target_class, target_method)|
+          TARGET_METHODS.each do |target_class, target_method|
             target_receiver = s(:const, nil, target_class)
 
-            next if receiver_node != target_receiver
-            next if method_name != target_method
-            next if node.parent && node.parent.block_type?
-            next if !arg_nodes.empty? && arg_nodes.last.block_pass_type?
+            next if node.receiver != target_receiver
+            next if node.method_name != target_method
+            next if cleanup?(node)
 
             add_offense(node,
-                        :expression,
-                        format(MSG, target_class, target_method))
+                        message: format(MSG,
+                                        class: target_class,
+                                        method: target_method))
           end
         end
+
+        private
+
+        def cleanup?(node)
+          parent = node.parent
+          node.block_argument? ||
+            (parent && (parent.block_type? || !parent.lvasgn_type?))
+        end
       end
     end
   end

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

@@ -1,14 +1,32 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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)
@@ -18,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)
@@ -42,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

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

@@ -1,10 +1,21 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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
@@ -12,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)
 
@@ -28,21 +39,19 @@ module RuboCop
                                 contents.source
                                   .gsub(/\A/, '# ')
                                   .gsub(/\n\n/, "\n#\n")
-                                  .gsub(/\n(?=[^\z#])/, "\n# "))
+                                  .gsub(/\n(?=[^#])/, "\n# "))
             end
             corrector.remove(eq_end)
           end
         end
 
+        private
+
         def parts(comment)
           expr = comment.loc.expression
           eq_begin = expr.resize(BEGIN_LENGTH)
-          eq_end = Parser::Source::Range.new(expr.source_buffer,
-                                             expr.end_pos - END_LENGTH,
-                                             expr.end_pos)
-          contents = Parser::Source::Range.new(expr.source_buffer,
-                                               eq_begin.end_pos,
-                                               eq_end.begin_pos)
+          eq_end = range_between(expr.end_pos - END_LENGTH, expr.end_pos)
+          contents = range_between(eq_begin.end_pos, eq_end.begin_pos)
           [eq_begin, eq_end, contents]
         end
       end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,15 +5,80 @@ module RuboCop
     module Style
       # Check for uses of braces or do/end around single line or
       # multi-line blocks.
-      class BlockDelimiters < Cop # rubocop:disable Metrics/ClassLength
+      #
+      # @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
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return if args.empty?
-          return if parentheses?(node) || operator?(method_name)
+          return unless node.arguments?
+          return if node.parenthesized? || node.operator_method?
 
-          args.each do |arg|
+          node.arguments.each do |arg|
             get_blocks(arg) do |block|
               # If there are no parentheses around the arguments, then braces
               # and do-end have different meaning due to how they bind, so we
@@ -27,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.'
@@ -51,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
@@ -70,54 +144,61 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          return if correction_would_break_code?(node)
+        def replace_braces_with_do_end(loc)
+          b = loc.begin
+          e = loc.end
 
           lambda do |corrector|
-            b = node.loc.begin
-            e = node.loc.end
-            if b.is?('{')
-              corrector.insert_before(b, ' ') unless whitespace_before?(b)
-              corrector.insert_before(e, ' ') unless whitespace_before?(e)
-              corrector.insert_after(b, ' ') unless whitespace_after?(b)
-              corrector.replace(b, 'do')
-              corrector.replace(e, 'end')
-            else
-              corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
-              corrector.replace(b, '{')
-              corrector.replace(e, '}')
-            end
+            corrector.insert_before(b, ' ') unless whitespace_before?(b)
+            corrector.insert_before(e, ' ') unless whitespace_before?(e)
+            corrector.insert_after(b, ' ') unless whitespace_after?(b)
+            corrector.replace(b, 'do')
+            corrector.replace(e, 'end')
           end
         end
 
-        def whitespace_before?(node)
-          node.source_buffer.source[node.begin_pos - 1, 1] =~ /\s/
+        def replace_do_end_with_braces(loc)
+          b = loc.begin
+          e = loc.end
+
+          lambda do |corrector|
+            corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
+
+            corrector.replace(b, '{')
+            corrector.replace(e, '}')
+          end
+        end
+
+        def whitespace_before?(range)
+          range.source_buffer.source[range.begin_pos - 1, 1] =~ /\s/
         end
 
-        def whitespace_after?(node, length = 1)
-          node.source_buffer.source[node.begin_pos + length, 1] =~ /\s/
+        def whitespace_after?(range, length = 1)
+          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
             yield node
           when :send
-            receiver, _method_name, *_args = *node
-            get_blocks(receiver, &block) if receiver
+            get_blocks(node.receiver, &block) if node.receiver
           when :hash
             # A hash which is passed as method argument may have no braces
             # In that case, one of the K/V pairs could contain a block node
             # which could change in meaning if do...end replaced {...}
-            return if node.loc.begin
-            node.children.each { |child| get_blocks(child, &block) }
+            return if node.braces?
+            node.each_child_node { |child| get_blocks(child, &block) }
           when :pair
-            node.children.each { |child| get_blocks(child, &block) }
+            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)
+
           case style
           when :line_count_based    then line_count_based_block_style?(node)
           when :semantic            then semantic_block_style?(node)
@@ -126,18 +207,13 @@ module RuboCop
         end
 
         def line_count_based_block_style?(node)
-          block_begin = node.loc.begin.source
-
-          (block_length(node) > 0) ^ (block_begin == '{')
+          node.multiline? ^ node.braces?
         end
 
         def semantic_block_style?(node)
           method_name = node.method_name
-          return true if ignored_method?(method_name)
-
-          block_begin = node.loc.begin.source
 
-          if block_begin == '{'
+          if node.braces?
             functional_method?(method_name) || functional_block?(node)
           else
             procedural_method?(method_name) || !return_value_used?(node)
@@ -145,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
                            '{'
@@ -156,17 +231,13 @@ module RuboCop
         end
 
         def return_value_chaining?(node)
-          node.parent && node.parent.send_type? && node.parent.loc.dot
+          node.parent && node.parent.send_type? && node.parent.dot?
         end
 
         def correction_would_break_code?(node)
-          if node.loc.begin.is?('do')
-            # Converting `obj.method arg do |x| end` to use `{}` would cause
-            # a syntax error.
-            send = node.children.first
-            _receiver, _method_name, *args = *send
-            !args.empty? && !parentheses?(send)
-          end
+          return unless node.keywords?
+
+          node.send_node.arguments? && !node.send_node.parenthesized?
         end
 
         def ignored_method?(method_name)