assaf-buildr 1.3.3

data/spec/core/application_spec.rb

@@ -0,0 +1,412 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require File.join(File.dirname(__FILE__), '../spec_helpers')
+
+
+describe Buildr::Application do
+
+  describe 'home_dir' do
+    it 'should point to ~/.buildr' do
+      Buildr.application.home_dir.should eql(File.expand_path('.buildr', ENV['HOME']))
+    end
+
+    it 'should point to existing directory' do
+      File.directory?(Buildr.application.home_dir).should be_true
+    end
+  end
+
+  describe '#run' do
+    it 'should execute *_load methods in order' do
+      last = nil
+      order = [:find_buildfile, :load_gems, :load_artifacts, :load_tasks, 
+               :load_requires, :load_buildfile, :load_imports, :top_level]
+      order.each { |method| Buildr.application.should_receive(method).ordered }
+      Buildr.application.stub!(:exit) # With this, shows the correct error instead of SystemExit.
+      Buildr.application.run
+    end
+  end
+
+  describe 'environment' do
+    it 'should return value of BUILDR_ENV' do
+      ENV['BUILDR_ENV'] = 'qa'
+      Buildr::Application.new.environment.should eql('qa')
+    end
+
+    it 'should default to development' do
+      Buildr::Application.new.environment.should eql('development')
+    end
+
+    it 'should set environment name from -e argument' do
+      ARGV.push('-e', 'test')
+      Buildr::Application.new.environment.should eql('test')
+      ENV['BUILDR_ENV'].should eql('test')
+    end
+    
+    it 'should be echoed to user' do
+      write 'buildfile'
+      lambda { Buildr.application.send :load_buildfile }.should show_info(%r{(in .*, development)})
+    end
+    
+    after do
+      ENV['BUILDR_ENV'] = nil
+    end
+  end
+
+  describe 'gems' do
+    before do
+      Buildr.application.private_methods(true).should include('load_gems')
+      class << Buildr.application
+        public :load_gems
+      end
+    end
+
+    def load_with_yaml
+      write 'build.yaml', <<-YAML
+        gems:
+        - rspec
+        - rake >= 0.8
+      YAML
+      Buildr.application.load_gems
+    end
+
+    it 'should return empty array if no gems specified' do
+      Buildr.application.load_gems
+      Buildr.application.gems.should be_empty
+    end
+
+    it 'should return one entry for each gem specified in buildr.yaml' do
+      load_with_yaml
+      Buildr.application.gems.size.should be(2)
+    end
+
+    it 'should return a Gem::Specification for each installed gem' do
+      load_with_yaml
+      Buildr.application.gems.each { |gem| gem.should be_kind_of(Gem::Specification) }
+    end
+
+    it 'should parse Gem name correctly' do
+      load_with_yaml
+      Buildr.application.gems.map(&:name).should include('rake', 'rspec')
+    end
+
+    it 'should find installed version of Gem' do
+      load_with_yaml
+      Buildr.application.gems.each { |gem| gem.version.should eql(Gem.loaded_specs[gem.name].version) }
+    end
+  end
+
+
+  describe 'load_gems' do
+    before do
+      Buildr.application.private_methods(true).should include('load_gems')
+      class << Buildr.application
+        public :load_gems
+      end
+      @spec = Gem::Specification.new do |spec|
+        spec.name = 'foo'
+        spec.version = '1.2'
+      end
+      $stdout.stub!(:isatty).and_return(true)
+    end
+
+    it 'should do nothing if no gems specified' do
+      lambda { Buildr.application.load_gems }.should_not raise_error
+    end
+
+    it 'should install nothing if specified gems already installed' do
+      Buildr.application.should_receive(:listed_gems).and_return([Gem.loaded_specs['rspec']])
+      Util.should_not_receive(:ruby)
+      lambda { Buildr.application.load_gems }.should_not raise_error
+    end
+
+    it 'should fail if required gem not found in remote repository' do
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Gem::SourceInfoCache.should_receive(:search).and_return([])
+      lambda { Buildr.application.load_gems }.should raise_error(LoadError, /cannot be found/i)
+    end
+
+    it 'should fail if need to install gem and not running in interactive mode' do
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Gem::SourceInfoCache.should_receive(:search).and_return([@spec])
+      $stdout.should_receive(:isatty).and_return(false)
+      lambda { Buildr.application.load_gems }.should raise_error(LoadError, /this build requires the gems/i)
+    end
+
+    it 'should ask permission before installing required gems' do
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Gem::SourceInfoCache.should_receive(:search).and_return([@spec])
+      $terminal.should_receive(:agree).with(/install/, true)
+      lambda { Buildr.application.load_gems }.should raise_error
+    end
+
+    it 'should fail if permission not granted to install gem' do
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Gem::SourceInfoCache.should_receive(:search).and_return([@spec])
+      $terminal.should_receive(:agree).and_return(false)
+      lambda { Buildr.application.load_gems }.should raise_error(LoadError, /cannot build without/i)
+    end
+
+    it 'should install gem if permission granted' do
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Gem::SourceInfoCache.should_receive(:search).and_return([@spec])
+      $terminal.should_receive(:agree).and_return(true)
+      Util.should_receive(:ruby) do |*args|
+        args.should include('install', 'foo', '-v', '1.2')
+      end
+      Buildr.application.should_receive(:gem).and_return(false)
+      Buildr.application.load_gems
+    end
+
+    it 'should reload gem cache after installing required gems' do
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Gem::SourceInfoCache.should_receive(:search).and_return([@spec])
+      $terminal.should_receive(:agree).and_return(true)
+      Util.should_receive(:ruby)
+      Gem.source_index.should_receive(:load_gems_in).with(Gem::SourceIndex.installed_spec_directories)
+      Buildr.application.should_receive(:gem).and_return(false)
+      Buildr.application.load_gems
+    end
+
+    it 'should load previously installed gems' do
+      Buildr.application.should_receive(:listed_gems).and_return([Gem.loaded_specs['rspec']])
+      Buildr.application.should_receive(:gem).with('rspec', Gem.loaded_specs['rspec'].version.to_s)
+      Buildr.application.load_gems
+    end
+
+    it 'should load newly installed gems' do
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Gem::SourceInfoCache.should_receive(:search).and_return([@spec])
+      $terminal.should_receive(:agree).and_return(true)
+      Util.should_receive(:ruby)
+      Buildr.application.should_receive(:gem).with('foo', @spec.version.to_s)
+      Buildr.application.load_gems
+    end
+
+    it 'should default to >=0 version requirement if not specified' do
+      write 'build.yaml', 'gems: foo'
+      Gem::SourceInfoCache.should_receive(:search).with(Gem::Dependency.new('foo', '>=0')).and_return([])
+      lambda { Buildr.application.load_gems }.should raise_error
+    end
+
+    it 'should parse exact version requirement' do
+      write 'build.yaml', 'gems: foo 2.5'
+      Gem::SourceInfoCache.should_receive(:search).with(Gem::Dependency.new('foo', '=2.5')).and_return([])
+      lambda { Buildr.application.load_gems }.should raise_error
+    end
+
+    it 'should parse range version requirement' do
+      write 'build.yaml', 'gems: foo ~>2.3'
+      Gem::SourceInfoCache.should_receive(:search).with(Gem::Dependency.new('foo', '~>2.3')).and_return([])
+      lambda { Buildr.application.load_gems }.should raise_error
+    end
+
+    it 'should parse multiple version requirements' do
+      write 'build.yaml', 'gems: foo >=2.0 !=2.1'
+      Gem::SourceInfoCache.should_receive(:search).with(Gem::Dependency.new('foo', ['>=2.0', '!=2.1'])).and_return([])
+      lambda { Buildr.application.load_gems }.should raise_error
+    end
+  end
+
+end
+
+
+describe Buildr, 'settings' do
+
+  describe 'user' do
+
+    it 'should be empty hash if no settings.yaml file' do
+      Buildr.settings.user.should == {}
+    end
+
+    it 'should return loaded settings.yaml file' do
+      write 'home/.buildr/settings.yaml', 'foo: bar'
+      Buildr.settings.user.should == { 'foo'=>'bar' }
+    end
+
+    it 'should return loaded settings.yml file' do
+      write 'home/.buildr/settings.yml', 'foo: bar'
+      Buildr.settings.user.should == { 'foo'=>'bar' }
+    end
+
+    it 'should fail if settings.yaml file is not a hash' do
+      write 'home/.buildr/settings.yaml', 'foo bar'
+      lambda { Buildr.settings.user }.should raise_error(RuntimeError, /expecting.*settings.yaml/i)
+    end
+
+    it 'should be empty hash if settings.yaml file is empty' do
+      write 'home/.buildr/settings.yaml'
+      Buildr.settings.user.should == {}
+    end
+  end
+
+  describe 'configuration' do
+    it 'should be empty hash if no build.yaml file' do
+      Buildr.settings.build.should == {}
+    end
+
+    it 'should return loaded build.yaml file' do
+      write 'build.yaml', 'foo: bar'
+      Buildr.settings.build.should == { 'foo'=>'bar' }
+    end
+
+    it 'should return loaded build.yml file' do
+      write 'build.yml', 'foo: bar'
+      Buildr.settings.build.should == { 'foo'=>'bar' }
+    end
+
+    it 'should fail if build.yaml file is not a hash' do
+      write 'build.yaml', 'foo bar'
+      lambda { Buildr.settings.build }.should raise_error(RuntimeError, /expecting.*build.yaml/i)
+    end
+
+    it 'should be empty hash if build.yaml file is empty' do
+      write 'build.yaml'
+      Buildr.settings.build.should == {}
+    end
+  end
+
+  describe 'profiles' do
+    it 'should be empty hash if no profiles.yaml file' do
+      Buildr.settings.profiles.should == {}
+    end
+
+    it 'should return loaded profiles.yaml file' do
+      write 'profiles.yaml', <<-YAML
+        development:
+          foo: bar
+      YAML
+      Buildr.settings.profiles.should == { 'development'=> { 'foo'=>'bar' } }
+    end
+
+    it 'should return loaded profiles.yml file' do
+      write 'profiles.yml', <<-YAML
+        development:
+          foo: bar
+      YAML
+      Buildr.settings.profiles.should == { 'development'=> { 'foo'=>'bar' } }
+    end
+
+    it 'should fail if profiles.yaml file is not a hash' do
+      write 'profiles.yaml', 'foo bar'
+      lambda { Buildr.settings.profiles }.should raise_error(RuntimeError, /expecting.*profiles.yaml/i)
+    end
+
+    it 'should be empty hash if profiles.yaml file is empty' do
+      write 'profiles.yaml'
+      Buildr.settings.profiles.should == {}
+    end
+  end
+
+  describe 'profile' do
+    it 'should be empty hash if no profiles.yaml' do
+      Buildr.settings.profile.should == {}
+    end
+
+    it 'should be empty hash if no matching profile' do
+      write 'profiles.yaml', <<-YAML
+        test:
+          foo: bar
+      YAML
+      Buildr.settings.profile.should == {}
+    end
+
+    it 'should return profile matching environment name' do
+      write 'profiles.yaml', <<-YAML
+        development:
+          foo: bar
+        test:
+          foo: baz
+      YAML
+      Buildr.settings.profile.should == { 'foo'=>'bar' }
+    end
+  end
+
+  describe 'buildfile task' do
+    before do
+      @buildfile_time = Time.now - 10
+      write 'buildfile'; File.utime(@buildfile_time, @buildfile_time, 'buildfile')
+    end
+    
+    it 'should point to the buildfile' do
+      Buildr.application.buildfile.should point_to_path('buildfile')
+    end
+    
+    it 'should be a defined task' do
+      Buildr.application.buildfile.should == file(File.expand_path('buildfile'))
+    end
+    
+    it 'should ignore any rake namespace' do
+      namespace 'dummy_ns' do
+        Buildr.application.buildfile.should point_to_path('buildfile')
+      end
+    end
+    
+    it 'should have the same timestamp as the buildfile' do
+      Buildr.application.buildfile.timestamp.should be_close(@buildfile_time, 1)
+    end
+    
+    it 'should have the same timestamp as build.yaml if the latter is newer' do
+      write 'build.yaml'; File.utime(@buildfile_time + 5, @buildfile_time + 5, 'build.yaml')
+      Buildr.application.run
+      Buildr.application.buildfile.timestamp.should be_close(@buildfile_time + 5, 1)
+    end
+    
+    it 'should have the same timestamp as the buildfile if build.yaml is older' do
+      write 'build.yaml'; File.utime(@buildfile_time - 5, @buildfile_time - 5, 'build.yaml')
+      Buildr.application.run
+      Buildr.application.buildfile.timestamp.should be_close(@buildfile_time, 1)
+    end
+    
+    it 'should have the same timestamp as build.rb in home dir if the latter is newer' do
+      write 'home/buildr.rb'; File.utime(@buildfile_time + 5, @buildfile_time + 5, 'home/buildr.rb')
+      Buildr.application.send :load_tasks
+      Buildr.application.buildfile.timestamp.should be_close(@buildfile_time + 5, 1)
+    end
+
+    it 'should include explicitly required files as dependencies' do
+      write 'some/file.rb'; File.utime(@buildfile_time + 5, @buildfile_time + 5, 'some/file.rb')
+      Buildr.application.instance_variable_set(:@requires, ['rbconfig', 'some/file.rb'])
+      Buildr.application.send :load_buildfile
+      Buildr.application.buildfile.timestamp.should be_close(@buildfile_time + 5, 1)
+      Buildr.application.buildfile.prerequisites.should include(File.expand_path('some/file.rb'))
+      Buildr.application.buildfile.prerequisites.should_not include('rbconfig')
+    end
+  end
+end
+
+
+describe Buildr do
+  
+  describe 'environment' do
+    it 'should be same as Buildr.application.environment' do
+      Buildr.environment.should eql(Buildr.application.environment)
+    end
+  end
+
+  describe 'application' do
+    it 'should be same as Rake.application' do
+      Buildr.application.should == Rake.application
+    end
+  end
+
+  describe 'settings' do
+    it 'should be same as Buildr.application.settings' do
+      Buildr.settings.should == Buildr.application.settings
+    end
+  end
+end
+

