buildr-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From lac...@apache.org
Subject svn commit: r706017 - in /incubator/buildr/trunk: CHANGELOG doc/pages/testing.textile lib/buildr/packaging/tar.rb spec/core/checks_spec.rb
Date Sun, 19 Oct 2008 14:09:44 GMT
Author: lacton
Date: Sun Oct 19 07:09:44 2008
New Revision: 706017

URL: http://svn.apache.org/viewvc?rev=706017&view=rev
Log:
BUILDR-159 Improved 'check' to accept both tar and tgz archives

Modified:
    incubator/buildr/trunk/CHANGELOG
    incubator/buildr/trunk/doc/pages/testing.textile
    incubator/buildr/trunk/lib/buildr/packaging/tar.rb
    incubator/buildr/trunk/spec/core/checks_spec.rb

Modified: incubator/buildr/trunk/CHANGELOG
URL: http://svn.apache.org/viewvc/incubator/buildr/trunk/CHANGELOG?rev=706017&r1=706016&r2=706017&view=diff
==============================================================================
--- incubator/buildr/trunk/CHANGELOG (original)
+++ incubator/buildr/trunk/CHANGELOG Sun Oct 19 07:09:44 2008
@@ -1,4 +1,5 @@
 1.3.4 (Pending)
+* Added:  BUILDR-159 Improved 'check' to accept both tar and tgz archives.
 * Change: Upgraded to use Rake 0.8.3, RSpec 1.1.8.
 * Change: Introduced new options from Rake 0.8.3: -I (libdir), -R (rakelib),
           --rules, --no-search, --silent.

Modified: incubator/buildr/trunk/doc/pages/testing.textile
URL: http://svn.apache.org/viewvc/incubator/buildr/trunk/doc/pages/testing.textile?rev=706017&r1=706016&r2=706017&view=diff
==============================================================================
--- incubator/buildr/trunk/doc/pages/testing.textile (original)
+++ incubator/buildr/trunk/doc/pages/testing.textile Sun Oct 19 07:09:44 2008
@@ -195,7 +195,7 @@
 | @empty@   | Given a file task checks that the file (or directory) is empty. |
 | @contain@ | Given a file task referencing a file, checks its contents, using string or
regular expression.  For a file task referencing a directory, checks that it contains the
specified files; global patterns using @*@ and @**@ are allowed. |
 
-All these matchers operate against a file task.  If you run them against a ZipTask (including
JAR, WAR, etc) they can also check the contents of the ZIP file.  And as you can see in the
examples above, you can also run them against a path in a ZIP file, checking its contents
as if it was a directory, or against an entry in a ZIP file, checking the content of that
file.
+All these matchers operate against a file task.  If you run them against a ZipTask (including
JAR, WAR, etc) or a TarTask, they can also check the contents of the archive.  And as you
can see in the examples above, you can also run them against a path in an archive, checking
its contents as if it was a directory, or against an entry in an archive, checking the content
of that file.
 
 p(note). The @package@ method returns a package task based on packaging type, identifier,
group, version and classifier.  The last four are inferred, but if you create a package with
different specifications (for example, you specify a classifier) your checks must call @package@
with the same qualifying arguments to return the very same package task.
 

Modified: incubator/buildr/trunk/lib/buildr/packaging/tar.rb
URL: http://svn.apache.org/viewvc/incubator/buildr/trunk/lib/buildr/packaging/tar.rb?rev=706017&r1=706016&r2=706017&view=diff
==============================================================================
--- incubator/buildr/trunk/lib/buildr/packaging/tar.rb (original)
+++ incubator/buildr/trunk/lib/buildr/packaging/tar.rb Sun Oct 19 07:09:44 2008
@@ -45,6 +45,35 @@
       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 @@
     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| tar.any? { |entry| exist = 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
 
 

Modified: incubator/buildr/trunk/spec/core/checks_spec.rb
URL: http://svn.apache.org/viewvc/incubator/buildr/trunk/spec/core/checks_spec.rb?rev=706017&r1=706016&r2=706017&view=diff
==============================================================================
--- incubator/buildr/trunk/spec/core/checks_spec.rb (original)
+++ incubator/buildr/trunk/spec/core/checks_spec.rb Sun Oct 19 07:09:44 2008
@@ -181,43 +181,6 @@
     end
     lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
   end
-
-  it "should pass if ZIP path exists" do
-    write "resources/test"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).path("resources")) { it.should exist }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
-  end
-
-  it "should fail if ZIP path does not exist" do
-    mkpath "resources"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar)) { it.path("not-resources").should exist }
-    end
-    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
-  end
-
-  it "should pass if ZIP entry exists" do
-    write "resources/test"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should exist }
-      check(package(:jar).path("resources").entry("test")) { it.should exist }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
-  end
-
-  it "should fail if ZIP path does not exist" do
-    mkpath "resources"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should exist }
-    end
-    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
-  end
 end
 
 
