ruby-lint 1.0.3 → 1.1.0

data/lib/ruby-lint/file_list.rb

@@ -0,0 +1,43 @@
+module RubyLint
+  ##
+  # The FileList class acts as a small wrapper around `Dir.glob` and is mainly
+  # used to turn a list of filenames/directory names into a list of just file
+  # names (excluding ones that don't exist).
+  #
+  class FileList
+    ##
+    # @param [Array] files
+    # @return [Array]
+    # @raise [Errno::ENOENT] Raised if a file or directory does not exist.
+    #
+    def process(files)
+      existing = []
+
+      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
+          raise Errno::ENOENT, "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'))
+    end
+  end # FileList
+end # RubyLint

data/lib/ruby-lint/file_scanner.rb

@@ -69,15 +69,15 @@ module RubyLint
       return @constant_paths_cache[constant]
     end
 
-    private
-
     ##
     # @return [Array]
     #
     def glob_ruby_files
-      return Dir.glob("#{directories.join(',')}/**/*.rb")
+      return Dir.glob("{#{directories.join(',')}}/**/*.rb")
     end
 
+    private
+
     ##
     # Searches all the files that could potentially define the given constant
     # and caches them.

data/lib/ruby-lint/generated_constant.rb

@@ -15,8 +15,11 @@ module RubyLint
   # @!attribute [r] superclass
   #  @return [String]
   #
+  # @!attribute [r] modules
+  #  @return [Array]
+  #
   class GeneratedConstant
-    attr_reader :methods, :name, :constant, :superclass
+    attr_reader :methods, :name, :constant, :superclass, :modules
 
     ##
     # @param [Hash] attributes
@@ -26,6 +29,7 @@ module RubyLint
         instance_variable_set("@#{key}", value)
       end
 
+      @modules    ||= []
       @methods    ||= []
       @superclass ||= 'Object'
     end

data/lib/ruby-lint/inspector.rb

@@ -8,6 +8,7 @@ module RubyLint
   #
   # @!attribute [r] constant
   #  @return [Class]
+  #
   # @!attribute [r] constant_name
   #  @return [String]
   #
@@ -18,70 +19,71 @@ module RubyLint
     # @param [String|Class] constant
     #
     def initialize(constant)
-      @constant_name = constant
+      @constant_name = constant.to_s
 
       if constant.is_a?(String)
-        constant = resolve_constant(constant)
+        @constant = resolve_constant(constant)
+      else
+        @constant = constant
       end
-
-      @constant = constant
     end
 
     ##
-    # Returns an Array containing all child constants and their children
+    # Returns an Array containing all constants and their child constants
     # (recursively).
     #
-    # The constants returned by this method are returned as String instances
-    # containing the full path (e.g. `Encoding::BINARY` instead of `BINARY`).
-    #
     # @param [Class] source
     # @param [Array] ignore
     # @return [Array<String>]
     #
     def inspect_constants(source = constant, ignore = [])
+      names          = []
       source_name    = source.to_s
-      constants      = []
       have_children  = []
       include_source = source != Object
 
-      if include_source
-        constants << source_name
-        ignore     = ignore + [source.to_s]
+      if include_source and !ignore.include?(source_name)
+        names  << source_name
+        ignore << source_name
       end
 
       source.constants.each do |name|
-        next unless source.const_defined?(name)
+        next if skip_constant?(source, name)
 
-        # FIXME: When using autoload/Rails in some cases this will trigger a
-        # load error. I have no idea why.
+        full_name = include_source ? "#{source_name}::#{name}" : name.to_s
+
+        # In certain cases this code tries to load a constant that apparently
+        # *is* defined but craps out upon error (e.g. Bundler::Specification).
         begin
           constant = source.const_get(name)
-        rescue LoadError => error
+        rescue Exception => error
           warn error.message
-
           next
         end
 
-        name      = name.to_s
-        full_name = include_source ? "#{source_name}::#{name}" : name
-
-        next if ignore.include?(full_name)
+        # Skip those that we've already processed.
+        if ignore.include?(full_name) or source == constant
+          next
+        end
 
-        ignore    << constant
-        constants << full_name
+        names         << full_name
+        ignore        << full_name
+        have_children << constant if process_child_constants?(constant)
+      end
 
