rubocop 0.30.1 → 0.31.0

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

@@ -29,7 +29,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             receiver, method_name, *_args = *node
 
             DEPRECATED_METHODS.each do |data|

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks if each_with_object is called with an immutable
+      # argument. Since the argument is the object that the given block shall
+      # make calls on to build something based on the enumerable that
+      # each_with_object iterates over, an immutable argument makes no sense.
+      # It's definitely a bug.
+      #
+      # @example
+      #
+      #   sum = numbers.each_with_object(0) { |e, a| a += e }
+      class EachWithObjectArgument < Cop
+        MSG = 'The argument to each_with_object can not be immutable.'
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+          return unless method_name == :each_with_object
+          return unless args.length == 1
+
+          arg = args.first
+          add_offense(node, :expression) if arg.int_type? || arg.float_type?
+        end
+      end
+    end
+  end
+end

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

@@ -71,6 +71,11 @@ module RuboCop
         def line_break_before_keyword?(whole_expression, rhs)
           rhs.loc.keyword.line > whole_expression.line
         end
+
+        def autocorrect(node)
+          align(node,
+                style == :variable ? node.each_ancestor(:lvasgn).first : node)
+        end
       end
     end
   end

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

@@ -41,7 +41,7 @@ module RuboCop
         private
 
         def check_ternary(arg, node)
-          condition, _, _ = *arg
+          condition, = *arg
           return unless offense?(condition)
 
           expr = node.loc.expression

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

@@ -36,7 +36,7 @@ module RuboCop
         end
 
         def autocorrect(range)
-          @corrections << ->(corrector) { corrector.insert_before(range, ' ') }
+          ->(corrector) { corrector.insert_before(range, ' ') }
         end
       end
     end

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

