Buildr 0.17.0

data/CHANGELOG

@@ -0,0 +1,189 @@
+0.17 (3/14/2007)
+* Added: project.task acts like Rake's task but can also fetch a task from
+  a project using the project's namespace.
+* Added: project.file acts like Rake's file but resolve relative paths
+  based on the project base directory.
+* Added: Rake tasks execute in the directory in which they were defined.
+* Added: enhanced Rake with circular dependency, and you can find all circular
+  dependencies by running rake check.
+* Added: enhanced Rake in_namespace, if the namespace starts with colon,
+  creates a namespace relative to the root instead of the current namespace.
+* Changed: a project definition is now a task definition.
+* Changed: use enhance to extend the project definition instead of after_define.
+* Changed: LocalDirectoryTask replaced with Project.local_task.
+* Changed: projects method accepts multiple names, returning only these project
+  definitions, returns all of them with no arguments.
+* Changed: package only defines the essentials once, so you can call package
+  on a project to retrieve a specific package by type/id.
+* Changed: zip task (and jar/war) no longer resolve artifacts for you,
+  must call artifacts directly.
+* Changed: cannot access a project before it's defined, but can do that with
+  sub-projects to establish dependencies.
+
+0.16 (3/7/2007)
+* Added: zip.include :as=> to include file under specified name.
+* Added: zip.merge to include the (expanded) contents of one zip file in another.
+* Added: experimental test task using JUnit and JMock.
+* Changed: project.to_s returns name, projects returns sorted by name.
+* Changed: project definition now executed using project's base directory
+  as the current directory.
+* Fixed: artifact test cases and minor code cleanup.
+* Fixed: attempts to download artifact even if created by task.
+* Fixed: release task now deletes old tagged copy and reports SVN usage.
+* Fixed: OpenJPA not including target directory in classpath.
+
+0.15 (2/28/2007)
+* Fixed: tasks fail unless deployment server specified.
+* Changed: deploy method executes deployment, instead of returning a task.
+
+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,55 @@
+# returning(obj)
+require "facet/kernel/with"
+# &:symbol goodness.
+require "facet/symbol/to_proc"
+# blank? on string and nil
+require "facet/string/blank"
+require "facet/nilclass/blank"
+# x.in?(y) is better than y.include?(x)
+require "facet/kernel/in"
+# What it says.
+require "facet/kernel/__DIR__"
+require "facet/kernel/instance_exec"
+require "facet/module/alias_method_chain"
+require "facet/module/memoize"
+require "facet/string/starts_with"
+
+
+module Buildr
+  VERSION = "0.17.0"
+end
+
+$LOAD_PATH.unshift File.join(__DIR__)
+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/jetty"
+require "java/compile"
+require "java/eclipse"
+#require "java/test"
+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,405 @@
+module Buildr
+
+  # This module gives you a way to access the individual properties of an
+  # artifact: id, group, type, classifier and version. It also provides other
+  # methods commonly used on an artifact, specifically #to_hash and #to_spec.
+  module ActsAsArtifact
+
+    ARTIFACT_ATTRIBUTES = [:group, :id, :type, :classifier, :version]
+
+    class << self
+      def included(mod)
+        mod.extend self
+      end
+    end
+
+    # The artifact identifier.
+    attr_reader :id
+    # The group identifier.
+    attr_reader :group
+    # The file type.
+    attr_reader :type
+    # The version number.
+    attr_reader :version
+    # Optional artifact 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>
+    # or
+    #   <group>:<artifact>:<type>:<classifier><:<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)
+      spec = Artifact.to_hash(spec)
+      ARTIFACT_ATTRIBUTES.each { |key| instance_variable_set("@#{key}", spec[key]) }
+      self
+    end
+
+    # Convenience method that returns a POM artifact.
+    def pom()
+      return self if type.to_s == "pom"
+      artifact(:group=>group, :id=>id, :version=>version, :type=>"pom", :classifier=>classifier)
+    end
+
+  end
+
+
+  # The Artifact task maps to an artifact file in the local repository
+  # and knows how to download the file from a remote repository.
+  #
+  # The task will only download the file if it does not exist. You can
+  # enhance the task to create the artifact yourself.
+  class Artifact < Rake::FileCreationTask
+
+    # The default file type for artifacts, if not specified.
+    DEFAULT_FILE_TYPE = "jar"
+
+    include ActsAsArtifact
+
+    class << self
+
+      # Lookup a previously registered artifact task based on the
+      # artifact specification (string or hash).
+      def lookup(spec)
+        @artifacts ||= {}
+        @artifacts[to_spec(spec)]
+      end
+
+      # Register an artifact task(s) for later lookup (see #lookup).
+      def register(*tasks)
+        @artifacts ||= {}
+        fail "You can only register an artifact task, strings and hashes are just not good enough" unless
+          tasks.all? { |task| task.respond_to?(:to_spec) && task.respond_to?(:invoke) }
+        tasks.each { |task| @artifacts[task.to_spec] = task }
+        tasks
+      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 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.
+      #
+      # :nodoc:
+      def to_hash(spec)
+        if spec.respond_to?(:to_spec)
+          to_hash spec.to_spec
+        elsif Hash === spec
+          # Sanitize the hash and check it's valid.
+          spec = ARTIFACT_ATTRIBUTES.inject({}) { |h, k| h[k] = spec[k] ; h }
+          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
+        elsif String === spec
+          group, id, type, version, *rest = spec.split(":")
+          unless rest.empty?
+            # Optional classifier comes before version.
+            classifier, version = version, rest.shift
+            fail "Expecting <project:id:type:version> or <project: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
+
+      # Convert a hash back to a spec string. This method accepts
+      # a string, hash or any object that responds to to_spec.
+      # :nodoc:
+      def to_spec(hash)
+        hash = to_hash(hash) unless Hash === 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.
+      # :nodoc:
+      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 execute()
+      # Default behavior: download the artifact from one of the remote
+      # repositories if the file does not exist. But this default behavior
+      # is counter useful 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.
+      super
+      unless Rake.application.options.dryrun || File.exist?(name)
+        repositories.download(to_spec)
+      end
+    end
+
+  end
+
+
+  # Holds the path to the local repository, URLs for remote repositories, and
+  # settings for the deployment repository.
+  class Repositories
+    include Singleton
+
+    # Returns the path to the local repository.
+    #
+    # The default path is .m2/repository relative to the home directory.
+    # You can change the location of the local repository by using a symbol
+    # link or by setting a different path. If you set a different path, do it
+    # in the buildr.rb file instead of the Rakefile. 
+    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.to_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.to_hash(spec) unless Hash === spec
+      path = locate(spec)
+      
+      puts "Downloading #{Artifact.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.to_spec(spec)}, tried the following repositories:\n#{repositories.remote.values.join("\n")}"
+    end
+
+    # Specifies the deployment repository. Accepts a hash with the different
+    # repository settings (e.g. url, username, password). Anything else is
+    # interepted as the URL.
+    #
+    # For example:
+    #   repositories.deploy_to = { :url=>"sftp://example.com/var/www/maven/",
+    #                              :username="john", :password=>"secret" }
+    # 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
+
+    # Returns the current deployment repository configuration. This is a more
+    # convenient way to specify deployment in the Rakefile, and override it
+    # locally. For example:
+    #   # Rakefile
+    #   repositories.deploy_to[:url] ||= "sftp://example.com"
+    #   # buildr.rb
+    #   repositories.deploy_to[:url] = "sftp://acme.org"
+    def deploy_to()
+      @deploy_to ||= {}
+    end
+
+  end
+
+
+  # Returns a global object for setting local, remote and deploy 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.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
+  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 Project
+        set |= artifacts(spec.packages)
+      when Rake::Task
+        set |= [spec]
+      when Array
+        set |= artifacts(*spec)
+      else
+        fail "Invalid artifact specification: #{spec.to_s || '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 
+
+  # Deploys all the specified artifacts/files. Specify the deployment
+  # server by passing a hash as the last argument, or have it use
+  # repositories.deploy_to.
+  #
+  # 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 deploy, perhaps you forgot to set repositories.deploy_to" if url.blank?
+
+    args.each { |arg| arg.invoke if arg.respond_to?(:invoke) }
+    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