ruby-lint 1.0.3 → 1.1.0

data/spec/ruby-lint/configuration_spec.rb

@@ -55,6 +55,12 @@ describe RubyLint::Configuration do
 
       blk.should raise_error(ArgumentError, /does not exist/)
     end
+
+    example 'setting the directories to nil' do
+      @configuration.directories = nil
+
+      @configuration.directories.should == []
+    end
   end
 
   context 'setting options via the constructor' do
@@ -85,6 +91,20 @@ describe RubyLint::Configuration do
     end
   end
 
+  context 'setting options directly' do
+    before do
+      @configuration = RubyLint::Configuration.new
+    end
+
+    example 'expand the directories set' do
+      @configuration.directories = ['lib']
+
+      @configuration.directories.should == [
+        File.expand_path('lib')
+      ]
+    end
+  end
+
   context 'setting options via a configuration file' do
     example 'set the options from a YAML file' do
       paths = [fixture_path('config.yml')]

data/spec/ruby-lint/constant_loader_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe RubyLint::ConstantLoader do
+  before do
+    @definitions = ruby_object.new
+    @loader      = RubyLint::ConstantLoader.new(:definitions => @definitions)
+  end
+
+  context 'bootstrapping definitions' do
+    before do
+      @loader.bootstrap
+    end
+
+    example 'bootstrap Module' do
+      @definitions.has_definition?(:const, 'Module').should == true
+    end
+
+    example 'bootstrap Fixnum' do
+      @definitions.has_definition?(:const, 'Fixnum').should == true
+    end
+
+    example 'bootstrap global variables' do
+      @definitions.has_definition?(:gvar, '$LOAD_PATH').should == true
+    end
+  end
+
+  context 'loading constants' do
+    before do
+      @loader.load_constant('PP')
+    end
+
+    example 'mark bootstrapped constants as loaded' do
+      @loader.bootstrap
+      @loader.loaded?('Module').should == true
+    end
+
+    example 'load a constant' do
+      @loader.loaded?('PP').should == true
+    end
+
+    example 'apply a constant to a definition' do
+      @definitions.has_definition?(:const, 'PP').should == true
+    end
+
+    example 'update the registry' do
+      @loader.registry.include?('PP').should == true
+    end
+  end
+
+  context 'dealing with case sensitivity' do
+    before do
+      @loader.bootstrap
+    end
+
+    example 'do not raise when loading process.rb for the PROCESS constant' do
+      block = lambda { @loader.load_constant('PROCESS') }
+
+      block.should_not raise_error
+    end
+  end
+
+  context 'iterating over an AST' do
+    before do
+      @ast = s(:root, s(:const, nil, 'PP'))
+    end
+
+    example 'load a constant' do
+      @loader.run([@ast])
+      @loader.loaded?('PP').should == true
+    end
+
+    example 'call the correct callbacks' do
+      @loader.should_receive(:on_const)
+        .with(an_instance_of(RubyLint::AST::Node))
+
+      @loader.run([@ast])
+    end
+  end
+end

data/spec/ruby-lint/definition/constant_proxy_spec.rb

@@ -1,54 +1,85 @@
 require 'spec_helper'
 
 describe RubyLint::Definition::ConstantProxy do
-  before do
-    @source = ruby_object.new(:name => 'global', :type => :global)
-    @proxy  = RubyLint::Definition::ConstantProxy.new(@source, 'Foo')
-  end
+  context 'without a registry' do
+    before do
+      @source = ruby_object.new(:name => 'global', :type => :global)
+      @proxy  = RubyLint::Definition::ConstantProxy.new(@source, 'Foo')
+    end
 
-  example 'create a new constant proxy' do
-    @proxy.proxy_source.should == @source
-    @proxy.proxy_name.should   == 'Foo'
-  end
+    example 'create a new constant proxy' do
+      @proxy.proxy_source.should == @source
+      @proxy.proxy_name.should   == 'Foo'
+    end
 
-  example 'act like a RubyObject definition' do
-    @proxy.lookup(:const, 'Bar').nil?.should == true
-  end
+    example 'act like a RubyObject definition' do
+      @proxy.lookup(:const, 'Bar').nil?.should == true
+    end
 
-  example 'cache the definition when it exists' do
-    @proxy.name.nil?.should == true
-    @proxy.type.nil?.should == true
+    example 'cache the definition when it exists' do
+      @proxy.name.nil?.should == true
+      @proxy.type.nil?.should == true
 
-    @proxy.lookup(:const, 'VERSION').nil?.should == true
+      @proxy.lookup(:const, 'VERSION').nil?.should == true
 
-    @source.define_constant('Foo').define_constant('VERSION')
+      @source.define_constant('Foo').define_constant('VERSION')
 
