rubocop 0.9.1 → 0.10.0

data/lib/rubocop/config.rb

@@ -25,11 +25,11 @@ module Rubocop
         hash = YAML.load_file(path)
 
         base_configs(path, hash['inherit_from']).reverse.each do |base_config|
+          if File.basename(base_config.loaded_path) == DOTFILE
+            make_excludes_absolute(base_config)
+          end
           base_config.each do |key, value|
             if value.is_a?(Hash)
-              if key == 'AllCops' && value['Excludes']
-                correct_relative_excludes(value, base_config, path)
-              end
               hash[key] = hash.has_key?(key) ? merge(value, hash[key]) : value
             end
           end
@@ -41,14 +41,14 @@ module Rubocop
         config
       end
 
-      def correct_relative_excludes(all_cops, base_config, path)
-        all_cops['Excludes'].map! do |exclude_elem|
-          if exclude_elem.is_a?(String) && exclude_elem =~ %r([^/].*/)
-            rel_path = relative_path(base_config.loaded_path,
-                                     File.dirname(path))
-            rel_path.to_s.sub(/#{DOTFILE}$/, '') + exclude_elem
-          else
-            exclude_elem
+      def make_excludes_absolute(config)
+        if config['AllCops'] && config['AllCops']['Excludes']
+          config['AllCops']['Excludes'].map! do |exclude_elem|
+            if exclude_elem.is_a?(String) && !exclude_elem.start_with?('/')
+              File.join(File.dirname(config.loaded_path), exclude_elem)
+            else
+              exclude_elem
+            end
           end
         end
       end
@@ -58,15 +58,15 @@ module Rubocop
         path_name.relative_path_from(Pathname.new(base)).to_s
       end
 
-      # Return a recursive merge of two hashes. That is, a normal hash
-      # merge, with the addition that any value that is a hash, and
-      # occurs in both arguments, will also be merged. And so on.
+      # Return an extended merge of two hashes. That is, a normal hash merge,
+      # with the addition that any value that is a hash, and occurs in both
+      # arguments (i.e., cop names), will also be merged.
       def merge(base_hash, derived_hash)
         result = {}
         base_hash.each do |key, value|
           result[key] = if derived_hash.has_key?(key)
                           if value.is_a?(Hash)
-                            merge(value, derived_hash[key])
+                            value.merge(derived_hash[key])
                           else
                             derived_hash[key]
                           end
@@ -107,6 +107,7 @@ module Rubocop
         if found_files.any? && found_files.last != config_file
           add_excludes_from_higher_level(config, load_file(found_files.last))
         end
+        make_excludes_absolute(config)
         merge_with_default(config, config_file)
       end
 
@@ -116,9 +117,7 @@ module Rubocop
           config['AllCops']['Excludes'] ||= []
           highest_config['AllCops']['Excludes'].each do |path|
             unless path.is_a?(Regexp) || path.start_with?('/')
-              diff_in_level = config.loaded_path.count('/') -
-                highest_config.loaded_path.count('/')
-              path = '../' * diff_in_level + path
+              path = File.join(File.dirname(highest_config.loaded_path), path)
             end
             config['AllCops']['Excludes'] << path
           end
@@ -209,10 +208,8 @@ module Rubocop
     end
 
     def file_to_exclude?(file)
-      relative_file_path = relative_path_to_loaded_dir(file)
-      patterns_to_exclude.any? do |pattern|
-        match_path?(pattern, relative_file_path)
-      end
+      file = File.join(Dir.pwd, file) unless file.start_with?('/')
+      patterns_to_exclude.any? { |pattern| match_path?(pattern, file) }
     end
 
     def patterns_to_include

data/lib/rubocop/config_store.rb

@@ -3,10 +3,8 @@
 module Rubocop
   # Handles chaching of configurations and association of inspected
   # ruby files to configurations.
-  module ConfigStore
-    module_function
-
-    def prepare
+  class ConfigStore
+    def initialize
       # @options_config stores a config that is specified in the command line.
       # This takes precedence over configs located in any directories
       @options_config = nil

data/lib/rubocop/cop/commissioner.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Commissioner class is responsible for processing the AST and delagating
+    # work to the specified cops.
+    class Commissioner < Parser::AST::Processor
+      attr_reader :errors
+
+      METHODS_NOT_DEFINED_IN_PARSER_PROCESSOR = [
+        :on_sym, :on_str, :on_int, :on_float
+      ]
+
+      def self.callback_methods
+        Parser::AST::Processor.instance_methods.select do |method|
+          method.to_s =~ /^on_/
+        end + METHODS_NOT_DEFINED_IN_PARSER_PROCESSOR
+      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 METHODS_NOT_DEFINED_IN_PARSER_PROCESSOR.include?(callback)
+          ''
+        else
+          'super'
+        end
+      end
+
+      def initialize(cops, options = {})
+        @cops = cops
+        @options = options
+        reset_errors
+      end
+
+      callback_methods.each do |callback|
+        class_eval <<-EOS
+          def #{callback}(node)
+            @cops.each do |cop|
+              if cop.respond_to?(:#{callback})
+                delegate_to(cop, :#{callback}, node)
+              end
+            end
+
+            #{call_super(callback)}
+          end
+        EOS
+      end
+
+      def investigate(processed_source)
+        reset_errors
+        invoke_cops_callback(processed_source)
+        process(processed_source.ast) if processed_source.ast
+        @cops.reduce([]) do |offences, cop|
+          offences.concat(cop.offences)
+          offences
+        end
+      end
+
+      private
+
+      def reset_errors
+        @errors = Hash.new { |hash, k| hash[k] = [] }
+      end
+
+      # There are cops that require their own custom processing.
+      # If they define the #investigate method all input parameters passed
+      # to the commissioner will be passed to the cop too in order to do
+      # its own processing.
+      def invoke_cops_callback(processed_source)
+        @cops.each do |cop|
+          if cop.respond_to?(:investigate)
+            cop.investigate(processed_source)
+          end
+        end
+      end
+
+      def delegate_to(cop, callback, node)
+        cop.send callback, node
+      rescue => e
+        if @options[:raise_error]
+          fail e
+        else
+          @errors[cop] << e
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/cop.rb

@@ -2,31 +2,33 @@
 
 module Rubocop
   module Cop
-    # A basic wrapper around Parser's tokens.
-    class Token
-      attr_reader :pos, :type, :text
-
-      def initialize(pos, type, text)
-        @pos, @type, @text = pos, type, text
-      end
-
-      def to_s
-        "[[#{@pos.line}, #{@pos.column}], #{@type}, #{@text.inspect}]"
-      end
-    end
-
     # A scaffold for concrete cops.
     #
     # The Cop class is meant to be extended.
     #
     # Cops track offences and can autocorrect them of the fly.
-    class Cop < Parser::Rewriter
+    #
+    # A commissioner object is responsible for traversing the AST and invoking
+    # the specific callbacks on each cop.
+    # If a cop needs to do its own processing of the AST or depends on
+    # something else it should define the #investigate method and do
+    # the processing there.
+    #
+    # @example
+    #
+    # class CustomCop < Cop
+    #   def investigate(processed_source)
+    #     # Do custom processing
+    #   end
+    # end
+    class Cop
       extend AST::Sexp
 
       attr_accessor :offences
       attr_accessor :debug
       attr_accessor :autocorrect
       attr_writer :disabled_lines
+      attr_reader :corrections
 
       @all = []
       @config = {}
@@ -67,20 +69,8 @@ module Rubocop
         @offences = []
         @debug = false
         @autocorrect = false
-      end
-
-      def inspect(source_buffer, source, tokens, ast, comments)
-        if autocorrect
-          filename = source_buffer.instance_variable_get(:@name)
-          new_source = rewrite(source_buffer, ast)
-          unless new_source == source_buffer.source
-            File.open(filename, 'w') { |f| f.write(new_source) }
-            source_buffer.instance_variable_set(:@source, nil)
-            source_buffer.read
-          end
-        else
-          process(ast)
-        end
+        @ignored_nodes = []
+        @corrections = []
       end
 
       def do_autocorrect(node)
@@ -90,9 +80,6 @@ module Rubocop
       def autocorrect_action(node)
       end
 
-      def ignore_node(node)
-      end
-
       def add_offence(severity, location, message)
         unless @disabled_lines && @disabled_lines.include?(location.line)
           message = debug ? "#{name}: #{message}" : message
@@ -104,8 +91,28 @@ module Rubocop
         self.class.cop_name
       end
 
+      def ignore_node(node)
+        @ignored_nodes << node
+      end
+
       private
 
+      def part_of_ignored_node?(node)
+        expression = node.loc.expression
+        @ignored_nodes.each do |ignored_node|
+          if ignored_node.loc.expression.begin_pos <= expression.begin_pos &&
+            ignored_node.loc.expression.end_pos >= expression.end_pos
+            return true
+          end
+        end
+
+        false
+      end
+
+      def ignored_node?(node)
+        @ignored_nodes.include?(node)
+      end
+
       def on_node(syms, sexp, excludes = [])
         yield sexp if Array(syms).include?(sexp.type)
 

data/lib/rubocop/cop/corrector.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # This class takes a source buffer and rewrite its source
+    # based on the different correction rules supplied.
+    #
+    # Important!
+    # The nodes modified by the corrections should be part of the
+    # AST of the source_buffer.
+    class Corrector
+      #
+      # @param source_buffer [Parser::Source::Buffer]
+      # @param corrections [Array(#call)]
+      #   Array of Objects that respond to #call. They will receive the
+      #   corrector itself and should use its method to modify the source.
+      #
+      # @example
+      #
+      # class AndOrCorrector
+      #   def initialize(node)
+      #     @node = node
+      #   end
+      #
+      #   def call(corrector)
+      #     replacement = (@node.type == :and ? '&&' : '||')
+      #     corrector.replace(@node.loc.operator, replacement)
+      #   end
+      # end
+      #
+      # corrections = [AndOrCorrector.new(node)]
+      # corrector = Corrector.new(source_buffer, corrections)
+      def initialize(source_buffer, corrections)
+        @source_buffer = source_buffer
+        @corrections = corrections
+        @source_rewriter = Parser::Source::Rewriter.new(source_buffer)
+      end
+
+      # Does the actual rewrite and returns string corresponding to
+      # the rewritten source.
+      #
+      # @return [String]
+      # TODO: Handle conflict exceptions raised from the Source::Rewriter
+      def rewrite
+        @corrections.each do |correction|
+          correction.call(self)
+        end
+
+        @source_rewriter.process
+      end
+
+      # Removes the source range.
+      #
+      # @param [Parser::Source::Range] range
+      def remove(range)
+        @source_rewriter.remove(range)
+      end
+
+      # Inserts new code before the given source range.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [String] content
+      def insert_before(range, content)
+        @source_rewriter.insert_before(range, content)
+      end
+
+      # Inserts new code after the given source range.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [String] content
+      def insert_after(range, content)
+        @source_rewriter.insert_after(range, content)
+      end
+
+      # Replaces the code of the source range `range` with `content`.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [String] content
+      def replace(range, content)
+        @source_rewriter.replace(range, content)
+      end
+    end
+  end
+end

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

@@ -11,17 +11,14 @@ module Rubocop
 
         def on_if(node)
           check(node)
-          super
         end
 
         def on_while(node)
           check(node)
-          super
         end
 
         def on_until(node)
           check(node)
-          super
         end
 
         private

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

@@ -0,0 +1,151 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks whether the end keywords are aligned properly for do
+      # end blocks.
+      #
+      # @example
+      #
+      #   variable = lambda do |i|
+      #     i
+      #   end
+      class BlockAlignment < Cop
+        MSG = 'end at %d, %d is not aligned with %s at %d, %d'
+
+        def initialize
+          super
+          @inspected_blocks = []
+        end
+
+        def on_block(node)
+          return if already_processed_node?(node)
+          method, = *node
+          start_node = method.loc.expression.source =~ /\n/ ? method : node
+          check_block_alignment(start_node.loc.expression, node.loc)
+        end
+
+        def on_and(node)
+          return if already_processed_node?(node)
+
+          _left, right = *node
+          if right.type == :block
+            check_block_alignment(node.loc.expression, right.loc)
+            @inspected_blocks << right
+          end
+        end
+
+        alias_method :on_or, :on_and
+
+        def on_lvasgn(node)
+          _, children = *node
+          process_block_assignment(node, children)
+        end
+
+        alias_method :on_ivasgn,   :on_lvasgn
+        alias_method :on_cvasgn,   :on_lvasgn
+        alias_method :on_gvasgn,   :on_lvasgn
+        alias_method :on_and_asgn, :on_lvasgn
+        alias_method :on_or_asgn,  :on_lvasgn
+
+        def on_casgn(node)
+          _, _, children = *node
+          process_block_assignment(node, children)
+        end
+
+        def on_op_asgn(node)
+          variable, _op, args = *node
+          process_block_assignment(variable, args)
+        end
+
+        def on_send(node)
+          _receiver, _method, *args = *node
+          process_block_assignment(node, args.last)
+        end
+
+        def on_masgn(node)
+          variables, args = *node
+          process_block_assignment(variables, args)
+        end
+
+        private
+
+        def process_block_assignment(begin_node, other_node)
+          return unless other_node
+
+          block_node = find_block_node(other_node)
+          return unless block_node.type == :block
+
+          # If the block is an argument in a function call, align end with
+          # the block itself, and not with the function.
+          if begin_node.type == :send
+            _receiver, method, *_args = *begin_node
+            begin_node = block_node if method.to_s =~ /^\w+$/
+          end
+
+          # Align with the expression that is on the same line
+          # where the block is defined
+          if begin_node.type != :mlhs && block_is_on_next_line?(begin_node,
+                                                                block_node)
+            return
+          end
+          return if already_processed_node?(block_node)
+
+          @inspected_blocks << block_node
+          check_block_alignment(begin_node.loc.expression, block_node.loc)
+        end
+
+        def find_block_node(node)
+          while [:send, :lvasgn].include?(node.type)
+            n = case node.type
+                when :send
+                  find_block_or_send_node(node) || break
+                when :lvasgn
+                  _variable, value = *node
+                  value
+                end
+            node = n if n
+          end
+          node
+        end
+
+        def find_block_or_send_node(send_node)
+          receiver, _method, args = *send_node
+          [receiver, args].find do |subnode|
+            subnode && [:block, :send].include?(subnode.type)
+          end
+        end
+
+        def check_block_alignment(start_loc, block_loc)
+          match = start_loc.source.match(/\n(\s*)((end)?\.\S+)\Z/)
+          if match
+            start_line = start_loc.line + start_loc.source.count("\n")
+            start_column = match.captures[0].length
+            start_source = match.captures[1]
+          else
+            start_line = start_loc.line
+            start_column = start_loc.column
+            start_source = start_loc.source.lines.to_a.first.chomp
+          end
+          end_loc = block_loc.end
+          if block_loc.begin.line != end_loc.line &&
+              start_column != end_loc.column
+            add_offence(:warning,
+                        end_loc,
+                        sprintf(MSG, end_loc.line, end_loc.column,
+                                start_source, start_line, start_column))
+          end
+        end
+
+        def already_processed_node?(node)
+          @inspected_blocks.include?(node)
+        end
+
+        def block_is_on_next_line?(begin_node, block_node)
+          begin_node.loc.line != block_node.loc.line
+        end
+      end
+    end
+  end
+end