rubocop 0.36.0 → 0.37.0

data/lib/rubocop/ast_node/builder.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   class Node

data/lib/rubocop/ast_node/sexp.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   # This module provides a shorthand method to create a {Node} like `AST::Sexp`.

data/lib/rubocop/ast_node/traversal.rb

@@ -0,0 +1,171 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  class Node
+    # Provides methods for traversing an AST.
+    # Does not transform an AST; for that, use Parser::AST::Processor.
+    # Override methods to perform custom processing. Remember to call `super`
+    # if you want to recursively process descendant nodes.
+    module Traversal
+      def walk(node)
+        return if node.nil?
+        send(:"on_#{node.type}", node)
+        nil
+      end
+
+      NO_CHILD_NODES    = [:true, :false, :nil, :int, :float, :complex,
+                           :rational, :str, :sym, :regopt, :self, :lvar,
+                           :ivar, :cvar, :gvar, :nth_ref, :back_ref, :cbase,
+                           :arg, :restarg, :blockarg, :shadowarg,
+                           :kwrestarg, :zsuper, :lambda, :redo, :retry].freeze
+      ONE_CHILD_NODE    = [:splat, :kwsplat, :block_pass, :not, :break, :next,
+                           :return, :preexe, :postexe, :match_current_line,
+                           :defined?, :arg_expr].freeze
+      MANY_CHILD_NODES  = [:dstr, :dsym, :xstr, :regexp, :array, :hash, :pair,
+                           :irange, :erange, :mlhs, :masgn, :or_asgn, :and_asgn,
+                           :undef, :alias, :args, :super, :yield, :or, :and,
+                           :while_post, :until_post, :iflipflop, :eflipflop,
+                           :match_with_lvasgn, :begin, :kwbegin].freeze
+      SECOND_CHILD_ONLY = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :optarg, :kwarg,
+                           :kwoptarg].freeze
+
+      NO_CHILD_NODES.each do |type|
+        module_eval("def on_#{type}(node); end")
+      end
+
+      ONE_CHILD_NODE.each do |type|
+        module_eval(<<-END)
+          def on_#{type}(node)
+            if (child = node.children[0])
+              send(:"on_\#{child.type}", child)
+            end
+          end
+        END
+      end
+
+      MANY_CHILD_NODES.each do |type|
+        module_eval(<<-END)
+          def on_#{type}(node)
+            node.children.each { |child| send(:"on_\#{child.type}", child) }
+            nil
+          end
+        END
+      end
+
+      SECOND_CHILD_ONLY.each do |type|
+        # Guard clause is for nodes nested within mlhs
+        module_eval(<<-END)
+          def on_#{type}(node)
+            if (child = node.children[1])
+              send(:"on_\#{child.type}", child)
+            end
+          end
+        END
+      end
+
+      def on_const(node)
+        return unless (child = node.children[0])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_casgn(node)
+        children = node.children
+        if (child = children[0]) # always const???
+          send(:"on_#{child.type}", child)
+        end
+        return unless (child = children[2])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_class(node)
+        children = node.children
+        child = children[0] # always const???
+        send(:"on_#{child.type}", child)
+        if (child = children[1])
+          send(:"on_#{child.type}", child)
+        end
+        return unless (child = children[2])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_def(node)
+        children = node.children
+        on_args(children[1])
+        return unless (child = children[2])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_send(node)
+        node.children.each_with_index do |child, i|
+          next if i == 1
+          send(:"on_#{child.type}", child) if child
+        end
+        nil
+      end
+
+      alias on_csend on_send
+
+      def on_op_asgn(node)
+        children = node.children
+        child = children[0]
+        send(:"on_#{child.type}", child)
+        child = children[2]
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_defs(node)
+        children = node.children
+        child = children[0]
+        send(:"on_#{child.type}", child)
+        on_args(children[2])
+        return unless (child = children[3])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_if(node)
+        children = node.children
+        child = children[0]
+        send(:"on_#{child.type}", child)
+        if (child = children[1])
+          send(:"on_#{child.type}", child)
+        end
+        return unless (child = children[2])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_while(node)
+        children = node.children
+        child = children[0]
+        send(:"on_#{child.type}", child)
+        return unless (child = children[1])
+        send(:"on_#{child.type}", child)
+      end
+
+      alias on_until  on_while
+      alias on_when   on_while
+      alias on_module on_while
+      alias on_sclass on_while
+
+      def on_block(node)
+        children = node.children
+        on_send(children[0])
+        on_args(children[1])
+        return unless (child = children[2])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_case(node)
+        node.children.each do |child|
+          send(:"on_#{child.type}", child) if child
+        end
+        nil
+      end
+
+      alias on_rescue  on_case
+      alias on_resbody on_case
+      alias on_ensure  on_case
+      alias on_for     on_case
+    end
+  end
+end

