rubocop 0.45.0 → 0.46.0

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

@@ -6,7 +6,8 @@ module RuboCop
       # This cop checks for non-local exit from iterator, without return value.
       # It warns only when satisfies all of these: `return` doesn't have return
       # value, the block is preceded by a method chain, the block has arguments,
-      # and the method which receives the block is not `define_method`.
+      # and the method which receives the block is not `define_method`
+      # or `define_singleton_method`.
       #
       # @example
       #
@@ -44,8 +45,9 @@ module RuboCop
 
             # `return` does not exit to outside of lambda block, this is safe.
             break if block_node.lambda?
-            # if a proc is passed to `Module#define_method`, `return` will not
-            # cause a non-local exit error
+            # if a proc is passed to `Module#define_method` or
+            # `Object#define_singleton_method`, `return` will not cause a
+            # non-local exit error
             break if define_method?(send_node)
 
             next if args_node.children.empty?
@@ -67,7 +69,7 @@ module RuboCop
 
         def define_method?(send_node)
           _receiver, selector = *send_node
-          selector == :define_method
+          %i(define_method define_singleton_method).include? selector
         end
       end
     end

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

@@ -64,7 +64,8 @@ module RuboCop
               return unless ASSIGNMENT_TYPES.include?(node.parent.parent.type)
             end
 
-            if array_splat?(node) && method_argument?(node)
+            if array_splat?(node) &&
+               (method_argument?(node) || part_of_an_array?(node))
               add_offense(node, :expression, ARRAY_PARAM_MSG)
             else
               add_offense(node, :expression)
@@ -76,13 +77,12 @@ module RuboCop
 
         def autocorrect(node)
           variable, = *node
-          parent = node.parent
           loc = node.loc
 
           lambda do |corrector|
             if !variable.array_type?
               corrector.replace(loc.expression, "[#{variable.source}]")
-            elsif unneeded_brackets?(parent)
+            elsif unneeded_brackets?(node)
               corrector.replace(loc.expression, remove_brackets(variable))
             else
               corrector.remove(loc.operator)
@@ -98,10 +98,19 @@ module RuboCop
           node.parent.send_type?
         end
 
+        def part_of_an_array?(node)
+          # The parent of a splat expansion is an array that does not have
+          # `begin` or `end`
+          parent = node.parent
+          parent.array_type? && parent.loc.begin && parent.loc.end
+        end
+
         def unneeded_brackets?(node)
           parent = node.parent
+          grandparent = node.parent.parent
 
-          node.when_type? || node.send_type? || (parent && parent.resbody_type?)
+          parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
+            (grandparent && grandparent.resbody_type?)
         end
 
         def remove_brackets(array)

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

@@ -10,18 +10,14 @@ module RuboCop
       #  x.top >= x.top
       class UselessComparison < Cop
         MSG = 'Comparison of something with itself detected.'.freeze
-
         OPS = %w(== === != < > <= >= <=>).freeze
 
-        def on_send(node)
-          # lambda.() does not have a selector
-          return unless node.loc.selector
-
-          op = node.loc.selector.source
-          return unless OPS.include?(op)
+        def_node_matcher :comparison?, "(send $_ {:#{OPS.join(' :')}} $_)"
 
-          receiver, _method, args = *node
-          add_offense(node, :selector) if receiver == args
+        def on_send(node)
+          comparison?(node) do |receiver, args|
+            add_offense(node, :selector) if receiver == args
+          end
         end
       end
     end

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

@@ -53,6 +53,7 @@ module RuboCop
         class MethodVariableTracker
           def initialize(body_node)
             @body_node = body_node
+            @local = nil
           end
 
           def contain_local_object?(variable_name)

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

@@ -23,11 +23,11 @@ module RuboCop
 
         def check_line(line, index, heredocs)
           return if line.length <= max
+          return if ignored_line?(line, index, heredocs)
+
           if ignore_cop_directives? && directive_on_source_line?(index)
             return check_directive_line(line, index)
           end
-          return if heredocs &&
-                    line_in_whitelisted_heredoc?(heredocs, index.succ)
           return check_uri_line(line, index) if allow_uri?
 
           offense(
@@ -36,6 +36,11 @@ module RuboCop
           )
         end
 
