ruby-lint 0.0.5 → 0.9.0

data/lib/ruby-lint/definitions/rails/abstract_controller.rb

@@ -479,3 +479,4 @@ RubyLint::GlobalScope.definitions.define_constant('AbstractController::ViewPaths
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'AbstractController').deep_freeze

data/lib/ruby-lint/definitions/rails/action_controller.rb

@@ -5651,3 +5651,4 @@ RubyLint::GlobalScope.definitions.define_constant('ActionController::UrlGenerati
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'ActionController').deep_freeze

data/lib/ruby-lint/definitions/rails/action_dispatch.rb

@@ -2936,3 +2936,4 @@ RubyLint::GlobalScope.definitions.define_constant('ActionDispatch::TestResponse'
   klass.define_instance_method('unprocessable?')
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'ActionDispatch').deep_freeze

data/lib/ruby-lint/definitions/rails/action_mailer.rb

@@ -1743,3 +1743,4 @@ RubyLint::GlobalScope.definitions.define_constant('ActionMailer::VERSION') do |k
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'ActionMailer').deep_freeze

data/lib/ruby-lint/definitions/rails/action_pack.rb

@@ -22,3 +22,4 @@ RubyLint::GlobalScope.definitions.define_constant('ActionPack::VERSION') do |kla
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'ActionPack').deep_freeze

data/lib/ruby-lint/definitions/rails/action_view.rb

@@ -7392,3 +7392,4 @@ RubyLint::GlobalScope.definitions.define_constant('ActionView::WrongEncodingErro
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'ActionView').deep_freeze

data/lib/ruby-lint/definitions/rails/active_model.rb

@@ -1578,3 +1578,4 @@ RubyLint::GlobalScope.definitions.define_constant('ActiveModel::Validator') do |
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'ActiveModel').deep_freeze

data/lib/ruby-lint/definitions/rails/active_record.rb

@@ -11793,3 +11793,4 @@ RubyLint::GlobalScope.definitions.define_constant('ActiveRecord::WrappedDatabase
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'ActiveRecord').deep_freeze

data/lib/ruby-lint/definitions/rails/active_support.rb

@@ -6019,3 +6019,4 @@ RubyLint::GlobalScope.definitions.define_constant('ActiveSupport::XmlMini_REXML'
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'ActiveSupport').deep_freeze

data/lib/ruby-lint/definitions/rails/arel.rb

@@ -3555,3 +3555,4 @@ RubyLint::GlobalScope.definitions.define_constant('Arel::WindowPredications') do
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'Arel').deep_freeze

data/lib/ruby-lint/definitions/rails/rails.rb

@@ -3288,3 +3288,4 @@ RubyLint::GlobalScope.definitions.define_constant('Rails::WelcomeController') do
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'Rails').deep_freeze

data/lib/ruby-lint/definitions/rails/sprockets.rb

@@ -3737,3 +3737,4 @@ RubyLint::GlobalScope.definitions.define_constant('Sprockets::YUICompressor') do
   end
 end
 
+RubyLint::GlobalScope.definitions.lookup(:const, 'Sprockets').deep_freeze

data/lib/ruby-lint/file_scanner.rb

@@ -44,6 +44,8 @@ module RubyLint
         paths   = Dir.glob(glob_pattern(segment))
       end
 
+      paths.map! { |path| File.expand_path(path) }
+
       ignore.each do |pattern|
         paths.reject! do |path|
           path.include?(pattern)

data/lib/ruby-lint/iterator.rb

@@ -50,7 +50,13 @@ module RubyLint
   # the specified node (`throw` calls bubble up regardless of `catch` calls,
   # unlike when using `begin/rescue`).
   #
+  # @!attribute [r] arity_cache Hash containing the amount of arguments for
+  #  each method.
+  #  @return [Hash]
+  #
   class Iterator
+    attr_reader :arity_cache
+
     ##
     # @param [Hash] options Hash containing custom options to set for the
     #  iterator.
@@ -61,6 +67,8 @@ module RubyLint
       end
 
       after_initialize if respond_to?(:after_initialize)
+
+      @arity_cache = {}
     end
 
     ##
@@ -72,8 +80,9 @@ module RubyLint
     def iterate(node)
       return unless node.is_a?(AST::Node)
 
