rubocop 0.31.0 → 0.32.0

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop detects instances of rubocop:disable comments that can be
+      # removed without causing any offenses to be reported. It's implemented
+      # as a cop in that it inherits from the Cop base class and calls
+      # add_offense. The unusual part of its implementation is that it doesn't
+      # have any on_* methods or an investigate method. This means that it
+      # doesn't take part in the investigation phase when the other cops do
+      # their work. Instead, it waits until it's called in a later stage of the
+      # execution. The reason it can't be implemented as a normal cop is that
+      # it depends on the results of all other cops to do its work.
+      class UnneededDisable < Cop
+        COP_NAME = 'Lint/UnneededDisable'
+
+        def check(file, offenses, cop_disabled_line_ranges, comments)
+          unneeded_cops = {}
+
+          cop_disabled_line_ranges[file].each do |cop, line_ranges|
+            cop_offenses = offenses.select { |o| o.cop_name == cop }
+            line_ranges.each do |line_range|
+              comment =
+                comments[file].find { |c| c.loc.line == line_range.begin }
+              unneeded_cop = find_unneeded(comment, offenses, cop, cop_offenses,
+                                           line_range)
+              if unneeded_cop
+                unneeded_cops[comment.loc.expression] ||= Set.new
+                unneeded_cops[comment.loc.expression].add(unneeded_cop)
+              end
+            end
+          end
+
+          unneeded_cops.each do |range, cops|
+            add_offense(range, range,
+                        "Unnecessary disabling of #{cops.sort.join(', ')}.")
+          end
+        end
+
+        private
+
+        def find_unneeded(comment, offenses, cop, cop_offenses, line_range)
+          if comment.loc.expression.source =~ /rubocop:disable\s+all\b/
+            'all cops' if offenses.none? { |o| line_range.include?(o.line) }
+          elsif cop_offenses.none? { |o| line_range.include?(o.line) }
+            cop
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,7 +16,7 @@ module RuboCop
         private
 
         def message(length, max_length)
-          format('Class definition is too long. [%d/%d]', length, max_length)
+          format('Class has too many lines. [%d/%d]', length, max_length)
         end
       end
     end

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

@@ -16,7 +16,7 @@ module RuboCop
         private
 
         def message(length, max_length)
-          format('Module definition is too long. [%d/%d]', length, max_length)
+          format('Module has too many lines. [%d/%d]', length, max_length)
         end
       end
     end

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

@@ -27,7 +27,7 @@ module RuboCop
           if count_keyword_args?
             node.children.size
           else
-            node.children.count { |a| a.type != :kwoptarg }
+            node.children.count { |a| ![:kwoptarg, :kwarg].include?(a.type) }
           end
         end
 

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

@@ -75,7 +75,7 @@ module RuboCop
       end
 
       def block_comment_within?(expr)
-        processed_source.comments.select(&:document?).find do |c|
+        processed_source.comments.select(&:document?).any? do |c|
           within?(c.loc.expression, expr)
         end
       end

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

@@ -22,6 +22,16 @@ module RuboCop
       def if_else?(node)
         node.loc.respond_to?(:else) && node.loc.else
       end
+
+      def if_node_parts(node)
+        case node.loc.keyword.source
+        when 'if', 'elsif' then condition, body, else_clause = *node
+        when 'unless'      then condition, else_clause, body = *node
+        else                    condition, body = *node
+        end
+
+        [condition, body, else_clause]
+      end
     end
   end
 end

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

@@ -11,12 +11,19 @@ module RuboCop
         processed_source.tokens.each_cons(2) do |t1, t2|
           next unless kind(t1) && t1.pos.line == t2.pos.line &&
                       t2.pos.column == t1.pos.column + offset &&
-                      ![:tRPAREN, :tRBRACK, :tPIPE].include?(t2.type)
+                      ![:tRPAREN, :tRBRACK, :tPIPE].include?(t2.type) &&
+                      !(t2.type == :tRCURLY && space_forbidden_before_rcurly?)
 
           add_offense(t1, t1.pos, format(MSG, kind(t1)))
         end
       end
 
