rubocop 0.24.1 → 0.25.0

data/lib/rubocop/cop/{style → metrics}/parameter_lists.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Metrics
       # This cop checks for methods with too many parameters.
       # The maximum number of parameters in configurable.
       # On Ruby 2.0+ keyword arguments can optionally

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

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop tries to produce a complexity score that's a measure of the
+      # complexity the reader experiences when looking at a method. For that
+      # reason it considers `when` nodes as something that doesn't add as much
+      # complexity as an `if` or a `&&`. Except if it's one of those special
+      # `case`/`when` constructs where there's no expression after `case`. Then
+      # the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when`
+      # nodes count. In contrast to the CyclomaticComplexity cop, this cop
+      # considers `else` nodes as adding complexity.
+      #
+      # @example
+      #
+      #   def my_method                   # 1
+      #     if cond                       # 1
+      #       case var                    # 2 (0.8 + 4 * 0.2, rounded)
+      #       when 1 then func_one
+      #       when 2 then func_two
+      #       when 3 then func_three
+      #       when 4..10 then func_other
+      #       end
+      #     else                          # 1
+      #       do_something until a && b   # 2
+      #     end                           # ===
+      #   end                             # 7 complexity points
+      class PerceivedComplexity < Cop
+        include MethodComplexity
+        include IfNode
+
+        MSG = 'Perceived complexity for %s is too high. [%d/%d]'
+        COUNTED_NODES = [:if, :case, :while, :until, :for, :rescue, :and, :or]
+
+        private
+
+        def complexity_score_for(node)
+          case node.type
+          when :case
+            expression, *whens, _else = *node
+            # If cond is nil, that means each when has an expression that
+            # evaluates to true or false. It's just an alternative to
+            # if/elsif/elsif... so the when nodes count.
+            if expression.nil?
+              whens.length
+            else
+              # Otherwise, the case node gets 0.8 complexity points and each
+              # when gets 0.2.
+              (0.8 + 0.2 * whens.length).round
+            end
+          when :if
+            if_else?(node) && !elsif?(node) ? 2 : 1
+          else
+            1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,14 +10,22 @@ module RuboCop
         c = correction(node)
         new_source = rewrite_node(node)
 
-        # Make the correction only if it doesn't change the AST.
-        if node != ProcessedSource.new(new_source).ast
+        # Make the correction only if it doesn't change the AST. Regenerate the
+        # AST for `node` so we get it without context. Otherwise the comparison
+        # could be misleading.
+        if ast_for(node.loc.expression.source) != ast_for(new_source)
           fail CorrectionNotPossible
         end
 
         @corrections << c
       end
 
+      private
+
+      def ast_for(source)
+        ProcessedSource.new(source).ast
+      end
+
       def rewrite_node(node)
         processed_source = ProcessedSource.new(node.loc.expression.source)
         c = correction(processed_source.ast)

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

@@ -14,12 +14,11 @@ module RuboCop
         cop_config['CountComments']
       end
 
-      def check(node, *_)
+      def check_code_length(node, *_)
         length = code_length(node)
         return unless length > max_length
 
-        add_offense(node, :keyword, format(message, length,
-                                           max_length)) do
+        add_offense(node, :keyword, message(length, max_length)) do
           self.max = length
         end
       end

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

@@ -10,35 +10,21 @@ module RuboCop
       SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
       CAMEL_CASE = /^@?[a-z][\da-zA-Z]+[!?=]?$/
 
-      def check(node, range)
-        return unless range
-
-        name = range.source.to_sym
+      def check_name(node, name, name_range)
         return if operator?(name)
 
-        if matches_config?(name)
+        if valid_name?(name)
           correct_style_detected
         else
-          add_offense(node, range, message(style)) do
+          add_offense(node, name_range, message(style)) do
             opposite_style_detected
           end
         end
       end
 
-      def matches_config?(name)
-        name =~ (style == :snake_case ? SNAKE_CASE : CAMEL_CASE)
-      end
-
-      # Returns a range containing the method name after the given regexp and
-      # a dot.
-      def after_dot(node, method_name_length, regexp)
-        expr = node.loc.expression
-        match = /\A#{regexp}\s*\.\s*/.match(expr.source)
-        return unless match
-        offset = match[0].length
-        begin_pos = expr.begin_pos + offset
-        Parser::Source::Range.new(expr.source_buffer, begin_pos,
-                                  begin_pos + method_name_length)
+      def valid_name?(name)
+        pattern = (style == :snake_case ? SNAKE_CASE : CAMEL_CASE)
+        name.match(pattern)
       end
     end
   end

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