+        def ignored_line?(line, index, heredocs)
+          matches_ignored_pattern?(line) ||
+            heredocs && line_in_whitelisted_heredoc?(heredocs, index.succ)
+        end
+
         def offense(loc, line)
           message = format(MSG, line.length, max)
           add_offense(nil, loc, message) { self.max = line.length }
@@ -81,6 +86,14 @@ module RuboCop
           end
         end
 
+        def matches_ignored_pattern?(line)
+          ignored_patterns.any? { |pattern| Regexp.new(pattern).match(line) }
+        end
+
+        def ignored_patterns
+          cop_config['IgnoredPatterns'] || []
+        end
+
         def allow_uri?
           cop_config['AllowURI']
         end
@@ -117,7 +130,7 @@ module RuboCop
         end
 
         def uri_regexp
-          @regexp ||= URI.regexp(cop_config['URISchemes'])
+          @regexp ||= URI::Parser.new.make_regexp(cop_config['URISchemes'])
         end
 
         def check_directive_line(line, index)

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

@@ -4,12 +4,12 @@ module RuboCop
   module Cop
     # Common functionality for checking modifier nodes.
     module AccessModifierNode
-      extend RuboCop::Sexp
+      extend NodePattern::Macros
 
-      PRIVATE_NODE = s(:send, nil, :private)
-      PROTECTED_NODE = s(:send, nil, :protected)
-      PUBLIC_NODE = s(:send, nil, :public)
-      MODULE_FUNCTION_NODE = s(:send, nil, :module_function)
+      def_node_matcher :private_node?, '(send nil :private)'
+      def_node_matcher :protected_node?, '(send nil :protected)'
+      def_node_matcher :public_node?, '(send nil :public)'
+      def_node_matcher :module_function_node?, '(send nil :module_function)'
 
       # Returns true when the node is an access modifier.
       def modifier_node?(node)
@@ -18,10 +18,10 @@ module RuboCop
 
       # Returns true when the node looks like an access modifier.
       def modifier_structure?(node)
-        [PRIVATE_NODE,
-         PROTECTED_NODE,
-         PUBLIC_NODE,
-         MODULE_FUNCTION_NODE].include?(node)
+        private_node?(node) ||
+          protected_node?(node) ||
+          public_node?(node) ||
+          module_function_node?(node)
       end
 
       # Returns true when the parent of what looks like an access modifier

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

@@ -7,23 +7,30 @@ module RuboCop
     module ConfigurableNumbering
       include ConfigurableEnforcedStyle
 
-      SNAKE_CASE = /(^_|[a-z]|_\d+)$/
-      NORMAL_CASE = /(^_|[A-Za-z]\d*)$/
-      NON_INTEGER = /(^_|[A-Za-z])$/
+      SNAKE_CASE = /(?:[a-z_]|_\d+)$/
+      NORMAL_CASE = /(?:_\D*|[A-Za-z]\d*)$/
+      NON_INTEGER = /[A-Za-z_]$/
 
       def check_name(node, name, name_range)
         return if operator?(name)
 
-        if valid_name?(node, name)
+        if valid_name?(node, name, style)
           correct_style_detected
         else
-          add_offense(node, name_range, message(style))
+          add_offense(node, name_range, message(style)) do
+            (supported_styles - [style]).each do |other_style|
+              if valid_name?(node, name, other_style)
+                unexpected_style_detected(other_style)
+                break
+              end
+            end
+          end
         end
       end
 
-      def valid_name?(node, name)
+      def valid_name?(node, name, given_style)
         pattern =
-          case style
+          case given_style
           when :snake_case
             SNAKE_CASE
           when :normalcase

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

@@ -11,13 +11,15 @@ module RuboCop
 
         MSG_EXTRA = 'Extra empty line detected at %s body %s.'.freeze
         MSG_MISSING = 'Empty line missing at %s body %s.'.freeze
+        MSG_DEFERRED = 'Empty line missing before first %s definition'.freeze
 
         def_node_matcher :constant_definition?, '{class module}'
+        def_node_matcher :empty_line_required?, '{def defs class module}'
 
         def autocorrect(args)
-          offence_style, range = args
+          offense_style, range = args
           lambda do |corrector|
-            case offence_style
+            case offense_style
             when :no_empty_lines then
               corrector.remove(range)
             when :empty_lines then
@@ -40,33 +42,61 @@ module RuboCop
 
           case style
           when :empty_lines_except_namespace