@@ -261,52 +224,6 @@
     end
     lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
   end
-
-  it "should pass if ZIP path is empty" do
-    mkpath "resources"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).path("resources")) { it.should be_empty }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
-  end
-
-  it "should fail if ZIP path has any entries" do
-    write "resources/test"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).path("resources")) { it.should be_empty }
-    end
-    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
-  end
-
-  it "should pass if ZIP entry has no content" do
-    write "resources/test"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should be_empty }
-      check(package(:jar).path("resources").entry("test")) { it.should be_empty }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
-  end
-
-  it "should fail if ZIP entry has content" do
-    write "resources/test", "something"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should be_empty }
-    end
-    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
-  end
-
-  it "should fail if ZIP entry does not exist" do
-    mkpath "resources"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should be_empty }
-    end
-    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
-  end
 end
 
 
@@ -412,126 +329,253 @@
 end
 
 
-describe Buildr::Checks::Expectation, " contain(zip.entry)" do
-
-  it "should pass if ZIP entry content matches string" do
-    write "resources/test", "something"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should contain("thing") }
-      #check(package(:jar)) { it.entry("resources/test").should contain("thing") }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
-  end
-
-  it "should pass if ZIP entry content matches pattern" do
-    write "resources/test", "something\nor\another"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should contain(/or/) }
-      #check(package(:jar)) { it.entry("resources/test").should contain(/or/) }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
-  end
-
-  it "should pass if ZIP entry content matches all arguments" do
-    write "resources/test", "something\nor\nanother"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should contain(/or/, /other/) }
-      #check(package(:jar)) { it.entry("resources/test").should contain(/or/, /other/) }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
-  end
-
-  it "should fail unless ZIP path contains all arguments" do
-    write "resources/test", "something"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should contain(/some/, /other/) }
-      #check(package(:jar)) { it.entry("resources/test").should contain(/some/, /other/)
}
-    end
-    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
-  end
-
-  it "should fail if ZIP entry content does not match" do
-    write "resources/test", "something"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should contain(/other/) }
-      #check(package(:jar)) { it.entry("resources/test").should contain(/other/) }
-    end
-    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
-  end
-
-  it "should fail if ZIP entry does not exist" do
-    mkpath "resources"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).entry("resources/test")) { it.should contain(/anything/) }
-      #check(package(:jar)) { it.entry("resources/test").should contain(/anything/) }
-    end
-    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
-  end
-end
-
-
-describe Buildr::Checks::Expectation, " contain(zip.path)" do
-
-  it "should pass if ZIP path contains file" do
-    write "resources/test"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).path("resources")) { it.should contain("test") }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
+describe Buildr::Checks::Expectation do
+  
+  shared_examples_for "all archive types" do
+    
+    describe '#exist' do
+      it "should pass if archive path exists" do
+        archive = @archive
+        write "resources/test"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).path("resources")) { it.should exist }
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should fail if archive path does not exist" do
+        archive = @archive
+        mkpath "resources"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive)) { it.path("not-resources").should exist }
+        end
+        lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError,
/Checks failed/)
+      end
+      
+      it "should pass if archive entry exists" do
+        archive = @archive
+        write "resources/test"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should exist }
+          check(package(archive).path("resources").entry("test")) { it.should exist }
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should fail if archive path does not exist" do
+        archive = @archive
+        mkpath "resources"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should exist }
+        end
+        lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError,
/Checks failed/)
+      end      
+    end
+    
+    describe '#be_empty' do
+      it "should pass if archive path is empty" do
+        archive = @archive
+        mkpath "resources"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).path("resources")) { it.should be_empty }
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should fail if archive path has any entries" do
+        archive = @archive
+        write "resources/test"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).path("resources")) { it.should be_empty }
+        end
+        lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError,
/Checks failed/)
+      end
+      
+      it "should pass if archive entry has no content" do
+        archive = @archive
+        write "resources/test"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should be_empty }
+          check(package(archive).path("resources").entry("test")) { it.should be_empty }
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should fail if archive entry has content" do
+        archive = @archive
+        write "resources/test", "something"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should be_empty }
+        end
+        lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError,
/Checks failed/)
+      end
+      
+      it "should fail if archive entry does not exist" do
+        archive = @archive
+        mkpath "resources"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should be_empty }
+        end
+        lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError,
/Checks failed/)
+      end
+    end
+    
+    describe "#contain(entry)" do
+      
+      it "should pass if archive entry content matches string" do
+        archive = @archive
+        write "resources/test", "something"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should contain("thing") }
+          #check(package(archive)) { it.entry("resources/test").should contain("thing") }
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should pass if archive entry content matches pattern" do
+        archive = @archive
+        write "resources/test", "something\nor\another"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should contain(/or/) }
+          #check(package(archive)) { it.entry("resources/test").should contain(/or/) }
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should pass if archive entry content matches all arguments" do
+        archive = @archive
+        write "resources/test", "something\nor\nanother"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should contain(/or/, /other/)
}
+          #check(package(archive)) { it.entry("resources/test").should contain(/or/, /other/)
}
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should fail unless archive path contains all arguments" do
+        archive = @archive
+        write "resources/test", "something"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should contain(/some/, /other/)
}
+          #check(package(archive)) { it.entry("resources/test").should contain(/some/, /other/)
}
+        end
+        lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError,
/Checks failed/)
+      end
+      
+      it "should fail if archive entry content does not match" do
+        archive = @archive
+        write "resources/test", "something"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should contain(/other/) }
+          #check(package(archive)) { it.entry("resources/test").should contain(/other/) }
+        end
+        lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError,
/Checks failed/)
+      end
+      
+      it "should fail if archive entry does not exist" do
+        archive = @archive
+        mkpath "resources"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).entry("resources/test")) { it.should contain(/anything/)
}
+          #check(package(archive)) { it.entry("resources/test").should contain(/anything/)
}
+        end
+        lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError,
/Checks failed/)
+      end
+    end
+    
+    describe "#contain(path)" do
+      
+      it "should pass if archive path contains file" do
+        archive = @archive
+        write "resources/test"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).path("resources")) { it.should contain("test") }
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should handle deep nesting" do
+        archive = @archive
+        write "resources/test/test2.efx"
+        define "foo", :version=>"1.0" do
+          package(archive).include("*")
+          check(package(archive)) { it.should contain("resources/test/test2.efx") }
+          check(package(archive).path("resources")) { it.should contain("test/test2.efx")
}
+          check(package(archive).path("resources/test")) { it.should contain("test2.efx")
}
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should pass if archive path contains pattern" do
+        archive = @archive
+        write "resources/with/test"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).path("resources")) { it.should contain("**/t*st") }
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should pass if archive path contains all arguments" do
+        archive = @archive
+        write "resources/with/test"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).path("resources")) { it.should contain("**/test", "**/*")
}
+        end
+        lambda { project("foo").task("package").invoke }.should_not raise_error
+      end
+      
+      it "should fail unless archive path contains all arguments" do
+        archive = @archive
+        write "resources/test"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).path("resources")) { it.should contain("test", "or-not")
}
+        end
+        lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError,
/Checks failed/)
+      end
+      
+      it "should fail if archive path is empty" do
+        archive = @archive
+        mkpath "resources"
+        define "foo", :version=>"1.0" do
+          package(archive).include("resources")
+          check(package(archive).path("resources")) { it.should contain("test") }
+        end
+        lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError,
/Checks failed/)
+      end
+    end
+  end
+  
+  describe 'ZIP' do
+    it_should_behave_like 'all archive types'
+    before { @archive = :jar }
+  end
+  
+  describe 'tar' do
+    it_should_behave_like 'all archive types'
+    before { @archive = :tar }
+  end
+  
+  describe 'tgz' do
+    it_should_behave_like 'all archive types'
+    before { @archive = :tgz }
   end
