archive-tar-external 1.2.0 → 1.2.1

data/CHANGES

@@ -1,3 +1,9 @@
+== 1.2.1 - 30-Jul-2007
+* The TarError class is now Tar::Error.
+* Added a Rakefile with tasks for installation and testing.
+* Removed the install.rb file. Installation is now handled by the Rakefile.
+* Documentation updates.
+
 == 1.2.0 - 7-Apr-2006
 * Project renamed 'archive-tar-external'.
 * The 'Tar' class is now Tar::External.

data/MANIFEST

@@ -0,0 +1,11 @@
+* MANIFEST
+* CHANGES
+* INSTALL
+* Rakefile
+* archive-tar-external.gemspec
+* doc/tar_external.txt
+* lib/archive/tar_external.rb
+* test/tc_archive.rb
+* test/temp1.txt
+* test/temp2.txt
+* test/temp3.txt

data/README

@@ -16,18 +16,13 @@
    
 == Prerequisites
    Ruby 1.8.0 or later.
-   The win32-open3 package (Windows only).
+   The win32-open3 package (MS Windows only).
    The "tar" command line program.
    At least one compression program, e.g. gzip, bzip2, zip, etc.
    
 == Installation
-=== Standard Installation
-   ruby test/tc_archive.rb (optional)
-   ruby install.rb
-
-=== Gem Installation
-   ruby archive-tar-external.gemspec
-   gem install archive-tar-external-XXX.gem
+   rake test (optional)
+   rake install (non-gem) or rake install_gem (gem)
    
 == Notes
    For further documentation and information, see the tar_external.txt file

data/doc/tar_external.txt

@@ -49,7 +49,7 @@ Archive::Tar::External.uncompress_archive(archive_name, program='gunzip')
 Archive;:Tar#add(file1 [, file2, ...])
 Archive::Tar::External#add_to_archive(file1 [, file2, ...])
    Adds a list of files to the current archive.  At least one file must be
-   provided or a TarError is raised.
+   provided or a Tar::Error is raised.
 
 Archive::Tar::External#archive_info
 Archive::Tar::External#info
@@ -100,11 +100,11 @@ Archive::Tar::External#update_archive(files)
    are not already in the archive or have been modified.
 
 == Exceptions
-TarError
+Tar::Error
    Raised if something goes wrong during the execution of any methods that
    use the tar command internally.
 
-CompressError
+Tar::CompressError
    Raised if something goes wrong during the Tar#compress_archive or
    Tar#uncompress_archive methods.
 
@@ -127,7 +127,7 @@ CompressError
    warranties of merchantability and fitness for a particular purpose.
 
 == Copyright
-   (C) 2003 - 2006 Daniel J. Berger
+   (C) 2003 - 2007 Daniel J. Berger
    All Rights Reserved
 
 == Author

data/lib/archive/tar_external.rb

@@ -1,277 +1,287 @@
-if RUBY_PLATFORM.match("mswin")
-   require "win32/open3"
+if RUBY_PLATFORM.match('mswin')
+   require 'win32/open3'
 else
-   require "open3"
+   require 'open3'
 end
 
+# The Archive module serves as a namespace only.
 module Archive
 
