ittayd-buildr 1.3.4 → 1.3.5

data/lib/buildr/packaging/tar.rb

@@ -1,186 +0,0 @@
-# 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 'archive-tar-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? || File.directory?(content.to_s)
-          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

@@ -1,172 +0,0 @@
-# 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/zip.rb

@@ -1,64 +0,0 @@
-# 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.
-
-
-$LOADED_FEATURES.unshift 'ftools' if RUBY_VERSION >= '1.9.0' # Required to properly load RubyZip under Ruby 1.9
-require 'zip/zip'
-require 'zip/zipfilesystem'
-
-
-module Zip #:nodoc:
-
-  class ZipCentralDirectory #:nodoc:
-    # Patch to add entries in alphabetical order.
-    def write_to_stream(io)
-      offset = io.tell
-      @entrySet.sort { |a,b| a.name <=> b.name }.each { |entry| entry.write_c_dir_entry(io) }
-      write_e_o_c_d(io, offset)
-    end
-  end
-
-
-  class ZipEntry
-
-    # :call-seq:
-    #   exist() => boolean
-    #
-    # Returns true if this entry exists.
-    def exist?()
-      Zip::ZipFile.open(zipfile) { |zip| zip.file.exist?(@name) }
-    end
-
-    # :call-seq:
-    #   empty?() => boolean
-    #
-    # Returns true if this entry is empty.
-    def empty?()
-      Zip::ZipFile.open(zipfile) { |zip| zip.file.read(@name) }.empty?
-    end
-
-    # :call-seq:
-    #   contain(patterns*) => boolean
-    #
-    # Returns true if this ZIP file entry matches against all the arguments. An argument may be
-    # a string or regular expression.
-    def contain?(*patterns)
-      content = Zip::ZipFile.open(zipfile) { |zip| zip.file.read(@name) }
-      patterns.map { |pattern| Regexp === pattern ? pattern : Regexp.new(Regexp.escape(pattern.to_s)) }.
-        all? { |pattern| content =~ pattern }
-    end
-
-  end
-end

data/lib/buildr/packaging/ziptask.rb

