buildr 1.3.3-java → 1.3.4-java

data/lib/buildr/packaging/artifact.rb

@@ -14,7 +14,6 @@
 # the License.
 
 
-require 'builder'
 require 'buildr/core/project'
 require 'buildr/core/transports'
 require 'buildr/packaging/artifact_namespace'
@@ -25,6 +24,9 @@ module Buildr
   desc 'Download all artifacts'
   task 'artifacts'
 
+  desc "Download all artifacts' sources"
+  task 'artifacts:sources'
+
   # Mixin with a task to make it behave like an artifact. Implemented by the packaging tasks.
   #
   # An artifact has an identifier, group identifier, type, version number and
@@ -81,7 +83,7 @@ module Buildr
     # Returns the artifact specification, in the structure:
     #   <group>:<artifact>:<type>:<version>
     # or
-    #   <group>:<artifact>:<type>:<classifier><:version>
+    #   <group>:<artifact>:<type>:<classifier>:<version>
     def to_spec
       classifier ? "#{group}:#{id}:#{type}:#{classifier}:#{version}" : "#{group}:#{id}:#{type}:#{version}"
     end
@@ -95,6 +97,17 @@ module Buildr
       Buildr.artifact(:group=>group, :id=>id, :version=>version, :type=>:pom)
     end
 
+    # :call-seq:
+    #   sources_artifact => Artifact
+    # 
+    # Convenience method that returns a sources artifact.
+    def sources_artifact
+      sources_spec = to_spec_hash.merge(:classifier=>'sources')
+      sources_task = OptionalArtifact.define_task(Buildr.repositories.locate(sources_spec))
+      sources_task.send :apply_spec, sources_spec
+      sources_task
+    end
+
     # :call-seq:
     #   pom_xml => string
     #
@@ -110,26 +123,22 @@ module Buildr
         xml.classifier    classifier if classifier
       end
     end
-
+    
     def install
       pom.install if pom && pom != self
       invoke
       installed = Buildr.repositories.locate(self)
       unless installed == name # If not already in local repository.
-        verbose(Buildr.application.options.trace || false) do
-          mkpath File.dirname(installed)
-          cp name, installed
-        end
+        mkpath File.dirname(installed)
+        cp name, installed
         info "Installed #{installed}"
       end
     end
 
     def uninstall
-      verbose(Buildr.application.options.trace || false) do
-        installed = Buildr.repositories.locate(self)
-        rm installed if File.exist?(installed) 
-        pom.uninstall if pom && pom != self
-      end
+      installed = Buildr.repositories.locate(self)
+      rm installed if File.exist?(installed) 
+      pom.uninstall if pom && pom != self
     end
 
     # :call-seq:
@@ -312,23 +321,19 @@ module Buildr
     # Use this when you want to install or upload an artifact from a given file, for example:
     #   test = artifact('group:id:jar:1.0').from('test.jar')
     #   install test
-    # See also Buildr#install and Buildr#deploy.
+    # See also Buildr#install and Buildr#upload.
     def from(path)
       path = File.expand_path(path.to_s)
       enhance [path] do
-        verbose false do
-          mkpath File.dirname(name)
-          pom.invoke unless type == :pom
-          cp path, name
-          info "Installed #{path} as #{to_spec}"
-        end
+        mkpath File.dirname(name)
+        pom.invoke unless type == :pom
+        cp path, name
+        info "Installed #{path} as #{to_spec}"
       end
       unless type == :pom
         pom.enhance do
-          verbose false do
-            mkpath File.dirname(pom.name)
-            File.open(pom.name, 'w') { |file| file.write pom.pom_xml }
-          end
+          mkpath File.dirname(pom.name)
+          File.open(pom.name, 'w') { |file| file.write pom.pom_xml }
         end
       end
       self
@@ -340,11 +345,10 @@ module Buildr
     #   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
-    # artifact in the local repository. Raises an exception if the artifact is not found.
+    # repository. Raises an exception if the artifact is not found.
     #
     # This method attempts to download the artifact from each repository in the order in
-    # which they are returned from #remote, until successful. It always downloads the POM first.
+    # which they are returned from #remote, until successful.
     def download
       trace "Downloading #{to_spec}"
       remote = Buildr.repositories.remote.map { |repo_url| URI === repo_url ? repo_url : URI.parse(repo_url) }