@@ -10,7 +10,7 @@ module RuboCop
 
       private
 
-      def check(node, *_)
+      def check_offset_of_node(node)
         check_offset(node, node.loc.keyword.source, 0)
       end
 

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

@@ -5,7 +5,7 @@ module RuboCop
     # Common functionality for checking if nodes.
     module IfNode
       def modifier_if?(node)
-        node.loc.end.nil?
+        node.loc.respond_to?(:end) && node.loc.end.nil?
       end
 
       def ternary_op?(node)

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # This module handles measurement and reporting of complexity in methods.
+    module MethodComplexity
+      include OnMethod
+      include ConfigurableMax
+
+      private
+
+      def on_method(node, method_name, _args, _body)
+        max = cop_config['Max']
+        complexity = complexity(node)
+        return unless complexity > max
+
+        add_offense(node, :keyword,
+                    format(self.class::MSG, method_name, complexity, max)) do
+          self.max = complexity
+        end
+      end
+
+      def complexity(node)
+        c = 1
+        on_node(self.class::COUNTED_NODES, node) do |n|
+          c += complexity_score_for(n)
+        end
+        c
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module RuboCop
     # Some common code shared between FavorUnlessOverNegatedIf and
     # FavorUntilOverNegatedWhile.
     module NegativeConditional
-      def check(node)
+      def check_negative_conditional(node)
         condition, _body, _rest = *node
 
         # Look at last expression of contents if there's a parenthesis

data/lib/rubocop/cop/mixin/{check_methods.rb → on_method.rb}

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     # Common functionality for checking instance methods and singeton methods.
-    module CheckMethods
+    module OnMethod
       def on_def(node)
         method_name, args, body = *node
-        check(node, method_name, args, body)
+        on_method(node, method_name, args, body)
       end
 
       def on_defs(node)
         _scope, method_name, args, body = *node
-        check(node, method_name, args, body)
+        on_method(node, method_name, args, body)
       end
 
       private

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking if and unless statements.
+    module OnNormalIfUnless
+      include IfNode
+
+      def on_if(node)
+        invoke_hook_for_normal_if_unless(node)
+      end
+
+      def on_unless(node)
+        invoke_hook_for_normal_if_unless(node)
+      end
+
+      def invoke_hook_for_normal_if_unless(node)
+        # We won't check modifier or ternary conditionals.
+        return if modifier_if?(node) || ternary_op?(node)
+        on_normal_if_unless(node)
+      end
+    end
+  end
+end

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

@@ -10,7 +10,8 @@ module RuboCop
       end
 
       def process(node, *types)
-        on_percent_literal(node, types) if percent_literal?(node)
+        return unless percent_literal?(node) && types.include?(type(node))
+        on_percent_literal(node)
       end
 
       def begin_source(node)

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

@@ -3,16 +3,16 @@
 module RuboCop
   module Cop
     # Common functionality for checking for spaces inside various
-    # kinds of parentheses.
+    # kinds of brackets.
     module SpaceInside
       include SurroundingSpace
       MSG = 'Space inside %s detected.'
 
       def investigate(processed_source)
         @processed_source = processed_source
-        left, right, kind = specifics
+        brackets = Brackets.new(*specifics)
         processed_source.tokens.each_cons(2) do |t1, t2|
-          next unless t1.type == left || t2.type == right
+          next unless brackets.left_side?(t1) || brackets.right_side?(t2)
 
           # If the second token is a comment, that means that a line break
           # follows, and that the rules for space inside don't apply.
@@ -22,13 +22,42 @@ module RuboCop
           range = Parser::Source::Range.new(processed_source.buffer,
                                             t1.pos.end_pos,
                                             t2.pos.begin_pos)
-          add_offense(range, range, format(MSG, kind))
+          add_offense(range, range, format(MSG, brackets.kind))
         end
       end
 
       def autocorrect(range)
         @corrections << ->(corrector) { corrector.remove(range) }
       end