-      before, after = callback_names(node)
-      skip_node     = catch :skip_child_nodes do
+      before    = :"on_#{node.type}"
+      after     = :"after_#{node.type}"
+      skip_node = catch :skip_child_nodes do
         execute_callback(before, node)
       end
 
@@ -104,17 +113,17 @@ module RubyLint
     # @param [Array] args Arguments to pass to the callback method.
     #
     def execute_callback(name, *args)
-      send(name, *args) if respond_to?(name)
-    end
+      return unless respond_to?(name)
 
-    ##
-    # Returns an array containin the callback names for the specified node.
-    #
-    # @param [RubyLint::Node] node
-    # @return [Array]
-    #
-    def callback_names(node)
-      return ["on_#{node.type}", "after_#{node.type}"]
+      unless arity_cache.key?(name)
+        arity_cache[name] = method(name).arity
+      end
+
+      if arity_cache[name] == 0
+        send(name)
+      else
+        send(name, *args)
+      end
     end
   end # Iterator
 end # RubyLint

data/lib/ruby-lint/method_call_info.rb

@@ -0,0 +1,31 @@
+module RubyLint
+  ##
+  # The MethodCallInfo class stores basic information about method calls such
+  # as the definition of the method and location information of the method
+  # call.
+  #
+  # @!attribute [r] definition
+  #  @return [RubyLint::Definition::RubyMethod]
+  #
+  # @!attribute [r] line
+  #  @return [Numeric] The line of the method call.
+  #
+  # @!attribute [r] column
+  #  @return [Numeric] The column of the method call.
+  #
+  # @!attribute [r] file
+  #  @return [String] The file of the method call.
+  #
+  class MethodCallInfo
+    attr_reader :definition, :line, :column, :file
+
+    ##
+    # @param [Hash] options
+    #
+    def initialize(options = {})
+      options.each do |key, value|
+        instance_variable_set("@#{key}", value) if respond_to?(key)
+      end
+    end
+  end # MethodCallInfo
+end # RubyLint

data/lib/ruby-lint/node_hash.rb

@@ -0,0 +1,105 @@
+module RubyLint
+  ##
+  # The NodeHash class is used to store information about {RubyLint::AST::Node}
+  # instances based on their SHA1 hashes. It's primarily used by
+  # {RubyLint::Runner} to store nodes and their associated comments.
+  #
+  # @!attribute [r] hash
+  #  @return [Hash]
+  #
+  class NodeHash
+    attr_reader :hash
+
+    ##
+    # Creates a new instance from a regular Hash.
+    #
+    # @param [Hash] hash
+    # @return [RubyLint::NodeHash]
+    #
+    def self.from_hash(hash)
+      converted = {}
+
+      hash.each do |key, value|
+        converted[key.sha1] = value
+      end
+
+      return new(converted)
+    end
+
+    ##
+    # @param [Hash] hash
+    #
+    def initialize(hash = {})
+      @hash = hash
+    end
+
+    ##
+    # Returns the value associated with the given node.
+    #
+    # @param [RubyLint::AST::Node] node
+    # @return [Mixed]
+    #
+    def [](node)
+      return @hash[node.sha1]
+    end
+
+    ##
+    # Checks if there's a value stored for the node.
+    #
+    # @param [RubyLint::AST::Node] node
+    # @return [TrueClass|FalseClass]
+    #
+    def key?(node)
+      return @hash.key?(node.sha1)
+    end
+
+    ##
+    # Sets a value for the given node.
+    #
+    # @param [RubyLint::AST::Node] node
+    # @param [Mixed] value
+    #
+    def []=(node, value)
+      return @hash[node.sha1] = value
+    end
+
+    ##
+    # @return [Array]
+    #
+    def keys
+      return @hash.keys
+    end
+
+    ##
+    # @return [Array]
+    #
+    def values
+      return @hash.values
+    end
+
+    ##
+    # @return [Array]
+    #
+    def to_a
+      return @hash.to_a
+    end
+
+    ##
+    # Merges the values of another NodeHash into the current one.
+    #
+    # @param [RubyLint::NodeHash] other
+    #
+    def merge!(other)
+      @hash.merge!(other.hash)
+    end
+
+    ##
+    # Merges a regular Hash into the current NodeHash.
+    #
+    # @param [Hash] hash
+    #
+    def merge_hash!(hash)
+      merge!(self.class.from_hash(hash))
+    end
+  end # NodeHash
+end # RubyLint