+      def space_forbidden_before_rcurly?
+        cfg = config.for_cop('Style/SpaceInsideBlockBraces')
+        style = cfg['Enabled'] ? cfg['EnforcedStyle'] : 'space'
+        style == 'no_space'
+      end
+
       # The normal offset, i.e., the distance from the punctuation
       # token where a space should be, is 1.
       def offset

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

@@ -10,7 +10,8 @@ module RuboCop
       def investigate(processed_source)
         processed_source.tokens.each_cons(2) do |t1, t2|
           next unless kind(t2) && t1.pos.line == t2.pos.line &&
-                      t2.pos.begin_pos > t1.pos.end_pos
+                      t2.pos.begin_pos > t1.pos.end_pos &&
+                      !(t1.type == :tLCURLY && space_required_after_lcurly?)
           buffer = processed_source.buffer
           pos_before_punctuation = Parser::Source::Range.new(buffer,
                                                              t1.pos.end_pos,
@@ -22,6 +23,12 @@ module RuboCop
         end
       end
 
+      def space_required_after_lcurly?
+        cfg = config.for_cop('Style/SpaceInsideBlockBraces')
+        style = cfg['Enabled'] ? cfg['EnforcedStyle'] : 'space'
+        style == 'space'
+      end
+
       def autocorrect(pos_before_punctuation)
         ->(corrector) { corrector.remove(pos_before_punctuation) }
       end

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

@@ -7,13 +7,10 @@ module RuboCop
       include IfNode
 
       def fit_within_line_as_modifier_form?(node)
-        case node.loc.keyword.source
-        when 'if'     then cond, body, _else = *node
-        when 'unless' then cond, _else, body = *node
-        else               cond, body = *node
-        end
+        cond, body, _else = if_node_parts(node)
 
         return false if length(node) > 3
+        return false if body && body.begin_type? # multiple statements
 
         body_length = body_length(body)
 

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

@@ -31,7 +31,7 @@ module RuboCop
       def inside_interpolation?(node)
         # A :begin node inside a :dstr node is an interpolation.
         begin_found = false
-        node.each_ancestor.find do |a|
+        node.each_ancestor.any? do |a|
           begin_found = true if a.type == :begin
           begin_found && a.type == :dstr
         end

data/lib/rubocop/cop/offense.rb

@@ -56,16 +56,29 @@ module RuboCop
       #
       # @return [Boolean]
       #   whether this offense is automatically corrected.
-      attr_reader :corrected
+      def corrected
+        @status == :unsupported ? nil : @status == :corrected
+      end
       alias_method :corrected?, :corrected
 
+      # @api public
+      #
+      # @!attribute [r] disabled?
+      #
+      # @return [Boolean]
+      #   whether this offense was locally disabled where it occurred
+      def disabled?
+        @status == :disabled
+      end
+
       # @api private
-      def initialize(severity, location, message, cop_name, corrected = false)
+      def initialize(severity, location, message, cop_name,
+                     status = :uncorrected)
         @severity = RuboCop::Cop::Severity.new(severity)
         @location = location
         @message = message.freeze
         @cop_name = cop_name.freeze
-        @corrected = corrected
+        @status = status
         freeze
       end
 

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

@@ -14,12 +14,15 @@ module RuboCop
       #   [1, 2, 3].reject { |e| e > 2 }.length
       #   [1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? }
       #   [1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? }
+      #   array.select(&:value).count
       #
       #   # good
       #   [1, 2, 3].count { |e| e > 2 }
       #   [1, 2, 3].count { |e| e < 2 }
       #   [1, 2, 3].count { |e| e > 2 && e.odd? }
       #   [1, 2, 3].count { |e| e < 2 && e.even? }
+      #   Model.select('field AS field_one').count
+      #   Model.select(:value).count
       class Count < Cop
         MSG = 'Use `count` instead of `%s...%s`.'
 
@@ -27,56 +30,56 @@ module RuboCop
         COUNTERS = [:count, :length, :size]
 
         def on_send(node)
-          expression, first_method, second_method, third_method = parse(node)
-
-          return unless COUNTERS.include?(third_method)
-
-          begin_pos = if SELECTORS.include?(first_method)
-                        return if second_method.is_a?(Symbol)
-                        expression.loc.selector.begin_pos
-                      else
-                        return unless SELECTORS.include?(second_method)
-                        expression.parent.loc.selector.begin_pos
-                      end
-
+          selector, selector_loc, params, counter = parse(node)
+          return unless COUNTERS.include?(counter)
+          return unless SELECTORS.include?(selector)
+          return if params && !params.block_pass_type?
           return if node.parent && node.parent.block_type?
 
           range = Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                            begin_pos,
+                                            selector_loc.begin_pos,
                                             node.loc.expression.end_pos)
 
