buildr 0.14.0

data/CHANGELOG

@@ -0,0 +1,151 @@
+0.14 (2/28/2007)
+* Added: check task that looks for obvious errors in the Rakefile.
+* Added: deploy task for managing deployment.
+* Added: release task that updates version numbers, commits and tags SVN.
+* Changed: the project name is now the fully qualified name, e.g. ode:axis2
+* Changed: you can now lookup a project before it's defined; you still can
+  only define a project once.
+* Changed: you can lookup projects by full qualified name.
+* Changed: release_to changed to deploy_to, which is now a getter/setter.
+* Fixed: removed Java.home which conflicted with JRuby.
+* Fixed: install task did not re-install modified files.
+* Fixed: deploying only uploads one artifact.
+* Fixed: timing issues.
+* Fixed: Maven classifier now used properly.
+
+0.13 (2/26/2007)
+* Added: global java method.
+* Added: project build method.
+* Added: OpenJPA mapping_tool method.
+* Added: Rakefile to generate Gem.
+* Changed: you can now lookup a sub-project from the top project method.
+* Changed: the projects methods return all sub-projects.
+* Fixed: bug in JarTask that resolved artifacts too early.
+* Fixed: global tasks (clean, build, etc) now complain if executed from a directory
+  that does not map to any project.
+* Fixed: to work with Rake 0.7.2.
+
+0.12 (2/24/2007)
+* Added: call prepare with list of tasks to add them as prerequisites.
+* Added: project.id returns the compound name, e.g. foo, foo-bar, foo-bar-baz.
+* Added: JavaCC, XMLBeans schema compiler, OpenJPA enhancer, APT tasks.
+* Changed: the default package ID is take from the project ID instead of its name.
+* Changed: renamed buildr and moved here.
+* Changed: moved all code into Buildr module.
+* Fixed: download breaking when POM not found.
+* Fixed: compile task fails if classpath is empty.
+* Fixed: zip task fails if target directory does not exist. 
+* Fixed: packaging task does not require build.
+* Fixed: compiler not showing command when trace is on.
+* Fixed: zip dependencies were all fucked up.
+* Fixed: package should not depend on build.
+
+0.11 (2/16/2007)
+* Added: test cases for unzip task
+* Added: prepare method to access prepare task
+* Added: prepare, compile and resources accept a block you can use to enhance the task
+* Changed: ZipTask executes all includes files as prerequisites, and now includes
+  directories correctly
+* Changed: Jar/WarTask are now extended using with(options) method 
+* Changed: JarTask now accepts array of sections (each being a hash) for the manifest,
+  and a proc/method to generate it
+* Changed: added HighLine to hide password entry on the command line
+* Changed: unzip now using UnzipTask with its own shorthand syntax.
+* Changed: filter task gets a consistent syntax to unzip
+
+0.10 (2/13/2007)
+* Added: modifier for artifacts
+* Added: ZipTask, WarTask
+* Added: get POM artifact directly from artifact
+* Changed: JAR and WAR packaging based on new and improved Zip task
+* Changed: options for packaging, but not affecting current Rakefile
+* Remove: delete task
+
+0.9 (2/9/2007)
+* Added: attributes for configuring compile (sources, classpath, target, options)
+* Added: shorthand notation for specifying compilation (to, with, using)
+* Changed: copy task is dead (name conflict), instead we get the better filter
+  task with include/exclude patterns
+* Changed: rewrite of compile task, now better than ever
+* Changed: compile can be used inside and outside project
+* Changed: compiler no longer infers anything from its prerequisites
+* Changed: compiler accepts files, artifacts and tasks on the classpath
+* Changed: resources task now working as expected
+* Remove: global task artifacts was the root of all evil and got canned.
+
+0.8 (2/5/2007)
+* Added: release task and release_to configuration for repositories
+* Added: SFTP uploader for releases
+* Added: convenience method group() for specifying multiple artifacts in same
+  group and version number
+* Added: install target copies package to local repository and adds a POM,
+  uninstall package removes package (and POM) from local repository
+* Changed: project lookup now happens through project() method
+* Changed: locating file in the local repository now happens through Repositories
+* Changed: downloading file into the local repository now happens through Repositories
+* Changed: notation for specifying multiple artifacts in a string is now foo,bar,baz
+* Changed: artifact identifier is now specified with the key :id
+* Changed: download POM alongside artifact and install in local repository
+* Changed: no more scoping artifacts collection in project, use compile.with instead
+* Changed: moved HTTP download logic to transports.rb
+* Removed: deprecated grouping with multiple artifacts under id key
+
+0.6 (2/1/2007)
+* Added:   Artifact resolution introduces the notion of a spec,
+           which can be supported using ActsAsArtifact
+* Added:   You can now use a project as an artifact, resulting in all its
+           packages being added, or use a task as artifact
+* Changed: project.sub_projects renamed project.projects
+* Changed: what used to be called dependencies is now called artifacts
+* Changed: all artifacts are now created as tasks that know how to download
+           themselves unless some other behavior is specified
+* Changed: local and remote repositories are now defined on the Rakefile
+           instead of individual projects
+* Changed: attributes now stored directly as instance variables
+* Changed: ANSI colors and progress bar now using Ruby Facets
+
+0.5 (1/24/2007)
+* Added: Build number for each top-level project, build_number method for accessing
+  it and build:increment task for updating the build number file.
+* Added: to_path method on project to resolve paths relative to base_dir.
+* Added: recursive_task method on project to create task in project/sub-project.
+* Added: compiler property for passing any options to Javac.
+* Changed: remove task renamed uninstall.
+* Changed: and to confuse more remove task (RemoveTask) renamed delete.
+* Changed: consolidated before_create/after_create to on_create.
+* Changed: version, group, artifact added as accessors to project.
+* Changed: project definition block takes project as argument.
+* Changed: project enhanced only if new settings or block.
+* Changed: local_repository is now separate attribute from repositories.
+* Changed: Directory structure, now split into rbs, rbs-java and tasks.
+* Removed: project.options. Using a different attributes mechanism.
+
+0.4 (1/23/2007)
+* Added: CopyTask now deals with files and directories, can copy multiple files,
+  and applies filter to all of them. Filter can be a hash or a proc.
+* Added: Project gets resources_filter attribute that can be used to set the
+  filter on all copied resources.
+* Added: HTTP module for getting and downloading files, and a download task.
+* Changed: Dependencies now check signatures for every file, if available,
+  and show download progress.
+
+0.3 (1/22/2007)
+* Added: Dependencies loaded from Maven repositories if not existing or built by project.
+  Use rake dependencies to force update, or let compilation take care of it.
+* Added: Copy task for copying one file to another, and filtering support.
+
+0.2 (1/21/2007)
+* Added: remove task to get rid of packages added to the local repository.
+* Changed: recompile project if any of its dependencies is newer than the source code.
+  Will cause recompile if any of the dependencies was compiled and packaged again.
+* Changed: compile task depends on javac task and resource copy tasks.
+  This might change when adding filtering later on.
+
+0.1 (1/19/2007)
+* Added: build and clean tasks
+* Added: resources are now copied over during compilation
+* Added: POM file generated in local repository (keep Maven happy)
+* Added: compile scope for use by javac
+* Added: WAR packaging.
+* Changed: Root project operates on the current directory, sub-projects on sub
+  directories. See Rakefile for example.

