buildr 1.3.0-java

data/lib/buildr/core/application_cli.rb

@@ -0,0 +1,134 @@
+# 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.
+
+# Portion of this file derived from Rake.
+# Copyright (c) 2003, 2004 Jim Weirich
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+require 'getoptlong'
+
+
+module Buildr
+  module CommandLineInterface
+    
+    OPTIONS = [     # :nodoc:
+        ['--help',     '-h', GetoptLong::NO_ARGUMENT,
+          'Display this help message.'],
+        ['--nosearch', '-n', GetoptLong::NO_ARGUMENT,
+          'Do not search parent directories for the buildfile.'],
+        ['--quiet',    '-q', GetoptLong::NO_ARGUMENT,
+          'Do not log messages to standard output.'],
+        ['--buildfile', '-f', GetoptLong::REQUIRED_ARGUMENT,
+          'Use FILE as the buildfile.'],
+        ['--require',  '-r', GetoptLong::REQUIRED_ARGUMENT,
+          'Require MODULE before executing buildfile.'],
+        ['--trace',    '-t', GetoptLong::NO_ARGUMENT,
+          'Turn on invoke/execute tracing, enable full backtrace.'],
+        ['--version',  '-v', GetoptLong::NO_ARGUMENT,
+          'Display the program version.'],
+        ['--environment', '-e', GetoptLong::REQUIRED_ARGUMENT,
+          'Environment name (e.g. development, test, production).']
+      ]
+
+    def collect_tasks
+      top_level_tasks.clear
+      ARGV.each do |arg|
+        if arg =~ /^(\w+)=(.*)$/
+          ENV[$1.upcase] = $2
+        else
+          top_level_tasks << arg
+        end
+      end
+      top_level_tasks.push("default") if top_level_tasks.size == 0
+    end
+    
+    def parse_options
+      opts = GetoptLong.new(*command_line_options)
+      opts.each { |opt, value| do_option(opt, value) }
+    end
+
+    def do_option(opt, value)
+      case opt
+      when '--help'
+        help
+        exit
+      when '--buildfile'
+        rakefiles.clear
+        rakefiles << value
+      when '--version'
+        puts version
+        exit
+      when '--environment'
+        ENV['BUILDR_ENV'] = value
+      when '--require'
+        requires << value
+      when '--nosearch', '--quiet', '--trace'
+        super
+      end
+    end
+
+    def command_line_options
+      OPTIONS.collect { |lst| lst[0..-2] }
+    end
+
+    def version
+      "Buildr #{Buildr::VERSION} #{RUBY_PLATFORM[/java/] && '(JRuby '+JRUBY_VERSION+')'}"
+    end
+
+    def usage
+      puts version
+      puts
+      puts 'Usage:'
+      puts '  buildr [options] [tasks] [name=value]'
+    end
+    
+    def help
+      usage
+      puts
+      puts 'Options:'
+      OPTIONS.sort.each do |long, short, mode, desc|
+        if mode == GetoptLong::REQUIRED_ARGUMENT
+          if desc =~ /\b([A-Z]{2,})\b/
+            long = long + "=#{$1}"
+          end
+        end
+        printf "  %-20s (%s)\n", long, short
+        printf "      %s\n", desc
+      end
+      puts
+      puts 'For help with your buildfile:'
+      puts '  buildr help'
+    end
+    
+  end
+end

data/lib/buildr/core/build.rb

