| # 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. |
| |
| module Buildr #:nodoc: |
| |
| # 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 pollution 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 different artifact combinations and/or versions. Assigning |
| # 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 below 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 preferred versions. |
| # |
| # To meet this goal, an ArtifactNamespace allows to specify ArtifactRequirement objects. |
| # In fact the only difference 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 preferred 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) rescue nil |
| const_set(:ROOT, new('root')) |
| end |
| |
| # Differs from Artifact.to_hash in that 1) it does not choke when version isn't present |
| # and 2) it assumes that if an artifact spec ends with a colon, e.g. "org.example:library:jdk5:" |
| # it indicates the last segment ("jdk5") is a classifier. |
| def to_hash(spec) |
| if spec.respond_to?(:to_spec) |
| to_hash spec.to_spec |
| elsif Hash === spec |
| return spec |
| elsif String === spec || Symbol === spec |
| spec = spec.to_s |
| if spec[-1,1] == ':' |
| group, id, type, classifier, *rest = spec.split(':').map { |part| part.empty? ? nil : part } |
| else |
| group, id, type, version, *rest = spec.split(':').map { |part| part.empty? ? nil : part } |
| unless rest.empty? |
| # Optional classifier comes before version. |
| classifier, version = version, rest.shift |
| end |
| end |
| fail "Expecting <group:id:type:version> or <group:id:type:classifier:version>, found <#{spec}>" unless rest.empty? |
| { :group => group, :id => id, :type => type, :version => version, :classifier => classifier }.reject { |k,v| v == nil } |
| else |
| fail "Unexpected artifact spec: #{spec.inspect}" |
| end |
| 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:jar: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.settings.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 |
| if name.size == 0 |
| instance = ROOT |
| else |
| name = name.to_s |
| @instances ||= Hash.new { |h, k| h[k] = new(k) } |
| instance = @instances[name] |
| end |
| 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 comparison 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_no_validation(spec[:spec]) |
| self.name = spec[:name] |
| @requirement = spec[:requirement] |
| @version = @requirement.default if VersionRequirement.requirement?(@version) |
| end |
| end |
| |
| def apply_spec_no_validation(spec) |
| spec = ArtifactNamespace.to_hash(spec) |
| ActsAsArtifact::ARTIFACT_ATTRIBUTES.each { |key| instance_variable_set("@#{key}", spec[key]) } |
| self |
| 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] = ArtifactNamespace.to_hash(parts.first) |
| when 2 |
| if /^\w+$/ === parts.first |
| result[:name] = parts.first |
| result[:spec] = ArtifactNamespace.to_hash(parts.last) |
| else |
| result[:spec] = ArtifactNamespace.to_hash(parts.first) |
| result[:requirement] = VersionRequirement.create(parts.last) |
| end |
| when 3 |
| result[:name] = parts.first |
| result[:spec] = ArtifactNamespace.to_hash(parts[1]) |
| result[:requirement] = VersionRequirement.create(parts.last) |
| end |
| else |
| result[:spec] = ArtifactNamespace.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 = ArtifactNamespace.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 |
| hash = to_spec_hash |
| return nil if hash.values.compact.length <= 1 |
| if hash[:classifier] |
| "#{hash[:group]}:#{hash[:id]}:#{hash[:type]}:#{hash[:classifier]}:" |
| else |
| "#{hash[:group]}:#{hash[:id]}:#{hash[:type]}" |
| end |
| end |
| |
| class << self |
| def unversioned_spec(spec) |
| hash = ArtifactNamespace.to_hash(spec) |
| return nil if hash.values.compact.length <= 1 |
| if hash[:classifier] |
| "#{hash[:group]}:#{hash[:id]}:#{hash[:type]}:#{hash[:classifier]}:" |
| else |
| "#{hash[:group]}:#{hash[:id]}:#{hash[:type]}" |
| 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 |
| yield ROOT if block_given? |
| 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 |
| if unvers |
| satisfied = previous.satisfied_by?(artifact) |
| else # we only have the version |
| satisfied = previous.requirement.satisfied_by?(artifact.version) |
| 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 ||= proc { 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 keys |
| values.map(&:name) |
| end |
| |
| def delete(name, include_parents = false) |
| registry.delete(name, include_parents) |
| self |
| end |
| |
| def clear |
| keys.each { |k| delete(k) } |
| 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: |
| artifact = nil |
| 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 && 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 |