-   class TarError < StandardError; end
-   class CompressError < StandardError; end
-   class Tar; end # Dummy, so our nesting/scoping works properly.
-
-   class Tar::External
-      VERSION = '1.2.0'
-
-      # The name of the archive file to be used, e.g. "test.tar"
-      attr_accessor :archive_name
-
-      # The name of the tar program you wish to use.  The default is "tar".
-      attr_accessor :tar_program
-
-      # The name of the archive file after compression, e.g. "test.tar.gz"
-      attr_reader :compressed_archive_name
-
-      # Returns an Archive::Tar::External object.  The +archive_name+ is the
-      # name of the tarball.  While a .tar extension is recommended based on
-      # years of convention, it is not enforced.
-      #
-      # Note that this does not actually create the archive unless you
-      # pass a value to +file_pattern+.  This then becomes a shortcut for
-      # Archive::Tar::External.new + Archive::Tar::External#create_archive.
-      #
-      # If +program+ is provided, then it compresses the archive as well by
-      # calling Archive::Tar::External#compress_archive internally.
-      #
-      def initialize(archive_name, file_pattern=nil, program=nil)
-         @archive_name            = archive_name.to_s
-         @compressed_archive_name = nil
-         @tar_program             = "tar"
-
-         if file_pattern
-            create_archive(file_pattern)
-         end
+   # The Tar class serves as a toplevel class namespace only.
+   class Tar
+
+      # Raised if something goes wrong during the execution of any methods
+      # which use the tar command internally.
+      class Error < StandardError; end
+
+      # Raised if something goes wrong during the Tar#compress_archive or
+      # Tar#uncompress_archive methods.      
+      class CompressError < StandardError; end
+
+      # This class encapsulates tar & zip operations.
+      class Tar::External
+         VERSION = '1.2.1'
+
+         # The name of the archive file to be used, e.g. "test.tar"
+         attr_accessor :archive_name
+
+         # The name of the tar program you wish to use.  The default is "tar".
+         attr_accessor :tar_program
+
+         # The name of the archive file after compression, e.g. "test.tar.gz"
+         attr_reader :compressed_archive_name
+
+         # Returns an Archive::Tar::External object.  The +archive_name+ is the
+         # name of the tarball.  While a .tar extension is recommended based on
+         # years of convention, it is not enforced.
+         #
+         # Note that this does not actually create the archive unless you
+         # pass a value to +file_pattern+.  This then becomes a shortcut for
+         # Archive::Tar::External.new + Archive::Tar::External#create_archive.
+         #
+         # If +program+ is provided, then it compresses the archive as well by
+         # calling Archive::Tar::External#compress_archive internally.
+         #
+         def initialize(archive_name, file_pattern=nil, program=nil)
+            @archive_name            = archive_name.to_s
+            @compressed_archive_name = nil
+            @tar_program             = "tar"
 
-         if program
-            compress_archive(program)
-         end
-      end
+            if file_pattern
+               create_archive(file_pattern)
+            end
 
-      # Assign a compressed archive name.  This autogenerates the archive_name
-      # based on the extension of the name provided, unless you provide the
-      # extension yourself.  If the extension is '.tgz', then the base of the
-      # name + '.tar' will be the new archive name.
-      #
-      # This should only be used if you have a pre-existing, compressed archive
-      # that you want to uncompress, and want to have a Tar::External object
-      # around.  Otherwise, use the class method Tar::External.uncompress.
-      #
-      def compressed_archive_name=(name, ext=File.extname(name))
-         if ext == '.tgz' || ext == '.TGZ'
-            @archive_name = File.basename(name, ext.downcase) + '.tar'
-         else
-            @archive_name = File.basename(name, ext)
+            if program
+               compress_archive(program)
+            end
          end
-         @compressed_archive_name = name
-      end
 
-      # Creates the archive using +file_pattern+.  Any errors that occur
-      # here will raise a TarError.
-      #
-      def create_archive(file_pattern)
-         cmd = "#{@tar_program} cf #{@archive_name} #{file_pattern}"
-         Open3.popen3(cmd){ |tar_in, tar_out, tar_err|
-            err = tar_err.gets
-            if err
-               raise TarError, err.chomp
-            end
-         }
-         self
-      end
-      alias :create :create_archive
-
-      # Compresses the archive with +program+, or gzip if no program is
-      # provided.  If you want to pass arguments to +program+, merely include
-      # them as part of the program name, e.g. "gzip -f".
-      #
-      # Any errors that occur here will raise a CompressError.
-      #
-      def compress_archive(program="gzip")
-         cmd = "#{program} #{@archive_name}"
-         Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
-            err = prog_err.gets 
-            if err
-               raise CompressError, err.chomp
+         # Assign a compressed archive name.  This autogenerates the archive_name
+         # based on the extension of the name provided, unless you provide the
+         # extension yourself.  If the extension is '.tgz', then the base of the
+         # name + '.tar' will be the new archive name.
+         #
+         # This should only be used if you have a pre-existing, compressed archive
+         # that you want to uncompress, and want to have a Tar::External object
+         # around.  Otherwise, use the class method Tar::External.uncompress.
+         #
+         def compressed_archive_name=(name, ext=File.extname(name))
+            if ext == '.tgz' || ext == '.TGZ'
+               @archive_name = File.basename(name, ext.downcase) + '.tar'
+            else
+               @archive_name = File.basename(name, ext)
             end
-
-            # Find the new file name with the extension.  There's probably a more
-            # reliable way to do this, but this should work 99% of the time.
-            name = Dir["#{@archive_name}.{gz,bz2,cpio,zip}"].first
             @compressed_archive_name = name