-          add_offense(node, range,
-                      format(MSG, first_method || second_method, third_method))
+          add_offense(node, range, format(MSG, selector, counter))
         end
 
         def autocorrect(node)
-          expression, first_method, second_method, = parse(node)
+          selector, selector_loc = parse(node)
 
-          return if first_method == :reject || second_method == :reject
+          return if selector == :reject
 
-          selector = if SELECTORS.include?(first_method)
-                       expression.loc.selector
-                     else
-                       expression.parent.loc.selector
-                     end
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            node.loc.dot.begin_pos,
+                                            node.loc.expression.end_pos)
 
           lambda do |corrector|
-            range = Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                              node.loc.dot.begin_pos,
-                                              node.loc.expression.end_pos)
             corrector.remove(range)
-            corrector.replace(selector, 'count')
+            corrector.replace(selector_loc, 'count')
           end
         end
 
         private
 
         def parse(node)
-          left, third_method = *node
-          expression, second_method = *left
-          _enumerable, first_method = *expression
+          left, counter = *node
+          expression, selector, params = *left
+
+          selector_loc =
+            if selector.is_a?(Symbol)
+              if expression && expression.parent.loc.respond_to?(:selector)
+                expression.parent.loc.selector
+              end
+            else
+              _enumerable, selector, params = *expression
+
+              expression.loc.selector if contains_selector?(expression)
+            end
+
+          [selector, selector_loc, params, counter]
+        end
 
-          [expression, first_method, second_method, third_method]
+        def contains_selector?(node)
+          node.respond_to?(:loc) && node.loc.respond_to?(:selector)
         end
       end
     end

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

@@ -1,89 +1,133 @@
-# encoding: utf-8
+# encoding: UTF-8
 
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `shuffle.first` and
-      # change them to use `sample` instead.
+      # This cop is used to identify usages of `shuffle.first`, `shuffle.last`
+      # and `shuffle[]` and change them to use `sample` instead.
       #
       # @example
       #   # bad
       #   [1, 2, 3].shuffle.first
+      #   [1, 2, 3].shuffle.first(2)
       #   [1, 2, 3].shuffle.last
-      #   [1, 2, 3].shuffle[0]
-      #   [1, 2, 3].shuffle[0, 3]
-      #   [1, 2, 3].shuffle(random: Random.new(1))
+      #   [1, 2, 3].shuffle[2]
+      #   [1, 2, 3].shuffle[0, 2]    # sample(2) will do the same
+      #   [1, 2, 3].shuffle[0..2]    # sample(3) will do the same
+      #   [1, 2, 3].shuffle(random: Random.new).first
       #
       #   # good
       #   [1, 2, 3].shuffle
       #   [1, 2, 3].sample
       #   [1, 2, 3].sample(3)
-      #   [1, 2, 3].sample(random: Random.new(1))
+      #   [1, 2, 3].shuffle[1, 3]    # sample(3) might return a longer Array
+      #   [1, 2, 3].shuffle[1..3]    # sample(3) might return a longer Array
+      #   [1, 2, 3].shuffle[foo, bar]
+      #   [1, 2, 3].shuffle(random: Random.new)
       class Sample < Cop
-        MSG = 'Use `sample` instead of `shuffle%s`.'
-        RANGE_TYPES = [:irange, :erange]
-        VALID_ARRAY_SELECTORS = [:first, :last, :[], nil]
+        MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
 
         def on_send(node)