-
-  it "should handle deep nesting" do
-    write "resources/test/test2.efx"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("*")
-      check(package(:jar)) { it.should contain("resources/test/test2.efx") }
-      check(package(:jar).path("resources")) { it.should contain("test/test2.efx") }
-      check(package(:jar).path("resources/test")) { it.should contain("test2.efx") }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
-  end
-
-
-  it "should pass if ZIP path contains pattern" do
-    write "resources/with/test"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).path("resources")) { it.should contain("**/t*st") }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
-  end
-
-  it "should pass if ZIP path contains all arguments" do
-    write "resources/with/test"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).path("resources")) { it.should contain("**/test", "**/*") }
-    end
-    lambda { project("foo").task("package").invoke }.should_not raise_error
-  end
-
-  it "should fail unless ZIP path contains all arguments" do
-    write "resources/test"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).path("resources")) { it.should contain("test", "or-not") }
-    end
-    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
-  end
-
-  it "should fail if ZIP path is empty" do
-    mkpath "resources"
-    define "foo", :version=>"1.0" do
-      package(:jar).include("resources")
-      check(package(:jar).path("resources")) { it.should contain("test") }
-    end
-    lambda { project("foo").task("package").invoke }.should raise_error(RuntimeError, /Checks
failed/)
-  end
-end
+end
\ No newline at end of file



Mime
View raw message