ruby-lint 1.0.3 → 1.1.0

data/lib/ruby-lint/cli.rb

@@ -1,5 +1,4 @@
 require 'slop'
 require_relative 'cli/base'
 require_relative 'cli/analyze'
-require_relative 'cli/ast'
-require_relative 'cli/plot'
+require_relative 'cli/cache'

data/lib/ruby-lint/cli/analyze.rb

@@ -75,33 +75,10 @@ Examples:
   # @return [Array]
   #
   def extract_files(files)
-    existing = []
+    return RubyLint::FileList.new.process(files)
 
-    files.each do |file|
-      file = File.expand_path(file)
-
-      if File.file?(file)
-        existing << file
-
-      elsif File.directory?(file)
-        existing = existing | glob_files(file)
-
-      else
-        abort "The file/directory #{file} does not exist"
-      end
-    end
-
-    return existing
-  end
-
-  ##
-  # Returns a list of Ruby files in the given directory. This list includes
-  # deeply nested files.
-  #
-  # @return [Array]
-  #
-  def glob_files(directory)
-    return Dir.glob(File.join(directory, '**/*.rb'))
+  rescue Errno::ENOENT => error
+    abort error.message
   end
 
   ##
@@ -130,6 +107,22 @@ Examples:
     @output_destination = destination
   end
 
+  # The stdout and stderr methods mainly exist to make testing a bit easier.
+
+  ##
+  # @return [IO]
+  #
+  def stdout
+    return STDOUT
+  end
+
+  ##
+  # @return [IO]
+  #
+  def stderr
+    return STDERR
+  end
+
   ##
   # @param [RubyLint::Configuration] configuration
   # @param [Hash] opts
@@ -160,6 +153,40 @@ Examples:
       "(#{memory_kb.round(2)} KB)"
   end
 
+  ##
+  # Shows a lump of debugging information before the rest of the output.
+  #
+  # @param [RubyLint::Configuration] config
+  #
+  #:nocov:
+  def debug_header(config)
+    directories = config.directories.map do |dir|
+      File.directory?(dir) ? "#{dir}: exists" : "#{dir}: doesn't exist"
+    end
+
+    directories = directories.empty? ? 'None' : directories.join("\n")
+
+    stderr.puts <<-EOF.strip
+ruby:      #{RUBY_DESCRIPTION}
+ruby-lint: #{RubyLint::VERSION}
+directory: #{Dir.pwd}
+
+Caching:
+
+enabled:   #{config.enable_cache}
+directory: #{config.cache_directory}
+
+Directories:
+
+#{directories}
+
+------
+    EOF
+
+    stderr.puts
+  end
+  #:nocov:
+
   run do |opts, args|
     abort 'You must specify at least one file to analyze' if args.empty?
 
@@ -169,6 +196,8 @@ Examples:
 
     configure(configuration, opts)
 
+    debug_header(configuration) if configuration.debug
+
     runner    = RubyLint::Runner.new(configuration)
     output    = runner.analyze(files)
     exec_time = Time.now.to_f - start_time

data/lib/ruby-lint/cli/cache.rb