-            if namespace?(body, with_one_child: true)
-              check_source(:no_empty_lines, first_line, last_line)
+            check_empty_lines_except_namespace(body, first_line, last_line)
+          when :empty_lines_special
+            check_empty_lines_special(body, first_line, last_line)
+          else
+            check_both(style, first_line, last_line)
+          end
+        end
+
+        def check_empty_lines_except_namespace(body, first_line, last_line)
+          if namespace?(body, with_one_child: true)
+            check_both(:no_empty_lines, first_line, last_line)
+          else
+            check_both(:empty_lines, first_line, last_line)
+          end
+        end
+
+        def check_empty_lines_special(body, first_line, last_line)
+          return unless body
+          if namespace?(body, with_one_child: true)
+            check_both(:no_empty_lines, first_line, last_line)
+          else
+            if first_child_requires_empty_line?(body)
+              check_beginning(:empty_lines, first_line)
             else
-              check_source(:empty_lines, first_line, last_line)
+              check_beginning(:no_empty_lines, first_line)
+              check_deferred_empty_line(body)
             end
-          else
-            check_source(style, first_line, last_line)
+            check_ending(:empty_lines, last_line)
           end
         end
 
-        def check_source(style, start_line, end_line)
+        def check_both(style, first_line, last_line)
+          check_beginning(style, first_line)
+          check_ending(style, last_line)
+        end
+
+        def check_beginning(style, first_line)
+          check_source(style, first_line, 'beginning')
+        end
+
+        def check_ending(style, last_line)
+          check_source(style, last_line - 2, 'end')
+        end
+
+        def check_source(style, line_no, desc)
           case style
           when :no_empty_lines
-            check_both(style, start_line, end_line, MSG_EXTRA, &:empty?)
+            check_line(style, line_no, message(MSG_EXTRA, desc), &:empty?)
           when :empty_lines
-            check_both(style, start_line, end_line, MSG_MISSING) do |line|
+            check_line(style, line_no, message(MSG_MISSING, desc)) do |line|
               !line.empty?
             end
           end
         end
 
-        def check_both(style, start_line, end_line, msg, &block)
-          kind = self.class::KIND
-          check_line(style, start_line, format(msg, kind, 'beginning'), &block)
-          check_line(style, end_line - 2, format(msg, kind, 'end'), &block)
-        end
-
         def check_line(style, line, msg)
           return unless yield(processed_source.lines[line])
 
@@ -75,13 +105,55 @@ module RuboCop
           add_offense([style, range], range, msg)
         end
 
-        def namespace?(node, with_one_child: true)
-          if node.begin_type?
+        def check_deferred_empty_line(body)
+          node = first_empty_line_required_child(body)
+          return unless node
+
+          line = previous_line_ignoring_comments(node.loc.first_line)
+          return if processed_source[line].empty?
+
+          range = source_range(processed_source.buffer, line + 2, 0)
+          add_offense([:empty_lines, range], range, deferred_message(node))
+        end
+
+        def namespace?(body, with_one_child: false)
+          if body.begin_type?
             return false if with_one_child
-            node.children.all? { |child| constant_definition?(child) }
+            body.children.all? { |child| constant_definition?(child) }
           else
-            constant_definition?(node)
+            constant_definition?(body)
+          end
+        end
+
+        def first_child_requires_empty_line?(body)
+          if body.begin_type?
+            empty_line_required?(body.children.first)
+          else
+            empty_line_required?(body)
+          end
+        end
+
+        def first_empty_line_required_child(body)
+          if body.begin_type?
+            body.children.find { |child| empty_line_required?(child) }
+          elsif empty_line_required?(body)
+            body
+          end
+        end
+
+        def previous_line_ignoring_comments(send_line)
+          (send_line - 2).downto(0) do |line|
+            return line unless comment_line?(processed_source[line])
           end
+          0
+        end
+
+        def message(type, desc)
+          format(type, self.class::KIND, desc)
+        end
+
+        def deferred_message(node)
+          format(MSG_DEFERRED, node.type)
         end
       end
     end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `sort { |a, b| a.foo <=> b.foo }`
