rubocop 0.37.2 → 0.38.0

data/lib/rubocop/cop/lint/unneeded_disable.rb

@@ -20,30 +20,10 @@ module RuboCop
 
         def check(offenses, cop_disabled_line_ranges, comments)
           unneeded_cops = Hash.new { |h, k| h[k] = Set.new }
-          disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
-          cop_disabled_line_ranges.each do |cop, line_ranges|
-            line_ranges.each_cons(2) do |previous_range, range|
-              next if previous_range.end != range.begin
-
-              # If a cop is disabled in a range that begins on the same line as
-              # the end of the previous range, it means that the cop was
-              # already disabled by an earlier comment. So it's unneeded
-              # whether there are offenses or not.
-              comment = comments.find { |c| c.loc.line == range.begin }
-              unneeded_cops[comment].add(cop)
-            end
-
-            line_ranges.each do |line_range|
-              comment = comments.find { |c| c.loc.line == line_range.begin }
-
-              unless all_disabled?(comment)
-                next if ignore_offense?(disabled_ranges, line_range)
-              end
-
-              unneeded_cop = find_unneeded(comment, offenses, cop, line_range)
-              unneeded_cops[comment].add(unneeded_cop) if unneeded_cop
-            end
+          each_unneeded_disable(cop_disabled_line_ranges,
+                                offenses, comments) do |comment, unneeded_cop|
+            unneeded_cops[comment].add(unneeded_cop)
           end
 
           add_offenses(unneeded_cops)
@@ -77,6 +57,39 @@ module RuboCop
 
         private
 
+        def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments)
+          disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
+
+          cop_disabled_line_ranges.each do |cop, line_ranges|
+            each_already_disabled(line_ranges, comments) do |comment|
+              yield comment, cop
+            end
+
+            line_ranges.each do |line_range|
+              comment = comments.find { |c| c.loc.line == line_range.begin }
+
+              unless all_disabled?(comment)
+                next if ignore_offense?(disabled_ranges, line_range)
+              end
+
+              unneeded_cop = find_unneeded(comment, offenses, cop, line_range)
+              yield comment, unneeded_cop if unneeded_cop
+            end
+          end
+        end
+
+        def each_already_disabled(line_ranges, comments)
+          line_ranges.each_cons(2) do |previous_range, range|
+            next if previous_range.end != range.begin
+
+            # If a cop is disabled in a range that begins on the same line as
+            # the end of the previous range, it means that the cop was
+            # already disabled by an earlier comment. So it's unneeded
+            # whether there are offenses or not.
+            yield comments.find { |c| c.loc.line == range.begin }
+          end
+        end
+
         def find_unneeded(comment, offenses, cop, line_range)
           if all_disabled?(comment)
             'all' if offenses.none? { |o| line_range.cover?(o.line) }

data/lib/rubocop/cop/lint/unused_block_argument.rb

@@ -13,7 +13,6 @@ module RuboCop
       #   end
       class UnusedBlockArgument < Cop
         include UnusedArgument
-        include Util
 
         def check_argument(variable)
           return unless variable.block_argument?

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -55,7 +55,7 @@ module RuboCop
         def check_scope(node, cur_vis = :public)
           unused = nil
 
-          node.children.each do |child|
+          node.child_nodes.each do |child|
             if (new_vis = access_modifier(child))
               # does this modifier just repeat the existing visibility?
               if new_vis == cur_vis
@@ -70,14 +70,14 @@ module RuboCop
               cur_vis = new_vis
             elsif method_definition?(child)
               unused = nil
-            elsif child.kwbegin_type?
-              cur_vis = check_scope(child, cur_vis)
+            elsif child.kwbegin_type? || child.send_type?
+              cur_vis, unused = check_scope(child, cur_vis)
             end
           end
 
           add_offense(unused, :expression, format(MSG, cur_vis)) if unused
 
-          cur_vis
+          [cur_vis, unused]
         end
       end
     end

data/lib/rubocop/cop/metrics/line_length.rb