-        if process_child_constants?(source, constant)
-          have_children << constant
-        end
+      have_children.each do |const|
+        names |= inspect_constants(const, ignore)
       end
 
-      have_children.each do |constant|
-        inspect_constants(constant, ignore).each do |child|
-          constants << child unless constants.include?(child)
-        end
+      # Reject every constant that, if we should include the source name, was
+      # not defined under that constant. This applies on for example Rubinius
+      # since `Range::Enumerator` is a constant that points to
+      # `Enumerable::Enumerator`.
+      if include_source
+        names = names.select { |name| name.start_with?(source_name) }
       end
 
-      return constants
+      return names
     end
 
     ##
@@ -114,16 +116,45 @@ module RubyLint
       return methods.sort_by(&:name)
     end
 
+    ##
+    # Returns the modules that are included in the constant.
+    #
+    # @return [Array]
+    #
+    def inspect_modules
+      modules = []
+
+      if constant.respond_to?(:ancestors)
+        parent = inspect_superclass
+
+        # Take all the modules included *directly* into the constant.
+        modules = constant.ancestors.take_while do |ancestor|
+          parent && ancestor != parent
+        end
+
+        # Get rid of non Module instances and modules that don't have a name.
+        modules = modules.select do |mod|
+          mod.instance_of?(Module) && mod.name
+        end
+      end
+
+      return modules
+    end
+
     ##
     # Returns the superclass of the current constant or `nil` if there is none.
     #
     # @return [Mixed]
     #
     def inspect_superclass
-      return constant.respond_to?(:superclass) ? constant.superclass : nil
-    end
+      parent = nil
 
-    private
+      if constant.respond_to?(:superclass) && constant.superclass.name
+        return constant.superclass
+      end
+
+      return parent
+    end
 
     ##
     # Gets the methods of the current constant minus those defined in Object.
@@ -132,30 +163,61 @@ module RubyLint
     # @return [Array]
     #
     def get_methods(getter = :methods)
-      diff    = constant.send(getter) - Object.send(getter)
-      methods = diff | constant.send(getter, false)
+      parent = inspect_superclass || Object
+      diff   = constant.__send__(getter, false) -
+        parent.__send__(getter, false)
+
+      methods = diff | constant.__send__(getter, false)
 
       # If the constant manually defines the initialize method (= private)
       # we'll also want to include it.
-      if getter == :instance_methods \
-      and constant.is_a?(Class) \
-      and constant.private_method_defined?(:initialize) \
-      and constant.instance_method(:initialize).source_location
+      if include_initialize?(getter)
         methods = methods | [:initialize]
       end
 
       return methods
     end
 
+    private
+
+    ##
+    # @param [Symbol] getter
+    # @return [TrueClass|FalseClass]
+    #
+    def include_initialize?(getter)
+      return getter == :instance_methods \
+        && constant.is_a?(Class) \
+        && constant.private_instance_methods(false).include?(:initialize) \
+        && constant.instance_method(:initialize).source_location
+    end
+
+    ##
+    # @param [Module|Class] const
+    # @param [Symbol] child_name
+    # @return [TrueClass|FalseClass]
+    #
+    def skip_constant?(const, child_name)
+      # Module and Class defines the same child constants as Object but in a
+      # recursive manner. This is a bit of a dirty way to prevent this code
+      # from going into an infinite loop.
+      if const == Module or const == Class
+        return true
+      end
+
+      # Config is deprecated and triggers a warning.
+      if const == Object and child_name == :Config
+        return true
+      end
+
+      return !const.const_defined?(child_name)
+    end
+
     ##
-    # @param [Class] source
     # @param [Class] constant
     # @return [TrueClass|FalseClass]
     #
-    def process_child_constants?(source, constant)
-      return constant.respond_to?(:consts) \
-        && constant != source \
-        && !constant.constants.empty?
+    def process_child_constants?(constant)
+      return constant.respond_to?(:constants) && !constant.constants.empty?
     end
 
     ##
@@ -166,7 +228,7 @@ module RubyLint
     # @return [UnboundMethod]
     #
     def method_information(type, name)
-      return constant.send(type, name)
+      return constant.__send__(type, name)
     end
 
     ##