data/lib/ruby-lint/parser.rb

@@ -39,11 +39,13 @@ module RubyLint
       buffer        = ::Parser::Source::Buffer.new(file, line)
       buffer.source = code
       ast, comments = internal_parser.parse_with_comments(buffer)
-      associator    = ::Parser::Source::Comment::Associator.new(comments, ast)
+      associator    = ::Parser::Source::Comment::Associator.new(ast, comments)
 
       internal_parser.reset
 
-      return AST::Node.new(:root, [ast]), associator.associate
+      root = AST::Node.new(:root, [ast], :location => ast.location)
+
+      return root, associator.associate
     end
   end # Parser
 end # RubyLint

data/lib/ruby-lint/runner.rb

@@ -7,14 +7,20 @@ module RubyLint
   # @!attribute [r] configuration
   #  @return [RubyLint::Configuration]
   #
+  # @!attribute [r] cache
+  #  @return [RubyLint::Cache]
+  #
   class Runner
-    attr_reader :configuration
+    attr_reader :configuration, :cache
 
     ##
     # @param [RubyLint::Configuration] configuration
     #
     def initialize(configuration)
-      @configuration   = configuration
+      @configuration = configuration
+      @cache         = Cache.new(configuration.cache_directory)
+
+      @cache.create_directory! if configuration.enable_cache
     end
 
     ##
@@ -77,7 +83,9 @@ module RubyLint
     # @return [Array]
     #
     def parse_file(parser, file)
-      return parser.parse(File.read(file), file)
+      ast, comments = parser.parse(File.read(file), file)
+
+      return ast, NodeHash.from_hash(comments)
     end
 
     ##
@@ -98,6 +106,10 @@ module RubyLint
     # @return [Array]
     #
     def process_external_files(root_ast)
+      if cached_values = get_cache(root_ast)
+        return cached_values
+      end
+
       loader = FileLoader.new(
         :directories  => configuration.directories,
         :ignore_paths => configuration.ignore_paths,
@@ -105,16 +117,21 @@ module RubyLint
       )
 
       nodes    = []
-      comments = {}
+      mtimes   = {}
+      comments = NodeHash.new
 
       loader.iterate(root_ast)
 
-      loader.nodes.each do |(ast, cmts)|
+      loader.nodes.each do |(ast, comment_associations)|
         nodes << ast
 
-        comments.merge!(cmts)
+        mtimes[ast.file] = File.mtime(ast.file) if configuration.enable_cache
+
+        comments.merge_hash!(comment_associations)
       end
 
+      set_cache(root_ast, nodes, comments, mtimes)
+
       return nodes, comments
     end
 
@@ -158,5 +175,44 @@ module RubyLint
         instance.iterate(ast)
       end
     end
+
+    ##
+    # Checks if the AST node has a cache file and if so returns the nodes and
+    # comments that are cached.
+    #
+    # @param [RubyLint::AST::Node] node
+    # @return [Array]
+    #
+    def get_cache(node)
+      return unless configuration.enable_cache
+
+      cache_name = node.sha1
+
+      if cache.exists?(cache_name)
+        entry = cache.get(cache_name)
+
+        if entry.valid?
+          return entry.nodes, entry.comments
+        else
+          cache.delete(cache_name)
+        end
+      end
+
+      return
+    end
+
+    ##
+    # Caches the values for the given node.
+    #
+    # @param [RubyLint::AST::Node] node
+    # @param [Array] nodes
+    # @param [RubyLint::NodeHash] comments
+    # @param [Hash] mtimes
+    #
+    def set_cache(node, nodes, comments, mtimes)
+      return unless configuration.enable_cache
+
+      cache.set(node.sha1, CacheEntry.new(nodes, comments, mtimes))
+    end
   end # Runner
 end # RubyLint

data/lib/ruby-lint/template/definition.erb

@@ -26,3 +26,5 @@ RubyLint::GlobalScope.definitions.define_constant('<%= constant.name %>') do |kl
   <%- end -%>
 end
 <% end %>
+
+RubyLint::GlobalScope.definitions.lookup(:const, '<%= @constants[0].name %>').deep_freeze