-         }
-         self
-      end
-      alias :compress :compress_archive
-
-      # Uncompresses the tarball using the program you pass to this method.  The
-      # default is "gunzip".  Just as for +compress_archive+, you can pass
-      # arguments along as part of the argument.
-      #
-      # Note that this is only for use with archives that have been zipped up
-      # with gunzip, or whatever.  If you want to *extract* the files from the
-      # tarball, use Tar::External#extract instead.
-      #
-      # Any errors that occur here will raise a CompressError.
-      #
-      def uncompress_archive(program="gunzip")
-         unless @compressed_archive_name
-            raise CompressError, "no compressed file found"
          end
-            
-         cmd = "#{program} #{@compressed_archive_name}"
 
-         Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
-            err = prog_err.gets
-            if err
-               raise CompressError, err.chomp
-            end
-            @compressed_archive_name = nil
-         }
-         self
-      end
-      alias :uncompress :uncompress_archive
-
-      # Uncompress an existing archive, using +program+ to uncompress it.
-      # The default decompression program is gunzip.
-      #
-      def self.uncompress_archive(archive, program='gunzip')
-         cmd = "#{program} #{archive}"
-
-         Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
-            err = prog_err.gets
-            if err
-               raise CompressError, err.chomp
+         # Creates the archive using +file_pattern+.  Any errors that occur
+         # here will raise a Error.
+         #
+         def create_archive(file_pattern)
+            cmd = "#{@tar_program} cf #{@archive_name} #{file_pattern}"
+            Open3.popen3(cmd){ |tar_in, tar_out, tar_err|
+               err = tar_err.gets
+               if err
+                  raise Error, err.chomp
+               end
+            }
+            self
+         end
+         alias :create :create_archive
+
+         # Compresses the archive with +program+, or gzip if no program is
+         # provided.  If you want to pass arguments to +program+, merely include
+         # them as part of the program name, e.g. "gzip -f".
+         #
+         # Any errors that occur here will raise a Tar::CompressError.
+         #
+         def compress_archive(program="gzip")
+            cmd = "#{program} #{@archive_name}"
+            Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
+               err = prog_err.gets 
+               if err
+                  raise CompressError, err.chomp
+               end
+
+               # Find the new file name with the extension.  There's probably a more
+               # reliable way to do this, but this should work 99% of the time.
+               name = Dir["#{@archive_name}.{gz,bz2,cpio,zip}"].first
+               @compressed_archive_name = name
+            }
+            self
+         end
+         alias :compress :compress_archive
+
+         # Uncompresses the tarball using the program you pass to this method.  The
+         # default is "gunzip".  Just as for +compress_archive+, you can pass
+         # arguments along as part of the argument.
+         #
+         # Note that this is only for use with archives that have been zipped up
+         # with gunzip, or whatever.  If you want to *extract* the files from the
+         # tarball, use Tar::External#extract instead.
+         #
+         # Any errors that occur here will raise a Tar::CompressError.
+         #
+         def uncompress_archive(program="gunzip")
+            unless @compressed_archive_name
+               raise CompressError, "no compressed file found"
             end
-         }
-      end
+               
+            cmd = "#{program} #{@compressed_archive_name}"
+
+            Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
+               err = prog_err.gets
+               if err
+                  raise CompressError, err.chomp
+               end
+               @compressed_archive_name = nil
+            }
+            self
+         end
+         alias :uncompress :uncompress_archive
+
+         # Uncompress an existing archive, using +program+ to uncompress it.
+         # The default decompression program is gunzip.
+         #
+         def self.uncompress_archive(archive, program='gunzip')
+            cmd = "#{program} #{archive}"
+
+            Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
+               err = prog_err.gets
+               if err
+                  raise CompressError, err.chomp
+               end
+            }
+         end
 
-      # An alias for Tar::External.uncompress_archive.
-      #
-      def self.uncompress(file, program='gunzip')
-         self.uncompress_archive(file, program)
-      end
+         # An alias for Tar::External.uncompress_archive.
+         #
+         def self.uncompress(file, program='gunzip')
+            self.uncompress_archive(file, program)
+         end
 