-    @proxy.name.should == 'Foo'
-    @proxy.type.should == :const
+      @proxy.name.should == 'Foo'
+      @proxy.type.should == :const
 
-    @proxy.lookup(:const, 'VERSION').is_a?(ruby_object).should == true
+      @proxy.lookup(:const, 'VERSION').is_a?(ruby_object).should == true
+    end
+
+    example 'delegating #inspect' do
+      foo = @source.define_constant('Foo')
+
+      @proxy.inspect.should == foo.inspect
+    end
   end
 
-  example 'autoload definitions from the global scope' do
-    proxy = RubyLint::Definition::ConstantProxy.new(
-      RubyLint::GlobalScope,
-      'ObjectSpace'
-    )
+  context 'with a registry' do
+    before do
+      @source   = ruby_object.new
+      @registry = RubyLint::Definition::Registry.new
+
+      @proxy = RubyLint::Definition::ConstantProxy
+        .new(@source, 'Foo', @registry)
+    end
 
-    proxy.type.should == :const
-    proxy.name.should == 'ObjectSpace'
+    example 'do not load anything when the registry is empty' do
+      @proxy.lookup(:const, 'Foo').nil?.should == true
+    end
 
-    proxy.proxy_definition.is_a?(ruby_object).should == true
+    example 'autoload a definition when possible' do
+      @registry.register('Foo') { |defs| defs.define_constant('Foo') }
+
+      @proxy.lookup(:const, 'Foo').is_a?(ruby_object).should == true
+    end
   end
 
-  example 'delegating #inspect' do
-    proxy = RubyLint::Definition::ConstantProxy.new(
-      RubyLint::GlobalScope,
-      'ObjectSpace'
-    )
+  context 'loading definitions automatically' do
+    before do
+      @source   = ruby_object.new
+      @registry = RubyLint::Definition::Registry.new
+
+      @proxy = RubyLint::Definition::ConstantProxy
+        .new(@source, 'ActionController', @registry)
+    end
+
+    example 'load a definition from the filesystem' do
+      @registry.should_receive(:load).with('ActionController')
+
+      @proxy.lookup(:const, 'Foo')
+    end
+
+    example 'do not load the definition when it is already loaded' do
+      @registry.should_not receive(:load)
 
-    object_space = RubyLint::GlobalScope.global_constant('ObjectSpace')
+      @registry.register('ActionController') do |defs|
+        defs.define_constant('ActionController')
+      end
 
-    proxy.inspect.should == object_space.inspect
+      @proxy.lookup(:const, 'Foo')
+    end
   end
 end

data/spec/ruby-lint/definition/registry_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe RubyLint::Definition::Registry do
+  before do
+    @registry = RubyLint::Definition::Registry.new
+  end
+
+  context 'registering definitions' do
+    example 'no definitions should be registered by default' do
+      @registry.registered.empty?.should == true
+    end
+
+    example 'register a definition' do
+      @registry.register('String') { }
+
+      @registry.registered.key?('String').should == true
+    end
+  end
+
+  context 'checking if definitions exist' do
+    example 'check for a non existing definition' do
+      @registry.include?('Foo').should == false
+    end
+
+    example 'check for an existing definition' do
+      @registry.register('Foo') { }
+
+      @registry.include?('Foo').should == true
+    end
+  end
+
+  context 'retrieving definitions' do
+    example 'raise when the constant does not exist' do
+      lambda { @registry.get('Foo') }.should raise_error(ArgumentError)
+    end
+
+    example 'return the definition when it exists' do
+      @registry.register('Foo') { }
+
+      @registry.get('Foo').is_a?(Proc).should == true
+    end
+  end
+
+  context 'applying definitions' do
+    before do
+      @root = ruby_object.new
+
+      @registry.register('Foo') do |defs|
+        defs.define_constant('Foo') do |foo|
+          foo.define_method('bar')
+        end
+      end
+
+      @registry.apply('Foo', @root)
+    end
+
+    example 'define the constant' do
+      @root.has_definition?(:const, 'Foo').should == true
+    end
+
+    example 'define sub definitions correctly' do
+      @root.lookup(:const, 'Foo')
+        .has_definition?(:method, 'bar')
+        .should == true
+    end
+
+    example 'do not overwrite existing definitions' do
+      foo = @root.lookup(:const, 'Foo')
+
+      @registry.apply('Foo', @root)
+
+      @root.lookup(:const, 'Foo').should == foo
+    end
+  end
+
+  context 'managing load paths' do
+    before do
+      @registry = RubyLint::Definition::Registry.new
+    end
+
+    example 'use the default load path' do
+      @registry.load_path
+        .should == RubyLint::Definition::Registry::DEFAULT_LOAD_PATH
+    end
+
+    example 'add a path to the load path' do
+      @registry.load_path << 'foo'
+
+      @registry.load_path.include?('foo').should == true
+    end
+  end
+
+  context 'loading constant definitions from the load path' do
+    before do
+      RubyLint.registry.load('Rational')
+    end
+
+    example 'load the String constant' do
+      RubyLint.registry.loaded_constants.include?('Rational').should == true
+    end
+
+    example 'register the String definition' do
+      RubyLint.registry.include?('Rational').should == true
+    end
+  end
+end