@@ -407,6 +411,22 @@ module Buildr
       fail "Failed to download #{to_spec}, tried the following repositories:\n#{remote_uris.join("\n")}"
     end
   end
+  
+  
+  # An artifact that is optional.
+  # If downloading fails, the user will be informed but it will not raise an exception.
+  class OptionalArtifact < Artifact
+    
+    protected
+    
+    # If downloading fails, the user will be informed but it will not raise an exception.
+    def download
+      super
+    rescue 
+      info "Failed to download #{to_spec}. Skipping it."
+    end
+    
+  end
 
 
   # Holds the path to the local repository, URLs for remote repositories, and settings for release server.
@@ -594,6 +614,7 @@ module Buildr
       task.send :apply_spec, spec
       Rake::Task['rake:artifacts'].enhance [task]
       Artifact.register(task)
+      Rake::Task['artifacts:sources'].enhance [task.sources_artifact] unless spec[:type] == :pom
     end
     task.enhance &block
   end
@@ -701,9 +722,7 @@ module Buildr
     task('install').tap do |task|
       task.enhance all, &block
       task 'uninstall' do
-        verbose false do
-          all.map(&:to_s ).each { |file| rm file if File.exist?(file) }
-        end
+        all.map(&:to_s ).each { |file| rm file if File.exist?(file) }
       end
     end
   end

data/lib/buildr/packaging/artifact_namespace.rb

@@ -14,7 +14,7 @@
 # the License.
 
 
-require 'buildr/java/version_requirement'
+require 'buildr/packaging/version_requirement'
 
 
 module Buildr
@@ -220,7 +220,7 @@ module Buildr
       # Forget all namespaces, create a new ROOT
       def clear
         @instances = nil
-        remove_const(:ROOT) if const_defined?(:ROOT)
+        remove_const(:ROOT) rescue nil
         const_set(:ROOT, new('root'))
       end
 
@@ -737,7 +737,7 @@ module Buildr
     # Like Hash#fetch
     def fetch(name, default = nil, &block)
       block ||= lambda { raise IndexError.new("No artifact found by name #{name.inspect} in namespace #{self}") }
-      real_name = name.to_s[/^\w+$/] ? name : ArtifactRequirement.unversioned_spec(name)
+      real_name = name.to_s[/^[\w\-\.]+$/] ? name : ArtifactRequirement.unversioned_spec(name)
       get(real_name.to_sym) || default || block.call(name)
     end
 
@@ -794,7 +794,7 @@ module Buildr
     def values_at(*names)
       names.map do |name| 
         catch :artifact do
-          unless name.to_s[/^\w+$/] 
+          unless name.to_s[/^[\w\-\.]+$/]
             unvers = ArtifactRequirement.unversioned_spec(name)
             unless unvers.to_s == name.to_s
               req = ArtifactRequirement.new(name)
@@ -812,7 +812,7 @@ module Buildr
     end
 
     def key?(name, include_parents = false)
-      name = ArtifactRequirement.unversioned_spec(name) unless name.to_s[/^\w+$/]
+      name = ArtifactRequirement.unversioned_spec(name) unless name.to_s[/^[\w\-\.]+$/]
       registry.key?(name, include_parents)
     end
 
