buildr 1.2.10 → 1.3.0

data/lib/buildr/java/version_requirement.rb

@@ -0,0 +1,172 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+module Buildr
+  
+  #
+  # See ArtifactNamespace#need
+  class VersionRequirement
+    
+    CMP_PROCS = Gem::Requirement::OPS.dup
+    CMP_REGEX = Gem::Requirement::OP_RE.dup
+    CMP_CHARS = CMP_PROCS.keys.join
+    BOOL_CHARS = '\|\&\!'
+    VER_CHARS = '\w\.'
+    
+    class << self
+      # is +str+ a version string?
+      def version?(str)
+        /^\s*[#{VER_CHARS}]+\s*$/ === str
+      end
+      
+      # is +str+ a version requirement?
+      def requirement?(str)
+        /[#{BOOL_CHARS}#{CMP_CHARS}\(\)]/ === str
+      end
+      
+      # :call-seq:
+      #    VersionRequirement.create(" >1 <2 !(1.5) ") -> requirement
+      #
+      # parse the +str+ requirement 
+      def create(str)
+        instance_eval normalize(str)
+      rescue StandardError => e
+        raise "Failed to parse #{str.inspect} due to: #{e}"
+      end
+
+      private
+      def requirement(req)
+        unless req =~ /^\s*(#{CMP_REGEX})?\s*([#{VER_CHARS}]+)\s*$/
+          raise "Invalid requirement string: #{req}"
+        end
+        comparator, version = $1, $2
+        version = Gem::Version.new(0).tap { |v| v.version = version }
+        VersionRequirement.new(nil, [$1, version])
+      end
+
+      def negate(vreq)
+        vreq.negative = !vreq.negative
+        vreq
+      end
+      
+      def normalize(str)
+        str = str.strip
+        if str[/[^\s\(\)#{BOOL_CHARS + VER_CHARS + CMP_CHARS}]/]
+          raise "version string #{str.inspect} contains invalid characters"
+        end
+        str.gsub!(/\s+(and|\&\&)\s+/, ' & ')
+        str.gsub!(/\s+(or|\|\|)\s+/, ' | ')
+        str.gsub!(/(^|\s*)not\s+/, ' ! ')
+        pattern = /(#{CMP_REGEX})?\s*[#{VER_CHARS}]+/
+        left_pattern = /[#{VER_CHARS}\)]$/
+        right_pattern = /^(#{pattern}|\()/
+        str = str.split.inject([]) do |ary, i|
+          ary << '&' if ary.last =~ left_pattern  && i =~ right_pattern
+          ary << i
+        end
+        str = str.join(' ')
+        str.gsub!(/!([^=])?/, ' negate \1')
+        str.gsub!(pattern) do |expr|
+          case expr.strip
+          when 'not', 'negate' then 'negate '
+          else 'requirement("' + expr + '")'
+          end
+        end
+        str.gsub!(/negate\s+\(/, 'negate(')
+        str
+      end
+    end
+
+    def initialize(op, *requirements) #:nodoc:
+      @op, @requirements = op, requirements
+    end
+
+    # Is this object a composed requirement?
+    #   VersionRequirement.create('1').composed? -> false
+    #   VersionRequirement.create('1 | 2').composed? -> true
+    #   VersionRequirement.create('1 & 2').composed? -> true
+    def composed?
+      requirements.size > 1
+    end
+
+    # Return the last requirement on this object having an = operator.
+    def default
+      default = nil
+      requirements.reverse.find do |r|
+        if Array === r
+          if !negative && (r.first.nil? || r.first.include?('='))
+            default = r.last.to_s
+          end
+        else
+          default = r.default
+        end
+      end
+      default
+    end
+
+    # Test if this requirement can be satisfied by +version+
+    def satisfied_by?(version)
+      return false unless version
+      unless version.kind_of?(Gem::Version)
+        raise "Invalid version: #{version.inspect}" unless self.class.version?(version)
+        version = Gem::Version.new(0).tap { |v| v.version = version.strip }
+      end
+      message = op == :| ? :any? : :all?
+      result = requirements.send message do |req|
+        if Array === req
+          cmp, rv = *req
+          CMP_PROCS[cmp || '='].call(version, rv)
+        else
+          req.satisfied_by?(version)
+        end
+      end
+      negative ? !result : result
+    end
+
+    # Either modify the current requirement (if it's already an or operation)
+    # or create a new requirement
+    def |(other)
+      operation(:|, other)
+    end
+
+    # Either modify the current requirement (if it's already an and operation)
+    # or create a new requirement
+    def &(other)
+      operation(:&, other)
+    end
+    
+    # return the parsed expression
+    def to_s
+      str = requirements.map(&:to_s).join(" " + @op.to_s + " ").to_s
+      str = "( " + str + " )" if negative || requirements.size > 1
+      str = "!" + str if negative
+      str
+    end
+
+    attr_accessor :negative
+    protected
+    attr_reader :requirements, :op
+    def operation(op, other)
+      @op ||= op 
+      if negative == other.negative && @op == op && other.requirements.size == 1
+        @requirements << other.requirements.first
+        self
+      else
+        self.class.new(op, self, other)
+      end
+    end
+  end # VersionRequirement
+end

data/lib/buildr/packaging.rb

@@ -0,0 +1,21 @@
+# 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/packaging/zip'
+require 'buildr/packaging/tar'
+require 'buildr/packaging/artifact'
+require 'buildr/packaging/package'
+require 'buildr/packaging/gems'

data/lib/{java → buildr/packaging}/artifact.rb

@@ -1,11 +1,29 @@
-require "core/project"
-require "core/transports"
-require "builder"
+# 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 'builder'
+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'
+  task 'artifacts'
 
   # Mixin with a task to make it behave like an artifact. Implemented by the packaging tasks.
   #
@@ -42,50 +60,50 @@ module Buildr
     end
 
     # :call-seq:
-    #   to_spec_hash() => Hash
+    #   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",
+    #   { :group=>'com.example',
+    #     :id=>'app',
     #     :type=>:jar,
-    #     :version=>"1.2" }
-    def to_spec_hash()
+    #     :version=>'1.2' }
+    def to_spec_hash
       base = { :group=>group, :id=>id, :type=>type, :version=>version }
-      classifier.blank? ? base : base.merge(:classifier=>classifier)
+      classifier ? base.merge(:classifier=>classifier) : base
     end
     alias_method :to_hash, :to_spec_hash
 
     # :call-seq:
-    #   to_spec() => String
+    #   to_spec => String
     #
     # 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}"
+    def to_spec
+      classifier ? "#{group}:#{id}:#{type}:#{classifier}:#{version}" : "#{group}:#{id}:#{type}:#{version}"
     end
 
     # :call-seq:
-    #   pom() => Artifact
+    #   pom => Artifact
     # 
     # Convenience method that returns a POM artifact.
-    def pom()
+    def pom
       return self if type == :pom
-      Buildr.artifact(:group=>group, :id=>id, :version=>version, :type=>:pom, :classifier=>classifier)
+      Buildr.artifact(:group=>group, :id=>id, :version=>version, :type=>:pom)
     end
 
     # :call-seq:
-    #   pom_xml() => string
+    #   pom_xml => string
     #
     # Creates POM XML for this artifact.
-    def pom_xml()
+    def pom_xml
       xml = Builder::XmlMarkup.new(:indent=>2)
       xml.instruct!
       xml.project do
-        xml.modelVersion  "4.0.0"
+        xml.modelVersion  '4.0.0'
         xml.groupId       group
         xml.artifactId    id
         xml.version       version
@@ -93,8 +111,29 @@ module Buildr
       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
+        puts "Installed #{installed}" if verbose
+      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
     #   upload(url)
     #   upload(options)
     #
@@ -108,18 +147,22 @@ module Buildr
       # 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" if upload_to[:url].blank?
+      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.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.
       puts "Deploying #{to_spec}" if verbose
-      path = group.gsub(".", "/") + "/#{id}/#{version}/#{File.basename(name)}"
+      path = group.gsub('.', '/') + "/#{id}/#{version}/#{File.basename(name)}"
       URI.upload uri + path, name, :permissions=>upload_to[:permissions]
     end
 
@@ -133,7 +176,7 @@ module Buildr
     end
     
     def group_path
-      group.gsub(".", "/")
+      group.gsub('.', '/')
     end
 
   end
@@ -166,10 +209,11 @@ module Buildr
       end
 
       # :call-seq:
-      #   list() => specs
+      #   list => specs
       #
       # Returns an array of specs for all the registered artifacts. (Anything created from artifact, or package).
-      def list()
+      def list
+        @artifacts ||= {}
         @artifacts.keys
       end
 
@@ -179,7 +223,7 @@ module Buildr
       # 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
+        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
@@ -203,21 +247,21 @@ module Buildr
           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}" 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] = spec[:type].blank? ? DEFAULT_TYPE : spec[:type].to_sym
+          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(":")
+          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 <project:id:type:version> or <project:id:type:classifier:version>, found <#{spec}>" unless rest.empty?
+            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"
+          fail 'Expecting a String, Hash or object that responds to to_spec'
         end
       end
 
@@ -228,8 +272,8 @@ module Buildr
       # 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]}" unless hash[:version].blank?
-        classifier = ":#{hash[:classifier]}" unless hash[:classifier].blank?
+        version = ":#{hash[:version]}" if hash[:version]
+        classifier = ":#{hash[:classifier]}" if hash[:classifier]
         "#{hash[:group]}:#{hash[:id]}:#{hash[:type] || DEFAULT_TYPE}#{classifier}#{version}"
       end
 
@@ -238,8 +282,8 @@ module Buildr
       #
       # Convert a hash spec to a file name.
       def hash_to_file_name(hash)
-        version = "-#{hash[:version]}" unless hash[:version].blank?
-        classifier = "-#{hash[:classifier]}" unless hash[:classifier].blank?
+        version = "-#{hash[:version]}" if hash[:version]
+        classifier = "-#{hash[:classifier]}" if hash[:classifier]
         "#{hash[:id]}#{version}#{classifier}.#{hash[:type] || DEFAULT_TYPE}"
       end
 
@@ -293,7 +337,7 @@ module Buildr
   protected
 
     # :call-seq:
-    #   download()
+    #   download
     # 
     # Downloads an artifact from one of the remote repositories, and stores it in the local
     # repository. Accepts a String or Hash artifact specification, and returns a path to the
@@ -301,11 +345,11 @@ module Buildr
     #
     # This method attempts to download the artifact from each repository in the order in
     # which they are returned from #remote, until successful. It always downloads the POM first.
-    def download()
-      puts "Downloading #{to_spec}" if Rake.application.options.trace
+    def download
+      puts "Downloading #{to_spec}" if Buildr.application.options.trace
       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?
+      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)}"
@@ -315,7 +359,7 @@ module Buildr
           false
         rescue Exception=>error
           puts error if verbose
-          puts error.backtrace.join("\n") if Rake.application.options.trace
+          puts error.backtrace.join("\n") if Buildr.application.options.trace
           false
         end
       end
@@ -350,8 +394,8 @@ module Buildr
         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
+        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
@@ -369,19 +413,23 @@ module Buildr
   #
   # 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"
+  #   repositories.remote << 'http://example.com/repo'
+  #   repositories.release_to = 'sftp://example.com/var/www/public/repo'
   class Repositories
     include Singleton
 
     # :call-seq:
-    #   local() => path
+    #   local => path
     #
     # 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(Gem::user_home, ".m2/repository")
+    # 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:
@@ -403,23 +451,38 @@ module Buildr
     # a file path.
     #
     # For example:
-    #   locate :group=>"log4j", :id=>"log4j", :version=>"1.1"
+    #   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))
+      File.join(local, spec[:group].split('.'), spec[:id], spec[:version], Artifact.hash_to_file_name(spec))
     end
 
     # :call-seq:
-    #   remote() => Array
+    #   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"
-    def remote()
-      @remote ||= []
+    #   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:
@@ -434,55 +497,10 @@ module Buildr
     # With nil, clears the array.
     def remote=(urls)
       case urls
-      when nil
-        @remote = nil
-      when Array
-        @remote = urls.dup
-      else
-        @remote = [urls.to_s]
-      end
-    end
-
-    # *Deprecated* Please use options.proxy.http instead of repositories.proxy.
-    def proxy()
-      warn_deprecated "Please use options.proxy.http instead of repositories.proxy"
-      Buildr.options.proxy.http
-    end
-
-    # *Deprecated* Please use options.proxy.http = <url> instead of repositories.proxy.
-    def proxy=(proxy)
-      warn_deprecated "Please use options.proxy.http = <url> instead of repositories.proxy"
-      Buildr.options.proxy.http = proxy
-    end
-  
-    # *Deprecated* Just create an artifact and invoke it. 
-    def download(spec)
-      warn_deprecated "Just create and artifact and invoke it."
-      spec = Artifact.to_hash(spec) unless Hash === spec
-      filename = locate(spec)
-      
-      puts "Downloading #{Artifact.to_spec(spec)}" if Rake.application.options.trace
-      return filename if remote.any? do |repo_url|
-        repo_url = URI.parse(repo_url) unless URI === repo_url
-        repo_url.path += "/" unless repo_url.path[-1] == "/"
-        begin
-          path = spec[:group].gsub(".", "/") +
-            "/#{spec[:id]}/#{spec[:version]}/#{Artifact.hash_to_file_name(spec)}"
-          mkpath File.dirname(filename), :verbose=>false
-          # We absolutely need the POM, so make sure we download it before the artifact
-          # (unless the artifact is a POM).
-          URI.download repo_url + path.ext("pom"), filename.ext("pom")  unless type == :pom
-          URI.download repo_url + path, filename
-          true
-        rescue URI::NotFoundError
-          false
-        rescue Exception=>error
-          puts error if verbose
-          puts error.backtrace.join("\n") if Rake.application.options.trace
-          false
-        end
+      when nil then @remote = nil
+      when Array then @remote = urls.dup
+      else @remote = [urls.to_s]
       end
-      fail "Failed to download #{Artifact.to_spec(spec)}, tried the following repositories:\n#{remote.join("\n")}"
     end
 
     # :call-seq:
@@ -495,51 +513,53 @@ module Buildr
     # 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" }
+    #   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
+    #   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"
+    #   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()
-      @release_to ||= {}
-    end
-
-    # *Deprecated* See release_to.
-    def deploy_to=(options)
-      warn_deprecated "Please use release_to instead."
-      self.release_to = options
-    end
-
-    # *Deprecated* See release_to.
-    def deploy_to()
-      warn_deprecated "Please use release_to instead."
-      self.release_to
+    #   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
+  #    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()
+  def repositories
     Repositories.instance
   end
 
@@ -558,20 +578,21 @@ module Buildr
   # 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")
+  #   artifact('log4j:log4j:jar:1.1')
   #
   # To use the artifact in a task:
-  #   compile.with artifact("log4j:log4j:jar:1.1")
+  #   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")
+  #   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]
+      Rake::Task['rake:artifacts'].enhance [task]
       Artifact.register(task)
     end
     task.enhance &block
@@ -583,12 +604,14 @@ module Buildr
   # Handles multiple artifacts at a time. This method is the plural equivalent of
   # #artifacts, but can do more things.
   #
-  # You can pass any number of arguments, each of which can be:
+  # 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 ]
@@ -597,12 +620,14 @@ module Buildr
   #   artifacts(xml, ws, db)
   #
   # Using artifacts created by a project:
-  #   artifact project("my-app")               # All packages
-  #   artifact project("mu-app").package(:war) # Only the WAR
-  def artifacts(*specs)
+  #   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 Hash
+      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)]
@@ -615,7 +640,7 @@ module Buildr
       when Struct
         set |= artifacts(spec.values)
       else
-        fail "Invalid artifact specification in: #{specs.to_s}"
+        fail "Invalid artifact specification in #{specs.inspect}"
       end
     end
   end
@@ -644,7 +669,7 @@ module Buildr
   end
 
   # :call-seq:
-  #   groups(ids, :under=>group_name, :version=>number) => artifacts
+  #   group(ids, :under=>group_name, :version=>number) => artifacts
   #
   # Convenience method for defining multiple artifacts that belong to the same group and version.
   # Accepts multiple artifact identifiers follows by two hash values:
@@ -652,9 +677,9 @@ module Buildr
   # * :version -- The version number
   #
   # For example:
-  #   group "xbean", "xbean_xpath", "xmlpublic", :under=>"xmlbeans", :version=>"2.1.0"
+  #   group 'xbean', 'xbean_xpath', 'xmlpublic', :under=>'xmlbeans', :version=>'2.1.0'
   # Or:
-  #   group %w{xbean xbean_xpath xmlpublic}, :under=>"xmlbeans", :version=>"2.1.0"
+  #   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 }
@@ -693,44 +718,10 @@ module Buildr
   def upload(*args, &block)
     artifacts = artifacts(args)
     raise ArgumentError, 'This method can only upload artifacts' unless artifacts.all? { |f| f.respond_to?(:to_spec) }
-    all = (artifacts + artifacts.map { |artifact| artifact.pom }).uniq
     task('upload').tap do |task|
       task.enhance &block if block
-      task.enhance all do
-        all.each { |artifact| artifact.upload }
-      end
-    end
-  end
-
-  # *Deprecated* For artifact, call it's upload method; for anything else, use URI.upload.
-  def deploy(*args)
-    warn_deprecated "If it's an artifact, call it's upload method directly. Otherwise, use URI.upload."
-    # Where do we release to?
-    options = Hash === args.last ? args.pop : {}
-    deploy_to = options[:url] ? options : repositories.release_to
-    fail "Don't know where to deploy, perhaps you forgot to set repositories.deploy_to" if deploy_to[:url].blank?
-
-    args.flatten.each { |arg| arg.invoke if arg.respond_to?(:invoke) }
-    # 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(deploy_to[:url].clone)
-    uri.path = uri.path + "/" unless uri.path[-1] == "/"
-    uri.user = deploy_to[:username] if deploy_to[:username]
-    uri.password = deploy_to[:password] if deploy_to[:password]
-
-    args.each do |arg|
-      if arg.respond_to?(:to_spec)
-        # Upload artifact relative to base URL, need to create path before uploading.
-        puts "Deploying #{arg.to_spec}" if verbose
-        spec = arg.to_spec_hash
-        path = spec[:group].gsub(".", "/") + "/#{spec[:id]}/#{spec[:version]}/" + Artifact.hash_to_file_name(spec)
-        URI.upload uri + path, arg.to_s, :permissions=>deploy_to[:permissions]
-      else
-        # Upload file to URL.
-        puts "Deploying #{arg}" if verbose
-        path = File.basename(args.to_s)
-        path = File.join(options[:path], path) if options[:path]
-        URI.upload uri + path, arg.to_s, :permissions=>deploy_to[:permissions]
+      task.enhance artifacts do
+        artifacts.each { |artifact| artifact.upload }
       end
     end
   end