@@ -16,30 +16,37 @@ module RuboCop
         def investigate(processed_source)
           heredocs = extract_heredocs(processed_source.ast) if allow_heredoc?
           processed_source.lines.each_with_index do |line, index|
-            next unless line.length > max
+            check_line(line, index, heredocs)
+          end
+        end
 
-            if allow_heredoc?
-              next if line_in_whitelisted_heredoc?(heredocs, index.succ)
-            end
+        def check_line(line, index, heredocs)
+          return unless line.length > max
+          return if heredocs &&
+                    line_in_whitelisted_heredoc?(heredocs, index.succ)
 
-            if allow_uri?
-              uri_range = find_excessive_uri_range(line)
-              next if uri_range && allowed_uri_position?(line, uri_range)
-            end
+          if allow_uri?
+            uri_range = find_excessive_uri_range(line)
+            return if uri_range && allowed_uri_position?(line, uri_range)
+          end
 
-            message = format(MSG, line.length, max)
+          offense(excess_range(uri_range, line, index), line)
+        end
 
-            excessive_position = if uri_range && uri_range.begin < max
-                                   uri_range.end
-                                 else
-                                   max
-                                 end
+        def offense(loc, line)
+          message = format(MSG, line.length, max)
+          add_offense(nil, loc, message) { self.max = line.length }
+        end
 
-            range = source_range(processed_source.buffer, index + 1,
-                                 excessive_position...(line.length))
+        def excess_range(uri_range, line, index)
+          excessive_position = if uri_range && uri_range.begin < max
+                                 uri_range.end
+                               else
+                                 max
+                               end
 
-            add_offense(nil, range, message) { self.max = line.length }
-          end
+          source_range(processed_source.buffer, index + 1,
+                       excessive_position...(line.length))
         end
 
         def max

data/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -24,7 +24,7 @@ module RuboCop
 
       def display_column(range)
         line = processed_source.lines[range.line - 1]
-        line[0, range.column].display_width
+        Unicode::DisplayWidth.of(line[0, range.column])
       end
 
       def check_alignment(items, base_column = nil)

data/lib/rubocop/cop/mixin/code_length.rb

@@ -19,7 +19,7 @@ module RuboCop
         length = code_length(node)
         return unless length > max_length
 
-        add_offense(node, :keyword, message(length, max_length)) do
+        add_offense(node, :expression, message(length, max_length)) do
           self.max = length
         end
       end

data/lib/rubocop/cop/mixin/if_node.rb

@@ -11,10 +11,6 @@ module RuboCop
           node.loc.respond_to?(:end) && node.loc.end.nil?
       end
 
-      def ternary_op?(node)
-        node.loc.respond_to?(:question)
-      end
-
       def elsif?(node)
         node.loc.respond_to?(:keyword) && node.loc.keyword &&
           node.loc.keyword.is?('elsif')

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -109,7 +109,11 @@ module RuboCop
       end
 
       def argument_in_method_call(node)
-        node.each_ancestor(:send).find do |a|
+        node.each_ancestor(:send, :block).find do |a|
+          # If the node is inside a block, it makes no difference if that block
+          # is an argument in a method call. It doesn't count.
+          break false if a.block_type?
+
           _, method_name, *args = *a
           next if assignment_call?(method_name)
           args.any? { |arg| within_node?(node, arg) }

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -27,12 +27,12 @@ module RuboCop
             corrector.insert_before(node.loc.end, "\n".freeze)
           end
         else
-          range = Parser::Source::Range.new(
-            node.source_range.source_buffer,
-            children(node).last.source_range.end_pos,
-            node.loc.end.begin_pos)
-
-          ->(corrector) { corrector.remove(range) }
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(node.loc.end,
+                                                          :left))
+            corrector.insert_after(children(node).last.source_range,
+                                   node.loc.end.source)
+          end
         end
       end
 

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -65,34 +65,36 @@ module RuboCop
       # on different lines, and each item within is on its own line, and the
       # closing bracket is on its own line.
       def multiline?(node)