-      # Returns an array of file names that are included within the tarball.
-      # This method does not extract the archive.
-      #
-      def archive_info
-         result = []
-         cmd = "#{@tar_program} tf #{@archive_name}"
-         Open3.popen3(cmd){ |ain, aout, aerr|
-            err = aerr.gets
-            if err
-               raise TarError, err.chomp
-            end
+         # Returns an array of file names that are included within the tarball.
+         # This method does not extract the archive.
+         #
+         def archive_info
+            result = []
+            cmd = "#{@tar_program} tf #{@archive_name}"
+            Open3.popen3(cmd){ |ain, aout, aerr|
+               err = aerr.gets
+               if err
+                  raise Error, err.chomp
+               end
+
+               while output = aout.gets
+                  result << output.chomp
+               end
+            }
+            result
+         end
+         alias :info :archive_info
 
-            while output = aout.gets
-               result << output.chomp
+         # Adds +files+ to an already existing archive.
+         #
+         def add_to_archive(*files)
+            if files.empty?
+               raise Error, "there must be at least one file specified"
             end
-         }
-         result
-      end
-      alias :info :archive_info
-
-      # Adds +files+ to an already existing archive.
-      #
-      def add_to_archive(*files)
-         if files.empty?
-            raise TarError, "there must be at least one file specified"
-         end
 
-         cmd = "#{@tar_program} rf #{@archive_name} #{files.join(" ")}"
-         Open3.popen3(cmd){ |ain, aout, aerr|
-            err = aerr.gets
+            cmd = "#{@tar_program} rf #{@archive_name} #{files.join(" ")}"
+            Open3.popen3(cmd){ |ain, aout, aerr|
+               err = aerr.gets
 
-            if err
-               raise TarError, err.chomp
-            end
-         }
-         self
-      end
-      alias :add :add_to_archive
-
-      # Updates the given +files+ in the archive, i.e. they are added if they
-      # are not already in the archive or have been modified.
-      #
-      def update_archive(*files)
-         if files.empty?
-            raise TarError, "there must be at least one file specified"
+               if err
+                  raise Error, err.chomp
+               end
+            }
+            self
          end
+         alias :add :add_to_archive
+
+         # Updates the given +files+ in the archive, i.e. they are added if they
+         # are not already in the archive or have been modified.
+         #
+         def update_archive(*files)
+            if files.empty?
+               raise Error, "there must be at least one file specified"
+            end
 
-         cmd = "#{@tar_program} uf #{@archive_name} #{files.join(" ")}"
+            cmd = "#{@tar_program} uf #{@archive_name} #{files.join(" ")}"
 
-         Open3.popen3(cmd){ |ain, aout, aerr|
-            err = aerr.gets
-            if err
-               raise TarError, err.chomp
-            end
-         }
-         self
-      end
-      alias :update :update_archive
-
-      # Expands the contents of the tarball.  It does NOT delete the tarball.
-      # If +files+ are provided, then only those files are extracted.
-      # Otherwise, all files are extracted.
-      #
-      # Note that some tar programs, notably the tar program shipped by Sun,
-      # does not issue any sort of warning or error if you try to extract a
-      # file that does not exist in the archive.
-      #
-      def extract_archive(*files)
-         cmd = "#{@tar_program} xf #{@archive_name}"
-
-         unless files.empty?
-            cmd << " " << files.join(" ")
+            Open3.popen3(cmd){ |ain, aout, aerr|
+               err = aerr.gets
+               if err
+                  raise Error, err.chomp
+               end
+            }
+            self
          end
+         alias :update :update_archive
+
+         # Expands the contents of the tarball.  It does NOT delete the tarball.
+         # If +files+ are provided, then only those files are extracted.
+         # Otherwise, all files are extracted.
+         #
+         # Note that some tar programs, notably the tar program shipped by Sun,
+         # does not issue any sort of warning or error if you try to extract a
+         # file that does not exist in the archive.
+         #
+         def extract_archive(*files)
+            cmd = "#{@tar_program} xf #{@archive_name}"
+
+            unless files.empty?
+               cmd << " " << files.join(" ")
+            end
 
-         Open3.popen3(cmd){ |ain, aout, aerr|
-            err = aerr.gets
+            Open3.popen3(cmd){ |ain, aout, aerr|
+               err = aerr.gets
 
-            if err
-               raise TarError, err.chomp
-            end
-         }
-         self
-      end
-      alias :expand_archive :extract_archive
-      alias :extract :extract_archive
-      alias :expand :extract_archive
-
-      # A class method that behaves identically to the equivalent instance
-      # method, except that you must specifiy that tarball as the first
-      # argument.  Also, the tar program is hard coded to 'tar xf'.
-      #
-      def self.extract_archive(archive, *files)
-         cmd = "tar xf #{archive}"
-
-         unless files.empty?
-            cmd << " " << files.join(" ")
+               if err
+                  raise Error, err.chomp
+               end
+            }
+            self
          end