data/lib/rubocop/cached_data.rb

@@ -31,7 +31,10 @@ module RuboCop
                 end
 
       {
-        severity: offense.severity,
+        # Calling #to_s here ensures that the serialization works when using
+        # other json serializers such as Oj. Some of these gems do not call
+        # #to_s implicitly.
+        severity: offense.severity.to_s,
         location: {
           begin_pos: offense.location.begin_pos,
           end_pos: offense.location.end_pos

data/lib/rubocop/cli.rb

@@ -78,7 +78,7 @@ module RuboCop
       puts RuboCop::Version.version(false) if @options[:version]
       puts RuboCop::Version.version(true) if @options[:verbose_version]
       print_available_cops if @options[:show_cops]
-      fail Finished
+      raise Finished
     end
 
     def apply_default_formatter

data/lib/rubocop/config.rb

@@ -17,6 +17,27 @@ module RuboCop
     COMMON_PARAMS = %w(Exclude Include Severity
                        AutoCorrect StyleGuide Details).freeze
     KNOWN_RUBIES = [1.9, 2.0, 2.1, 2.2, 2.3].freeze
+    OBSOLETE_COPS = {
+      'Style/TrailingComma' =>
+        'The `Style/TrailingComma` cop no longer exists. Please use ' \
+        '`Style/TrailingCommaInLiteral` and/or ' \
+        '`Style/TrailingCommaInArguments` instead.',
+      'Rails/DefaultScope' =>
+        'The `Rails/DefaultScope` cop no longer exists.',
+      'Style/SingleSpaceBeforeFirstArg' =>
+        'The `Style/SingleSpaceBeforeFirstArg` cop has been renamed to ' \
+        '`Style/SpaceBeforeFirstArg. ',
+      'Lint/SpaceBeforeFirstArg' =>
+        'The `Lint/SpaceBeforeFirstArg` cop has been removed, since it was a ' \
+        'duplicate of `Style/SpaceBeforeFirstArg`. Please use ' \
+        '`Style/SpaceBeforeFirstArg` instead.',
+      'Style/SpaceAfterControlKeyword' =>
+        'The `Style/SpaceAfterControlKeyword` cop has been removed. Please ' \
+        'use `Style/SpaceAroundKeyword` instead.',
+      'Style/SpaceBeforeModifierKeyword' =>
+        'The `Style/SpaceBeforeModifierKeyword` cop has been removed. Please ' \
+        'use `Style/SpaceAroundKeyword` instead.'
+    }.freeze
 
     attr_reader :loaded_path
 
@@ -34,7 +55,7 @@ module RuboCop
         next unless self[key]['Exclude']
 
         self[key]['Exclude'].map! do |exclude_elem|
-          if exclude_elem.is_a?(String) && !exclude_elem.start_with?('/')
+          if exclude_elem.is_a?(String) && !absolute?(exclude_elem)
             File.expand_path(File.join(base_dir_for_path_parameters,
                                        exclude_elem))
           else
@@ -51,7 +72,7 @@ module RuboCop
       self['AllCops'] ||= {}
       excludes = self['AllCops']['Exclude'] ||= []
       highest_config['AllCops']['Exclude'].each do |path|
-        unless path.is_a?(Regexp) || path.start_with?('/')
+        unless path.is_a?(Regexp) || absolute?(path)
           path = File.join(File.dirname(highest_config.loaded_path), path)
         end
         excludes << path unless excludes.include?(path)
@@ -76,11 +97,7 @@ module RuboCop
     end
 
     def cop_enabled?(cop)
-      department = if cop.respond_to?(:cop_type)
-                     cop.cop_type.to_s.capitalize
-                   else
-                     cop.split('/')[-2]
-                   end
+      department = cop.cop_type.to_s.capitalize!
 
       if (dept_config = self[department])
         return false if dept_config['Enabled'] == false
@@ -182,9 +199,9 @@ module RuboCop
     def warn_about_unrecognized_cops(invalid_cop_names)
       invalid_cop_names.each do |name|
         if name == 'Syntax'
-          fail ValidationError,
-               "configuration for Syntax cop found in #{loaded_path}\n" \
-               'This cop cannot be configured.'
+          raise ValidationError,
+                "configuration for Syntax cop found in #{loaded_path}\n" \
+                'This cop cannot be configured.'
         end
 
         # There could be a custom cop with this name. If so, don't warn
@@ -197,7 +214,7 @@ module RuboCop
 
     def validate_section_presence(name)
       return unless key?(name) && self[name].nil?
-      fail ValidationError, "empty section #{name} found in #{loaded_path}"
+      raise ValidationError, "empty section #{name} found in #{loaded_path}"
     end
 
     def validate_parameter_names(valid_cop_names)
@@ -222,7 +239,7 @@ module RuboCop
         msg = "invalid EnforcedStyle '#{style}' for #{name} found in " \
               "#{loaded_path}\n" \
               "Valid choices are: #{valid.join(', ')}"
-        fail ValidationError, msg
+        raise ValidationError, msg
       end
     end
 
@@ -239,19 +256,18 @@ module RuboCop
 
     def check_obsolete_parameter(cop, parameter, alternative = nil)
       if key?(cop) && self[cop].key?(parameter)
-        fail ValidationError, "obsolete parameter #{parameter} (for #{cop}) " \
+        raise ValidationError, "obsolete parameter #{parameter} (for #{cop}) " \
                               "found in #{loaded_path}" \
                               "#{"\n" if alternative}#{alternative}"
       end
     end
 
     def reject_obsolete_cops
-      if key?('Style/TrailingComma')
-        fail ValidationError, 'The `Style/TrailingComma` cop no longer ' \
-                              'exists. Please use ' \
-                              '`Style/TrailingCommaInLiteral` and/or ' \
-                              "`Style/TrailingCommaInArguments` instead.\n" \
-                              "(configuration found in #{loaded_path})"
+      OBSOLETE_COPS.each do |cop_name, message|
+        next unless key?(cop_name) || key?(cop_name.split('/').last)
+        message += "\n(obsolete configuration found in #{loaded_path}, please" \
+                   ' update it)'
+        raise ValidationError, message
       end
     end
 
@@ -260,7 +276,7 @@ module RuboCop
       return unless target
 
       unless KNOWN_RUBIES.include?(target)
-        fail ValidationError, "Unknown Ruby version #{target.inspect} found " \
+        raise ValidationError, "Unknown Ruby version #{target.inspect} found " \
                               'in `TargetRubyVersion` parameter (in ' \
                               "#{loaded_path}).\nKnown versions: " \
                               "#{KNOWN_RUBIES.join(', ')}"

data/lib/rubocop/config_loader.rb

@@ -150,7 +150,7 @@ module RuboCop
         puts "configuration from #{absolute_path}" if debug?
 
         unless hash.is_a?(Hash)
-          fail(TypeError, "Malformed configuration in #{absolute_path}")
+          raise(TypeError, "Malformed configuration in #{absolute_path}")
         end
 
         hash
@@ -179,8 +179,8 @@ module RuboCop
       def resolve_inheritance_from_gems(hash, gems)
         (gems || {}).each_pair do |gem_name, config_path|
           if gem_name == 'rubocop'
-            fail ArgumentError,
-                 "can't inherit configuration from the rubocop gem"
+            raise ArgumentError,
+                  "can't inherit configuration from the rubocop gem"
           end
 
           hash['inherit_from'] = Array(hash['inherit_from'])
@@ -214,8 +214,9 @@ module RuboCop
       end
 
       def old_auto_config_file_warning
-        fail RuboCop::Error, 'rubocop-todo.yml is obsolete; it must be called' \
-                             " #{AUTO_GENERATED_FILE} instead"
+        raise RuboCop::Error,
+              'rubocop-todo.yml is obsolete; it must be called' \
+              " #{AUTO_GENERATED_FILE} instead"
       end
     end
   end

data/lib/rubocop/cop/commissioner.rb

@@ -5,42 +5,43 @@ module RuboCop
   module Cop
     # Commissioner class is responsible for processing the AST and delegating
     # work to the specified cops.
-    class Commissioner < Parser::AST::Processor
+    class Commissioner
+      include RuboCop::Node::Traversal
+
       attr_reader :errors
 
       def self.callback_methods
-        Parser::Meta::NODE_TYPES.map { |type| "on_#{type}" }
+        Parser::Meta::NODE_TYPES.map { |type| :"on_#{type}" }
       end
 
-      # Methods that are not defined in Parser::AST::Processor
-      # won't have a `super` to call. So we should not attempt
-      # to invoke `super` when defining them.
-      def self.call_super(callback)
-        if Parser::AST::Processor.method_defined?(callback)
-          'super'
-        else
-          ''
-        end
-      end
-
-      def initialize(cops, forces, options = {})
+      def initialize(cops, forces = [], options = {})
         @cops = cops
         @forces = forces
         @options = options
+        @callbacks = {}
+
         reset_errors
       end
 
+      # In the dynamically generated methods below, a call to `super` is used
+      # to continue iterating over the children of a node.
+      # However, if we know that a certain node type (like `int`) never has
+      # child nodes, there is no reason to pay the cost of calling `super`.
+      no_child_callbacks = Node::Traversal::NO_CHILD_NODES.map do |type|
+        :"on_#{type}"
+      end
+
       callback_methods.each do |callback|
+        next unless RuboCop::Node::Traversal.method_defined?(callback)
         class_eval <<-EOS, __FILE__, __LINE__
           def #{callback}(node)
-            @cops.each do |cop|
-              next unless cop.respond_to?(:#{callback})
+            @callbacks[:#{callback}].each do |cop|
               with_cop_error_handling(cop) do
                 cop.send(:#{callback}, node)
               end
             end
 
-            #{call_super(callback)}
+            #{!no_child_callbacks.include?(callback) && 'super'}
           end
         EOS
       end
@@ -48,10 +49,11 @@ module RuboCop
       def investigate(processed_source)
         reset_errors
         remove_irrelevant_cops(processed_source.buffer.name)
+        setup_callbacks
         prepare(processed_source)
         invoke_custom_processing(@cops, processed_source)
         invoke_custom_processing(@forces, processed_source)
-        process(processed_source.ast) if processed_source.ast
+        walk(processed_source.ast) if processed_source.ast
         @cops.flat_map(&:offenses)
       end
 
@@ -65,6 +67,13 @@ module RuboCop
         @cops.reject! { |cop| cop.excluded_file?(filename) }
       end
 
+      def setup_callbacks
+        @callbacks.clear
+        self.class.callback_methods.each do |method|
+          @callbacks[method] = @cops.select { |cop| cop.respond_to?(method) }
+        end
+      end
+
       # TODO: Bad design.
       def prepare(processed_source)
         @cops.each { |cop| cop.processed_source = processed_source }

data/lib/rubocop/cop/cop.rb

@@ -32,8 +32,9 @@ module RuboCop
         case found_ns.size
         when 0 then name # No namespace found. Deal with it later in caller.
         when 1 then cop_name_with_namespace(name, origin, basename, found_ns[0])
-        else fail AmbiguousCopName, "Ambiguous cop name `#{basename}` used in" \
-                                    "#{origin} needs namespace qualifier."
+        else raise AmbiguousCopName,
+                   "Ambiguous cop name `#{basename}` used in" \
+                   "#{origin} needs namespace qualifier."
         end
       end
 
@@ -95,11 +96,11 @@ module RuboCop
       end
 
       def self.cop_name
-        @cop_name ||= name.to_s.split('::').last(2).join('/')
+        @cop_name ||= name.split('::').last(2).join('/')
       end
 
       def self.cop_type
-        name.to_s.split('::')[-2].downcase.to_sym
+        @cop_type ||= name.split('::')[-2].downcase.to_sym
       end
 
       def self.lint?
@@ -128,7 +129,7 @@ module RuboCop
       end
 
       def cop_config
-        @config.for_cop(self)
+        @cop_config ||= @config.for_cop(self)
       end
 
       def debug?
@@ -201,7 +202,7 @@ module RuboCop
       end
 
       def cop_name
-        self.class.cop_name
+        @cop_name ||= self.class.cop_name
       end
 
       alias name cop_name