data/lib/ruby-lint/method_call/attribute.rb

@@ -85,7 +85,9 @@ module RubyLint
           name = name + '='
         end
 
-        context.define_instance_method(name)
+        context.define_instance_method(name) do |method|
+          method.define_argument('value') if setter
+        end
 
         unless context.has_definition?(:ivar, ivar_name)
           ivar = Definition::RubyObject.new(

data/lib/ruby-lint/rake_task.rb

@@ -0,0 +1,98 @@
+require_relative '../ruby-lint'
+require 'rake/tasklib'
+
+module RubyLint
+  ##
+  # Class for easily creating Rake tasks without having to shell out to the
+  # commandline executable.
+  #
+  # Basic usage:
+  #
+  #     require 'ruby-lint/rake_task'
+  #
+  #     RubyLint::RakeTask.new do |task|
+  #       task.name  = 'lint'
+  #       task.files = ['lib/my-project-name']
+  #     end
+  #
+  # @!attribute [rw] name
+  #  @return [String] The name of the task.
+  #
+  # @!attribute [rw] description
+  #  @return [String] The description of the task.
+  #
+  # @!attribute [rw] debug
+  #  @return [TrueClass|FalseClass] Enables/disables debugging mode.
+  #
+  # @!attribute [rw] files
+  #  @return [Array] The files to check.
+  #
+  # @!attribute [rw] configuration
+  #  @return [String] Path to the configuration file to use.
+  #
+  class RakeTask < Rake::TaskLib
+    attr_accessor :name, :description, :debug, :files, :configuration
+
+    ##
+    # @param [Hash] options
+    #
+    def initialize(options = {})
+      @name        = 'lint'
+      @description = 'Check source code using ruby-lint'
+
+      options.each do |key, value|
+        instance_variable_set("@#{key}", value) if respond_to?(key)
+      end
+
+      yield self if block_given?
+
+      desc(description)
+      task(name) do
+        validate!
+        run_task
+      end
+    end
+
+    ##
+    # Checks if the task is configured properly, exists with code 1 if this
+    # isn't the case.
+    #
+    def validate!
+      if configuration and !File.file?(configuration)
+        abort "The configuration file #{configuration} does not exist"
+      end
+
+      if files.empty?
+        abort 'No files to check were specified'
+      end
+    end
+
+    ##
+    # Processes a list of files and writes the output to STDOUT.
+    #
+    def run_task
+      config = create_configuration
+      runner = RubyLint::Runner.new(config)
+      list   = FileList.new
+      output = runner.analyze(list.process(files))
+
+      puts(output) unless output.empty?
+    end
+
+    ##
+    # @return [RubyLint::Configuration]
+    #
+    def create_configuration
+      config_files = RubyLint::Configuration.configuration_files
+
+      if configuration
+        config_files = [configuration]
+      end
+
+      config       = RubyLint::Configuration.load_from_file(config_files)
+      config.debug = debug
+
+      return config
+    end
+  end # RakeTask
+end # RubyLint

data/lib/ruby-lint/ruby_lint.rb

@@ -0,0 +1,11 @@
+module RubyLint
+  ##
+  # Returns the global registry instance used for registering and applying
+  # definitions.
+  #
+  # @return [RubyLint::Definition::Registry]
+  #
+  def self.registry
+    return @registry ||= Definition::Registry.new
+  end
+end # RubyLint

data/lib/ruby-lint/runner.rb

@@ -67,8 +67,6 @@ module RubyLint
 
       comments.merge!(extra_comments)
 
-      autoload_constants(extra_ast)
-
       vm = run_vm(extra_ast, comments)
 
       run_analysis(ast, vm, report)
@@ -88,15 +86,6 @@ module RubyLint
       return ast, NodeHash.from_hash(comments)
     end
 
-    ##
-    # Automatically loads definitions using {RubyLint::ConstantLoader}.
-    #
-    # @param [Array] nodes
-    #
-    def autoload_constants(nodes)
-      nodes.each { |node| GlobalScope.constant_loader.iterate(node) }
-    end
-
     ##
     # Processes external Ruby files using {RubyLint::FileLoader}. The return
     # value is a collection of AST nodes and a Hash containing all the