data/spec/ruby-lint/definition/ruby_object_spec.rb

@@ -107,6 +107,14 @@ describe ruby_object do
     found.name.should == 'example'
   end
 
+  example 'create a shim of a definition' do
+    object = ruby_object.new(:type => :const, :name => 'Foo')
+    shim   = object.shim
+
+    shim.name.should    == object.name
+    shim.parents.should == [object]
+  end
+
   example 'create a RubyObject that represents an instance' do
     object = ruby_object.new(:type => :const, :name => 'String')
 
@@ -203,31 +211,6 @@ describe ruby_object do
     obj.file.should   == '(ruby-lint)'
   end
 
-  context 'deep freezing definitions' do
-    before :all do
-      @const  = ruby_object.new(:type => :const, :name => 'Foo')
-      @method = ruby_method.new(:type => :method, :name => 'test')
-
-      @const.add_definition(@method)
-
-      @const.deep_freeze
-    end
-
-    example 'freeze the root constant' do
-      @const.frozen?.should == true
-    end
-
-    example 'freeze the definitions list of the root constant' do
-      @const.definitions.frozen?.should == true
-    end
-
-    example 'freeze child definitions' do
-      @method.frozen?.should         == true
-      @method.calls.frozen?.should   == true
-      @method.callers.frozen?.should == true
-    end
-  end
-
   context 'defining self' do
     before do
       @class    = ruby_object.new(:instance_type => :class)
@@ -261,4 +244,21 @@ describe ruby_object do
       @class.lookup(:method, 'self').return_value.should == @class
     end
   end
+
+  context 'constant proxies' do
+    before do
+      @root  = ruby_object.new(:type => :const, :name => 'Foo')
+      @proxy = @root.constant_proxy('Bar')
+    end
+
+    example 'create a constant proxy' do
+      @proxy.is_a?(RubyLint::Definition::ConstantProxy).should == true
+    end
+
+    example 'point to the definition when it exists' do
+      baz = @root.define_constant('Bar').define_constant('Baz')
+
+      @proxy.lookup(:const, 'Baz').should == baz
+    end
+  end
 end

data/spec/ruby-lint/definition_builder/primitive_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe RubyLint::DefinitionBuilder::Primitive do
-  before do
-    @root = ruby_object.new(:name => 'root')
+  before :all do
+    @vm = RubyLint::VirtualMachine.new
   end
 
   example 'build an integer definition' do
-    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:int, 10), @root)
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:int, 10), @vm)
     built   = builder.build
 
     built.type.should  == :int
@@ -14,7 +14,7 @@ describe RubyLint::DefinitionBuilder::Primitive do
   end
 
   example 'build a float definition' do
-    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:float, 10.0), @root)
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:float, 10.0), @vm)
     built   = builder.build
 
     built.type.should  == :float
@@ -22,7 +22,7 @@ describe RubyLint::DefinitionBuilder::Primitive do
   end
 
   example 'build a string definition' do
-    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:str, 'a'), @root)
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:str, 'a'), @vm)
     built   = builder.build
 
     built.type.should  == :str
@@ -30,7 +30,7 @@ describe RubyLint::DefinitionBuilder::Primitive do
   end
 
   example 'build a symbol definition' do
-    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:sym, :a), @root)
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:sym, :a), @vm)
     built   = builder.build
 
     built.type.should  == :sym
@@ -38,7 +38,7 @@ describe RubyLint::DefinitionBuilder::Primitive do
   end
 
   example 'build primitives as instances by default' do
-    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:int, 10), @root)
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:int, 10), @vm)
 
     builder.build.instance?.should == true
   end
@@ -46,7 +46,7 @@ describe RubyLint::DefinitionBuilder::Primitive do
   example 'allow custom options to be defined' do
     builder = RubyLint::DefinitionBuilder::Primitive.new(
       s(:int, 10),
-      @root,
+      @vm,
       :instance_type => :class
     )
 
@@ -54,9 +54,9 @@ describe RubyLint::DefinitionBuilder::Primitive do
   end
 
   example 'include the definitions of the corresponding Ruby class' do
-    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:int, 10), @root)
+    builder = RubyLint::DefinitionBuilder::Primitive.new(s(:int, 10), @vm)
     built   = builder.build
 
     built.lookup(:instance_method, 'to_s').is_a?(ruby_object).should == true
   end
-end
+end