@@ -32,7 +32,7 @@ module RuboCop
         private
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             receiver, _method_name, *_args = *node
             corrector.replace(
               node.loc.expression,

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

@@ -7,7 +7,7 @@ module RuboCop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       class ClassLength < Cop
-        include CodeLength
+        include ClassishLength
 
         def on_class(node)
           check_code_length(node)
@@ -18,30 +18,6 @@ module RuboCop
         def message(length, max_length)
           format('Class definition is too long. [%d/%d]', length, max_length)
         end
-
-        def code_length(node)
-          class_body_line_numbers = line_range(node).to_a[1...-1]
-
-          target_line_numbers = class_body_line_numbers -
-                                line_numbers_of_inner_classes(node)
-
-          target_line_numbers.reduce(0) do |length, line_number|
-            source_line = processed_source[line_number]
-            next length if irrelevant_line(source_line)
-            length + 1
-          end
-        end
-
-        def line_numbers_of_inner_classes(node)
-          line_numbers = Set.new
-
-          node.each_descendant(:class, :module) do |inner_node|
-            line_range = line_range(inner_node)
-            line_numbers.merge(line_range)
-          end
-
-          line_numbers.to_a
-        end
       end
     end
   end

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks if the length a module exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class ModuleLength < Cop
+        include ClassishLength
+
+        def on_module(node)
+          check_code_length(node)
+        end
+
+        private
+
+        def message(length, max_length)
+          format('Module definition is too long. [%d/%d]', length, max_length)
+        end
+      end
+    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.reject { |a| a.type == :kwoptarg }.size
+            node.children.count { |a| a.type != :kwoptarg }
           end
         end
 

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

@@ -35,9 +35,9 @@ module RuboCop
         # value of @column_delta. A local variable fixes the problem.
         column_delta = @column_delta
 
-        fail CorrectionNotPossible if block_comment_within?(expr)
+        return if block_comment_within?(expr)
 
-        @corrections << lambda do |corrector|
+        lambda do |corrector|
           each_line(expr) do |line_begin_pos|
             autocorrect_line(corrector, line_begin_pos, expr, column_delta,
                              heredoc_ranges)

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

@@ -15,10 +15,10 @@ module RuboCop
 
         # Make the correction only if it doesn't change the AST for the buffer.
         if processed_source.ast != ProcessedSource.new(new_buffer_src).ast
-          fail CorrectionNotPossible
+          return
         end
 
-        @corrections << correction(node)
+        correction(node)
       end
 
       private

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Common functionality for checking length of classes and modules.
+    module ClassishLength
+      include CodeLength
+
+      private
+
+      def code_length(node)
+        body_line_numbers = line_range(node).to_a[1...-1]
+
+        target_line_numbers = body_line_numbers -
+                              line_numbers_of_inner_thing(node, :module) -
+                              line_numbers_of_inner_thing(node, :class)
+
+        target_line_numbers.reduce(0) do |length, line_number|
+          source_line = processed_source[line_number]
+          next length if irrelevant_line(source_line)
+          length + 1
+        end
+      end
+
+      def line_numbers_of_inner_thing(node, type)
+        line_numbers = Set.new
+
+        node.each_descendant(:module, type) do |inner_node|
+          line_range = line_range(inner_node)
+          line_numbers.merge(line_range)
+        end
+
+        line_numbers.to_a
+      end
+    end
+  end
+end

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

@@ -12,7 +12,7 @@ module RuboCop
         MSG_MISSING = 'Empty line missing at %s body %s.'
 
         def autocorrect(range)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             case style
             when :no_empty_lines then corrector.remove(range)
             when :empty_lines    then corrector.insert_before(range, "\n")

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

@@ -24,7 +24,7 @@ module RuboCop
 
         if kw_loc.line != end_loc.line &&
            kw_loc.column != end_loc.column + offset
-          add_offense(nil, end_loc,
+          add_offense(node, end_loc,
                       format(MSG, end_loc.line, end_loc.column,
                              alignment_base, kw_loc.line, kw_loc.column)) do
             opposite_style_detected
@@ -37,6 +37,19 @@ module RuboCop
       def parameter_name
         'AlignWith'
       end
+
+      def align(node, alignment_node)
+        source_buffer = node.loc.expression.source_buffer
+        begin_pos = node.loc.end.begin_pos
+        whitespace = Parser::Source::Range.new(source_buffer,
+                                               begin_pos - node.loc.end.column,
+                                               begin_pos)
+        return false unless whitespace.source.strip.empty?
+
+        column = alignment_node ? alignment_node.loc.expression.column : 0
+
+        ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+      end
     end
   end
 end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Common functionality for checking minimum body length.
+    module MinBodyLength
+      def min_body_length?(node)
+        (node.loc.end.line - node.loc.keyword.line) > min_body_length
+      end
+
+      def min_body_length
+        length = cop_config['MinBodyLength'] || 1
+        return length if length.is_a?(Integer) && length > 0
+
+        fail 'MinBodyLength needs to be a positive integer!'
+      end
+    end
+  end
+end

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

@@ -22,6 +22,7 @@ module RuboCop
       def visibility_and_def_on_same_line?(receiver, method_name, args)
         !receiver &&
           [:public, :protected, :private,
+           :private_class_method, :public_class_method,
            :module_function].include?(method_name) &&
           args.size == 1 && [:def, :defs].include?(args.first.type)
       end

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

@@ -11,7 +11,7 @@ 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].include?(t2.type)
+                      ![:tRPAREN, :tRBRACK, :tPIPE].include?(t2.type)
 
           add_offense(t1, t1.pos, format(MSG, kind(t1)))
         end
@@ -24,9 +24,7 @@ module RuboCop
       end
 
       def autocorrect(token)
-        @corrections << lambda do |corrector|
-          corrector.replace(token.pos, token.pos.source + ' ')
-        end
+        ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
       end
     end
   end

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

@@ -23,9 +23,7 @@ module RuboCop
       end
 
       def autocorrect(pos_before_punctuation)
-        @corrections << lambda do |corrector|
-          corrector.remove(pos_before_punctuation)
-        end
+        ->(corrector) { corrector.remove(pos_before_punctuation) }
       end
     end
   end

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

@@ -27,7 +27,7 @@ module RuboCop
       end
 
       def autocorrect(range)
-        @corrections << ->(corrector) { corrector.remove(range) }
+        ->(corrector) { corrector.remove(range) }
       end
 
       # Wraps info about the brackets. Makes it easy to check whether a token

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

@@ -6,7 +6,6 @@ module RuboCop
     module StatementModifier
       include IfNode
 
-      # TODO: Extremely ugly solution that needs lots of polish.
       def fit_within_line_as_modifier_form?(node)
         case node.loc.keyword.source
         when 'if'     then cond, body, _else = *node
@@ -19,8 +18,9 @@ module RuboCop
         body_length = body_length(body)
 
         return false if body_length == 0
-
         return false if cond.each_node.any?(&:lvasgn_type?)
+        return false if body_has_comment?(body)
+        return false if end_keyword_has_comment?(node)
 
         indentation = node.loc.keyword.column
         kw_length = node.loc.keyword.size
@@ -28,7 +28,8 @@ module RuboCop
         space = 1
         total = indentation + body_length + space + kw_length + space +
                 cond_length
-        total <= max_line_length && !body_has_comment?(body)
+
+        total <= max_line_length
       end
 
       def max_line_length
@@ -37,7 +38,7 @@ module RuboCop
       end
 
       def length(node)
-        node.loc.expression.source.lines.to_a.size
+        node.loc.expression.source.lines.grep(/\S/).size
       end
 
       def body_length(body)
@@ -49,9 +50,15 @@ module RuboCop
       end
 
       def body_has_comment?(body)
-        comment_lines = processed_source.comments.map(&:location).map(&:line)
-        body_line = body.loc.expression.line
-        comment_lines.include?(body_line)
+        comment_lines.include?(body.loc.expression.line)
+      end
+
+      def end_keyword_has_comment?(node)
+        comment_lines.include?(node.loc.end.line)
+      end
+
+      def comment_lines
+        @comment_lines ||= processed_source.comments.map(&:location).map(&:line)
       end
     end
   end

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

@@ -17,7 +17,7 @@ module RuboCop
       end
 
       def autocorrect(node)
-        @corrections << lambda do |corrector|
+        lambda do |corrector|
           replacement = node.loc.begin.is?('"') ? "'" : '"'
           corrector.replace(node.loc.begin, replacement)
           corrector.replace(node.loc.end, replacement)

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

@@ -26,9 +26,7 @@ module RuboCop
         def autocorrect(node)
           return if [:kwarg, :kwoptarg].include?(node.type)
 
-          @corrections << lambda do |corrector|
-            corrector.insert_before(node.loc.name, '_')
-          end
+          ->(corrector) { corrector.insert_before(node.loc.name, '_') }
         end
       end
     end

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

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of `count` on an
+      # `Enumerable` and change them to `size`.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].select { |e| e > 2 }.size
+      #   [1, 2, 3].reject { |e| e > 2 }.size
+      #   [1, 2, 3].select { |e| e > 2 }.length
+      #   [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? }
+      #
+      #   # 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? }
+      class Count < Cop
+        MSG = 'Use `count` instead of `%s...%s`.'
+
+        SELECTORS = [:reject, :select]
+        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
+
+          return if node.parent && node.parent.block_type?
+
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            begin_pos,
+                                            node.loc.expression.end_pos)
+
+          add_offense(node, range,
+                      format(MSG, first_method || second_method, third_method))
+        end
+
+        def autocorrect(node)
+          expression, first_method, second_method, = parse(node)
+
+          return if first_method == :reject || second_method == :reject
+
+          selector = if SELECTORS.include?(first_method)
+                       expression.loc.selector
+                     else
+                       expression.parent.loc.selector
+                     end
+
+          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')
+          end
+        end
+
+        private
+
+        def parse(node)
+          left, third_method = *node
+          expression, second_method = *left
+          _enumerable, first_method = *expression
+
+          [expression, first_method, second_method, third_method]
+        end
+      end
+    end
+  end
+end