+      # can be replaced by `sort_by(&:foo)`.
+      # This cop also checks `max` and `min` methods.
+      #
+      # @example
+      #   @bad
+      #   array.sort { |a, b| a.foo <=> b.foo }
+      #   array.max { |a, b| a.foo <=> b.foo }
+      #   array.min { |a, b| a.foo <=> b.foo }
+      #
+      #   @good
+      #   array.sort_by(&:foo)
+      #   array.sort_by { |v| v.foo }
+      #   array.sort_by do |var|
+      #     var.foo
+      #   end
+      #   array.max_by(&:foo)
+      #   array.min_by(&:foo)
+      class CompareWithBlock < Cop
+        MSG = 'Use `%s_by(&:%s)` instead of ' \
+              '`%s { |%s, %s| %s.%s <=> %s.%s }`.'.freeze
+
+        def_node_matcher :compare?, <<-END
+          (block $(send _ {:sort :min :max}) (args (arg $_a) (arg $_b)) (send (send (lvar _a) $_m) :<=> (send (lvar _b) $_m)))
+        END
+
+        def on_block(node)
+          compare?(node) do |send, var_a, var_b, method|
+            range = compare_range(send, node)
+            compare_method = send.method_name
+            add_offense(node, range,
+                        format(MSG, compare_method, method,
+                               compare_method, var_a, var_b,
+                               var_a, method, var_b, method))
+          end
+        end
+
+        def autocorrect(node)
+          send, = *node
+
+          lambda do |corrector|
+            method = node.children.last.children.last.children.last
+            corrector.replace(compare_range(send, node),
+                              "#{send.method_name}_by(&:#{method})")
+          end
+        end
+
+        private
+
+        def compare_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -42,32 +42,32 @@ module RuboCop
 
         MSG = 'Use `count` instead of `%s...%s`.'.freeze
 
-        SELECTORS = [:reject, :select].freeze
-        COUNTERS = [:count, :length, :size].freeze
+        def_node_matcher :count_candidate?, <<-PATTERN
+          {
+            (send (block $(send _ ${:select :reject}) ...) ${:count :length :size})
+            (send $(send _ ${:select :reject} (:block_pass _)) ${:count :length :size})
+          }
+        PATTERN
 
         def on_send(node)
           return if rails_safe_mode?
 
-          @selector, @selector_loc, @params, @counter = parse(node)
+          count_candidate?(node) do |selector_node, selector, counter|
+            return unless eligible_node?(node)
 
-          check(node)
+            range = source_starting_at(node) do
+              selector_node.loc.selector.begin_pos
+            end
+
+            add_offense(node, range, format(MSG, selector, counter))
+          end
         end
 
         private
 
-        attr_reader :selector, :selector_loc, :params, :counter
-
-        def check(node)
-          return unless eligible_node?(node) && eligible_params? &&
-                        eligible_method_chain?
-
-          range = source_starting_at(node) { @selector_loc.begin_pos }
-
-          add_offense(node, range, format(MSG, @selector, @counter))
-        end
-
         def autocorrect(node)
-          selector, selector_loc = parse(node)
+          selector_node, selector, _counter = count_candidate?(node)
+          selector_loc = selector_node.loc.selector
 
           return if selector == :reject
 
@@ -83,48 +83,12 @@ module RuboCop
           !(node.parent && node.parent.block_type?)
         end
 
-        def eligible_params?
-          !(params && !params.block_pass_type?)
-        end
-
-        def eligible_method_chain?
-          COUNTERS.include?(counter) && SELECTORS.include?(selector)
-        end
-
-        def parse(node)
-          head, counter = *node
-          expression, selector, params = *head
-          if selector.is_a?(Symbol)
-            selector_loc = selector_location(expression, head.loc)
-          else
-            _, selector, params = *expression
-            if contains_selector?(expression)
-              selector_loc = expression.loc.selector
-            end
-          end
-
-          [selector, selector_loc, params, counter]
-        end
-
-        def selector_location(expression, head_loc)
-          if expression && expression.parent.loc.respond_to?(:selector)
-            expression.parent.loc.selector
-          elsif head_loc.respond_to?(:selector)
-            head_loc.selector
-          end
-        end
-
-        def contains_selector?(node)
-          node.respond_to?(:loc) && node.loc.respond_to?(:selector)
-        end
-
         def source_starting_at(node)
-          begin_pos =
-            if block_given?
-              yield node
-            else
-              node.source_range.begin_pos
-            end
+          begin_pos = if block_given?
+                        yield node
+                      else
+                        node.source_range.begin_pos
+                      end
 
           range_between(begin_pos, node.source_range.end_pos)
         end