ittayd-buildr 1.3.4 → 1.3.5

data/lib/buildr/packaging/artifact.rb

@@ -1,759 +0,0 @@
-# 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/core/project'
-require 'buildr/core/transports'
-require 'buildr/packaging/artifact_namespace'
-
-
-module Buildr
-
-  desc 'Download all artifacts'
-  task 'artifacts'
-
-  desc "Download all artifacts' sources"
-  task 'artifacts:sources'
-
-  # Mixin with a task to make it behave like an artifact. Implemented by the packaging tasks.
-  #
-  # An artifact has an identifier, group identifier, type, version number and
-  # optional classifier. All can be used to locate it in the local repository,
-  # download from or upload to a remote repository.
-  #
-  # The #to_spec and #to_hash methods allow it to be used everywhere an artifact is
-  # accepted.
-  module ActsAsArtifact
-
-    ARTIFACT_ATTRIBUTES = [:group, :id, :type, :classifier, :version]
-
-    class << self
-    private
-      def included(mod)
-        mod.extend self
-      end
-    end
-
-    # The artifact identifier.
-    attr_reader :id
-    # The group identifier.
-    attr_reader :group
-    # The file type. (Symbol)
-    attr_reader :type
-    # The version number.
-    attr_reader :version
-    # Optional artifact classifier.
-    attr_reader :classifier
-
-    def snapshot?
-      version =~ /-SNAPSHOT$/
-    end
-
-    # :call-seq:
-    #   to_spec_hash => Hash
-    #
-    # Returns the artifact specification as a hash. For example:
-    #   com.example:app:jar:1.2
-    # becomes:
-    #   { :group=>'com.example',
-    #     :id=>'app',
-    #     :type=>:jar,
-    #     :version=>'1.2' }
-    def to_spec_hash
-      base = { :group=>group, :id=>id, :type=>type, :version=>version }
-      classifier ? base.merge(:classifier=>classifier) : base
-    end
-    alias_method :to_hash, :to_spec_hash
-
-    # :call-seq:
-    #   to_spec => String
-    #
-    # Returns the artifact specification, in the structure:
-    #   <group>:<artifact>:<type>:<version>
-    # or
-    #   <group>:<artifact>:<type>:<classifier>:<version>
-    def to_spec
-      classifier ? "#{group}:#{id}:#{type}:#{classifier}:#{version}" : "#{group}:#{id}:#{type}:#{version}"
-    end
-
-    # :call-seq:
-    #   pom => Artifact
-    # 
-    # Convenience method that returns a POM artifact.
-    def pom
-      return self if type == :pom
-      Buildr.artifact(:group=>group, :id=>id, :version=>version, :type=>:pom)
-    end
-
-    # :call-seq:
-    #   sources_artifact => Artifact
-    # 
-    # Convenience method that returns a sources artifact.
-    def sources_artifact
-      sources_spec = to_spec_hash.merge(:classifier=>'sources')
-      sources_task = OptionalArtifact.define_task(Buildr.repositories.locate(sources_spec))
-      sources_task.send :apply_spec, sources_spec
-      sources_task
-    end
-
-    # :call-seq:
-    #   pom_xml => string
-    #
-    # Creates POM XML for this artifact.
-    def pom_xml
-      xml = Builder::XmlMarkup.new(:indent=>2)
-      xml.instruct!
-      xml.project do
-        xml.modelVersion  '4.0.0'
-        xml.groupId       group
-        xml.artifactId    id
-        xml.version       version
-        xml.classifier    classifier if classifier
-      end
-    end
-    
-    def install
-      pom.install if pom && pom != self
-      invoke
-      installed = Buildr.repositories.locate(self)
-      unless installed == name # If not already in local repository.
-        verbose(Buildr.application.options.trace || false) do
-          mkpath File.dirname(installed)
-          cp name, installed
-        end
-        info "Installed #{installed}"
-      end
-    end
-
-    def uninstall
-      verbose(Buildr.application.options.trace || false) do
-        installed = Buildr.repositories.locate(self)
-        rm installed if File.exist?(installed) 
-        pom.uninstall if pom && pom != self
-      end
-    end
-
-    # :call-seq:
-    #   upload
-    #   upload(url)
-    #   upload(options)
-    #
-    # Uploads the artifact, its POM and digital signatures to remote server.
-    #
-    # In the first form, uses the upload options specified by repositories.release_to.
-    # In the second form, uses a URL that includes all the relevant information.
-    # In the third form, uses a hash with the options :url, :username, :password,
-    # and :permissions. All but :url are optional.
-    def upload(upload_to = nil)
-      # Where do we release to?
-      upload_to ||= Buildr.repositories.release_to
-      upload_to = { :url=>upload_to } unless Hash === upload_to
-      raise ArgumentError, 'Don\'t know where to upload, perhaps you forgot to set repositories.release_to' unless upload_to[:url]
-      invoke # Make sure we exist.
-
-      # Upload POM ahead of package, so we don't fail and find POM-less package (the horror!)
-      pom.upload(upload_to) if pom && pom != self
-
-      # Set the upload URI, including mandatory slash (we expect it to be the base directory).
-      # Username/password may be part of URI, or separate entities.
-      uri = URI.parse(upload_to[:url].clone)
-      uri.path = uri.path + '/' unless uri.path[-1] == '/'
-      uri.user = upload_to[:username] if upload_to[:username]
-      uri.password = upload_to[:password] if upload_to[:password]
-
-      # Upload artifact relative to base URL, need to create path before uploading.
-      info "Deploying #{to_spec}"
-      path = group.gsub('.', '/') + "/#{id}/#{version}/#{File.basename(name)}"
-      URI.upload uri + path, name, :permissions=>upload_to[:permissions]
-    end
-
-  protected
-
-    # Apply specification to this artifact.
-    def apply_spec(spec)
-      spec = Artifact.to_hash(spec)
-      ARTIFACT_ATTRIBUTES.each { |key| instance_variable_set("@#{key}", spec[key]) }
-      self
-    end
-    
-    def group_path
-      group.gsub('.', '/')
-    end
-
-  end
-
- 
-  # A file task referencing an artifact in the local repository.
-  #
-  # This task includes all the artifact attributes (group, id, version, etc). It points
-  # to the artifact's path in the local repository. When invoked, it will download the
-  # artifact into the local repository if the artifact does not already exist.
-  #
-  # Note: You can enhance this task to create the artifact yourself, e.g. download it from
-  # a site that doesn't have a remote repository structure, copy it from a different disk, etc.
-  class Artifact < Rake::FileCreationTask
-
-    # The default artifact type.
-    DEFAULT_TYPE = :jar
-
-    include ActsAsArtifact
-
-    class << self
-
-      # :call-seq:
-      #   lookup(spec) => Artifact
-      #
-      # Lookup a previously registered artifact task based on its specification (String or Hash).
-      def lookup(spec)
-        @artifacts ||= {}
-        @artifacts[to_spec(spec)]
-      end
-
-      # :call-seq:
-      #   list => specs
-      #
-      # Returns an array of specs for all the registered artifacts. (Anything created from artifact, or package).
-      def list
-        @artifacts ||= {}
-        @artifacts.keys
-      end
-
-      # :call-seq:
-      #   register(artifacts) => artifacts
-      #
-      # Register an artifact task(s) for later lookup (see #lookup).
-      def register(*tasks)
-        @artifacts ||= {}
-        fail 'You can only register an artifact task, one of the arguments is not a Task that responds to to_spec' unless
-          tasks.all? { |task| task.respond_to?(:to_spec) && task.respond_to?(:invoke) }
-        tasks.each { |task| @artifacts[task.to_spec] = task }
-        tasks
-      end
-
-      # :call-seq:
-      #   to_hash(spec_hash) => spec_hash
-      #   to_hash(spec_string) => spec_hash
-      #   to_hash(artifact) => spec_hash
-      #
-      # Turn a spec into a hash. This method accepts a String, Hash or any object that responds to
-      # the method to_spec. There are several reasons to use this method:
-      # * You can pass anything that could possibly be a spec, and get a hash.
-      # * It will check that the spec includes the group identifier, artifact
-      #   identifier and version number and set the file type, if missing.
-      # * It will always return a new specs hash.
-      def to_hash(spec)
-        if spec.respond_to?(:to_spec)
-          to_hash spec.to_spec
-        elsif Hash === spec
-          rake_check_options spec, :id, :group, :type, :classifier, :version
-          # Sanitize the hash and check it's valid.
-          spec = ARTIFACT_ATTRIBUTES.inject({}) { |h, k| h[k] = spec[k].to_s if spec[k] ; h }
-          fail "Missing group identifier for #{spec.inspect}" unless spec[:group]
-          fail "Missing artifact identifier for #{spec.inspect}" unless spec[:id]
-          fail "Missing version for #{spec.inspect}" unless spec[:version]
-          spec[:type] = (spec[:type] || DEFAULT_TYPE).to_sym
-          spec
-        elsif String === spec
-          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
-            fail "Expecting <group:id:type:version> or <group:id:type:classifier:version>, found <#{spec}>" unless rest.empty?
-          end
-          to_hash :group=>group, :id=>id, :type=>type, :version=>version, :classifier=>classifier
-        else
-          fail 'Expecting a String, Hash or object that responds to to_spec'
-        end
-      end
-
-      # :call-seq:
-      #   to_spec(spec_hash) => spec_string
-      #
-      # Convert a hash back to a spec string. This method accepts
-      # a string, hash or any object that responds to to_spec.
-      def to_spec(hash)
-        hash = to_hash(hash) unless Hash === hash
-        version = ":#{hash[:version]}" if hash[:version]
-        classifier = ":#{hash[:classifier]}" if hash[:classifier]
-        "#{hash[:group]}:#{hash[:id]}:#{hash[:type] || DEFAULT_TYPE}#{classifier}#{version}"
-      end
-
-      # :call-seq:
-      #   hash_to_file_name(spec_hash) => file_name
-      #
-      # Convert a hash spec to a file name.
-      def hash_to_file_name(hash)
-        version = "-#{hash[:version]}" if hash[:version]
-        classifier = "-#{hash[:classifier]}" if hash[:classifier]
-        "#{hash[:id]}#{version}#{classifier}.#{hash[:type] || DEFAULT_TYPE}"
-      end
-
-    end
-
-    def initialize(*args) #:nodoc:
-      super
-      enhance do |task|
-        # Default behavior: download the artifact from one of the remote repositories
-        # if the file does not exist. But this default behavior is counter productive
-        # if the artifact knows how to build itself (e.g. download from a different location),
-        # so don't perform it if the task found a different way to create the artifact.
-        task.enhance do
-          unless File.exist?(name)
-            info "Downloading #{to_spec}"
-            download
-            pom.invoke rescue nil if pom && pom != self
-          end
-        end
-      end
-    end
-
-    # :call-seq:
-    #   from(path) => self
-    #
-    # Use this when you want to install or upload an artifact from a given file, for example:
-    #   test = artifact('group:id:jar:1.0').from('test.jar')
-    #   install test
-    # See also Buildr#install and Buildr#upload.
-    def from(path)
-      path = File.expand_path(path.to_s)
-      enhance [path] do
-        verbose false do
-          mkpath File.dirname(name)
-          pom.invoke unless type == :pom
-          cp path, name
-          info "Installed #{path} as #{to_spec}"
-        end
-      end
-      unless type == :pom
-        pom.enhance do
-          verbose false do
-            mkpath File.dirname(pom.name)
-            File.open(pom.name, 'w') { |file| file.write pom.pom_xml }
-          end
-        end
-      end
-      self
-    end
-
-  protected
-
-    # :call-seq:
-    #   download
-    # 
-    # Downloads an artifact from one of the remote repositories, and stores it in the local
-    # repository. Raises an exception if the artifact is not found.
-    #
-    # This method attempts to download the artifact from each repository in the order in
-    # which they are returned from #remote, until successful.
-    def download
-      trace "Downloading #{to_spec}"
-      remote = Buildr.repositories.remote.map { |repo_url| URI === repo_url ? repo_url : URI.parse(repo_url) }
-      remote = remote.each { |repo_url| repo_url.path += '/' unless repo_url.path[-1] == '/' }
-      fail 'No remote repositories defined!' if remote.empty?
-      exact_success = remote.find do |repo_url|
-        begin
-          path = "#{group_path}/#{id}/#{version}/#{File.basename(name)}"
-          URI.download repo_url + path, name
-          true
-        rescue URI::NotFoundError
-          false
-        rescue Exception=>error
-          info error
-          trace error.backtrace.join("\n")
-          false
-        end
-      end
-
-      if exact_success
-        return
-      elsif snapshot?
-        download_m2_snapshot(remote)
-      else
-        fail_download(remote)
-      end
-    end
-
-    def download_m2_snapshot(remote_uris)
-      remote_uris.find do |repo_url|
-        snapshot_url = current_snapshot_repo_url(repo_url)
-        if snapshot_url
-          begin
-            URI.download snapshot_url, name
-          rescue URI::NotFoundError
-            false
-          end
-        else
-          false
-        end
-      end or fail_download(remote_uris)
-    end
-
-    def current_snapshot_repo_url(repo_url)
-      begin
-        metadata_path = "#{group_path}/#{id}/#{version}/maven-metadata.xml"
-        metadata_xml = StringIO.new
-        URI.download repo_url + metadata_path, metadata_xml
-        metadata = REXML::Document.new(metadata_xml.string).root
-        timestamp = REXML::XPath.first(metadata, '//timestamp').text
-        build_number = REXML::XPath.first(metadata, '//buildNumber').text
-        snapshot_of = version[0, version.size - 9]
-        repo_url + "#{group_path}/#{id}/#{version}/#{id}-#{snapshot_of}-#{timestamp}-#{build_number}.#{type}"
-      rescue URI::NotFoundError
-        nil
-      end
-    end
-
-    def fail_download(remote_uris)
-      fail "Failed to download #{to_spec}, tried the following repositories:\n#{remote_uris.join("\n")}"
-    end
-  end
-  
-  
-  # An artifact that is optional.
-  # If downloading fails, the user will be informed but it will not raise an exception.
-  class OptionalArtifact < Artifact
-    
-    protected
-    
-    # If downloading fails, the user will be informed but it will not raise an exception.
-    def download
-      super
-    rescue 
-      info "Failed to download #{to_spec}. Skipping it."
-    end
-    
-  end
-
-
-  # Holds the path to the local repository, URLs for remote repositories, and settings for release server.
-  #
-  # You can access this object from the #repositories method. For example:
-  #   puts repositories.local
-  #   repositories.remote << 'http://example.com/repo'
-  #   repositories.release_to = 'sftp://example.com/var/www/public/repo'
-  class Repositories
-    include Singleton
-
-    # :call-seq:
-    #   local => path
-    #
-    # Returns the path to the local repository.
-    #
-    # The default path is .m2/repository relative to the home directory.
-    # You can set this using the M2_REPO environment variable or the repositories/local
-    # value in your settings.yaml file.
-    def local
-      @local ||= File.expand_path(ENV['M2_REPO'] || ENV['local_repo'] ||
-        (Buildr.settings.user['repositories'] && Buildr.settings.user['repositories']['local']) ||
-        File.join(ENV['HOME'], '.m2/repository'))
-    end
-
-    # :call-seq:
-    #   local = path
-    #
-    # Sets the path to the local repository.
-    #
-    # The best place to set the local repository path is from a buildr.rb file
-    # located in your home directory. That way all your projects will share the same
-    # path, without affecting other developers collaborating on these projects.
-    def local=(dir)
-      @local = dir ? File.expand_path(dir) : nil
-    end
-
-    # :call-seq:
-    #   locate(spec) => path
-    #
-    # Locates an artifact in the local repository based on its specification, and returns
-    # a file path.
-    #
-    # For example:
-    #   locate :group=>'log4j', :id=>'log4j', :version=>'1.1'
-    #     => ~/.m2/repository/log4j/log4j/1.1/log4j-1.1.jar
-    def locate(spec)
-      spec = Artifact.to_hash(spec)
-      File.join(local, spec[:group].split('.'), spec[:id], spec[:version], Artifact.hash_to_file_name(spec))
-    end
-
-    # :call-seq:
-    #   remote => Array
-    #
-    # Returns an array of all the remote repository URLs.
-    #
-    # When downloading artifacts, repositories are accessed in the order in which they appear here.
-    # The best way is to add repositories individually, for example:
-    #   repositories.remote << 'http://example.com/repo'
-    #
-    # You can also specify remote repositories in the settings.yaml (per user) and build.yaml (per build)
-    # files.  Both sets of URLs are loaded by default into this array, URLs from the personal setting
-    # showing first.
-    #
-    # For example:
-    #   repositories:
-    #     remote:
-    #     - http://example.com/repo
-    #     - http://elsewhere.com/repo
-    def remote
-      unless @remote
-        @remote = [Buildr.settings.user, Buildr.settings.build].inject([]) { |repos, hash|
-          repos | Array(hash['repositories'] && hash['repositories']['remote'])
-        }
-      end
-      @remote
-    end
-
-    # :call-seq:
-    #   remote = Array
-    #   remote = url
-    #   remote = nil
-    #
-    # With a String argument, clears the array and set it to that single URL.
-    #
-    # With an Array argument, clears the array and set it to these specific URLs.
-    #
-    # With nil, clears the array.
-    def remote=(urls)
-      case urls
-      when nil then @remote = nil
-      when Array then @remote = urls.dup
-      else @remote = [urls.to_s]
-      end
-    end
-
-    # :call-seq:
-    #   release_to = url
-    #   release_to = hash
-    #
-    # Specifies the release server. Accepts a Hash with different repository settings
-    # (e.g. url, username, password), or a String to only set the repository URL.
-    #
-    # Besides the URL, all other settings depend on the transport protocol in use.
-    #
-    # For example:
-    #   repositories.release_to = 'sftp://john:secret@example.com/var/www/repo/'
-    #
-    #   repositories.release_to = { :url=>'sftp://example.com/var/www/repo/',
-    #                                :username='john', :password=>'secret' }
-    # Or in the settings.yaml file:
-    #   repositories:
-    #     release_to: sftp://john:secret@example.com/var/www/repo/
-    #
-    #   repositories:
-    #     release_to:
-    #       url: sftp://example.com/var/www/repo/
-    #       username: john
-    #       password: secret
-    def release_to=(options)
-      options = { :url=>options } unless Hash === options
-      @release_to = options
-    end
-
-    # :call-seq:
-    #   release_to => hash
-    #
-    # Returns the current release server setting as a Hash. This is a more convenient way to
-    # configure the settings, as it allows you to specify the settings progressively.
-    #
-    # For example, the Buildfile will contain the repository URL used by all developers:
-    #   repositories.release_to[:url] ||= 'sftp://example.com/var/www/repo'
-    # Your private buildr.rb will contain your credentials:
-    #   repositories.release_to[:username] = 'john'
-    #   repositories.release_to[:password] = 'secret'
-    def release_to
-      unless @release_to
-        value = Buildr.settings.user['repositories'] && Buildr.settings.user['repositories']['release_to']
-        @release_to = Hash === value ? value.inject({}) { |hash, (key, value)| hash.update(key.to_sym=>value) } : { :url=>Array(value).first }
-      end
-      @release_to
-    end
-
-  end
-
-  # :call-seq:
-  #    repositories => Repositories
-  #
-  # Returns an object you can use for setting the local repository path, remote repositories
-  # URL and release server settings.
-  #
-  # See Repositories.
-  def repositories
-    Repositories.instance
-  end
-
-  # :call-seq:
-  #   artifact(spec) => Artifact
-  #   artifact(spec) { |task| ... } => Artifact
-  #
-  # Creates a file task to download and install the specified artifact in the local repository.
-  #
-  # You can use a String or a Hash for the artifact specification. The file task will point at
-  # the artifact's path inside the local repository. You can then use this tasks as a prerequisite
-  # for other tasks.
-  #
-  # This task will download and install the artifact only once. In fact, it will download and
-  # install the artifact if the artifact does not already exist. You can enhance it if you have
-  # a different way of creating the artifact in the local repository. See Artifact for more details.
-  #
-  # For example, to specify an artifact:
-  #   artifact('log4j:log4j:jar:1.1')
-  #
-  # To use the artifact in a task:
-  #   compile.with artifact('log4j:log4j:jar:1.1')
-  #
-  # To specify an artifact and the means for creating it:
-  #   download(artifact('dojo:dojo-widget:zip:2.0')=>
-  #     'http://download.dojotoolkit.org/release-2.0/dojo-2.0-widget.zip')
-  def artifact(spec, &block) #:yields:task
-    spec = artifact_ns.fetch(spec) if spec.kind_of?(Symbol)
-    spec = Artifact.to_hash(spec)
-    unless task = Artifact.lookup(spec)
-      task = Artifact.define_task(repositories.locate(spec))
-      task.send :apply_spec, spec
-      Rake::Task['rake:artifacts'].enhance [task]
-      Artifact.register(task)
-      Rake::Task['artifacts:sources'].enhance [task.sources_artifact] unless spec[:type] == :pom
-    end
-    task.enhance &block
-  end
-
-  # :call-seq:
-  #   artifacts(*spec) => artifacts
-  #
-  # Handles multiple artifacts at a time. This method is the plural equivalent of
-  # #artifact, but can do more things.
-  #
-  # Returns an array of artifacts built using the supplied
-  # specifications, each of which can be:
-  # * An artifact specification (String or Hash). Returns the appropriate Artifact task.
-  # * An artifact of any other task. Returns the task as is.
-  # * A project. Returns all artifacts created (packaged) by that project.
-  # * A string. Returns that string, assumed to be a file name.
-  # * An array of artifacts or a Struct.
-  # * A symbol. Returns the named artifact from the current ArtifactNamespace
-  #
-  # For example, handling a collection of artifacts:
-  #   xml = [ xerces, xalan, jaxp ]
-  #   ws = [ axis, jax-ws, jaxb ]
-  #   db = [ jpa, mysql, sqltools ]
-  #   artifacts(xml, ws, db)
-  #
-  # Using artifacts created by a project:
-  #   artifacts project('my-app')               # All packages
-  #   artifacts project('my-app').package(:war) # Only the WAR
-  def artifacts(*specs, &block)
-    specs.flatten.inject([]) do |set, spec|
-      case spec
-      when ArtifactNamespace
-        set |= spec.artifacts
-      when Symbol, Hash
-        set |= [artifact(spec)]
-      when /([^:]+:){2,4}/ # A spec as opposed to a file name.
-        set |= [artifact(spec)]
-      when String # Must always expand path.
-        set |= [File.expand_path(spec)]
-      when Project
-        set |= artifacts(spec.packages)
-      when Rake::Task
-        set |= [spec]
-      when Struct
-        set |= artifacts(spec.values)
-      else
-        fail "Invalid artifact specification in #{specs.inspect}"
-      end
-    end
-  end
-
-  def transitive(*specs)
-    specs.flatten.inject([]) do |set, spec|
-      case spec
-      when /([^:]+:){2,4}/ # A spec as opposed to a file name.
-        artifact = artifact(spec)
-        set |= [artifact] unless artifact.type == :pom
-        set |= POM.load(artifact.pom).dependencies.map { |spec| artifact(spec) }
-      when Hash
-        set |= [transitive(spec)]
-      when String # Must always expand path.
-        set |= transitive(file(File.expand_path(spec)))
-      when Project
-        set |= transitive(spec.packages)
-      when Rake::Task
-        set |= spec.respond_to?(:to_spec) ? transitive(spec.to_spec) : [spec]
-      when Struct
-        set |= transitive(spec.values)
-      else
-        fail "Invalid artifact specification in: #{specs.to_s}"
-      end
-    end
-  end
-
-  # :call-seq:
-  #   group(ids, :under=>group_name, :version=>number) => artifacts
-  #
-  # Convenience method for defining multiple artifacts that belong to the same group, type and version.
-  # Accepts multiple artifact identifiers followed by two or three hash values:
-  # * :under -- The group identifier
-  # * :version -- The version number
-  # * :type -- The artifact type (optional)
-  #
-  # For example:
-  #   group 'xbean', 'xbean_xpath', 'xmlpublic', :under=>'xmlbeans', :version=>'2.1.0'
-  # Or:
-  #   group %w{xbean xbean_xpath xmlpublic}, :under=>'xmlbeans', :version=>'2.1.0'
-  def group(*args)
-    hash = args.pop
-    args.flatten.map { |id| artifact :group=>hash[:under], :type=>hash[:type], :version=>hash[:version], :id=>id }
-  end 
-
-  # :call-seq:
-  #   install(artifacts)
-  #
-  # Installs the specified artifacts in the local repository as part of the install task.
-  #
-  # You can use this to install various files in the local repository, for example:
-  #   install artifact('group:id:jar:1.0').from('some_jar.jar')
-  #   $ buildr install
-  def install(*args, &block)
-    artifacts = artifacts(args)
-    raise ArgumentError, 'This method can only install artifacts' unless artifacts.all? { |f| f.respond_to?(:to_spec) }
-    all = (artifacts + artifacts.map { |artifact| artifact.pom }).uniq
-    task('install').tap do |task|
-      task.enhance all, &block
-      task 'uninstall' do
-        verbose false do
-          all.map(&:to_s ).each { |file| rm file if File.exist?(file) }
-        end
-      end
-    end
-  end
-
-  # :call-seq:
-  #   upload(artifacts)
-  #
-  # Uploads the specified artifacts to the release server as part of the upload task.
-  #
-  # You can use this to upload various files to the release server, for example:
-  #   upload artifact('group:id:jar:1.0').from('some_jar.jar')
-  #   $ buildr upload
-  def upload(*args, &block)
-    artifacts = artifacts(args)
-    raise ArgumentError, 'This method can only upload artifacts' unless artifacts.all? { |f| f.respond_to?(:to_spec) }
-    task('upload').tap do |task|
-      task.enhance &block if block
-      task.enhance artifacts do
-        artifacts.each { |artifact| artifact.upload }
-      end
-    end
-  end
-
-end