@@ -0,0 +1,60 @@
+RubyLint::CLI.options.command :cache do
+  banner      'Usage: ruby-lint cache [COMMAND] [OPTIONS]'
+  description 'Manages ruby-lint cache files'
+
+  separator <<-EOF.chomp
+
+About:
+
+  This command can be used to view and manage cache entries created by
+  ruby-lint. This command is mainly meant to be used for debugging purposes.
+
+Examples:
+
+  Print a summary of the cache:
+
+      $ ruby-lint cache
+
+  Clear the cache:
+
+      $ ruby-lint cache clear
+  EOF
+
+  separator RubyLint::CLI::OPTIONS_HEADER
+
+  RubyLint::CLI.help_option(self)
+
+  run do
+    config  = RubyLint::Configuration.load_from_file
+    pattern = File.join(config.cache_directory, '*.cache')
+    files   = Dir.glob(pattern)
+    size    = files.map { |file| File.size(file) }.inject(:+).to_f
+
+    size_kb = (size / 1024).round(2)
+    size_mb = (size / 1024 / 1024).round(2)
+
+    puts <<-EOF.strip
+Directory:   #{config.cache_directory}
+Total files: #{files.length}
+Total size:  #{size_kb} KB (#{size_mb} MB)
+    EOF
+  end
+
+  command :clear do
+    banner      'Usage: ruby-lint cache clear [OPTIONS]'
+    description 'Removes all the cache files'
+
+    separator RubyLint::CLI::OPTIONS_HEADER
+
+    RubyLint::CLI.help_option(self)
+
+    run do
+      config  = RubyLint::Configuration.load_from_file
+      pattern = File.join(config.cache_directory, '*.cache')
+
+      Dir.glob(pattern).each do |file|
+        File.unlink(file)
+      end
+    end
+  end
+end

data/lib/ruby-lint/configuration.rb

@@ -201,13 +201,19 @@ module RubyLint
     # @param [Array] directories
     #
     def directories=(directories)
-      directories.each do |dir|
-        unless File.directory?(dir)
-          raise ArgumentError, "The directory #{dir} does not exist"
+      valid = []
+
+      if directories
+        directories.each do |dir|
+          unless File.directory?(dir)
+            raise ArgumentError, "The directory #{dir} does not exist"
+          end
+
+          valid << File.expand_path(dir)
         end
       end
 
-      @directories = directories
+      @directories = valid
     end
 
     ##

data/lib/ruby-lint/constant_loader.rb

@@ -1,33 +1,75 @@
 module RubyLint
   ##
-  # The ConstantLoader class tries to pre-load various constants in a given
-  # file before the definitions are being built and analysis is performed.
+  # The ConstantLoader is an iterator class (using {RubyLint::Iterator}) that
+  # iterates over an AST and tries to load the corresponding built-in
+  # definitions. For example, if it finds a constant node for the `ERB` class
+  # it will apply the definitions for `ERB` to the ones set in
+  # {RubyLint::ConstantLoader#definitions}.
   #
-  # Note that this pre-loader is rather basic and as such there are chances you
-  # still have to manually require definitions to ensure that they are being
-  # used.
+  # This class also takes care of bootstrapping the target definitions so that
+  # the bare minimum definitions (e.g. Module and Object) are always available.
+  # Global variables are also bootstrapped.
   #
   # @!attribute [r] loaded
-  #  @return [Hash] Hash containing the loaded constants.
+  #  @return [Set] Set containing the loaded constants.
+  #
+  # @!attribute [r] definitions
+  #  @return [RubyLint::Definition::RubyObject]
   #
   class ConstantLoader < Iterator
-    attr_reader :loaded
+    attr_reader :loaded, :definitions
+
+    ##
+    # Built-in definitions that should be bootstrapped.
+    #
+    # @return [Array]
+    #
+    BOOTSTRAP_CONSTS = %w{Module Class Kernel BasicObject Object}
 
     ##
-    # List of directories to search for definition files.
+    # List of global variables that should be bootstrapped.
     #
     # @return [Array]
     #