data/lib/ruby-lint/version.rb

@@ -1,3 +1,3 @@
 module RubyLint
-  VERSION = '0.0.5'
+  VERSION = '0.9.0'
 end # RubyLint

data/lib/ruby-lint/virtual_machine.rb

@@ -195,7 +195,7 @@ module RubyLint
     #
     # @param [RubyLint::AST::Node] node
     #
-    def on_assign(node)
+    def on_assign
       reset_assignment_value
       value_stack.add_stack
     end
@@ -212,10 +212,10 @@ module RubyLint
         value = assignment_value
       end
 
-      assign_variable(type, name, value)
+      assign_variable(type, name, value, node)
     end
 
-    ASSIGNMENT_TYPES.each do |callback, type|
+    ASSIGNMENT_TYPES.each do |callback, _|
       alias_method :"on_#{callback}", :on_assign
       alias_method :"after_#{callback}", :after_assign
     end
@@ -259,7 +259,7 @@ module RubyLint
     ##
     # @param [RubyLint::AST::Node] node
     #
-    def on_masgn(node)
+    def on_masgn
       add_stacks
     end
 
@@ -267,9 +267,7 @@ module RubyLint
     # Processes a mass variable assignment using the stacks created by
     # {#on_masgn}.
     #
-    # @param [RubyLint::AST::Node] node
-    #
-    def after_masgn(node)
+    def after_masgn
       variables = variable_stack.pop
       values    = value_stack.pop.first
       values    = values && values.value ? values.value : []
@@ -284,16 +282,14 @@ module RubyLint
     ##
     # @param [RubyLint::AST::Node] node
     #
-    def on_or_asgn(node)
+    def on_or_asgn
       add_stacks
     end
 
     ##
     # Processes an `or` assignment in the form of `variable ||= value`.
     #
-    # @param [RubyLint::AST::Node] node
-    #
-    def after_or_asgn(node)
+    def after_or_asgn
       variable = variable_stack.pop.first
       value    = value_stack.pop.first
 
@@ -305,7 +301,7 @@ module RubyLint
     ##
     # @param [RubyLint::AST::Node] node
     #
-    def on_and_asgn(node)
+    def on_and_asgn
       add_stacks
     end
 
@@ -314,7 +310,7 @@ module RubyLint
     #
     # @param [RubyLint::AST::Node] node
     #
-    def after_and_asgn(node)
+    def after_and_asgn
       variable = variable_stack.pop.first
       value    = value_stack.pop.first
 
@@ -330,7 +326,7 @@ module RubyLint
 
     # Creates the callback methods for various variable types such as local
     # variables.
-    ASSIGNMENT_TYPES.each do |asgn_name, type|
+    ASSIGNMENT_TYPES.each do |_, type|
       define_method("on_#{type}") do |node|
         increment_reference_amount(node)
         push_variable_value(node)
@@ -361,9 +357,9 @@ module RubyLint
     end
 
     ##
-    # @param [RubyLint::AST::Node] node
+    # Adds a new stack for Array values.
     #
-    def on_array(node)
+    def on_array
       value_stack.add_stack
     end
 
@@ -383,9 +379,9 @@ module RubyLint
     end
 
     ##
-    # @param [RubyLint::AST::Node] node
+    # Adds a new stack for Hash values.
     #
-    def on_hash(node)
+    def on_hash
       value_stack.add_stack
     end
 
@@ -405,18 +401,16 @@ module RubyLint
     end
 
     ##
-    # @param [RubyLint::AST::Node] node
+    # Adds a new value stack for key/value pairs.
     #
-    def on_pair(node)
+    def on_pair
       value_stack.add_stack
     end
 
     ##
-    # Processes a key/value pair.
-    #
-    # @param [RubyLint::AST::Node] node
+    # @see #on_pair
     #
-    def after_pair(node)
+    def after_pair
       key, value = value_stack.pop
 
       return unless key
@@ -431,9 +425,9 @@ module RubyLint
     end
 
     ##
-    # @param [RubyLint::AST::Node] node
+    # Pushes the value of `self` onto the current stack.
     #
-    def on_self(node)
+    def on_self
       push_value(current_scope.lookup(:keyword, 'self'))
     end
 
@@ -447,9 +441,9 @@ module RubyLint
     end
 
     ##