+
+      # Wraps info about the brackets. Makes it easy to check whether a token
+      # is one of the brackets.
+      #
+      # @example Parentheses `()`
+      #   Brackets.new(:tLPAREN, :tRPAREN, 'parentheses')
+      #
+      # @example Square brackets `[]`
+      #   Brackets.new([:tLBRACK, :tLBRACK2], :tRBRACK, 'square brackets')
+      #
+      class Brackets
+        attr_reader :kind
+
+        def initialize(left, right, kind)
+          @left_side_types = [left].flatten
+          @right_side_type = right
+          @kind = kind
+        end
+
+        def left_side?(token)
+          # Left side bracket has to be able to match multiple types
+          # (e.g. :tLBRACK and :tLBRACK2)
+          @left_side_types.include?(token.type)
+        end
+
+        def right_side?(token)
+          @right_side_type == token.type
+        end
+      end
     end
   end
 end

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

@@ -7,14 +7,14 @@ module RuboCop
       include IfNode
 
       # TODO: Extremely ugly solution that needs lots of polish.
-      def check(sexp, comments)
-        case sexp.loc.keyword.source
-        when 'if'     then cond, body, _else = *sexp
-        when 'unless' then cond, _else, body = *sexp
-        else               cond, body = *sexp
+      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
 
-        return false if length(sexp) > 3
+        return false if length(node) > 3
 
         body_length = body_length(body)
 
@@ -24,22 +24,22 @@ module RuboCop
           return false
         end
 
-        indentation = sexp.loc.keyword.column
-        kw_length = sexp.loc.keyword.size
+        indentation = node.loc.keyword.column
+        kw_length = node.loc.keyword.size
         cond_length = cond.loc.expression.size
         space = 1
         total = indentation + body_length + space + kw_length + space +
           cond_length
-        total <= max_line_length && !body_has_comment?(body, comments)
+        total <= max_line_length && !body_has_comment?(body)
       end
 
       def max_line_length
         cop_config && cop_config['MaxLineLength'] ||
-        config.for_cop('Style/LineLength')['Max']
+        config.for_cop('Metrics/LineLength')['Max']
       end
 
-      def length(sexp)
-        sexp.loc.expression.source.lines.to_a.size
+      def length(node)
+        node.loc.expression.source.lines.to_a.size
       end
 
       def body_length(body)
@@ -50,8 +50,8 @@ module RuboCop
         end
       end
 
-      def body_has_comment?(body, comments)
-        comment_lines = comments.map(&:location).map(&:line)
+      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)
       end

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

@@ -7,6 +7,10 @@ module RuboCop
     # adding offenses for the faulty string nodes, and with filtering out
     # nodes.
     module StringHelp
+      # Regex matches IF there is a ' or there is a \\ in the string that is
+      # not preceeded/followed by another \\ (e.g. "\\x34") but not "\\\\".
+      ESCAPED_CHAR_REGEXP = /(?<! \\) \\{2}* \\ (?! \\)/x
+
       def on_str(node)
         # Constants like __FILE__ are handled as strings,
         # but don't respond to begin.

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

@@ -8,6 +8,7 @@ module RuboCop
         between = Parser::Source::Range.new(t1.pos.source_buffer,
                                             t1.pos.end_pos,
                                             t2.pos.begin_pos).source
+
         # Check if the range between the tokens starts with a space. It can
         # contain other characters, e.g. a unary plus, but it must start with
         # space.

data/lib/rubocop/cop/rails/delegate.rb

@@ -29,13 +29,13 @@ module RuboCop
       #     foo.bar
       #   end
       class Delegate < Cop
-        include CheckMethods
+        include OnMethod
 
         MSG = 'Use `delegate` to define delegations.'
 
         private
 
-        def check(node, method_name, args, body)
+        def on_method(node, method_name, args, body)
           return unless trivial_delegate?(method_name, args, body)
           return if private_or_protected_delegation(node)
           add_offense(node, :keyword, MSG)

data/lib/rubocop/cop/rails/output.rb

@@ -14,8 +14,10 @@ module RuboCop
                      :pretty_print]
 
         def on_send(node)
-          receiver, method_name, *_args = *node
-          return unless receiver.nil? && BLACKLIST.include?(method_name)
+          receiver, method_name, *args = *node
+          return unless receiver.nil? &&
+                        !args.empty? &&
+                        BLACKLIST.include?(method_name)
 
           add_offense(node, :selector)
         end