data/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2006, Intalio Inc.
+
+   Licensed 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.
+

data/lib/buildr.rb

@@ -0,0 +1,43 @@
+# Remember that all these need to be Gem dependencies.
+gem "facets"
+gem "builder"
+gem "net-ssh"
+gem "net-sftp"
+gem "rubyzip"
+gem "highline"
+
+module Buildr
+  VERSION = "0.14.0"
+end
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__))
+require "core/core.rb"
+require "core/project.rb"
+require "core/artifact.rb"
+require "core/build.rb"
+require "core/transports.rb"
+
+require "tasks/download"
+require "tasks/filter"
+require "tasks/zip"
+
+require "java/java"
+require "java/compile"
+require "java/javacc"
+require "java/openjpa"
+require "java/packaging"
+require "java/xmlbeans"
+
+include Buildr
+
+# The greate method_missing/Object extend bug requires us to load
+# XMLBuilder after we're done enhancing Object.
+require "builder"
+
+# Load the settings files.
+if File.exist?(File.join(ENV["HOME"], "buildr.rb"))
+  load File.join(ENV["HOME"], "buildr.rb")
+end
+if File.exist?(File.join(Rake.application.original_dir, "buildr.rb"))
+  load File.join(Rake.application.original_dir, "buildr.rb")
+end

data/lib/core/artifact.rb

