assaf-buildr 1.3.3

data/lib/buildr/packaging/artifact_namespace.rb

@@ -0,0 +1,972 @@
+# 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 'buildr/java/version_requirement'
+
+
+module Buildr
+  
+  # An ArtifactNamespace is a hierarchical dictionary used to manage ArtifactRequirements.
+  # It can be used to have different artifact versions per project
+  # or to allow users to select a version for addons or modules.
+  #
+  # Namespaces are opened using the Buildr.artifact_ns method, most important methods are:
+  # [need]      Used to create a requirement on the namespace.
+  # [use]       Set the artifact version to use for a requirement.
+  # [values_at] Reference requirements by name.
+  # [each]      Return each ArtifactRequirement in the namespace.
+  # The method_missing method for instances provides some syntactic sugar to these.
+  # See the following examples, and the methods for ArtifactRequirement.
+  #
+  # = Avoiding constant polution on buildfile
+  #
+  # Each project has its own ArtifactNamespace inheriting the one from the 
+  # parent project up to the root namespace.
+  # 
+  # Consider the following snippet, as project grows, each subproject 
+  # may need diferent artifact combinations and/or versions. Asigning 
+  # artifact specifications to constants can make it painful to maintain
+  # their references even if using structs/hashes.
+  #
+  #   -- buildfile --
+  #   SPRING = 'org.springframework:spring:jar:2.5'
+  #   SPRING_OLD = 'org.springframework:spring:jar:1.0'
+  #   LOGGING = ['comons-logging:commons-logging:jar:1.1.1', 
+  #              'log4j:log4j:jar:1.2.15']
+  #   WL_LOGGING = artifact('bea:wlcommons-logging:jar:8.1').from('path/to/wlcommons-logging.jar')
+  #   LOGGING_WEBLOGIC = ['comons-logging:commons-logging:jar:1.1.1', 
+  #                       WL_LOGGING]
+  #   COMMONS = struct :collections => 'commons-collection:commons-collection:jar:3.1',
+  #                    :net => 'commons-net:commons-net:jar:1.4.0'
+  #   
+  #   define 'example1' do
+  #     define 'one' do
+  #       compile.with SPRING, LOGGING_WEBLOGIC, COMMONS
+  #     end
+  #     define 'two' do
+  #       compile.with SPRING_OLD, LOGGING, COMMONS
+  #     end
+  #     define 'three' do
+  #       compile.with "commons-collections:commons-collections:jar:2.2"
+  #     end
+  #   end
+  #
+  # 
+  # With ArtifactNamespace you can do some more advanced stuff, the following
+  # annotated snipped could still be reduced if default artifact definitions were
+  # loaded from yaml file (see section bellow and ArtifactNamespace.load).
+  # 
+  #   -- buildfile --
+  #   artifact_ns do |ns| # the current namespace (root if called outside a project)
+  #     # default artifacts
+  #     ns.spring = 'org.springframework:spring:jar:2.5'
+  #     # default logger is log4j
+  #     ns.logger = 'log4j:log4j:jar:1.2.15'
+  #
+  #     # create a sub namespace by calling the #ns method,
+  #     # artifacts defined on the sub-namespace can be referenced by
+  #     # name :commons_net or by calling commons.net
+  #     ns.ns :commons, :net => 'commons-net:commons-net:jar:1.4.0',
+  #                     :logging => 'comons-logging:commons-logging:jar:1.1.1'
+  #
+  #
+  #     # When a child namespace asks for the :log artifact, 
+  #     # these artifacts will be searched starting from the :current namespace.
+  #     ns.virtual :log, :logger, :commons_logging
+  #   end
+  #   
+  #   artifact_ns('example2:one') do |ns| # namespace for the one subproject
+  #     ns.logger = artifact('bea:wlcommons-logging:jar:8.1').from('path/to/wlcommons-logging.jar')
+  #   end
+  #   artifact_ns('example2:two') do |ns| 
+  #     ns.spring = '1.0' # for project two use an older spring version (just for an example)
+  #   end
+  #   artifact_ns('example2:three').commons_collections = 2.2'
+  #   artifact_ns('example2:four') do |ns|
+  #     ns.beanutils = 'commons-beanutils:commons-beanutils:jar:1.5'        # just for this project
+  #     ns.ns(:compilation).use :commons_logging, :beanutils, :spring       # compile time dependencies
+  #     ns.ns(:testing).use :log, :beanutils, 'cglib:cglib-nodep:jar:2.1.3' # run time dependencies
+  #   end
+  #   
+  #   define 'example2' do 
+  #     define 'one' do
+  #       compile.with :spring, :log, :commons # uses weblogic logging
+  #     end
+  #     define 'two' do
+  #       compile.with :spring, :log, :commons # will take old spring
+  #     end
+  #     define 'three' do
+  #       compile.with :commons_collections
+  #       test.with artifact_ns('example2:two').spring # use spring from project two
+  #     end
+  #     define 'four' do
+  #       compile.with artifact_ns.compilation
+  #       test.with artifact_ns.testing
+  #     end
+  #     task(:down_them_all) do # again, just to fill this space with something ;)
+  #       parent.projects.map(&method(:artifact_ns)).map(&:artifacts).map(&:invoke)
+  #     end
+  #   end
+  #
+  # = Loading from a yaml file (e. profiles.yaml)
+  #
+  # If your projects use lots of jars (after all we are using java ;) you may prefer
+  # to have constant artifact definitions on an external file.
+  # Doing so would allow an external tool (or future Buildr feature) to maintain
+  # an artifacts.yaml for you.
+  # An example usage is documented on the ArtifactNamespace.load method.
+  #
+  # = For addon/plugin writers & Customizing artifact versions
+  # 
+  # Sometimes users would need to change the default artifact versions used by some
+  # module, for example, the XMLBeans compiler needs this, because of compatibility
+  # issues. Another example would be to select the groovy version to use on all our
+  # projects so that Buildr modules requiring groovy jars can use user prefered versions.
+  #
+  # To meet this goal, an ArtifactNamespace allows to specify ArgumentRequirement objects.
+  # In fact the only diference with the examples you have already seen is that requirements
+  # have an associated VersionRequirement, so that each time a user tries to select a version,
+  # buildr checks if it satisfies the requirements.
+  #
+  # Requirements are declared using the ArtifactNamespace#need method, but again,
+  # syntactic sugar is provided by ArtifactNamespace#method_missing.
+  #
+  # The following example is taken from the XMLBeans compiler module.
+  # And illustrates how addon authors should specify their requirements, 
+  # provide default versions, and document the namespace for users to customize.
+  # 
+  #    module Buildr::XMLBeans
+  #
+  #       # You need to document this constant, giving users some hints
+  #       # about when are (maybe some of) these artifacts used. I mean, 
+  #       # some modules, add jars to the Buildr classpath when its file 
+  #       # is required, you would need to tell your users, so that they
+  #       # can open the namespace and specify their defaults. Of course
+  #       # when the requirements are defined, buildr checks if any compatible
+  #       # version has been already defined, if so, uses it.
+  #       #
+  #       # Some things here have been changed to illustrate their meaning.
+  #       REQUIRES = ArtifactNamespace.for(self).tap do |ns|
+  #
+  #         # This jar requires a >2.0 version, default being 2.3.0
+  #         ns.xmlbeans! 'org.apache.xmlbeans:xmlbeans:jar:2.3.0', '>2'
+  #
+  #         # Users can customize with Buildr::XMLBeans::REQUIRES.stax_api = '1.2'
+  #         # This is a non-flexible requirement, only satisfied by version 1.0.1
+  #         ns.stax_api! 'stax:stax-api:jar:1.0.1'
+  #
+  #         # This one is not part of XMLBeans, but is just another example
+  #         # illustrating an `artifact requirement spec`.
+  #
+  #         ns.need " some_name ->  ar:ti:fact:3.2.5 ->  ( >2 & <4)"
+  #
+  #         # As you can see it's just an artifact spec, prefixed with
+  #         # ' some_name -> ', this means users can use that name to 
+  #         # reference the requirement, also this string has a VersionRequirement
+  #         # just after another ->.
+  #       end
+  #
+  #       # The REQUIRES constant is an ArtifactNamespace instance, 
+  #       # that means we can use it directly. Note that calling 
+  #       # Buildr.artifact_ns would lead to the currently executing context,
+  #       # not the one for this module.
+  #       def use
+  #         # test if user specified his own version, if so, we could perform some
+  #         # functionallity based on this.
+  #         REQUIRES.some_name.selected? # => false 
+  #         
+  #         REQUIRES.some_name.satisfied_by?('1.5') # => false
+  #         puts REQUIRES.some_name.requirement     # => ( >2 & <4 )
+  #
+  #         REQUIRES.artifacts # get the Artifact tasks
+  #       end
+  #
+  #    end 
+  #
+  # A more advanced example using ArtifactRequirement listeners is included 
+  # in the artifact_namespace_spec.rb description for 'Extension using ArtifactNamespace'
+  # That's it for addon writers, now, users can select their prefered version with
+  # something like:
+  #
+  #    require 'buildr/xmlbeans'
+  #    Buildr::XMLBeans::REQUIRES.xmlbeans = '2.2.0'
+  #
+  # More advanced stuff, if users really need to select an xmlbeans version
+  # per project, they can do so letting :current (that is, the currently running
+  # namespace) be parent of the REQUIRES namespace:
+  #
+  #    Buildr::XMLBeans::REQUIRES.parent = :current
+  #
+  # Now, provided that the compiler does not caches its artifacts, it will 
+  # select the correct version. (See the first section for how to select per project 
+  # artifacts).
+  #
+  #
+  class ArtifactNamespace
+    class << self
+      # Forget all namespaces, create a new ROOT
+      def clear
+        @instances = nil
+        remove_const(:ROOT) if const_defined?(:ROOT)
+        const_set(:ROOT, new('root'))
+      end
+
+      # Populate namespaces from a hash of hashes. 
+      # The following example uses the profiles yaml to achieve this.
+      #
+      #   -- profiles.yaml --
+      #   development:
+      #     artifacts:
+      #       root:        # root namespace
+      #         spring:     org.springframework:spring:jar:2.5
+      #         groovy:     org.codehaus.groovy:groovy:jar:1.5.4
+      #         logging:    # define a named group
+      #           - log4j:log4j:jar:1.2.15
+      #           - commons-logging:commons-logging:1.1.1
+      #       
+      #       # open Buildr::XMLBeans namespace
+      #       Buildr::XMLBeans:
+      #         xmlbeans: 2.2
+      #
+      #       # for subproject one:oldie
+      #       one:oldie:
+      #         spring:  org.springframework:spring:jar:1.0
+      #
+      #   -- buildfile --
+      #   ArtifactNamespace.load(Buildr.profile['artifacts'])
+      def load(namespaces = {})
+        namespaces.each_pair { |name, uses| instance(name).use(uses) }
+      end
+      
+      # :call-seq:
+      #   ArtifactNamespace.instance { |current_ns| ... } -> current_ns
+      #   ArtifactNamespace.instance(name) { |ns| ... } -> ns
+      #   ArtifactNamespace.instance(:current) { |current_ns| ... } -> current_ns
+      #   ArtifactNamespace.instance(:root) { |root_ns| ... } -> root_ns
+      #
+      # Obtain an instance for the given name
+      def instance(name = nil)
+        case name
+        when :root, 'root' then return ROOT
+        when ArtifactNamespace then return name
+        when Array then name = name.join(':')
+        when Module, Project then name = name.name
+        when :current, 'current', nil then
+          task = Thread.current[:rake_chain]
+          task = task.instance_variable_get(:@value) if task
+          name = case task
+                 when Project then task.name
+                 when Rake::Task then task.scope.join(':')
+                 when nil then Buildr.application.current_scope.join(':')
+                 end
+        end
+        name = name.to_s
+        return ROOT if name.size == 0
+        name = name.to_s
+        @instances ||= Hash.new { |h, k| h[k] = new(k) }
+        instance = @instances[name]
+        yield(instance) if block_given?
+        instance
+      end
+
+      alias_method :[], :instance
+      alias_method :for, :instance
+      
+      # :call-seq:
+      #   ArtifactNamespace.root { |ns| ... } -> ns
+      #
+      # Obtain the root namespace, returns the ROOT constant
+      def root
+        yield ROOT if block_given?
+        ROOT
+      end
+    end
+
+    module DClone #:nodoc:
+      def dclone 
+        clone = self.clone
+        clone.instance_variables.each do |i| 
+          value = clone.instance_variable_get(i)
+          value = value.dclone rescue
+          clone.instance_variable_set(i, value)
+        end
+        clone
+      end
+    end
+
+    class Registry < Hash #:nodoc:
+      include DClone
+
+      attr_accessor :parent
+      def alias(new_name, old_name)
+        new_name = new_name.to_sym
+        old_name = old_name.to_sym
+        if obj = get(old_name, true)
+          self[new_name] = obj
+          @aliases ||= []
+          group = @aliases.find { |a| a.include?(new_name) }
+          group.delete(new_name) if group
+          group = @aliases.find { |a| a.include?(old_name) }
+          @aliases << (group = [old_name]) unless group
+          group << new_name unless group.include?(new_name)
+        end
+        obj
+      end
+      
+      def aliases(name)
+        return [] unless name
+        name = name.to_sym
+        ((@aliases ||= []).find { |a| a.include?(name) } || [name]).dup
+      end
+
+      def []=(key, value)
+        return unless key
+        super(key.to_sym, value)
+      end
+
+      def get(key, include_parent = nil)
+        [].tap { |a| aliases(key).select { |n| a[0] = self[n] } }.first || 
+          (include_parent && parent && parent.get(key, include_parent))
+      end
+
+      def keys(include_parent = nil)
+        (super() | (include_parent && parent && parent.keys(include_parent) || [])).uniq
+      end
+
+      def values(include_parent = nil)
+        (super() | (include_parent && parent && parent.values(include_parent) || [])).uniq
+      end
+
+      def key?(key, include_parent = nil)
+        return false unless key
+        super(key.to_sym) || (include_parent && parent && parent.key?(key, include_parent))
+      end
+
+      def delete(key, include_parent = nil)
+        aliases(key).map {|n| super(n) } && include_parent && parent && parent.delete(key, include_parent)
+      end
+    end
+
+    # An artifact requirement is an object that ActsAsArtifact and has
+    # an associated VersionRequirement. It also knows the name (some times equal to the 
+    # artifact id) that is used to store it in an ArtifactNamespace.
+    class ArtifactRequirement
+      attr_accessor :version
+      attr_reader :name, :requirement
+
+      include DClone
+  
+      # Create a requirement from an `artifact requirement spec`.
+      # This spec has three parts, separated by  -> 
+      # 
+      #     some_name ->  ar:ti:fact:3.2.5 ->  ( >2 & <4)
+      #
+      # As you can see it's just an artifact spec, prefixed with
+      #     some_name ->
+      # the :some_name symbol becomes this object's name and
+      # is used to store it on an ArtifactNamespace.
+      #
+      #                   ar:ti:fact:3.2.5
+      #
+      # The second part is an artifact spec by itself, and specifies
+      # all remaining attributes, the version of this spec becomes
+      # the default version of this requirement.
+      #
+      # The last part consist of a VersionRequirement.
+      #                                     ->  ( >2 & <4)
+      #                        
+      # VersionRequirement supports RubyGem's comparision operators
+      # in adition to parens, logical and, logical or and negation.
+      # See the docs for VersionRequirement for more info on operators.
+      def initialize(spec)
+        self.class.send :include, ActsAsArtifact unless ActsAsArtifact === self
+        if ArtifactRequirement === spec
+          copy_attrs(spec)
+        else
+          spec = requirement_hash(spec)
+          apply_spec(spec[:spec])
+          self.name = spec[:name]
+          @requirement = spec[:requirement]
+          @version = @requirement.default if VersionRequirement.requirement?(@version)
+        end
+      end
+
+      # Copy attributes from other to this object
+      def copy_attrs(other)
+        (ActsAsArtifact::ARTIFACT_ATTRIBUTES + [:name, :requirement]).each do |attr|
+          value = other.instance_variable_get("@#{attr}")
+          value = value.dup if value && !value.kind_of?(Numeric) && !value.kind_of?(Symbol)
+          instance_variable_set("@#{attr}", value)
+        end
+      end
+
+      def name=(name)
+        @name = name.to_s
+      end
+      
+      # Set a the requirement, this must be an string formatted for
+      # VersionRequirement#create to parse.
+      def requirement=(version_requirement)
+        @requirement = VersionRequirement.create(version_requirement.to_s)
+      end
+
+      # Return a hash consisting of :name, :spec, :requirement
+      def requirement_hash(spec = self)
+        result = {}
+        if String === spec 
+          parts = spec.split(/\s*->\s*/, 3).map(&:strip)
+          case parts.size
+          when 1
+            result[:spec] = Artifact.to_hash(parts.first)
+          when 2
+            if /^\w+$/ === parts.first
+              result[:name] = parts.first
+              result[:spec] = Artifact.to_hash(parts.last)
+            else
+              result[:spec] = Artifact.to_hash(parts.first)
+              result[:requirement] = VersionRequirement.create(parts.last)
+            end
+          when 3
+            result[:name] = parts.first
+            result[:spec] = Artifact.to_hash(parts[1])
+            result[:requirement] = VersionRequirement.create(parts.last)
+          end
+        else
+          result[:spec] = Artifact.to_hash(spec)
+        end
+        result[:name] ||= result[:spec][:id].to_s.to_sym
+        result[:requirement] ||= VersionRequirement.create(result[:spec][:version])
+        result
+      end
+      
+      # Test if this requirement is satisfied by an artifact spec.
+      def satisfied_by?(spec)
+        return false unless requirement
+        spec = Artifact.to_hash(spec)
+        hash = to_spec_hash
+        hash.delete(:version)
+        version = spec.delete(:version)
+        hash == spec && requirement.satisfied_by?(version)
+      end
+
+      # Has user selected a version for this requirement?
+      def selected?
+        @selected
+      end
+
+      def selected! #:nodoc:
+        @selected = true
+        @listeners.each { |l| l.call(self) } if @listeners
+        self
+      end
+
+      def add_listener(&callback)
+        (@listeners ||= []) << callback
+      end
+
+      # Return the Artifact object for the currently selected version
+      def artifact
+        ::Buildr.artifact(self)
+      end
+
+      # Format this requirement as an `artifact requirement spec`
+      def to_requirement_spec
+        result = to_spec
+        result = "#{name} -> #{result}" if name
+        result = "#{result} -> #{requirement}" if requirement
+        result
+      end
+
+      def to_s #:nodoc:
+        id ? to_requirement_spec : version
+      end
+
+      # Return an artifact spec without the version part.
+      def unversioned_spec
+        str = to_spec
+        return nil if str =~ /^:+/
+        ary = str.split(':')
+        ary = ary[0...-1] if ary.size > 3
+        ary.join(':')
+      end
+    
+      class << self
+        # Return an artifact spec without the version part.
+        def unversioned_spec(spec)
+          str = spec.to_s
+          return nil if str =~ /^:+/
+          ary = str.split(':')
+          ary = ary[0...-1] if ary.size > 3
+          if ary.size > 2
+            ary.join(':')
+          else
+            new(spec).unversioned_spec
+          end
+        end
+      end
+    end
+
+    include DClone
+    include Enumerable
+    attr_reader :name
+    
+    def initialize(name = nil) #:nodoc:
+      @name = name.to_s if name
+    end
+    clear
+    
+    def root
+      ROOT
+    end
+    
+    # ROOT namespace has no parent
+    def parent
+      if root?
+        nil
+      elsif @parent.kind_of?(ArtifactNamespace)
+        @parent
+      elsif @parent
+        ArtifactNamespace.instance(@parent)
+      elsif name
+        parent_name = name.gsub(/::?[^:]+$/, '')
+        parent_name == name ? root : ArtifactNamespace.instance(parent_name)
+      else
+        root
+      end
+    end
+    
+    # Set the parent for the current namespace, except if it is ROOT
+    def parent=(other)
+      raise 'Cannot set parent of root namespace' if root?
+      @parent = other
+      @registry = nil
+    end
+    
+    # Is this the ROOT namespace?
+    def root?
+      ROOT == self
+    end
+
+    # Create a named sub-namespace, sub-namespaces are themselves 
+    # ArtifactNamespace instances but cannot be referenced by
+    # the Buildr.artifact_ns, ArtifactNamespace.instance methods. 
+    # Reference needs to be through this object using the given +name+
+    #
+    #   artifact_ns('foo').ns(:bar).need :thing => 'some:thing:jar:1.0'
+    #   artifact_ns('foo').bar # => the sub-namespace 'foo.bar'
+    #   artifact_ns('foo').bar.thing # => the some thing artifact
+    #
+    # See the top level ArtifactNamespace documentation for examples
+    def ns(name, *uses, &block)
+      name = name.to_sym
+      sub = registry[name]
+      if sub
+        raise TypeError.new("#{name} is not a sub namespace of #{self}") unless sub.kind_of?(ArtifactNamespace)
+      else
+        sub = ArtifactNamespace.new("#{self.name}.#{name}")
+        sub.parent = self
+        registry[name] = sub
+      end
+      sub.use(*uses)
+      yield sub if block_given?
+      sub
+    end
+
+    # Test if a sub-namespace by the given name exists
+    def ns?(name)
+      sub = registry[name.to_sym]
+      ArtifactNamespace === sub
+    end
+
+    # :call-seq:
+    #   artifact_ns.need 'name -> org:foo:bar:jar:~>1.2.3 -> 1.2.5'
+    #   artifact_ns.need :name => 'org.foo:bar:jar:1.0'
+    #
+    # Create a new ArtifactRequirement on this namespace.
+    # ArtifactNamespace#method_missing provides syntactic sugar for this.
+    def need(*specs)
+      named = specs.flatten.inject({}) do |seen, spec|
+        if Hash === spec && (spec.keys & ActsAsArtifact::ARTIFACT_ATTRIBUTES).empty?
+          spec.each_pair do |name, spec|
+            if Array === spec # a group
+              seen[name] ||= spec.map { |s| ArtifactRequirement.new(s) }
+            else
+              artifact = ArtifactRequirement.new(spec)
+              artifact.name = name
+              seen[artifact.name] ||= artifact
+            end
+          end
+        else
+          artifact = ArtifactRequirement.new(spec)
+          seen[artifact.name] ||= artifact
+        end
+        seen
+      end
+      named.each_pair do |name, artifact|
+        if Array === artifact # a group
+          artifact.each do |a| 
+            unvers = a.unversioned_spec
+            previous = registry[unvers]
+            if previous && previous.selected? && a.satisfied_by?(previous)
+              a.version = previous.version
+            end
+            registry[unvers] = a
+          end
+          group(name, *(artifact.map { |a| a.unversioned_spec } + [{:namespace => self}]))
+        else
+          unvers = artifact.unversioned_spec
+          previous = registry.get(unvers, true)
+          if previous && previous.selected? && artifact.satisfied_by?(previous)
+            artifact.version = previous.version
+            artifact.selected!
+          end
+          registry[unvers] = artifact
+          registry.alias name, unvers unless name.to_s[/^\s*$/]
+        end
+      end
+      self
+    end
+
+    # :call-seq:
+    #   artifact_ns.use 'name -> org:foo:bar:jar:1.2.3'
+    #   artifact_ns.use :name => 'org:foo:bar:jar:1.2.3'
+    #   artifact_ns.use :name => '2.5.6'
+    #
+    # First and second form are equivalent, the third is used when an 
+    # ArtifactRequirement has been previously defined with :name, so it
+    # just selects the version.
+    #
+    # ArtifactNamespace#method_missing provides syntactic sugar for this.
+    def use(*specs)
+      named = specs.flatten.inject({}) do |seen, spec|
+        if Hash === spec && (spec.keys & ActsAsArtifact::ARTIFACT_ATTRIBUTES).empty?
+          spec.each_pair do |name, spec|
+            if ArtifactNamespace === spec # create as subnamespace
+              raise ArgumentError.new("Circular reference") if self == spec
+              registry[name.to_sym] = spec
+            elsif Numeric === spec || (String === spec && VersionRequirement.version?(spec))
+              artifact = ArtifactRequirement.allocate
+              artifact.name = name
+              artifact.version = spec.to_s
+              seen[artifact.name] ||= artifact
+            elsif Symbol === spec
+              self.alias name, spec
+            elsif Array === spec # a group
+              seen[name] ||= spec.map { |s| ArtifactRequirement.new(s) }
+            else
+              artifact = ArtifactRequirement.new(spec)
+              artifact.name = name
+              seen[artifact.name] ||= artifact
+            end
+          end
+        else
+          if Symbol === spec
+            artifact = get(spec).dclone
+          else
+            artifact = ArtifactRequirement.new(spec)
+          end
+          seen[artifact.name] ||= artifact
+        end
+        seen
+      end
+      named.each_pair do |name, artifact|
+        is_group = Array === artifact
+        artifact = [artifact].flatten.map do |artifact|
+          unvers = artifact.unversioned_spec
+          previous = get(unvers, false) || get(name, false) 
+          if previous # have previous on current namespace
+            if previous.requirement # we must satisfy the requirement
+              unless unvers # we only have the version
+                satisfied = previous.requirement.satisfied_by?(artifact.version)
+              else
+                satisfied = previous.satisfied_by?(artifact)
+              end
+              raise "Unsatisfied dependency #{previous} " +
+                "not satisfied by #{artifact}" unless satisfied
+              previous.version = artifact.version # OK, set new version
+              artifact = previous # use the same object for aliases  
+            else # not a requirement, set the new values
+              unless artifact.id == previous.id && name != previous.name
+                previous.copy_attrs(artifact)
+                artifact = previous
+              end
+            end
+          else
+            if unvers.nil? && # we only have the version
+                (previous = get(unvers, true, false, false))
+              version = artifact.version
+              artifact.copy_attrs(previous)
+              artifact.version = version
+            end
+            artifact.requirement = nil  
+          end
+          artifact.selected!
+        end
+        artifact = artifact.first unless is_group
+        if is_group
+          names = artifact.map do |art| 
+            unv = art.unversioned_spec
+            registry[unv] = art
+            unv
+          end
+          group(name, *(names + [{:namespace => self}]))
+        elsif artifact.id
+          unvers = artifact.unversioned_spec
+          registry[name] = artifact
+          registry.alias unvers, name
+        else
+          registry[name] = artifact
+        end
+      end
+      self
+    end
+
+    # Like Hash#fetch
+    def fetch(name, default = nil, &block)
+      block ||= lambda { raise IndexError.new("No artifact found by name #{name.inspect} in namespace #{self}") }
+      real_name = name.to_s[/^\w+$/] ? name : ArtifactRequirement.unversioned_spec(name)
+      get(real_name.to_sym) || default || block.call(name)
+    end
+
+    # :call-seq:
+    #   artifact_ns[:name] -> ArtifactRequirement
+    #   artifact_ns[:many, :names] -> [ArtifactRequirement]
+    def [](*names)
+      ary = values_at(*names)
+      names.size == 1 ? ary.first : ary
+    end
+
+    # :call-seq:
+    #   artifact_ns[:name] = 'some:cool:jar:1.0.2'
+    #   artifact_ns[:name] = '1.0.2'
+    #
+    # Just like the use method
+    def []=(*names)
+      values = names.pop
+      values = [values] unless Array === values
+      names.each_with_index do |name, i|
+        use name => (values[i] || values.last)
+      end
+    end
+
+    # yield each ArtifactRequirement
+    def each(&block)
+      values.each(&block)
+    end
+
+    # return Artifact objects for each requirement
+    def artifacts(*names)
+      (names.empty? && values || values_at(*names)).map(&:artifact)
+    end
+
+    # Return all requirements for this namespace
+    def values(include_parents = false, include_groups = true)
+      seen, dict = {}, registry
+      while dict
+        dict.each do |k, v|
+          v = v.call if v.respond_to?(:call)
+          v = v.values if v.kind_of?(ArtifactNamespace)
+          if Array === v && include_groups
+            v.compact.each { |v| seen[v.name] = v unless seen.key?(v.name) }
+          else
+            seen[v.name] = v unless seen.key?(v.name)
+          end
+        end
+        dict = include_parents ? dict.parent : nil
+      end
+      seen.values
+    end
+
+    # Return only the named requirements
+    def values_at(*names)
+      names.map do |name| 
+        catch :artifact do
+          unless name.to_s[/^\w+$/] 
+            unvers = ArtifactRequirement.unversioned_spec(name)
+            unless unvers.to_s == name.to_s
+              req = ArtifactRequirement.new(name)
+              reg = self
+              while reg
+                candidate = reg.send(:get, unvers, false, false, true)
+                throw :artifact, candidate if req.satisfied_by?(candidate)
+                reg = reg.parent
+              end
+            end
+          end
+          get(name.to_sym)
+        end
+      end
+    end
+
+    def key?(name, include_parents = false)
+      name = ArtifactRequirement.unversioned_spec(name) unless name.to_s[/^\w+$/]
+      registry.key?(name, include_parents)
+    end
+
+    def delete(name, include_parents = false)
+      registry.delete(name, include_parents)
+      self
+    end
+    
+    # :call-seq:
+    #   group :who, :me, :you
+    #   group :them, :me, :you, :namespace => ns
+    #
+    # Create a virtual group on this namespace. When the namespace
+    # is asked for the +who+ artifact, it's value is an array made from
+    # the remaining names. These names are searched by default from the current
+    # namespace. 
+    # Second form specified the starting namespace to search from.
+    def group(group_name, *members)
+      namespace = (Hash === members.last && members.pop[:namespace]) || :current
+      registry[group_name] = lambda do
+        artifacts = self.class[namespace].values_at(*members)
+        artifacts = artifacts.first if members.size == 1
+        artifacts
+      end
+      self
+    end
+
+    alias_method :virtual, :group
+
+    # Create an alias for a named requirement.
+    def alias(new_name, old_name)
+      registry.alias(new_name, old_name) or
+        raise NameError.new("Undefined artifact name: #{old_name}")
+    end
+
+    def to_s #:nodoc:
+      name.to_s
+    end
+
+    # :call-seq:
+    #   artifact_ns.cool_aid!('cool:aid:jar:2.3.4', '~>2.3') -> artifact_requirement
+    #   artifact_ns.cool_aid = '2.3.5'
+    #   artifact_ns.cool_aid  -> artifact_requirement
+    #   artifact_ns.cool_aid? -> true | false
+    #
+    # First form creates an ArtifactRequirement on the namespace.
+    # It is equivalent to providing a requirement_spec to the #need method:
+    #   artifact_ns.need "cool_aid -> cool:aid:jar:2.3.4 -> ~>2.3"
+    # the second argument is optional.
+    #
+    # Second form can be used to select an artifact version
+    # and is equivalent to:
+    #   artifact_ns.use :cool_aid => '1.0'
+    #
+    # Third form obtains the named ArtifactRequirement, can be 
+    # used to test if a named requirement has been defined.
+    # It is equivalent to:
+    #   artifact_ns.fetch(:cool_aid) { nil }
+    #
+    # Last form tests if the ArtifactRequirement has been defined
+    # and a version has been selected for use.
+    # It is equivalent to:
+    #
+    #   artifact_ns.has_cool_aid?
+    #   artifact_ns.values_at(:cool_aid).flatten.all? { |a| a && a.selected? }
+    #
+    def method_missing(name, *args, &block)
+      case name.to_s
+      when /!$/ then
+        name = $`.intern
+        if args.size < 1 && args.size > 2
+          raise ArgumentError.new("wrong number of arguments for #{name}!(spec, version_requirement?)")
+        end
+        need name => args.first
+        get(name).tap { |r| r.requirement = args.last if args.size == 2 }
+      when /=$/ then use $` => args.first
+      when /\?$/ then
+        name = $`.gsub(/^(has|have)_/, '').intern
+        [get(name)].flatten.all? { |a| a && a.selected? }
+      else 
+        if block || args.size > 0
+          raise ArgumentError.new("wrong number of arguments #{args.size} for 0 or block given")
+        end
+        get(name)
+      end
+    end
+
+    # Return an anonymous module 
+    #   # first create a requirement
+    #   artifact_ns.cool_aid! 'cool:aid:jar:>=1.0'
+    #
+    #   # extend an object as a cool_aid delegator
+    #   jars = Object.new.extend(artifact_ns.accessor(:cool_aid))
+    #   jars.cool_aid = '2.0'
+    #
+    #   artifact_ns.cool_aid.version # -> '2.0'
+    def accessor(*names)
+      ns = self
+      Module.new do 
+        names.each do |name|
+          define_method("#{name}") { ns.send("#{name}") }
+          define_method("#{name}?") { ns.send("#{name}?") }
+          define_method("#{name}=") { |vers| ns.send("#{name}=", vers) }
+        end
+      end
+    end
+
+   private
+    def get(name, include_parents = true, include_subs = true, include_self = true) #:nodoc:
+      if include_subs && name.to_s[/_/] # try sub namespaces first
+        sub, parts = self, name.to_s.split('_')
+        sub_name = parts.shift.to_sym
+        until sub != self || parts.empty?
+          if registry[sub_name].kind_of?(ArtifactNamespace)
+            sub = registry[sub_name]
+            artifact = sub[parts.join('_')]
+          else
+            sub_name = [sub_name, parts.shift].join('_').to_sym
+          end
+        end
+      end
+      unless artifact
+        if include_self
+          artifact = registry.get(name, include_parents)
+        elsif include_parents && registry.parent
+          artifact = registry.parent.get(name, true)
+        end
+      end
+      artifact = artifact.call if artifact.respond_to?(:call)
+      artifact
+    end
+
+    def registry
+      @registry ||= Registry.new.tap do |m|
+        m.parent = parent.send(:registry) unless root?
+      end
+    end
+     
+  end # ArtifactNamespace
+
+  # :call-seq:
+  #   project.artifact_ns -> ArtifactNamespace
+  #   Buildr.artifact_ns(name) -> ArtifactNamespace
+  #   Buildr.artifact_ns -> ArtifactNamespace for the currently running Project
+  #
+  # Open an ArtifactNamespace.
+  # If a block is provided, the namespace is yielded to it.
+  #
+  # See also ArtifactNamespace.instance
+  def artifact_ns(name = nil, &block)
+    name = self if name.nil? && self.kind_of?(Project)
+    ArtifactNamespace.instance(name, &block)
+  end
+  
+end
+
+