-        elements = if node.type == :send
-                     _receiver, _method_name, *args = *node
-                     args.flat_map do |a|
-                       # For each argument, if it is a multi-line hash,
-                       # then promote the hash elements to method arguments
-                       # for the purpose of determining multi-line-ness.
-                       if a.hash_type? && a.loc.first_line != a.loc.last_line
-                         a.children
-                       else
-                         a
-                       end
-                     end
-                   else
-                     node.children
-                   end
-
         # No need to process anything if the whole node is not multiline
         # Without the 2nd check, Foo.new({}) is considered multiline, which
         # it should not be. Essentially, if there are no elements, the
         # expression can not be multiline.
-        return if !node.multiline? || elements.empty?
-
-        items = elements.map(&:source_range)
-        if style == :consistent_comma
-          items.one? || items.each_cons(2).any? { |a, b| !on_same_line?(a, b) }
-        else
-          items << node.loc.end
-          items.each_cons(2).all? { |a, b| !on_same_line?(a, b) }
+        return false unless node.multiline?
+
+        items = elements(node).map(&:source_range)
+        return false if items.empty?
+
+        # If brackets are on different lines and there is one item at least,
+        # then comma is needed anytime for consistent_comma.
+        return true if style == :consistent_comma
+
+        items << node.loc.end
+        items.each_cons(2).all? { |a, b| !on_same_line?(a, b) }
+      end
+
+      def elements(node)
+        return node.children unless node.send_type?
+
+        _receiver, _method_name, *args = *node
+        args.flat_map do |a|
+          # For each argument, if it is a multi-line hash,
+          # then promote the hash elements to method arguments
+          # for the purpose of determining multi-line-ness.
+          if a.hash_type? && a.loc.first_line != a.loc.last_line
+            a.children
+          else
+            a
+          end
         end
       end
 

data/lib/rubocop/cop/mixin/unused_argument.rb

@@ -27,7 +27,15 @@ module RuboCop
         def autocorrect(node)
           return if [:kwarg, :kwoptarg].include?(node.type)
 
-          ->(corrector) { corrector.insert_before(node.loc.name, '_') }
+          if node.blockarg_type?
+            lambda do |corrector|
+              range = range_with_surrounding_space(node.source_range, :left)
+              range = range_with_surrounding_comma(range, :left)
+              corrector.remove(range)
+            end
+          else
+            ->(corrector) { corrector.insert_before(node.loc.name, '_') }
+          end
         end
       end
     end

data/lib/rubocop/cop/offense.rb

@@ -87,6 +87,22 @@ module RuboCop
         @status == :disabled
       end
 
+      # @api public
+      #
+      # @return [Parser::Source::Range]
+      #   the range of the code that is highlighted
+      def highlighted_area
+        column_length = if location.first_line == location.last_line
+                          location.column_range.count
+                        else
+                          location.source_line.length - location.column
+                        end
+
+        Parser::Source::Range.new(location.source_line,
+                                  location.column,
+                                  location.column + column_length)
+      end
+
       # @api private
       # This is just for debugging purpose.
       def to_s

data/lib/rubocop/cop/performance/casecmp.rb

@@ -9,26 +9,31 @@ module RuboCop
       #
       # @example
       #   @bad
-      #   'aBc'.downcase == 'abc'
-      #   'abc'.upcase.eql? 'ABC'
-      #   'abc' == 'ABC'.downcase
-      #   'ABC'.eql? 'abc'.upcase
-      #   'abc'.downcase == 'abc'.downcase
+      #   str.downcase == 'abc'
+      #   str.upcase.eql? 'ABC'
+      #   'abc' == str.downcase
+      #   'ABC'.eql? str.upcase
+      #   str.downcase == str.downcase
       #
       #   @good
-      #   'aBc'.casecmp('ABC').zero?
-      #   'abc'.casecmp('abc').zero?
-      #   'abc'.casecmp('ABC'.downcase).zero?
+      #   str.casecmp('ABC').zero?
+      #   'abc'.casecmp(str).zero?
       class Casecmp < Cop
         MSG = 'Use `casecmp` instead of `%s %s`.'.freeze
         CASE_METHODS = [:downcase, :upcase].freeze
 
         def_node_matcher :downcase_eq, <<-END