-    LOAD_PATH = [
-      File.expand_path('../definitions/core', __FILE__),
-      File.expand_path('../definitions/rails', __FILE__)
+    BOOTSTRAP_GVARS = [
+      '$!', '$$', '$&', '$\'', '$*', '$+', '$,', '$-0', '$-F', '$-I', '$-K',
+      '$-W', '$-a', '$-d', '$-i', '$-l', '$-p', '$-v', '$-w', '$.', '$/', '$0',
+      '$1', '$2', '$3', '$4', '$5', '$6', '$7', '$8', '$9', '$:', '$;', '$<',
+      '$=', '$>', '$?', '$@', '$DEBUG', '$FILENAME', '$KCODE',
+      '$LOADED_FEATURES', '$LOAD_PATH', '$PROGRAM_NAME', '$SAFE', '$VERBOSE',
+      '$\"', '$\\', '$_', '$`', '$stderr', '$stdin', '$stdout', '$~'
     ]
 
+    ##
+    # Bootstraps various core definitions.
+    #
+    def bootstrap
+      types = VariablePredicates::RUBY_CLASSES.values
+
+      (BOOTSTRAP_CONSTS | types).each do |name|
+        load_constant(name)
+      end
+
+      BOOTSTRAP_GVARS.each do |gvar|
+        definitions.define_global_variable(gvar)
+      end
+    end
+
+    ##
+    # Bootstraps various core definitions (Fixnum, Object, etc) and loads the
+    # extra constants referred in the supplied AST.
+    #
+    # @param [Array<RubyLint::AST::Node>] ast
+    #
+    def run(ast)
+      ast.each { |node| iterate(node) }
+    end
+
     ##
     # Called after a new instance of the class is created.
     #
     def after_initialize
-      @loaded = {}
+      @loaded = Set.new
     end
 
     ##
@@ -44,7 +86,14 @@ module RubyLint
     # @return [TrueClass|FalseClass]
     #
     def loaded?(constant)
-      return loaded.key?(constant)
+      return loaded.include?(constant)
+    end
+
+    ##
+    # @return [RubyLint::Definition::Registry]
+    #
+    def registry
+      return RubyLint.registry
     end
 
     ##
@@ -55,18 +104,22 @@ module RubyLint
     def load_constant(constant)
       return if loaded?(constant)
 
-      filename = constant.snake_case + '.rb'
+      registry.load(constant)
 
-      LOAD_PATH.each do |path|
-        path = File.join(path, filename)
+      return unless registry.include?(constant)
 
-        if File.file?(path)
-          require(path)
-          loaded[constant] = true
+      apply(constant)
+    end
 
-          break
-        end
-      end
+    private
+
+    ##
+    # @param [String] constant
+    #
+    def apply(constant)
+      loaded << constant
+
+      registry.apply(constant, definitions)
     end
   end # ConstantLoader
 end # RubyLint

data/lib/ruby-lint/definition/constant_proxy.rb

@@ -13,22 +13,32 @@ module RubyLint
     # @!attribute [r] proxy_name
     #  @return [String]
     #
+    # @!attribute [r] registry
+    #  @return [RubyLint::Definition::Registry]
+    #
     # @!attribute [r] proxy_definition
     #  @return [RubyLint::Definition::RubyObject]
     #
     class ConstantProxy
-      attr_reader :proxy_source, :proxy_name, :proxy_definition
+      include VariablePredicates
+
+      attr_reader :proxy_source, :proxy_name, :proxy_definition, :registry
 
       ##
       # @param [RubyLint::Definition::RubyObject] source The source definition
       #  to use for looking up the definition associated with the current
       #  proxy.
+      #
       # @param [String] name The name/constant path of the constant that this
       #  proxy belongs to.
       #
-      def initialize(source, name)
+      # @param [RubyLint::Registry] registry The registry to use when trying
+      #  to autoload a constant.
+      #
+      def initialize(source, name, registry = nil)
         @proxy_source = source
         @proxy_name   = name
+        @registry     = registry
       end
 
       # Pre-define all the methods of the definition, this is faster than
@@ -58,7 +68,45 @@ module RubyLint
       def lookup_proxy_definition
         return if proxy_definition
 
-        @proxy_definition = proxy_source.lookup_constant_path(proxy_name)
+        found = lookup_constant
+        root  = root_constant
+
+        if !found and use_registry?(root)
+          registry.apply(root, proxy_source)
+
+          found = lookup_constant
+        end
+
+        @proxy_definition = found
+      end
+
+      ##
+      # @param [String] constant
+      # @return [TrueClass|FalseClass]
+      #
+      def use_registry?(constant)
+        return false unless registry
+
+        # Don't load the constant if we already have it.
+        return true if registry.include?(constant)
+
+        registry.load(constant)
+
+        return registry.include?(constant)
+      end
+
+      ##
+      # @return [String]
+      #
+      def root_constant
+        return proxy_name.split(RubyObject::PATH_SEPARATOR)[0]
+      end
+
+      ##
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def lookup_constant
+        return proxy_source.lookup_constant_path(proxy_name)
       end
     end # ConstantProxy
   end # Definition

data/lib/ruby-lint/definition/registry.rb

@@ -0,0 +1,126 @@
+module RubyLint
+  module Definition
+    ##
+    # The Registry class is used to register and store definitions that have
+    # to be applied to instances of {RubyLint::VirtualMachine}. It can also be
+    # used to load constant definition files from a custom load path.
+    #
+    # @!attribute [r] load_path
+    #  @return [Array] List of directories to search in for definitions.
+    #
+    # @!attribute [r] loaded_constants
+    #  @return [Set] Set containing the constants loaded from the load path.
+    #
+    # @!attribute [r] registered
+    #  @return [Hash] Returns the registered definitions as a Hash. The keys
+    #   are set to the constant names, the values to `Proc` instances that,
+    #   when evaluated, create the corresponding definitions.
+    #
+    class Registry
+      attr_reader :load_path, :loaded_constants, :registered
+
+      ##
+      # The default load path to use.
+      #
+      # @return [Array]
+      #
+      DEFAULT_LOAD_PATH = [
+        File.expand_path('../../definitions/core', __FILE__),
+        File.expand_path('../../definitions/rails', __FILE__),
+        File.expand_path('../../definitions/gems', __FILE__)
+      ]
+
+      def initialize
+        @registered       = {}
+        @load_path        = DEFAULT_LOAD_PATH.dup
+        @loaded_constants = Set.new
+      end
+
+      ##
+      # Registers a new definition with the given name.
+      #
+      # @param [String] name The name of the constant.
+      #
+      def register(name, &block)
+        registered[name] = block
+      end
+
+      ##
+      # Gets the constant with the given name.
+      #
+      # @param [String] constant
+      # @raise [ArgumentError] Raised if the given constant doesn't exist.
+      #
+      def get(constant)
+        found = registered[constant]
+
+        if found
+          return found
+        else
+          raise ArgumentError, "The constant #{constant} does not exist"
+        end
+      end
+
+      ##
+      # Returns `true` if the given constant has been registered.
+      #
+      # @param [String] constant
+      # @return [TrueClass|FalseClass]
+      #
+      def include?(constant)
+        return registered.key?(constant) || loaded_constants.include?(constant)
+      end
+
+      ##
+      # Applies the definitions of a given name to the given
+      # {RubyLint::Definition::RubyObject} instance.
+      #
+      # @param [String] constant
+      # @param [RubyLint::Definition::RubyObject] definitions
+      #
+      def apply(constant, definitions)
+        unless definitions.defines?(:const, constant)
+          get(constant).call(definitions)
+        end
+      end
+
+      ##
+      # Tries to find a definition in the current load path and loads it if
+      # found.
+      #
+      # @param [String] constant The name of the top level constant.
+      #
+      def load(constant)
+        return if include?(constant)
+
+        filename = file_for_constant(constant)
+
+        load_path.each do |dir|
+          filepath = File.join(dir, filename)
+
+          if File.file?(filepath)
+            require(filepath)
+
+            # Only update the path if we actually found the right constant
+            # file.
+            if registered.key?(constant)
+              loaded_constants << constant
+            end
+
+            break
+          end
+        end
+      end
+
+      private
+
+      ##
+      # @param [String] constant
+      # @return [String]
+      #
+      def file_for_constant(constant)
+        return constant.snake_case + '.rb'
+      end
+    end # Registry
+  end # Definition
+end # RubyLint