-    # @param [RubyLint::AST::Node] node
+    # Pops the scope created by the module.
     #
-    def after_module(node)
+    def after_module
       pop_scope
     end
 
@@ -474,9 +468,9 @@ module RubyLint
     end
 
     ##
-    # @param [RubyLint::AST::Node] node
+    # Pops the scope created by the class.
     #
-    def after_class(node)
+    def after_class
       pop_scope
     end
 
@@ -495,9 +489,9 @@ module RubyLint
     end
 
     ##
-    # @param [RubyLint::AST::Node] node
+    # Pops the scope created by the block.
     #
-    def after_block(node)
+    def after_block
       pop_scope
     end
 
@@ -521,9 +515,10 @@ module RubyLint
     end
 
     ##
-    # @param [RubyLint::AST::Node] node
+    # Pops the scope created by the `sclass` block and resets the method
+    # definition/send type.
     #
-    def after_sclass(node)
+    def after_sclass
       reset_method_type
       pop_scope
     end
@@ -569,9 +564,7 @@ module RubyLint
     ##
     # Exports various variables to the outer scope of the method definition.
     #
-    # @param [RubyLint::AST::Node] node
-    #
-    def after_def(node)
+    def after_def
       previous = pop_scope
       current  = current_scope
 
@@ -584,7 +577,7 @@ module RubyLint
 
     # Creates callbacks for various argument types such as :arg and :optarg.
     ARGUMENT_TYPES.each do |type|
-      define_method("on_#{type}") do |node|
+      define_method("on_#{type}") do
         value_stack.add_stack
       end
 
@@ -686,21 +679,24 @@ Received: #{arguments.length}
         retval = context.call_method(name)
 
         retval ? push_value(retval) : push_unknown_value
+
+        # Track the method call
+        track_method_call(context, name, node)
       else
         push_unknown_value
       end
     end
 
     VISIBILITIES.each do |vis|
-      define_method("on_send_#{vis}") do |node|
+      define_method("on_send_#{vis}") do
         @visibility = vis
       end
     end
 
     ##
-    # @param [RubyLint::AST::Node] node
+    # Adds a new value stack for the values of an alias.
     #
-    def on_alias(node)
+    def on_alias
       value_stack.add_stack
     end
 
@@ -867,8 +863,9 @@ Received: #{arguments.length}
     # @param [Symbol] type The type of variable.
     # @param [String] name The name of the variable
     # @param [RubyLint::Definition::RubyObject] value
+    # @param [RubyLint::AST::Node] node
     #
-    def assign_variable(type, name, value)
+    def assign_variable(type, name, value, node)
       existing   = current_scope.lookup(type, name)
       ref_amount = existing ? existing.reference_amount + 1 : 0
       variable   = Definition::RubyObject.new(
@@ -876,7 +873,10 @@ Received: #{arguments.length}
         :name             => name,
         :value            => value,
         :instance_type    => :instance,
-        :reference_amount => ref_amount
+        :reference_amount => ref_amount,
+        :line             => node.line,
+        :column           => node.column,
+        :file             => node.file
       )
 
       buffer_assignment_value(variable.value)
@@ -1117,5 +1117,37 @@ Received: #{arguments.length}
       # first one but there should be a nicer way to do this.
       definition.returns(definitions[0]) if definitions[0]
     end
+
+    ##
+    # Tracks a method call.
+    #
+    # @param [RubyLint::Definition::RubyMethod] definition
+    # @param [String] name
+    # @param [RubyLint::AST::Node] node
+    #
+    def track_method_call(definition, name, node)
+      method   = definition.lookup(definition.method_call_type, name)
+      current  = current_scope
+      location = {
+        :line   => node.line,
+        :column => node.column,
+        :file   => node.file
+      }
+
+      # Add the call to the current scope if we're dealing with a writable
+      # method definition.
+      if current.respond_to?(:calls) and !current.frozen?
+        current.calls.push(
+          MethodCallInfo.new(location.merge(:definition => method))
+        )
+      end
+
+      # Add the caller to the called method, this allows for inverse lookups.
+      unless method.frozen?
+        method.callers.push(
+          MethodCallInfo.new(location.merge(:definition => definition))
+        )
+      end
+    end
   end # VirtualMachine
 end # RubyLint