@@ -0,0 +1,262 @@
+# 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/core/project'
+require 'buildr/core/common'
+require 'buildr/core/checks'
+require 'buildr/core/environment'
+
+
+module Buildr
+
+  class Options
+
+    # Runs the build in parallel when true (defaults to false). You can force a parallel build by
+    # setting this option directly, or by running the parallel task ahead of the build task.
+    #
+    # This option only affects recurvise tasks. For example:
+    #   buildr parallel package
+    # will run all package tasks (from the sub-projects) in parallel, but each sub-project's package
+    # task runs its child tasks (prepare, compile, resources, etc) in sequence.
+    attr_accessor :parallel
+
+  end
+
+  task('parallel') { Buildr.options.parallel = true }
+
+
+  module Build
+
+    include Extension
+
+    first_time do
+      desc 'Build the project'
+      Project.local_task('build') { |name| "Building #{name}" }
+      desc 'Clean files generated during a build'
+      Project.local_task('clean') { |name| "Cleaning #{name}" }
+
+      desc 'The default task it build'
+      task 'default'=>'build'
+    end
+
+    before_define do |project|
+      project.recursive_task 'build'
+      project.recursive_task 'clean'
+      project.clean do
+        verbose(true) do
+          rm_rf project.path_to(:target)
+          rm_rf project.path_to(:reports)
+        end
+      end
+    end
+
+
+    # *Deprecated:* Use +path_to(:target)+ instead.
+    def target
+      Buildr.application.deprecated 'Use path_to(:target) instead'
+      layout.expand(:target)
+    end
+
+    # *Deprecated:* Use Layout instead.
+    def target=(dir)
+      Buildr.application.deprecated 'Use Layout instead'
+      layout[:target] = _(dir)
+    end
+
+    # *Deprecated:* Use +path_to(:reports)+ instead.
+    def reports()
+      Buildr.application.deprecated 'Use path_to(:reports) instead'
+      layout.expand(:reports)
+    end
+
+    # *Deprecated:* Use Layout instead.
+    def reports=(dir)
+      Buildr.application.deprecated 'Use Layout instead'
+      layout[:reports] = _(dir)
+    end
+
+    # :call-seq:
+    #    build(*prereqs) => task
+    #    build { |task| .. } => task
+    #
+    # Returns the project's build task. With arguments or block, also enhances that task.
+    def build(*prereqs, &block)
+      task('build').enhance prereqs, &block
+    end
+
+    # :call-seq:
+    #    clean(*prereqs) => task
+    #    clean { |task| .. } => task
+    #
+    # Returns the project's clean task. With arguments or block, also enhances that task.
+    def clean(*prereqs, &block)
+      task('clean').enhance prereqs, &block
+    end
+
+  end
+
+
+  class Release
+
+    THIS_VERSION_PATTERN  = /THIS_VERSION|VERSION_NUMBER\s*=\s*(["'])(.*)\1/
+    NEXT_VERSION_PATTERN  = /NEXT_VERSION\s*=\s*(["'])(.*)\1/
+
+    class << self
+
+      # :call-seq:
+      #   make()
+      #
+      # Make a release.
+      def make()
+        check
+        version = with_next_version do |filename, version| 
+          options = ['--buildfile', filename, 'DEBUG=no']
+          options << '--environment' << Buildr.environment unless Buildr.environment.to_s.empty?
+          sh "#{command} clean upload #{options.join(' ')}"
+        end
+        tag version
+        commit version + '-SNAPSHOT'
+      end
+
+    protected
+
+      def command() #:nodoc:
+        Config::CONFIG['arch'] =~ /dos|win32/i ? $PROGRAM_NAME.ext('cmd') : $PROGRAM_NAME
+      end
+
+      # :call-seq:
+      #   check()
+      #
+      # Check that we don't have any local changes in the working copy. Fails if it finds anything
+      # in the working copy that is not checked into source control.
+      def check()
+        fail "SVN URL must end with 'trunk' or 'branches/...'" unless svn_url =~ /(trunk)|(branches.*)$/
+        # Status check reveals modified file, but also SVN externals which we can safely ignore.
+        status = svn('status', '--ignore-externals').reject { |line| line =~ /^X\s/ }
+        fail "Uncommitted SVN files violate the First Principle Of Release!\n#{status}" unless
+          status.empty?
+      end
+
+      # :call-seq:
+      #   with_next_version() { |filename| ... } => version
+      #
+      # Yields to block with upgraded version number, before committing to use it. Returns the *new*
+      # current version number.
+      #
+      # We need a Buildfile with upgraded version numbers to run the build, but we don't want the
+      # Buildfile modified unless the build succeeds. So this method updates the version numbers in
+      # a separate (Buildfile.next) file, yields to the block with that filename, and if successful
+      # copies the new file over the existing one.
+      #
+      # Version numbers are updated as follows. The next release version becomes the current one,
+      # and the next version is upgraded by one to become the new next version. So:
+      #   THIS_VERSION = 1.1.0
+      #   NEXT_VERSION = 1.2.0
+      # becomes:
+      #   THIS_VERSION = 1.2.0
+      #   NEXT_VERSION = 1.2.1
+      # and the method will return 1.2.0.
+      def with_next_version()
+        new_filename = Buildr.application.buildfile + '.next'
+        modified = change_version do |this_version, next_version|
+          one_after = next_version.split('.')
+          one_after[-1] = one_after[-1].to_i + 1
+          [ next_version, one_after.join('.') ]
+        end
+        File.open(new_filename, 'w') { |file| file.write modified }
+        begin
+          yield new_filename
+          mv new_filename, Buildr.application.buildfile
+        ensure
+          rm new_filename rescue nil
+        end
+        File.read(Buildr.application.buildfile).scan(THIS_VERSION_PATTERN)[0][1]
+      end
+
+      # :call-seq:
+      #   change_version() { |this, next| ... } => buildfile
+      #
+      # Change version numbers in the current Buildfile, but without writing a new file (yet).
+      # Returns the contents of the Buildfile with the modified version numbers.
+      #
+      # This method yields to the block with the current (this) and next version numbers and expects
+      # an array with the new this and next version numbers.
+      def change_version()
+        buildfile = File.read(Buildr.application.buildfile)
+        this_version = buildfile.scan(THIS_VERSION_PATTERN)[0][1] or
+          fail "Looking for THIS_VERSION = \"...\" in your Buildfile, none found"
+        next_version = buildfile.scan(NEXT_VERSION_PATTERN)[0][1] or
+          fail "Looking for NEXT_VERSION = \"...\" in your Buildfile, none found"
+        this_version, next_version = yield(this_version, next_version)
+        if verbose
+          puts 'Upgrading version numbers:'
+          puts "  This:  #{this_version}"
+          puts "  Next:  #{next_version}"
+        end
+        buildfile.gsub(THIS_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{this_version}"}) }.
+          gsub(NEXT_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{next_version}"}) }
+      end
+
+      # :call-seq:
+      #   tag(version)
+      #
+      # Tags the current working copy with the release version number.
+      def tag(version)
+        url = svn_url.sub(/(trunk$)|(branches.*)$/, "tags/#{version}")
+        svn 'remove', url, '-m', 'Removing old copy' rescue nil
+        svn 'copy', Dir.pwd, url, '-m', "Release #{version}"
+      end
+
+      # :call-seq:
+      #   commit(version)
+      #
+      # Last, we commit what we currently have in the working copy.
+      def commit(version)
+        buildfile = File.read(Buildr.application.buildfile).
+          gsub(THIS_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{version}"}) }
+        File.open(Buildr.application.buildfile, 'w') { |file| file.write buildfile }
+        svn 'commit', '-m', "Changed version number to #{version}", Buildr.application.buildfile
+      end
+
+      # :call-seq:
+      #   svn(*args)
+      #
+      # Executes SVN command and returns the output.
+      def svn(*args)
+        cmd = 'svn ' + args.map { |arg| arg[' '] ? %Q{"#{arg}"} : arg }.join(' ')
+        puts cmd if verbose
+        `#{cmd}`.tap { fail 'SVN command failed' unless $?.exitstatus == 0 }
+      end
+
+      # Return the current SVN URL
+      def svn_url
+        url = svn('info').scan(/URL: (.*)/)[0][0]
+      end
+    end
+
+  end
+
+  desc 'Make a release'
+  task 'release' do |task|
+    Release.make
+  end
+
+end
+
+
+class Buildr::Project
+  include Buildr::Build
+end

data/lib/buildr/core/checks.rb

@@ -0,0 +1,382 @@
+# 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/core/project'
+require 'buildr/packaging/zip'
+require 'test/unit'
+require 'spec/matchers'
+require 'spec/expectations'
+
+
+module Buildr
+  # Methods added to Project to allow checking the build.
+  module Checks
+
+    module Matchers #:nodoc:
+
+      class << self
+
+        # Define matchers that operate by calling a method on the tested object.
+        # For example:
+        #   foo.should contain(bar)
+        # calls:
+        #   foo.contain(bar)
+        def match_using(*names)
+          names.each do |name|
+            matcher = Class.new do
+              # Initialize with expected arguments (i.e. contain(bar) initializes with bar).
+              define_method(:initialize) { |*args| @expects = args }
+              # Matches against actual value (i.e. foo.should exist called with foo).
+              define_method(:matches?) do |actual|
+                @actual = actual
+                return actual.send("#{name}?", *@expects) if actual.respond_to?("#{name}?")
+                return actual.send(name, *@expects) if actual.respond_to?(name)
+                raise "You can't check #{actual}, it doesn't respond to #{name}."
+              end
+              # Some matchers have arguments, others don't, treat appropriately.
+              define_method :failure_message do
+                args = " " + @expects.map{ |arg| "'#{arg}'" }.join(", ") unless @expects.empty?
+                "Expected #{@actual} to #{name}#{args}"
+              end
+              define_method :negative_failure_message do
+                args = " " + @expects.map{ |arg| "'#{arg}'" }.join(", ") unless @expects.empty?
+                "Expected #{@actual} to not #{name}#{args}"
+              end
+            end
+            # Define method to create matcher.
+            define_method(name) { |*args| matcher.new(*args) }
+          end
+        end
+
+      end
+
+      # Define delegate matchers for exist and contain methods.
+      match_using :exist, :contain
+
+    end
+
+
+    # An expectation has subject, description and block. The expectation is validated by running the block,
+    # and can access the subject from the method #it. The description is used for reporting.
+    #
+    # The expectation is run by calling #run_against. You can share expectations by running them against
+    # different projects (or any other context for that matter).
+    #
+    # If the subject is missing, it is set to the argument of #run_against, typically the project itself.
+    # If the description is missing, it is set from the project. If the block is missing, the default behavior
+    # prints "Pending" followed by the description. You can use this to write place holders and fill them later.
+    class Expectation
+
+      attr_reader :description, :subject, :block
+
+      # :call-seq:
+      #   initialize(subject, description?) { .... }
+      #   initialize(description?) { .... }
+      #
+      # First argument is subject (returned from it method), second argument is description. If you omit the
+      # description, it will be set from the subject. If you omit the subject, it will be set from the object
+      # passed to run_against.
+      def initialize(*args, &block)
+        @description = args.pop if String === args.last
+        @subject = args.shift
+        raise ArgumentError, "Expecting subject followed by description, and either one is optional. Not quite sure what to do with this list of arguments." unless args.empty?
+        @block = block || lambda { puts "Pending: #{description}" if verbose }
+      end
+
+      # :call-seq:
+      #   run_against(context)
+      #
+      # Runs this expectation against the context object. The context object is different from the subject,
+      # but used as the subject if no subject specified (i.e. returned from the it method).
+      #
+      # This method creates a new context object modeled after the context argument, but a separate object
+      # used strictly for running this expectation, and used only once. The context object will pass methods
+      # to the context argument, so you can call any method, e.g. package(:jar).
+      #
+      # It also adds all matchers defined in Buildr and RSpec, and two additional methods:
+      # * it() -- Returns the subject.
+      # * description() -- Returns the description.
+      def run_against(context)
+        subject = @subject || context
+        description = @description ? "#{subject} #{@description}" : subject.to_s
+        # Define anonymous class and load it with:
+        # - All instance methods defined in context, so we can pass method calls to the context.
+        # - it() method to return subject, description() method to return description.
+        # - All matchers defined by Buildr and RSpec.
+        klass = Class.new
+        klass.instance_eval do
+          context.class.instance_methods(false).each do |method|
+            define_method(method) { |*args| context.send(method, *args) }
+          end
+          define_method(:it) { subject }
+          define_method(:description) { description }
+          include Spec::Matchers
+          include Matchers
+        end
+
+        # Run the expectation. We only print the expectation name when tracing (to know they all ran),
+        # or when we get a failure.
+        begin
+          puts description if Buildr.application.options.trace
+          klass.new.instance_eval &@block
+        rescue Exception=>error
+          raise error.exception("#{description}\n#{error}").tap { |wrapped| wrapped.set_backtrace(error.backtrace) }
+        end
+      end
+
+    end
+
+
+    include Extension
+
+    before_define do |project|
+      # The check task can do any sort of interesting things, but the most important is running expectations.
+      project.task("check") do |task|
+        project.expectations.inject(true) do |passed, expect|
+          begin
+            expect.run_against project
+            passed
+          rescue Exception=>error
+            if verbose
+              puts error.backtrace.detect { |line| line =~ /#{Buildr.application.buildfile}/ } || ""
+              puts error
+            end
+            false
+          end
+        end or fail "Checks failed for project #{project.name} (see errors above)."
+      end
+      project.task("package").enhance do |task|
+        # Run all actions before checks.
+        task.enhance { project.task("check").invoke }
+      end
+    end
+
+
+    # :call-seq:
+    #    check(description) { ... }
+    #    check(subject, description) { ... }
+    #
+    # Adds an expectation. The expectation is run against the project by the check task, executed after packaging.
+    # You can access any package created by the project.
+    #
+    # An expectation is written using a subject, description and block to validate the expectation. For example:
+    #
+    # For example:
+    #   check package(:jar), "should exist" do
+    #     it.should exist
+    #   end
+    #   check package(:jar), "should contain a manifest" do
+    #     it.should contain("META-INF/MANIFEST.MF")
+    #   end
+    #   check package(:jar).path("com/acme"), "should contain classes" do
+    #     it.should_not be_empty
+    #   end
+    #   check package(:jar).entry("META-INF/MANIFEST"), "should be a recent license" do
+    #     it.should contain(/Copyright (C) 2007/)
+    #   end
+    #
+    # If you omit the subject, the project is used as the subject. If you omit the description, the subject is
+    # used as description.
+    #
+    # During development you can write placeholder expectations by omitting the block. This will simply report
+    # the expectation as pending.
+    def check(*args, &block)
+      expectations << Checks::Expectation.new(*args, &block)
+    end
+
+    # :call-seq:
+    #   expectations() => Expectation*
+    #
+    # Returns a list of expectations (see #check).
+    def expectations()
+      @expectations ||= []
+    end
+
+  end
+
+end
+
+
+module Rake #:nodoc:
+  class FileTask
+
+    # :call-seq:
+    #   exist?() => boolean
+    #
+    # Returns true if this file exists.
+    def exist?()
+      File.exist?(name)
+    end
+
+    # :call-seq:
+    #   empty?() => boolean
+    #
+    # Returns true if file/directory is empty.
+    def empty?()
+      File.directory?(name) ? Dir.glob("#{name}/*").empty? : File.read(name).empty?
+    end
+
+    # :call-seq:
+    #   contain?(pattern*) => boolean
+    #   contain?(file*) => boolean
+    #
+    # For a file, returns true if the file content matches against all the arguments. An argument may be
+    # a string or regular expression.
+    #
+    # For a directory, return true if the directory contains the specified files. You can use relative
+    # file names and glob patterns (using *, **, etc).
+    def contain?(*patterns)
+      if File.directory?(name)
+        patterns.map { |pattern| "#{name}/#{pattern}" }.all? { |pattern| !Dir[pattern].empty? }
+      else
+        contents = File.read(name)
+        patterns.map { |pattern| Regexp === pattern ? pattern : Regexp.new(Regexp.escape(pattern.to_s)) }.
+          all? { |pattern| contents =~ pattern }
+      end
+    end
+
+  end
+end
+
+
+module Zip #:nodoc:
+  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
+
+
+class Buildr::ArchiveTask
+
+  class Path #:nodoc:
+
+    # :call-seq:
+    #   exist() => boolean
+    #
+    # Returns true if this path exists. This only works if the path has any entries in it,
+    # so exist on path happens to be the opposite of empty.
+    def exist?()
+      !entries.empty?
+    end
+
+    # :call-seq:
+    #   empty?() => boolean
+    #
+    # Returns true if this path is empty (has no other entries inside).
+    def empty?()
+      entries.all? { |entry| entry.empty? }
+    end
+
+    # :call-seq:
+    #   contain(file*) => boolean
+    #
+    # Returns true if this ZIP file path contains all the specified files. You can use relative
+    # file names and glob patterns (using *, **, etc).
+    def contain?(*files)
+      files.all? { |file| entries.detect { |entry| File.fnmatch(file, entry.to_s, File::FNM_PATHNAME) } }
+    end
+
+    # :call-seq:
+    #   entry(name) => ZipEntry
+    #
+    # Returns a ZIP file entry. You can use this to check if the entry exists and its contents,
+    # for example:
+    #   package(:jar).path("META-INF").entry("LICENSE").should contain(/Apache Software License/)
+    def entry(name)
+      root.entry("#{@path}#{name}")
+    end
+
+  protected
+
+    def entries() #:nodoc:
+      return root.entries unless @path
+      @entries ||= root.entries.inject([]) { |selected, entry|
+        selected << entry.name.sub(@path, "") if entry.name.index(@path) == 0
+        selected
+      }
+    end
+
+  end
+
+  # :call-seq:
+  #   empty?() => boolean
+  #
+  # Returns true if this ZIP file is empty (has no other entries inside).
+  def empty?()
+    path("").empty
+  end
+
+  # :call-seq:
+  #   contain(file*) => boolean
+  #
+  # Returns true if this ZIP file contains all the specified files. You can use absolute
+  # file names and glob patterns (using *, **, etc).
+  def contain?(*files)
+    path("").contain?(*files)
+  end
+
+end
+
+
+class Buildr::ZipTask #:nodoc:
+
+  # :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
+
+end
+
+
+class Buildr::Project
+  include Buildr::Checks
+end