@@ -1,313 +0,0 @@
-# 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'
-
-
-module Buildr
-
-  # The ZipTask creates a new Zip file. You can include any number of files and and directories,
-  # use exclusion patterns, and include files into specific directories.
-  #
-  # For example:
-  #   zip('test.zip').tap do |task|
-  #     task.include 'srcs'
-  #     task.include 'README', 'LICENSE'
-  #   end
-  #
-  # See Buildr#zip and ArchiveTask.
-  class ZipTask < ArchiveTask
-
-    # Compression leve for this Zip.
-    attr_accessor :compression_level
-
-    def initialize(*args) #:nodoc:
-      self.compression_level = Zlib::NO_COMPRESSION
-      super
-    end
-
-    # :call-seq:
-    #   entry(name) => Entry
-    #
-    # Returns a ZIP file entry. You can use this to check if the entry exists and its contents,
-    # for example:
-    #   package(:jar).entry("META-INF/LICENSE").should contain(/Apache Software License/)
-    def entry(entry_name)
-      ::Zip::ZipEntry.new(name, entry_name)
-    end
-
-    def entries #:nodoc:
-      @entries ||= Zip::ZipFile.open(name) { |zip| zip.entries }
-    end
-
-  private
-
-    def create_from(file_map)
-      Zip::ZipOutputStream.open name do |zip|
-        seen = {}
-        mkpath = lambda do |dir|
-          unless dir == '.' || seen[dir]
-            mkpath.call File.dirname(dir)
-            zip.put_next_entry(dir + '/', compression_level)
-            seen[dir] = true
-          end
-        end
-
-        file_map.each do |path, content|
-          mkpath.call File.dirname(path)
-          if content.respond_to?(:call)
-            zip.put_next_entry(path, compression_level)
-            content.call zip
-          elsif content.nil? || File.directory?(content.to_s)
-            mkpath.call path
-          else
-            zip.put_next_entry(path, compression_level)
-            File.open content.to_s, 'rb' do |is|
-              while data = is.read(4096)
-                zip << data
-              end
-            end
-          end
-        end
-      end
-    end
-
-  end
-
-
-  # :call-seq:
-  #    zip(file) => ZipTask
-  #
-  # The ZipTask creates a new Zip file. You can include any number of files and
-  # and directories, use exclusion patterns, and include files into specific
-  # directories.
-  #
-  # For example:
-  #   zip('test.zip').tap do |task|
-  #     task.include 'srcs'
-  #     task.include 'README', 'LICENSE'
-  #   end
-  def zip(file)
-    ZipTask.define_task(file)
-  end
-
-
-  # An object for unzipping a file into a target directory. You can tell it to include
-  # or exclude only specific files and directories, and also to map files from particular
-  # paths inside the zip file into the target directory. Once ready, call #extract.
-  #
-  # Usually it is more convenient to create a file task for extracting the zip file
-  # (see #unzip) and pass this object as a prerequisite to other tasks.
-  #
-  # See Buildr#unzip.
-  class Unzip
-
-    # The zip file to extract.
-    attr_accessor :zip_file
-    # The target directory to extract to.
-    attr_accessor :target
-
-    # Initialize with hash argument of the form target=>zip_file.
-    def initialize(args)
-      @target, arg_names, @zip_file = Buildr.application.resolve_args([args])
-      @paths = {}
-    end
-
-    # :call-seq:
-    #   extract
-    #
-    # Extract the zip file into the target directory.
-    #
-    # You can call this method directly. However, if you are using the #unzip method,
-    # it creates a file task for the target directory: use that task instead as a
-    # prerequisite. For example:
-    #   build unzip(dir=>zip_file)
-    # Or:
-    #   unzip(dir=>zip_file).target.invoke
-    def extract
-      # If no paths specified, then no include/exclude patterns
-      # specified. Nothing will happen unless we include all files.
-      if @paths.empty?
-        @paths[nil] = FromPath.new(self, nil)
-      end
-
-      # Otherwise, empty unzip creates target as a file when touching.
-      mkpath target.to_s, :verbose=>false
-      Zip::ZipFile.open(zip_file.to_s) do |zip|
-        entries = zip.collect
-        @paths.each do |path, patterns|
-          patterns.map(entries).each do |dest, entry|
-            next if entry.directory?
-            dest = File.expand_path(dest, target.to_s)
-            trace "Extracting #{dest}"
-            mkpath File.dirname(dest), :verbose=>false rescue nil
-            entry.extract(dest) { true }
-          end
-        end
-      end
-      # Let other tasks know we updated the target directory.
-      touch target.to_s, :verbose=>false
-    end
-
-    # :call-seq:
-    #   include(*files) => self
-    #   include(*files, :path=>name) => self
-    #
-    # Include all files that match the patterns and returns self.
-    #
-    # Use include if you only want to unzip some of the files, by specifying
-    # them instead of using exclusion. You can use #include in combination
-    # with #exclude.
-    def include(*files)
-      if Hash === files.last
-        from_path(files.pop[:path]).include *files
-      else
-        from_path(nil).include *files
-      end
-      self
-    end
-    alias :add :include
-
-    # :call-seq:
-    #   exclude(*files) => self
-    #
-    # Exclude all files that match the patterns and return self.
-    #
-    # Use exclude to unzip all files except those that match the pattern.
-    # You can use #exclude in combination with #include.
-    def exclude(*files)
-      if Hash === files.last
-        from_path(files.pop[:path]).exclude *files
-      else
-        from_path(nil).exclude *files
-      end
-      self
-    end
-
-    # :call-seq:
-    #   from_path(name) => Path
-    #
-    # Allows you to unzip from a path. Returns an object you can use to
-    # specify which files to include/exclude relative to that path.
-    # Expands the file relative to that path.
-    #
-    # For example:
-    #   unzip(Dir.pwd=>'test.jar').from_path('etc').include('LICENSE')
-    # will unzip etc/LICENSE into ./LICENSE.
-    #
-    # This is different from:
-    #  unzip(Dir.pwd=>'test.jar').include('etc/LICENSE')
-    # which unzips etc/LICENSE into ./etc/LICENSE.
-    def from_path(name)
-      @paths[name] ||= FromPath.new(self, name)
-    end
-    alias :path :from_path
-
-    # :call-seq:
-    #   root => Unzip
-    #
-    # Returns the root path, essentially the Unzip object itself. In case you are wondering
-    # down paths and want to go back.
-    def root
-      self
-    end
-
-    # Returns the path to the target directory.
-    def to_s
-      target.to_s
-    end
-
-    class FromPath #:nodoc:
-
-      def initialize(unzip, path)
-        @unzip = unzip
-        if path
-          @path = path[-1] == ?/ ? path : path + '/'
-        else
-          @path = ''
-        end
-      end
-
-      # See UnzipTask#include
-      def include(*files) #:doc:
-        @include ||= []
-        @include |= files
-        self
-      end
-
-      # See UnzipTask#exclude
-      def exclude(*files) #:doc:
-        @exclude ||= []
-        @exclude |= files
-        self
-      end
-
-      def map(entries)
-        includes = @include || ['**/*']
-        excludes = @exclude || []
-        entries.inject({}) do |map, entry|
-          if entry.name =~ /^#{@path}/
-            short = entry.name.sub(@path, '')
-            if includes.any? { |pat| File.fnmatch(pat, short, File::FNM_PATHNAME) } &&
-               !excludes.any? { |pat| File.fnmatch(pat, short, File::FNM_PATHNAME) }
-              map[short] = entry
-            end
-          end
-          map
-        end
-      end
-
-      # Documented in Unzip.
-      def root
-        @unzip
-      end
-
-      # The target directory to extract to.
-      def target
-        @unzip.target
-      end
-
-    end
-
-  end
-
-  # :call-seq:
-  #    unzip(to_dir=>zip_file) => Zip
-  #
-  # Creates a task that will unzip a file into the target directory. The task name
-  # is the target directory, the prerequisite is the file to unzip.
-  #
-  # This method creates a file task to expand the zip file. It returns an Unzip object
-  # that specifies how the file will be extracted. You can include or exclude specific
-  # files from within the zip, and map to different paths.
-  #
-  # The Unzip object's to_s method return the path to the target directory, so you can
-  # use it as a prerequisite. By keeping the Unzip object separate from the file task,
-  # you overlay additional work on top of the file task.
-  #
-  # For example:
-  #   unzip('all'=>'test.zip')
-  #   unzip('src'=>'test.zip').include('README', 'LICENSE') 
-  #   unzip('libs'=>'test.zip').from_path('libs')
-  def unzip(args)
-    target, arg_names, zip_file = Buildr.application.resolve_args([args])
-    task = file(File.expand_path(target.to_s)=>zip_file)
-    Unzip.new(task=>zip_file).tap do |setup|
-      task.enhance { setup.extract }
-    end
-  end
-
-end