@@ -883,7 +883,7 @@ module Buildr
       case name.to_s
       when /!$/ then
         name = $`.intern
-        if args.size < 1 && args.size > 2
+        if args.size < 1 || args.size > 2
           raise ArgumentError.new("wrong number of arguments for #{name}!(spec, version_requirement?)")
         end
         need name => args.first

data/lib/buildr/packaging/gems.rb

@@ -15,9 +15,9 @@
 
 
 require 'buildr/packaging/package'
-require 'buildr/packaging/zip'
-require 'rubyforge'
-require 'rubygems/package'
+require 'buildr/packaging/archive'
+gem 'rubyforge' ; autoload :RubyForge, 'rubyforge'
+Gem.autoload :Package, 'rubygems/package'
 
 
 module Buildr
@@ -75,7 +75,7 @@ module Buildr
   end
 
 
-  module PackageAsGem
+  module PackageAsGem #:nodoc:
 
     def package_as_gem(file_name) #:nodoc:
       PackageGemTask.define_task(file_name).tap do |gem|

data/lib/buildr/packaging/package.rb

@@ -35,7 +35,7 @@ module Buildr
       Project.local_task('uninstall') { |name| "Uninstalling packages from #{name}" }
       desc 'Upload packages created by the project'
       Project.local_task('upload'=>'package') { |name| "Deploying packages from #{name}" }
-      # Anything that comes after local packaging (install, deploy) executes the integration tests,
+      # Anything that comes after local packaging (install, upload) executes the integration tests,
       # which do not conflict with integration invoking the project's own packaging (package=>
       # integration=>foo:package is not circular, just confusing to debug.)
       task 'package' do
@@ -160,6 +160,7 @@ module Buildr
         # used as a dependency, before we get to run the package task.
         task 'package'=>package
         package.enhance [task('build')]
+        package.enhance { info "Packaging #{File.basename(file_name)}" }
 
         if spec[:file]
           class << package ; self ; end.send(:define_method, :type) { spec[:type] }
@@ -170,7 +171,7 @@ module Buildr
           # Another task to create the POM file.
           pom = package.pom
           pom.enhance do
-            mkpath File.dirname(pom.name), :verbose=>false
+            mkpath File.dirname(pom.name)
             File.open(pom.name, 'w') { |file| file.write pom.pom_xml }
           end
           file(Buildr.repositories.locate(package)=>package) { package.install }

data/lib/buildr/packaging/tar.rb

@@ -14,8 +14,8 @@
 # the License.
 
 
-require 'buildr/packaging/zip'
-require 'archive/tar/minitar'
+require 'buildr/packaging/archive'
+gem 'archive-tar-minitar' ; autoload :Archive, 'archive/tar/minitar'
 
 
 module Buildr
@@ -45,6 +45,35 @@ module Buildr
       self.mode = '0755'
     end
 
+    # :call-seq:
+    #   entry(name) => Entry
+    #
+    # Returns a Tar file entry. You can use this to check if the entry exists and its contents,
+    # for example:
+    #   package(:tar).entry("src/LICENSE").should contain(/Apache Software License/)
+    def entry(entry_name)
+      Buildr::TarEntry.new(self, entry_name)
+    end
+    
+    def entries() #:nodoc:
+      tar_entries = nil
+      with_uncompressed_tar { |tar| tar_entries = tar.entries }
+      tar_entries
+    end
+    
+    # :call-seq:
+    #   with_uncompressed_tar { |tar_entries| ... }
+    #
+    # Yields an Archive::Tar::Minitar::Input object to the provided block.
+    # Opening, closing and Gzip-decompressing is automatically taken care of.
+    def with_uncompressed_tar &block
+      if gzip
+        Zlib::GzipReader.open(name) { |tar| Archive::Tar::Minitar.open(tar, &block) }
+      else
+        Archive::Tar::Minitar.open(name, &block)
+      end
+    end
+    
   private
 
     def create_from(file_map)
@@ -81,7 +110,60 @@ module Buildr
     end
 
   end
-
+  
+  
+  class TarEntry #:nodoc:
+    
+    def initialize(tar_task, entry_name)
+      @tar_task = tar_task
+      @entry_name = entry_name
+    end
+    
+    # :call-seq:
+    #   contain?(*patterns) => boolean
+    #
+    # Returns true if this Tar file entry matches against all the arguments. An argument may be
+    # a string or regular expression.
+    def contain?(*patterns)
+      content = read_content_from_tar
+      patterns.map { |pattern| Regexp === pattern ? pattern : Regexp.new(Regexp.escape(pattern.to_s)) }.
+        all? { |pattern| content =~ pattern }
+    end
+    
+    # :call-seq:
+    #   empty?() => boolean
+    #
+    # Returns true if this entry is empty.
+    def empty?()
+      read_content_from_tar.nil?
+    end
+    
+    # :call-seq:
+    #   exist() => boolean
+    #
+    # Returns true if this entry exists.
+    def exist?()
+      exist = false
+      @tar_task.with_uncompressed_tar { |tar| exist = tar.any? { |entry| entry.name == @entry_name } }
+      exist
+    end
+    
+    def to_s #:nodoc:
+      @entry_name
+    end
+    
+    private
+    
+    def read_content_from_tar
+      content = Errno::ENOENT.new("No such file or directory - #{@entry_name}")
+      @tar_task.with_uncompressed_tar do |tar|
+        content = tar.inject(content) { |content, entry| entry.name == @entry_name ? entry.read : content }
+      end
+      raise content if Exception === content
+      content
+    end
+  end
+  
 end
 
 

data/lib/buildr/packaging/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