mguymon-buildr 1.4.5-java

data/lib/buildr/packaging/repository_array.rb

@@ -0,0 +1,108 @@
+# 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
+  # Extention of Array to standardize URLs into { :url => 'url', :username => 'username', :password => 'password' }.
+  #   :url = url of remote repository
+  #   :username = optional username for authentication
+  #   :password = optional password for authentication
+  class RepositoryArray < Array
+    
+    def initialize( *args )
+      if !args.nil? && args.is_a?(Array) && args.size == 1
+        args = args[0]
+        converted = args.map {|url| convert_remote_url(url) }
+        super(converted)
+      else
+        super(args)
+      end
+    end
+    
+    # Concatenation—Returns a new array built by concatenating the two arrays together to produce a third array of standardized URL Hashes.  
+    def +(urls)
+      concat(urls)      
+    end
+    
+    # Append—Pushes the given object on to the end of this array, as a standardize URL Hash. This expression returns the array itself, so several appends may be chained together. 
+    def <<(url)
+      converted = convert_remote_url( url )
+      super( converted )
+    end
+    
+    # Appends the elements in other_array to self, as standardized URL Hashes    
+    def concat(urls)
+      if !urls.nil?
+        converted = urls.map { |url| convert_remote_url( url ) }
+        super(converted)
+      else
+        super(nil)
+      end 
+    end
+    
+    # :call-seq:
+    #   url = url => hash
+    #   url = Hash => hash
+    #
+    # With a String url, returns a standardize URL Hash. 
+    #
+    # With a Hash argument { :url => 'url', :username => 'username', :password => 'password' }, returns a standardize URL Hash.    
+    #
+    def convert_remote_url(url)
+      if url.is_a? String
+        return {:url =>  URI.parse(url)}
+      elsif url.is_a? Hash
+        hash = { :url =>  URI.parse((url[:url] || url['url'])) }
+        username = url[:username] || url['username']
+        hash[:username] = username if username
+        
+        password = (url[:password] || url['password'])
+        hash[:password] = password if password
+        
+        return hash
+      elsif url.is_a? URI
+        return { :url => url }
+      else
+        raise ArgumentError, "Unsupported :url, must be String, Hash, or URI: #{url.inspect}"
+      end
+    end
+    
+    # Inserts the given values before the element with the given index (which may be negative), as standardized URL Hashes
+    def insert( index, *args)
+      if !args.nil?
+        pos = index
+        args.each do |url| 
+          convert = convert_remote_url( url )
+          super( pos, convert )
+          if index >= 0
+            pos = pos + 1          
+          end
+        end
+      else
+        super( index, nil )  
+      end
+    end
+    
+    # Replaces the contents of self with the contents of other_array, truncating or expanding if necessary. The contents of other_array
+    # is converted standardized URL Hashes.
+    def replace( other_array )
+      if !other_array.nil?
+        converted = other_array.map { |url| convert_remote_url( url ) }
+        super( converted )
+      else
+        super( nil )  
+      end
+    end
+  end
+end

data/lib/buildr/packaging/tar.rb

@@ -0,0 +1,189 @@
+# 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/archive'
+gem 'minitar' ; autoload :Archive, 'archive/tar/minitar'
+
+
+module Buildr
+
+  # The TarTask creates a new Tar file. You can include any number of files and and directories,
+  # use exclusion patterns, and include files into specific directories.
+  #
+  # To create a GZipped Tar, either set the gzip option to true, or use the .tgz or .gz suffix.
+  #
+  # For example:
+  #   tar("test.tgz").tap do |task|
+  #     task.include "srcs"
+  #     task.include "README", "LICENSE"
+  #   end
+  #
+  # See Buildr#tar and ArchiveTask.
+  class TarTask < ArchiveTask
+
+    # To create a GZipped Tar, either set this option to true, or use the .tgz/.gz suffix.
+    attr_accessor :gzip
+    # Permission mode for files contained in the Tar.  Defaults to 0755.
+    attr_accessor :mode
+
+    def initialize(*args, &block) #:nodoc:
+      super
+      self.gzip = name =~ /\.t?gz$/
+      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)
+      if gzip
+        StringIO.new.tap do |io|
+          create_tar io, file_map
+          io.seek 0
+          Zlib::GzipWriter.open(name) { |gzip| gzip.write io.read }
+        end
+      else
+        File.open(name, 'wb') { |file| create_tar file, file_map }
+      end
+    end
+
+    def create_tar(out, file_map)
+      Archive::Tar::Minitar::Writer.open(out) do |tar|
+        options = { :mode=>mode || '0755', :mtime=>Time.now }
+
+        file_map.each do |path, content|
+          if content.respond_to?(:call)
+            tar.add_file(path, options) { |os, opts| content.call os }
+          elsif content.nil?
+          elsif File.directory?(content.to_s)
+            stat = File.stat(content.to_s)
+            tar.mkdir(path, options.merge(:mode=>stat.mode, :mtime=>stat.mtime))
+          else
+            File.open content.to_s, 'rb' do |is|
+              tar.add_file path, options.merge(:mode=>is.stat.mode, :mtime=>is.stat.mtime, :uid=>is.stat.uid, :gid=>is.stat.gid) do |os, opts|
+                while data = is.read(4096)
+                  os.write(data)
+                end
+              end
+            end
+          end
+        end
+      end
+    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
+
+
+# :call-seq:
+#    tar(file) => TarTask
+#
+# The TarTask creates a new Tar file. You can include any number of files and
+# and directories, use exclusion patterns, and include files into specific
+# directories.
+#
+# To create a GZipped Tar, either set the gzip option to true, or use the .tgz or .gz suffix.
+#
+# For example:
+#   tar("test.tgz").tap do |tgz|
+#     tgz.include "srcs"
+#     tgz.include "README", "LICENSE"
+#   end
+def tar(file)
+  TarTask.define_task(file)
+end

data/lib/buildr/packaging/version_requirement.rb

@@ -0,0 +1,192 @@
+# 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.
+
+
+# Rubygems 1.3.6 removed the 'version' accessor so monkey-patch it back to
+# circumvent version validation.  This is needed because Gem::Version doesn't
+# accept version specs with dashes.
+unless Gem::Version.new(0).respond_to?(:version=)
+  class Gem::Version
+    def version=(version)
+      @version = version.to_s
+      @version.strip!
+
+      # re-prime @segments
+      @segments = nil
+      segments
+    end
+  end
+end
+
+module Buildr
+
+  #
+  # See ArtifactNamespace#need
+  class VersionRequirement
+
+    CMP_PROCS = Gem::Requirement::OPS.dup
+    CMP_REGEX = if defined?(Gem::Requirement::OP_RE)
+      Gem::Requirement::OP_RE
+    else
+      Gem::Requirement::OPS.keys.map { |k| Regexp.quote k }.join "|"
+    end
+    CMP_CHARS = CMP_PROCS.keys.join
+    BOOL_CHARS = '\|\&\!'
+    VER_CHARS = '\w\.\-'
+
+    class << self
+      # is +str+ a version string?
+      def version?(str)
+        /^\s*\d[#{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