+         alias :expand_archive :extract_archive
+         alias :extract :extract_archive
+         alias :expand :extract_archive
+
+         # A class method that behaves identically to the equivalent instance
+         # method, except that you must specifiy that tarball as the first
+         # argument. Also, the tar program is hard coded to 'tar xf'.
+         #
+         def self.extract_archive(archive, *files)
+            cmd = "tar xf #{archive}"
+
+            unless files.empty?
+               cmd << " " << files.join(" ")
+            end
 
-         Open3.popen3(cmd){ |ain, aout, aerr|
-            err = aerr.gets
+            Open3.popen3(cmd){ |ain, aout, aerr|
+               err = aerr.gets
 
-            if err
-               raise TarError, err.chomp
-            end
-         }
-         self
-      end
+               if err
+                  raise Error, err.chomp
+               end
+            }
+            self
+         end
 
-      # Alias for self.extract_archive
-      def self.expand_archive(*args)
-         self.extract_archive(*args)
-      end
+         # Alias for self.extract_archive
+         def self.expand_archive(*args)
+            self.extract_archive(*args)
+         end
 
-      # Alias for self.extract_archive
-      def self.extract(*args)
-         self.extract_archive(*args)
-      end
+         # Alias for self.extract_archive
+         def self.extract(*args)
+            self.extract_archive(*args)
+         end
 
-      # Alias for self.extract_archive
-      def self.expand(*args)
-         self.extract_archive(*args)
+         # Alias for self.extract_archive
+         def self.expand(*args)
+            self.extract_archive(*args)
+         end
       end
    end
 end

data/test/tc_archive.rb

@@ -1,21 +1,16 @@
 ###############################################################################
 # tc_archive.rb
 #
-# Test suite for the archive-tarsimple package.
+# Test suite for the archive-tarsimple package. This test case should be
+# run via the 'rake test' Rake task.
 ###############################################################################
-base = File.basename(Dir.pwd)
-if base == 'test' || base =~ /archive-tar-external/i
-   Dir.chdir('..') if base == 'test'
-   $LOAD_PATH.unshift(Dir.pwd + '/lib')
-   Dir.chdir('test') rescue nil
-end
-
 require 'archive/tar_external'
 require 'test/unit'
 include Archive
 
 class TC_Archive < Test::Unit::TestCase
    def setup
+      Dir.chdir('test') unless File.basename(Dir.pwd) == 'test'
       @t        = Tar::External.new('test.tar')
       @tar_name = 'test.tar'
       @pattern  = '*.txt'
@@ -23,7 +18,7 @@ class TC_Archive < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal('1.2.0', Tar::External::VERSION)
+      assert_equal('1.2.1', Tar::External::VERSION)
    end
 
    def test_constructor
@@ -67,7 +62,7 @@ class TC_Archive < Test::Unit::TestCase
       assert_respond_to(@t, :create) # Alias
 
       assert_raises(ArgumentError){ @t.create_archive }
-      assert_raises(TarError){ @t.create_archive('*.blah') }
+      assert_raises(Tar::Error){ @t.create_archive('*.blah') }
 
       assert_nothing_raised{ @t.create_archive(@pattern) }
       assert(@t.create_archive(@pattern))
@@ -135,7 +130,7 @@ class TC_Archive < Test::Unit::TestCase
    def test_extract_archive_advanced
       @t.tar_program = 'gtar' if PLATFORM.match('solaris')
       assert_nothing_raised{ @t.create('*.txt') }
-      assert_raises(TarError){ @t.expand('blah.txt') }
+      assert_raises(Tar::Error){ @t.expand('blah.txt') }
 
       assert_nothing_raised{ @t.extract_archive }
       assert_nothing_raised{ @t.extract_archive('temp2.txt') }

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.4
 specification_version: 1
 name: archive-tar-external
 version: !ruby/object:Gem::Version 
-  version: 1.2.0
-date: 2006-04-07 00:00:00 -06:00
+  version: 1.2.1
+date: 2007-07-30 00:00:00 -06:00
 summary: A simple way to create tar archives using external calls
 require_paths: 
 - lib
@@ -25,6 +25,7 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Daniel Berger
 files: 
@@ -37,6 +38,7 @@ files:
 - test/temp3.txt
 - README
 - CHANGES
+- MANIFEST
 test_files: 
 - test/tc_archive.rb
 rdoc_options: []
@@ -44,6 +46,8 @@ rdoc_options: []
 extra_rdoc_files: 
 - README
 - CHANGES
+- MANIFEST
+- doc/tar_external.txt
 executables: []
 
 extensions: []