-          _receiver, first_method, params, = *node
-          return unless first_method == :shuffle
-          _receiver, second_method, params, = *node.parent if params.nil?
-          return unless VALID_ARRAY_SELECTORS.include?(second_method)
-          return if second_method.nil? && params.nil?
-
-          add_offense(node, range_of_shuffle(node), message(node, params))
+          analyzer = ShuffleAnalyzer.new(node)
+          return unless analyzer.offensive?
+          add_offense(node, analyzer.source_range, analyzer.message)
         end
 
         def autocorrect(node)
-          _receiver, _method, params, selector = *node
-          _receiver, _method, params, selector = *node.parent if params.nil?
-
-          return if params && RANGE_TYPES.include?(params.type)
-
-          range = if params && (params.hash_type? || params.lvar_type?)
-                    range_of_shuffle(node)
-                  else
-                    Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                              node.loc.selector.begin_pos,
-                                              node.parent.loc.selector.end_pos)
-                  end
-
-          lambda do |corrector|
-            corrector.replace(range, 'sample')
-            return if selector.nil?
-            corrector.insert_after(range, "(#{selector.loc.expression.source})")
-          end
+          ShuffleAnalyzer.new(node).autocorrect
         end
 
-        private
-
-        def message(node, params)
-          if params && params.lvar_type?
-            format(MSG, shuffle_params(node))
-          elsif node.parent
-            _params, selector = *node.parent
-            if selector == :[]
-              format(MSG, node.parent.loc.selector.source)
-            else
-              format(MSG, ".#{node.parent.loc.selector.source}")
+        # An internal class for representing a shuffle + method node analyzer.
+        class ShuffleAnalyzer
+          def initialize(shuffle_node)
+            @shuffle_node = shuffle_node
+            @method_node  = shuffle_node.parent
+          end
+
+          def autocorrect
+            ->(corrector) { corrector.replace(source_range, correct) }
+          end
+
+          def message
+            format(MSG, correct: correct, incorrect: source_range.source)
+          end
+
+          def offensive?
+            shuffle_node.to_a[1] == :shuffle && corrigible?
+          end
+
+          def source_range
+            Parser::Source::Range.new(shuffle_node.loc.expression.source_buffer,
+                                      shuffle_node.loc.selector.begin_pos,
+                                      method_node.loc.expression.end_pos)
+          end
+
+          private
+
+          attr_reader :method_node, :shuffle_node
+
+          def correct
+            args = [sample_arg, shuffle_arg].compact.join(', ')
+            args.empty? ? 'sample' : "sample(#{args})"
+          end
+
+          def corrigible?
+            case method
+            when :first, :last then true
+            when :[]           then sample_size != :unknown
+            else false
             end
-          else
-            format(MSG, shuffle_params(node))
           end
-        end
 
-        def range_of_shuffle(node)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.loc.selector.begin_pos,
-                                    node.loc.selector.end_pos)
-        end
+          def method
+            method_node.to_a[1]
+          end
 
-        def shuffle_params(node)
-          params = Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                             node.loc.selector.end_pos,
-                                             node.loc.expression.end_pos)
+          def method_arg
+            _, _, arg = *method_node
+            arg.loc.expression.source if arg
+          end
+
+          # FIXME: use Range#size once Ruby 1.9 support is dropped
+          def range_size(range_node)
+            vals = *range_node
+            return :unknown unless vals.all?(&:int_type?)
+            low, high = *vals.map(&:to_a).map(&:first)
+            return :unknown unless low.zero? && high >= 0
+            case range_node.type
+            when :erange then high - low
+            when :irange then high - low + 1
+            end
+          end
 
-          params.source
+          def sample_arg
+            case method
+            when :first, :last then method_arg
+            when :[]           then sample_size
+            end
+          end
+
+          def sample_size
+            _, _, *args = *method_node
+            case args.size
+            when 1
+              arg = args.first
+              case arg.type
+              when :erange, :irange then range_size(arg)
+              when :int             then arg.to_a.first.zero? ? nil : :unknown
+              else :unknown
+              end
+            when 2
+              first, second = *args
+              return :unknown unless first.int_type? && first.to_a.first.zero?
+              second.int_type? ? second.to_a.first : :unknown
+            end
+          end
+
+          def shuffle_arg
+            _, _, arg = *shuffle_node
+            arg.loc.expression.source if arg
+          end
         end
       end
     end