@@ -0,0 +1,394 @@
+module Buildr
+
+  # This module gives you a way to access the individual properties of an
+  # artifact: id, group, type and version. It can also return the artifact
+  # specification.
+  module ActsAsArtifact
+
+    class << self
+      def included(mod)
+        mod.extend self
+      end
+    end
+
+    # The artifact id.
+    attr_reader :id
+    # The group id.
+    attr_reader :group
+    # The file type.
+    attr_reader :type
+    # The version number.
+    attr_reader :version
+    # Optional classifier.
+    attr_reader :classifier
+
+    # Returns the artifact specification as a hash.
+    def to_spec_hash()
+      base = { :group=>group, :id=>id, :type=>type, :version=>version }
+      classifier.blank? ? base : base.merge(:classifier=>classifier)
+    end
+    alias_method :to_hash, :to_spec_hash
+
+    # Returns the artifact specification, in the structure:
+    #   <group>:<artifact>:<type>:<version>
+    def to_spec()
+      classifier.blank? ? "#{group}:#{id}:#{type}:#{version}" : "#{group}:#{id}:#{type}:#{classifier}:#{version}"
+    end
+
+    # Apply specification to this artifact.
+    def apply_spec(spec)
+      case spec
+      when String
+        @group, @id, @type, @version, *rest = spec.split(":")
+        unless rest.empty?
+          @classifier, @version = @version, rest.shift
+          fail "Expecting project:id:type:version or project:id:type:classifier:version, found #{spec}" unless rest.empty?
+        end
+      when Hash
+        [:group, :id, :type, :version, :classifier].each { |key| instance_variable_set("@#{key}", spec[key]) }
+        @type ||= DEFAULT_FILE_TYPE
+      else
+        raise ArgumentError, "Expecting a string or a hash"
+      end
+      self
+    end
+
+    def pom()
+      return self if type.to_s == "pom"
+      artifact(:group=>group, :id=>id, :version=>version, :type=>"pom", :classifier=>classifier)
+    end
+
+  end
+
+
+  # Use the artifact and artifacts method to create artifact tasks.
+  class Artifact < Rake::FileCreationTask
+
+    # The default file type for artifacts, if not specified.
+    DEFAULT_FILE_TYPE = "jar"
+
+    include ActsAsArtifact
+
+    class << self
+
+      # Lookup an artifact task based on its specification.
+      def lookup(spec)
+        @artifacts ||= {}
+        @artifacts[hash_to_spec(spec)]
+      end
+
+      # Register a task as an artifact. Returns the task when calling
+      # #artifacts. For example, a project will use this to register the
+      # packages it creates.
+      def register(task)
+        @artifacts ||= {}
+        if task.respond_to?(:to_hash)
+          @artifacts[hash_to_spec(task.to_hash)] = task
+        else
+          fail "Can only call with an artifact task"
+        end
+      end
+
+      # 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 you'll want
+      # to use this method:
+      # * You can pass it anything that could possibly be a spec, and get a hash.
+      # * It will check that your spec includes the group identifier, artifact
+      #   identifier and version number, and set the file type, if not specified.
+      # * It will always return a new specs hash.
+      # * Calling to_s on the hash will return a spec string.
+      #
+      # :nodoc:
+      def spec_to_hash(spec)
+        return spec_to_hash(spec.to_spec) if spec.respond_to?(:to_spec)
+        if String === spec
+          group, id, type, version, *rest = spec.split(":")
+          unless rest.empty?
+            classifier, version = version, rest.shift
+            fail "Expecting project:id:type:version or project:id:type:classifier:version, found #{spec}" unless rest.empty?
+          end
+          fail "Missing file type for #{spec}" if type.blank?
+          spec_to_hash :group=>group, :id=>id, :type=>type, :version=>version, :classifier=>classifier
+        elsif Hash === spec 
+          spec = spec.clone
+          fail "Missing group identifier for #{spec.inspect}" if spec[:group].blank?
+          fail "Missing artifact identifier for #{spec.inspect}" if spec[:id].blank?
+          fail "Missing version for #{spec.inspect}" if spec[:version].blank?
+          spec[:type] = DEFAULT_FILE_TYPE if spec[:type].blank?
+          spec
+        else
+          fail "Spec must be a string, hash or object that responds to to_spec"
+        end
+      end
+
+      # Convert a hash back to a spec string.
+      def hash_to_spec(hash)
+        version = ":#{hash[:version]}" unless hash[:version].blank?
+        classifier = ":#{hash[:classifier]}" unless hash[:classifier].blank?
+        "#{hash[:group]}:#{hash[:id]}:#{hash[:type] || DEFAULT_FILE_TYPE}#{classifier}#{version}"
+      end
+
+      # Convert a hash to a file name.
+      def hash_to_file_name(hash)
+        version = "-#{hash[:version]}" unless hash[:version].blank?
+        classifier = "-#{hash[:classifier]}" unless hash[:classifier].blank?
+        "#{hash[:id]}#{version}#{classifier}.#{hash[:type] || DEFAULT_FILE_TYPE}"
+      end
+
+    end
+
+    def initialize(*args)
+      super
+      enhance do |task|
+        # Download the artifact form one of the remote repositories if the
+        # file does not exist in the local repository, and no other behavior
+        # specified. If this task has been enhanced, delegate to the other
+        # enhancers. We don't know if this is the first or other enhancement,
+        # but we only need to know it's not the only one.
+        if @actions.size == 1
+          repositories.download(to_spec)
+        end
+      end
+    end
+
+  end
+
+
+  # Singleton object for specifying the local, remote and release repositories.
+  class Repositories
+    include Singleton
+
+    # Returns the path to the local repository.
+    #
+    # The default path is .m2/repository relative to the home directory.
+    def local()
+      @local ||= ENV["local_repo"] || File.join(ENV["HOME"], ".m2", "repository")
+    end
+
+    # Sets the path to the local repository.
+    def local=(dir)
+      @local = dir ? File.expand_path(dir) : nil
+    end
+
+    # Locates an artifact in the local repository based on its specification.
+    #
+    # 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.spec_to_hash(spec) unless Hash === spec
+      File.join(local, spec[:group].split("."), spec[:id], spec[:version], Artifact.hash_to_file_name(spec))
+    end
+
+    # Returns a hash of all the remote repositories. The key is the repository
+    # identifier, and the value is the repository base URL.
+    def remote()
+      @remote ||= {}
+    end
+
+    # Sets the remote repositories from a hash. See #remote.
+    def remote=(hash)
+      case hash
+      when nil
+        @remote = {}
+      when Hash
+        @remote = hash.clone
+      else
+        raise ArgumentError, "Expecting a hash" unless Hash === hash
+      end
+    end
+
+    # Adds more remote repositories from a hash. See #remote.
+    #
+    # For example:
+    #   repositories.remote.add :ibiblio=>"http://www.ibiblio.org/maven2"
+    def add(hash)
+      remote.merge!(hash)
+    end
+
+    # Attempts to download the artifact from one of the remote repositories
+    # and store it in the local repository. Returns the path if downloaded,
+    # otherwise raises an exception.
+    def download(spec)
+      spec = Artifact.spec_to_hash(spec) unless Hash === spec
+      path = locate(spec)
+      
+      puts "Downloading #{Artifact.hash_to_spec(spec)}" if Rake.application.options.trace
+      return path if remote.any? do |repo_id, repo_url|
+        begin
+          rel_path = spec[:group].gsub(".", "/") +
+            "/#{spec[:id]}/#{spec[:version]}/#{Artifact.hash_to_file_name(spec)}"
+          Transports.perform URI.parse(repo_url.to_s) do |http|
+            mkpath File.dirname(path), :verbose=>false
+            http.download(rel_path, path)
+            begin
+              http.download(rel_path.ext("pom"), path.ext("pom"))
+            rescue Transports::NotFound
+            end
+          end
+          true
+        rescue Exception=>error
+          warn error if Rake.application.options.trace
+          false
+        end
+      end
+      fail "Failed to download #{Artifact.hash_to_spec(spec)}, tried the following repositories:\n#{repositories.remote.values.join("\n")}"
+    end
+
+    # Specifies deployment target for all artifacts generated by this project.
+    #
+    # For example:
+    #   repositories.deploy_to = "sftp://example.com/var/www/maven/"
+    # or:
+    #   repositories.deploy_to = "sftp://john:secret@example.com/var/www/maven/"
+    def deploy_to=(options)
+      options = { :url=>options } unless Hash === options
+      @deploy_to = options
+    end
+
+    def deploy_to()
+      @deploy_to || {}
+    end
+
+  end
+
+  # Returns a global object for setting local and remote repositories.
+  # See Repositories.
+  def repositories()
+    Repositories.instance
+  end
+
+  # Creates a file task to download and install the specified artifact.
+  #
+  # The artifact specification can be a string or a hash.
+  # The file task points to the artifact in the local repository.
+  #
+  # You can provide alternative behavior to create the artifact instead
+  # of downloading it from a remote repository.
+  #
+  # For example, to specify an artifact:
+  #   artifact("log4j:log4j:jar:1.1")
+  #
+  # To use the artifact in a task:
+  #   unzip artifact("org.apache.pxe:db-derby:zip:1.2")
+  #
+  # 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)
+    spec = Artifact.spec_to_hash(spec)
+    unless task = Artifact.lookup(spec)
+      task = Artifact.define_task(repositories.locate(spec))
+      Artifact.register(task)
+    end
+    task.apply_spec spec
+    task.enhance(&block) if block_given?
+    task
+  end
+
+  # Creates multiple artifacts from a set of specifications and returns
+  # an array of tasks.
+  #
+  # You can pass any number of arguments, each of which can be:
+  # * An artifact specification, string or hash. Returns a new task for
+  #   each specification, by calling #artifact.
+  # * An artifact task or any other task. Returns the task as is.
+  # * A project. Returns all packaging tasks in that project.
+  # * An array of artifacts. Returns all the artifacts found there.
+  #
+  # This method handles arrays of artifacts as if they are flattend,
+  # to help in managing large combinations of artifacts. For example:
+  #   xml = [ xerces, xalan, jaxp ]
+  #   ws = [ axis, jax-ws, jaxb ]
+  #   db = [ jpa, mysql, sqltools ]
+  #   base = [ xml, ws, db ]
+  #   artifacts(base, models, services)
+  #
+  # You can also pass tasks and project. This is particularly useful for
+  # dealing with dependencies between projects that are part of the same
+  # build.
+  #
+  # For example:
+  #   artifacts(base, models, services, module1, module2)
+  #
+  # When passing a project as argument, it expands that project to all
+  # its packaging tasks. You can then use the resulting artifacts as
+  # dependencies that will force these packages to be build inside the
+  # project, without installing them in the local repository.
+  def artifacts(*specs)
+    specs.inject([]) do |set, spec|
+      case spec
+      when Hash
+        set |= [artifact(spec)]
+      when /:.*:.*:/
+        set |= [artifact(spec)]
+      when String
+        set |= [file(spec)]
+      when Rake::Task
+        set |= [spec]
+      when Project
+        set |= artifacts(spec.packages)
+      when Array
+        set |= artifacts(*spec)
+      else
+        fail "Invalid artifact specification: #{spec || 'nil'}"
+      end
+      set
+    end
+  end
+
+  # Convenience method for defining multiple artifacts that belong
+  # to the same version and group. Accepts multiple artifact identifiers
+  # (or arrays of) followed by two has keys:
+  # * :under -- The group identifier
+  # * :version -- The version number
+  #
+  # 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], :version=>hash[:version], :id=>id }
+  end 
+
+  # Creates and return a task that will deploy all the specified
+  # artifacts and files. Specify the deployment server by passing it
+  # as the last argument (must be a hash).
+  #
+  # For example:
+  #   deploy(*process.packages, :url=>"sftp://example.com/var/www/maven")
+  def deploy(*args)
+    # Where do we release to?
+    if Hash === args.last
+      options = args.pop
+    else
+      options = repositories.deploy_to
+      options = { :url=>options.to_s } unless Hash === options
+    end
+    url = options[:url]
+    options = options.reject { |k,v| k === :url }
+    fail "Don't know where to release, specify a URL or use repositories.deploy_to = url|hash" if url.blank?
+
+    # Arguments are artifacts and types so we depend on them.
+    task(url=>args).enhance do |task|
+      Transports.perform url, options do |session|
+        args.each do |artifact|
+          if artifact.respond_to?(:to_spec)
+            # Upload artifact relative to base URL, need to create path before uploading.
+            puts "Deploying #{artifact.to_spec}" if verbose
+            spec = artifact.to_spec_hash
+            path = spec[:group].gsub(".", "/") + "/#{spec[:id]}/#{spec[:version]}/"
+            session.mkpath path
+            session.upload artifact.to_s, path + Artifact.hash_to_file_name(spec)
+          else
+            # Upload artifact to URL.
+            puts "Deploying #{artifact}" if verbose
+            session.upload artifact, File.basename(artifact)
+          end
+        end
+      end
+    end
+  end
+
+end