-          (send $(send _ ${:downcase :upcase}) ${:== :eql? :!=} $_)
+          (send
+            $(send _ ${:downcase :upcase})
+            ${:== :eql? :!=}
+            ${str (send _ {:downcase :upcase} ...) (begin str)})
         END
 
         def_node_matcher :eq_downcase, <<-END
-          (send _ ${:== :eql? :!=} $(send _ ${:downcase :upcase}))
+          (send
+            {str (send _ {:downcase :upcase} ...) (begin str)}
+            ${:== :eql? :!=}
+            $(send _ ${:downcase :upcase}))
         END
 
         def on_send(node)

data/lib/rubocop/cop/performance/count.rb

@@ -4,8 +4,9 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `count` on an
-      # `Enumerable` and change them to `size`.
+      # This cop is used to identify usages of `count` on an `Enumerable` that
+      # follow calls to `select` or `reject`. Querying logic can instead be
+      # passed to the `count` call.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/performance/fixed_size.rb

@@ -7,21 +7,22 @@ module RuboCop
       # Do not compute the size of statically sized objects.
       class FixedSize < Cop
         MSG = 'Do not compute the size of statically sized objects.'.freeze
-        COUNTERS = [:count, :length, :size].freeze
-        STATIC_SIZED_TYPES = [:array, :hash, :str, :sym].freeze
+
+        def_node_matcher :counter, <<-MATCHER
+          (send ${array hash str sym} {:count :length :size} $...)
+        MATCHER
 
         def on_send(node)
-          variable, method, arg = *node
-          return unless variable
-          return unless COUNTERS.include?(method)
-          return unless STATIC_SIZED_TYPES.include?(variable.type)
-          return if contains_splat?(variable)
-          return if contains_double_splat?(variable)
-          return if string_argument?(arg)
-          if node.parent
-            return if node.parent.casgn_type? || node.parent.block_type?
+          counter(node) do |variable, arg|
+            return if contains_splat?(variable)
+            return if contains_double_splat?(variable)
+            return if !arg.nil? && string_argument?(arg.first)
+            if node.parent
+              return if node.parent.casgn_type? || node.parent.block_type?
+            end
+
+            add_offense(node, :expression)
           end
-          add_offense(node, :expression)
         end
 
         private

data/lib/rubocop/cop/performance/reverse_each.rb

@@ -15,26 +15,27 @@ module RuboCop
       #   [].reverse_each
       class ReverseEach < Cop
         MSG = 'Use `reverse_each` instead of `reverse.each`.'.freeze
+        UNDERSCORE = '_'.freeze
 
-        def on_send(node)
-          receiver, second_method = *node
-          return unless second_method == :each
-          return if receiver.nil?
-          _, first_method = *receiver
-          return unless first_method == :reverse
+        def_node_matcher :reverse_each?, <<-MATCHER
+          (send $(send array :reverse) :each)
+        MATCHER
 
-          source_buffer = node.source_range.source_buffer
-          location_of_reverse = receiver.loc.selector.begin_pos
-          end_location = node.loc.selector.end_pos
+        def on_send(node)
+          reverse_each?(node) do |receiver|
+            source_buffer = node.source_range.source_buffer
+            location_of_reverse = receiver.loc.selector.begin_pos
+            end_location = node.loc.selector.end_pos
 
-          range = Parser::Source::Range.new(source_buffer,
-                                            location_of_reverse,
-                                            end_location)
-          add_offense(node, range, MSG)
+            range = Parser::Source::Range.new(source_buffer,
+                                              location_of_reverse,
+                                              end_location)
+            add_offense(node, range, MSG)
+          end
         end
 
         def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, '_') }
+          ->(corrector) { corrector.replace(node.loc.dot, UNDERSCORE) }
         end
       end
     end