data/spec/core/artifact_namespace_spec.rb

@@ -0,0 +1,646 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require File.join(File.dirname(__FILE__), '../spec_helpers')
+
+describe Buildr::ArtifactNamespace do
+
+  before(:each) { Buildr::ArtifactNamespace.clear }
+
+  def abc_module
+    Object.module_eval 'module A; module B; module C; end; end; end'
+    yield
+  ensure
+    Object.send :remove_const, :A
+  end
+
+  describe '.root' do 
+    it 'should return the top level namespace' do
+      Buildr::ArtifactNamespace.root.should be_root
+    end
+    
+    it 'should yield the namespace if a block is given' do
+      Buildr::ArtifactNamespace.root { |ns| ns.should be_root }
+    end
+  end
+
+  describe '.instance' do 
+    it 'should return the top level namespace when invoked outside a project definition' do
+      artifact_ns.should be_root
+    end
+
+    it 'should return the namespace for the receiving project' do 
+      define('foo') { }
+      project('foo').artifact_ns.name.should == 'foo'
+    end
+    
+    it 'should return the current project namespace when invoked inside a project' do
+      define 'foo' do
+        artifact_ns.should_not be_root
+        artifact_ns.name.should == 'foo'
+        task :doit do 
+          artifact_ns.should_not be_root
+          artifact_ns.name.should == 'foo'
+        end.invoke
+      end
+    end
+  
+    it 'should return the root namespace if given :root' do
+      artifact_ns(:root).should be_root
+    end
+    
+    it 'should return the namespace for the given name' do 
+      artifact_ns(:foo).name.should == 'foo'
+      artifact_ns('foo:bar').name.should == 'foo:bar'
+      artifact_ns(['foo', 'bar', 'baz']).name.should == 'foo:bar:baz'
+      abc_module do 
+        artifact_ns(A::B::C).name.should == 'A::B::C'
+      end
+      artifact_ns(:root).should be_root
+      artifact_ns(:current).should be_root
+      define 'foo' do
+        artifact_ns(:current).name.should == 'foo'
+        define 'baz' do
+          artifact_ns(:current).name.should == 'foo:baz'
+        end
+      end
+    end
+  end
+
+  describe '#parent' do 
+    it 'should be nil for root namespace' do 
+      artifact_ns(:root).parent.should be_nil
+    end
+    
+    it 'should be the parent namespace for nested modules' do 
+      abc_module do
+        artifact_ns(A::B::C).parent.should == artifact_ns(A::B)
+        artifact_ns(A::B).parent.should == artifact_ns(A)
+        artifact_ns(A).parent.should == artifact_ns(:root)
+      end
+    end
+
+    it 'should be the parent namespace for nested projects' do
+      define 'a' do 
+        define 'b' do 
+          define 'c' do
+            artifact_ns.parent.should == artifact_ns(parent)
+          end
+          artifact_ns.parent.should == artifact_ns(parent)
+        end
+        artifact_ns.parent.should == artifact_ns(:root)
+      end
+    end
+  end
+  
+  describe '#parent=' do
+    it 'should reject to set parent for root namespace' do 
+      lambda { artifact_ns(:root).parent = :foo }.should raise_error(Exception, /cannot set parent/i)
+    end
+
+    it 'should allow to set parent' do
+      artifact_ns(:bar).parent = :foo
+      artifact_ns(:bar).parent.should == artifact_ns(:foo)
+      artifact_ns(:bar).parent = artifact_ns(:baz)
+      artifact_ns(:bar).parent.should == artifact_ns(:baz)
+    end
+
+    it 'should allow to set parent to :current' do
+      abc_module do 
+        mod = A::B
+        artifact_ns(mod).parent = :current
+        def mod.stuff 
+          Buildr::artifact_ns(self)
+        end
+        define 'a' do
+          define 'b' do
+            mod.stuff.parent.should == artifact_ns
+          end
+          mod.stuff.parent.should == artifact_ns
+        end
+      end
+    end
+  end
+  
+  describe '#need' do 
+    it 'should accept an artifact spec' do
+      define 'one' do
+        artifact_ns.need 'a:b:c:1'
+        # referenced by spec
+        artifact_ns['a:b:c'].should_not be_selected
+        
+        # referenced by name
+        artifact_ns[:b].should_not be_selected
+        artifact_ns[:b].should be_satisfied_by('a:b:c:1')
+        artifact_ns[:b].should_not be_satisfied_by('a:b:c:2')
+        artifact_ns[:b].should_not be_satisfied_by('d:b:c:1')
+        artifact_ns[:b].version.should == '1'
+      end
+    end
+
+    it 'should accept a requirement_spec' do
+      define 'one' do
+        artifact_ns.need 'thing -> a:b:c:2.1 -> ~>2.0'
+        # referenced by spec
+        artifact_ns['a:b:c'].should_not be_selected
+        
+        # referenced by name
+        artifact_ns.key?(:b).should be_false
+        artifact_ns[:thing].should_not be_selected
+        artifact_ns[:thing].should be_satisfied_by('a:b:c:2.5')
+        artifact_ns[:thing].should_not be_satisfied_by('a:b:c:3')
+        artifact_ns[:thing].version.should == '2.1'
+      end
+    end
+
+    it 'should accept a hash :name -> requirement_spec' do 
+      define 'one' do
+        artifact_ns.need :thing => 'a:b:c:2.1 -> ~>2.0'
+        artifact_ns[:thing].should be_satisfied_by('a:b:c:2.5')
+        artifact_ns[:thing].should_not be_satisfied_by('a:b:c:3')
+        artifact_ns[:thing].version.should == '2.1'
+      end
+
+      define 'two' do
+        artifact_ns.need :thing => 'a:b:c:(~>2.0 | 2.1)'
+        artifact_ns[:thing].should be_satisfied_by('a:b:c:2.5')
+        artifact_ns[:thing].should_not be_satisfied_by('a:b:c:3')
+        artifact_ns[:thing].version.should == '2.1'
+      end
+    end
+
+    it 'should take a hash :name -> specs_array' do 
+      define 'one' do 
+        artifact_ns.need :things => ['foo:bar:jar:1.0',
+                                     'foo:baz:jar:2.0',]
+        artifact_ns['foo:bar:jar'].should_not be_selected
+        artifact_ns['foo:baz:jar'].should_not be_selected
+        artifact_ns[:bar, :baz].should == [nil, nil]
+        artifact_ns[:things].map(&:unversioned_spec).should include('foo:bar:jar', 'foo:baz:jar')
+        artifact_ns.alias :baz, 'foo:baz:jar'
+        artifact_ns[:baz].should == artifact_ns['foo:baz:jar']
+      end
+    end
+
+    it 'should select best matching version if defined' do 
+      define 'one' do 
+        artifact_ns.use :a => 'foo:bar:jar:1.5'
+        artifact_ns.use :b => 'foo:baz:jar:2.0'
+        define 'two' do
+          artifact_ns[:a].requirement.should be_nil
+          artifact_ns[:a].should be_selected
+
+          artifact_ns.need :c => 'foo:bat:jar:3.0'
+          artifact_ns['foo:bat:jar'].should_not be_selected
+          artifact_ns[:c].should_not be_selected
+          
+          artifact_ns.need :one => 'foo:bar:jar:>=1.0'
+          artifact_ns[:one].version.should == '1.5'
+          artifact_ns[:one].should be_selected
+          artifact_ns[:a].requirement.should be_nil
+
+          artifact_ns.need :two => 'foo:baz:jar:>2'
+          artifact_ns[:two].version.should be_nil
+          artifact_ns[:two].should_not be_selected
+          artifact_ns[:b].requirement.should be_nil
+        end
+      end
+    end
+  end
+
+  describe '#use' do 
+    it 'should register the artifact on namespace' do
+      define 'one' do
+        artifact_ns.use :thing => 'a:b:c:1'
+        artifact_ns[:thing].requirement.should be_nil
+        artifact_ns[:thing].version.should == '1'
+        artifact_ns[:thing].id.should == 'b'
+        define 'one' do
+          artifact_ns.use :thing => 'a:d:c:2'
+          artifact_ns[:thing].requirement.should be_nil
+          artifact_ns[:thing].version.should == '2'
+          artifact_ns[:thing].id.should == 'd'
+          
+          artifact_ns.use :copied => artifact_ns.parent[:thing]
+          artifact_ns[:copied].should_not == artifact_ns.parent[:thing]
+          artifact_ns[:copied].requirement.should be_nil
+          artifact_ns[:copied].version.should == '1'
+          artifact_ns[:copied].id.should == 'b'
+
+          artifact_ns.use :aliased => :copied
+          artifact_ns[:aliased].should == artifact_ns[:copied]
+
+          lambda { artifact_ns.use :invalid => :unknown }.should raise_error(NameError, /undefined/i)
+        end
+        artifact_ns[:copied].should be_nil
+      end
+    end
+
+    it 'should register two artifacts with different version on namespace' do
+      define 'one' do
+        artifact_ns.use :foo => 'a:b:c:1'
+        artifact_ns.use :bar => 'a:b:c:2'
+        artifact_ns[:foo].version.should == '1'
+        artifact_ns[:bar].version.should == '2'
+        # unversioned references the last version set.
+        artifact_ns['a:b:c'].version.should == '2'
+      end
+    end
+    
+    it 'should complain if namespace requirement is not satisfied' do
+      define 'one' do
+        artifact_ns.need :bar => 'foo:bar:baz:~>1.5'
+        lambda { artifact_ns.use :bar => '1.4' }.should raise_error(Exception, /unsatisfied/i)
+      end
+    end
+
+    it 'should be able to register a group' do 
+      specs = ['its:me:here:1', 'its:you:there:2']
+      artifact_ns.use :them => specs
+      artifact_ns[:them].map(&:to_spec).should == specs
+      artifact_ns['its:me:here'].should_not be_nil
+      artifact_ns[:you].should be_nil
+    end
+
+    it 'should be able to assign sub namespaces' do 
+      artifact_ns(:foo).bar = "foo:bar:baz:0"
+      artifact_ns(:moo).foo = artifact_ns(:foo)
+      artifact_ns(:moo).foo.should == artifact_ns(:foo)
+      artifact_ns(:moo).foo_bar.should == artifact_ns(:foo).bar
+    end
+
+  end
+
+  describe '#values' do 
+    it 'returns the artifacts defined on namespace' do 
+      define 'foo' do
+        artifact_ns.use 'foo:one:baz:1.0'
+        define 'bar' do
+          artifact_ns.use 'foo:two:baz:1.0'
+          
+          specs = artifact_ns.values.map(&:to_spec)
+          specs.should include('foo:two:baz:1.0')
+          specs.should_not include('foo:one:baz:1.0')
+
+          specs = artifact_ns.values(true).map(&:to_spec)
+          specs.should include('foo:two:baz:1.0', 'foo:one:baz:1.0')
+        end
+      end
+    end
+  end
+
+  describe '#values_at' do 
+    it 'returns the named artifacts' do 
+      define 'foo' do
+        artifact_ns.use 'foo:one:baz:1.0'
+        define 'bar' do
+          artifact_ns.use :foo_baz => 'foo:two:baz:1.0'
+          
+          specs = artifact_ns.values_at('one').map(&:to_spec)
+          specs.should include('foo:one:baz:1.0')
+          specs.should_not include('foo:two:baz:1.0')
+
+          specs = artifact_ns.values_at('foo_baz').map(&:to_spec)
+          specs.should include('foo:two:baz:1.0')
+          specs.should_not include('foo:one:baz:1.0')
+        end
+      end
+    end
+
+    it 'returns first artifacts by their unversioned spec' do
+      define 'foo' do
+        artifact_ns.use 'foo:one:baz:2.0'
+        define 'bar' do
+          artifact_ns.use :older => 'foo:one:baz:1.0'
+          
+          specs = artifact_ns.values_at('foo:one:baz').map(&:to_spec)
+          specs.should include('foo:one:baz:1.0')
+          specs.should_not include('foo:one:baz:2.0')
+        end
+        specs = artifact_ns.values_at('foo:one:baz').map(&:to_spec)
+        specs.should include('foo:one:baz:2.0')
+        specs.should_not include('foo:one:baz:1.0')
+      end
+    end
+
+    it 'return first artifact satisfying a dependency' do
+      define 'foo' do
+        artifact_ns.use 'foo:one:baz:2.0'
+        define 'bar' do
+          artifact_ns.use :older => 'foo:one:baz:1.0'
+          
+          specs = artifact_ns.values_at('foo:one:baz:>1.0').map(&:to_spec)
+          specs.should include('foo:one:baz:2.0')
+          specs.should_not include('foo:one:baz:1.0')
+        end
+      end
+    end
+  end
+  
+  describe '#method_missing' do 
+    it 'should use cool_aid! to create a requirement' do 
+      define 'foo' do
+        artifact_ns.cool_aid!('cool:aid:jar:2').should be_kind_of(ArtifactNamespace::ArtifactRequirement)
+        artifact_ns[:cool_aid].version.should == '2'
+        artifact_ns[:cool_aid].should_not be_selected
+        define 'bar' do 
+          artifact_ns.cool_aid! 'cool:aid:man:3', '>2'
+          artifact_ns[:cool_aid].version.should == '3'
+          artifact_ns[:cool_aid].requirement.should be_satisfied_by('2.5')
+          artifact_ns[:cool_aid].should_not be_selected
+        end
+      end
+    end
+
+    it 'should use cool_aid= as shorhand for [:cool_aid]=' do 
+      artifact_ns.cool_aid = 'cool:aid:jar:1'
+      artifact_ns[:cool_aid].should be_selected
+    end
+    
+    it 'should use cool_aid as shorthand for [:cool_aid]' do
+      artifact_ns.need :cool_aid => 'cool:aid:jar:1'
+      artifact_ns.cool_aid.should_not be_selected
+    end
+
+    it 'should use cool_aid? to test if artifact has been defined and selected' do
+      artifact_ns.need :cool_aid => 'cool:aid:jar:>1'
+      artifact_ns.should_not have_cool_aid
+      artifact_ns.should_not have_unknown
+      artifact_ns.cool_aid = '2'
+      artifact_ns.should have_cool_aid
+    end
+  end
+
+  describe '#ns' do 
+    it 'should create a sub namespace' do
+      artifact_ns.ns :foo
+      artifact_ns[:foo].should be_kind_of(ArtifactNamespace)
+      artifact_ns(:foo).should_not === artifact_ns.foo
+      artifact_ns.foo.parent.should == artifact_ns
+    end
+    
+    it 'should take any use arguments' do
+      artifact_ns.ns :foo, :bar => 'foo:bar:jar:0', :baz => 'foo:baz:jar:0'
+      artifact_ns.foo.bar.should be_selected
+      artifact_ns.foo[:baz].should be_selected
+    end
+    
+    it 'should access sub artifacts using with foo_bar like syntax' do 
+      artifact_ns.ns :foo, :bar => 'foo:bar:jar:0', :baz => 'foo:baz:jar:0'
+      artifact_ns[:foo_baz].should be_selected
+      artifact_ns.foo_bar.should be_selected
+      
+      artifact_ns.foo.ns :bat, 'bat:man:jar:>1'
+      batman = artifact_ns.foo.bat.man
+      batman.should be_selected
+      artifact_ns[:foo_bat_man] = '3'
+      artifact_ns[:foo_bat_man].should == batman
+      artifact_ns[:foo_bat_man].version.should == '3'
+    end
+
+    it 'should include sub artifacts when calling #values' do 
+      artifact_ns.ns :bat, 'bat:man:jar:>1'
+      artifact_ns.values.should_not be_empty
+      artifact_ns.values.first.unversioned_spec.should == 'bat:man:jar'
+    end
+
+    it 'should reopen a sub-namespace' do
+      artifact_ns.ns :bat, 'bat:man:jar:>1'
+      bat = artifact_ns[:bat]
+      bat.should == artifact_ns.ns(:bat)
+    end
+
+    it 'should fail reopening if not a sub-namespace' do
+      artifact_ns.foo = 'foo:bar:baz:0'
+      lambda { artifact_ns.ns(:foo) }.should raise_error(TypeError, /not a sub/i)
+    end
+
+    it 'should clone artifacts when assigned' do 
+      artifact_ns(:foo).bar = "foo:bar:jar:0"
+      artifact_ns(:moo).ns :muu, :miu => artifact_ns(:foo).bar
+      artifact_ns(:moo).muu.miu.should_not == artifact_ns(:foo).bar
+      artifact_ns(:moo).muu.miu.to_spec.should == artifact_ns(:foo).bar.to_spec
+    end
+    
+    it 'should clone parent artifacts by name' do
+      define 'foo' do
+        artifact_ns.bar = "foo:bar:jar:0"
+        define 'moo' do
+          artifact_ns.ns(:muu).use :bar
+          artifact_ns.muu_bar.should be_selected
+          artifact_ns.muu.bar.should_not == artifact_ns.bar
+        end
+      end
+    end
+  end
+
+  it 'should be an Enumerable' do
+    artifact_ns.should be_kind_of(Enumerable)
+    artifact_ns.use 'foo:bar:baz:1.0'
+    artifact_ns.map(&:artifact).should include(artifact('foo:bar:baz:1.0'))
+  end
+
+end # ArtifactNamespace
+
+describe Buildr do
+  before(:each) { Buildr::ArtifactNamespace.clear }
+
+  describe '.artifacts' do 
+    it 'should take ruby symbols and ask the current namespace for them' do
+      define 'foo' do 
+        artifact_ns.cool = 'cool:aid:jar:1.0'
+        artifact_ns.use 'some:other:jar:1.0'
+        artifact_ns.use 'bat:man:jar:1.0'
+        compile.with :cool, :other, :'bat:man:jar'
+        compile.classpath.map(&:to_spec).should include('cool:aid:jar:1.0', 'some:other:jar:1.0', 'bat:man:jar:1.0')
+      end
+    end
+    
+    it 'should take a namespace' do 
+      artifact_ns(:moo).muu = 'moo:muu:jar:1.0'
+      define 'foo' do
+        compile.with artifact_ns(:moo)
+        compile.classpath.map(&:to_spec).should include('moo:muu:jar:1.0')
+      end
+    end
+  end
+  
+  describe '.artifact' do
+    it 'should search current namespace if given a symbol' do 
+      define 'foo' do 
+        artifact_ns.use :cool => 'cool:aid:jar:1.0'
+        define 'bar' do
+          artifact(:cool).should == artifact_ns[:cool].artifact
+        end
+      end
+    end
+    
+    it 'should search current namespace if given a symbol spec' do 
+      define 'foo' do 
+        artifact_ns.use 'cool:aid:jar:1.0'
+        define 'bar' do
+          artifact(:'cool:aid:jar').should == artifact_ns[:aid].artifact
+        end
+      end
+    end
+    
+    it 'should fail when no artifact by that name is found' do
+      define 'foo' do 
+        artifact_ns.use 'cool:aid:jar:1.0'
+        define 'bar' do
+          lambda { artifact(:cool) }.should raise_error(IndexError, /artifact/)
+        end
+      end
+    end
+  end
+end
+
+describe "Extension using ArtifactNamespace" do
+  before(:each) { Buildr::ArtifactNamespace.clear }
+
+  def abc_module
+    Object.module_eval 'module A; module B; module C; end; end; end'
+    yield
+  ensure
+    Object.send :remove_const, :A
+  end
+  
+  it 'can register namespace listeners' do
+    abc_module do
+      # An example extension to illustrate namespace listeners and method forwarding
+      class A::Example
+        
+        module Ext
+          include Buildr::Extension
+          def example; @example ||= A::Example.new; end
+          before_define do |p|
+            Rake::Task.define_task('example') { p.example.doit }
+          end
+        end
+        
+        REQUIRES = ArtifactNamespace.for(self) do |ns|
+          ns.xmlbeans! 'org.apache.xmlbeans:xmlbeans:jar:2.3.0', '>2'
+          ns.stax_api! 'stax:stax-api:jar:>=1.0.1'
+        end
+
+        attr_reader :options, :requires
+        
+        def initialize
+          # We could actually use the REQUIRES namespace, but to make things
+          # a bit more interesting, suppose each Example instance can have its 
+          # own artifact requirements in adition to those specified on REQUIRES.
+          # To achieve this we create an anonymous namespace.
+          @requires = ArtifactNamespace.new # a namespace per instance
+          REQUIRES.each { |requirement| @requires.need requirement }
+          
+          # For user convenience, we make the options object respond to
+          #    :xmlbeans, :xmlbeans=, :xmlbeans?
+          # forwarding them to the namespace.
+          @options = OpenObject.new.extend(@requires.accessor(:xmlbeans, :stax_api))
+          # Register callbacks so we can perform some logic when an artifact
+          # is selected by the user.
+          options.xmlbeans.add_listener &method(:selected_xmlbeans)
+          options.stax_api.add_listener do |stax|
+            # Now using a proc
+            stax.should be_selected
+            stax.version.should == '1.6180'
+            options[:math] = :golden # customize our options for this version
+            # In this example we set the stax version when running outside
+            # a project definition. This means we have no access to the project
+            # namespace unless we had a reference to the project or knew it's name
+            Buildr.artifact_ns(:current).name.should == 'root'
+          end
+        end
+
+        include Spec::Matchers # for assertions
+        
+        # Called with the ArtifactRequirement that has just been selected
+        # by a user. This allows extension author to selectively perform
+        # some action by inspecting the requirement state.
+        def selected_xmlbeans(xmlbeans)
+          xmlbeans.should be_selected
+          xmlbeans.version.should == '3.1415'
+          options[:math] = :pi
+          # This example just sets xmlbeans for foo:bar project
+          # So the currently running namespace should have the foo:bar name
+          Buildr.artifact_ns(:current).name.should == 'foo:bar'
+        end
+
+        # Suppose we invoke an ant task here or something else.
+        def doit
+          # Now call ant task with our selected artifact and options
+          classpath = requires.map(&:artifact).map(&:to_s).join(File::PATH_SEPARATOR)
+          lambda { ant('thing') { |ant| ant.classpath classpath, :math => options[:math] } }
+          
+          # We are not a Project instance, hence we have no artifact_ns
+          lambda { artifact_ns }.should raise_error(NameError)
+
+          # Extension authors may NOT rely project's namespaces.
+          # However the ruby-way gives you power and at the same time 
+          # makes you dangerous, (think open-modules, monkey-patching)
+          # Given that buildr is pure ruby, consider it a sharp-edged sword.
+          # Having said that, you may actually inspect a project's 
+          # namespace, but don't write on it without letting your users
+          # know you will.
+          # This example obtains the current project namespace to make
+          # some assertions.
+          
+          # To obtain a project's namespace we need either
+          # 1) a reference to the project, and call artifact_ns on it
+          #      project.artifact_ns  # the namespace for project
+          # 2) know the project name
+          #      Buildr.artifact_ns('the:project')
+          # 3) Use :current to reference the currently running project
+          #      Buildr.artifact_ns(:current)
+          name = Buildr.artifact_ns(:current).name
+          case name
+          when 'foo:bar'
+            options[:math].should == :pi
+            requires.xmlbeans.version.should == '3.1415'
+            requires.stax_api.version.should == '1.0.1'
+          when 'foo:baz'
+            options[:math].should == :golden
+            requires.xmlbeans.version.should == '2.3.0'
+            requires.stax_api.version.should == '1.6180'
+          else
+            fail "This example expects foo:bar or foo:baz projects not #{name.inspect}"
+          end
+        end
+      end
+      
+      define 'foo' do
+        define 'bar' do
+          extend A::Example::Ext
+          task('setup') do
+            example.options.xmlbeans = '3.1415'
+          end
+          task('run' => [:setup, :example])
+        end
+        define 'baz' do
+          extend A::Example::Ext
+        end
+      end
+
+      project('foo:bar').example.requires.should_not == project('foo:baz').example.requires
+      project('foo:bar').example.requires.xmlbeans.should_not == project('foo:baz').example.requires.xmlbeans
+      
+      # current namespace outside a project is :root, see the stax callback
+      project('foo:baz').example.options.stax_api = '1.6180'
+      # we call the task outside the project, see #doit
+      lambda { task('foo:bar:run').invoke }.should run_task('foo:bar:example')
+      lambda { task('foo:baz:example').invoke }.should run_task('foo:baz:example')
+    end
+  end
+end