archive-tar-external 1.3.2 → 1.5.0

data/certs/djberg96_pub.pem

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIEcDCCAtigAwIBAgIBATANBgkqhkiG9w0BAQsFADA/MREwDwYDVQQDDAhkamJl
+cmc5NjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
+MB4XDTE4MDMxODE1MjIwN1oXDTI4MDMxNTE1MjIwN1owPzERMA8GA1UEAwwIZGpi
+ZXJnOTYxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
+bTCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBALgfaroVM6CI06cxr0/h
+A+j+pc8fgpRgBVmHFaFunq28GPC3IvW7Nvc3Y8SnAW7pP1EQIbhlwRIaQzJ93/yj
+u95KpkP7tA9erypnV7dpzBkzNlX14ACaFD/6pHoXoe2ltBxk3CCyyzx70mTqJpph
+75IB03ni9a8yqn8pmse+s83bFJOAqddSj009sGPcQO+QOWiNxqYv1n5EHcvj2ebO
+6hN7YTmhx7aSia4qL/quc4DlIaGMWoAhvML7u1fmo53CYxkKskfN8MOecq2vfEmL
+iLu+SsVVEAufMDDFMXMJlvDsviolUSGMSNRTujkyCcJoXKYYxZSNtIiyd9etI0X3
+ctu0uhrFyrMZXCedutvXNjUolD5r9KGBFSWH1R9u2I3n3SAyFF2yzv/7idQHLJJq
+74BMnx0FIq6fCpu5slAipvxZ3ZkZpEXZFr3cIBtO1gFvQWW7E/Y3ijliWJS1GQFq
+058qERadHGu1yu1dojmFRo6W2KZvY9al2yIlbkpDrD5MYQIDAQABo3cwdTAJBgNV
+HRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUFZsMapgzJimzsbaBG2Tm8j5e
+AzgwHQYDVR0RBBYwFIESZGpiZXJnOTZAZ21haWwuY29tMB0GA1UdEgQWMBSBEmRq
+YmVyZzk2QGdtYWlsLmNvbTANBgkqhkiG9w0BAQsFAAOCAYEAW2tnYixXQtKxgGXq
+/3iSWG2bLwvxS4go3srO+aRXZHrFUMlJ5W0mCxl03aazxxKTsVVpZD8QZxvK91OQ
+h9zr9JBYqCLcCVbr8SkmYCi/laxIZxsNE5YI8cC8vvlLI7AMgSfPSnn/Epq1GjGY
+6L1iRcEDtanGCIvjqlCXO9+BmsnCfEVehqZkQHeYczA03tpOWb6pon2wzvMKSsKH
+ks0ApVdstSLz1kzzAqem/uHdG9FyXdbTAwH1G4ZPv69sQAFAOCgAqYmdnzedsQtE
+1LQfaQrx0twO+CZJPcRLEESjq8ScQxWRRkfuh2VeR7cEU7L7KqT10mtUwrvw7APf
+DYoeCY9KyjIBjQXfbj2ke5u1hZj94Fsq9FfbEQg8ygCgwThnmkTrrKEiMSs3alYR
+ORVCZpRuCPpmC8qmqxUnARDArzucjaclkxjLWvCVHeFa9UP7K3Nl9oTjJNv+7/jM
+WZs4eecIcUc4tKdHxcAJ0MO/Dkqq7hGaiHpwKY76wQ1+8xAh
+-----END CERTIFICATE-----

data/doc/archive_tar_external.md

@@ -0,0 +1,134 @@
+## Description
+A simple tar interface using external system calls.
+
+## Synopsis
+```ruby
+# Assuming we have three .txt files, t1.txt, t2.txt, t3.txt ...
+require 'archive/tar/external'
+include Archive
+
+t = Tar::External.new("myfile.tar")
+ 
+t.create_archive("*.txt")
+t.compress_archive("bzip2") # 'myfile.tar.bz2' now exists
+
+t.uncompress_archive("bunzip2")
+
+t.archive_name # "myfile.tar"
+t.archive_info # ["t1.txt","t2.txt","t3.txt"]
+
+t.add_to_archive("t4.txt","t5.txt")
+t.expand_archive
+```
+
+## Constants
+`VERSION`- The current version number of this library. This is a string.
+
+## Singleton Methods
+`.new(archive_name, pattern=nil, program=nil)`
+
+Creates an instance of 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.
+   
+If `pattern` is provided, then the `create_archive` method is called internally.
+   
+If `program` is provided, then the `compress_archive` method is called internally.
+
+Note that `archive_name` name must be a string, or a `TypeError` is raised.
+
+`.expand_archive(archive_name, file1 [, file2, ...])`
+
+Identical to the instance method of the same name, except that you must
+specify the `archive_name`, and the tar program is hard coded to `tar xf`.
+
+`.uncompress_archive(archive_name, program='gunzip')`
+
+Identical to the instance method of the same name, except that you must
+specify the +archive_name+ as the first argument.
+
+## Instance Methods
+```
+#add(file1 [, file2, ...])
+#add_to_archive(file1 [, file2, ...])
+```
+
+Adds a list of files to the current archive. At least one file must be
+provided or an `Archive::Tar::Error` is raised.
+
+```
+#archive_info
+#info
+```
+
+Returns an array of file names that are included within the tarball.
+
+`#archive_name`
+
+Returns the current archive name.
+
+`#archive_name=`
+
+Sets the current archive name.
+
+```
+#compress(program="gzip")
+#compress_archive(program="gzip")
+```
+
+Compresses the tarball using the program you pass to this method. The default is "gzip".
+
+Note that any arguments you want to be passed along with the program can simply
+be included as part of the program, e.g. "gzip -f".
+
+```
+#create(file_pattern)
+#create_archive(file_pattern, options = 'cf')
+```
+
+Creates a new tarball, including those files which match `file_pattern`
+using `options`, which are set to 'cf' (create file) by default.
+
+```
+#expand_archive(files=nil)
+#extract_archive(files=nil)
+```
+
+Expands the contents of the tarball. Note that this method does NOT delete the tarball.
+
+If file names are provided, then only those files are extracted.
+
+`#tar_program`
+
+Returns the name of the tar program used. The default is "tar".
+
+`#tar_program=(program_name)`
+
+Sets the name of the tar program to be used.
+
+```
+#uncompress(program="gunzip")
+#uncompress_archive(program="gunzip")
+```
+
+Uncompresses the tarball using the program you pass to this method. The default is "gunzip".
+
+Like the `compress_archive` method, you can pass arguments along as part of the method call.
+
+```
+#update(files)
+#update_archive(files)
+```
+
+Updates the given `files` in the archive, i.e they are added if they
+are not already in the archive or have been modified.
+
+## Exceptions
+`Archive::Tar::Error`
+
+Raised if something goes wrong during the execution of any methods that
+use the tar command internally.
+
+`Archive::Tar::CompressError`
+
+Raised if something goes wrong during the `compress_archive` or `uncompress_archive` methods.

data/lib/archive-tar-external.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'archive/tar/external'

data/lib/archive/tar/external.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 require 'open3'
 
 # The Archive module serves as a namespace only.
 module Archive
-
   # 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
@@ -17,40 +17,43 @@ module Archive
     # This class encapsulates tar & zip operations.
     class Tar::External
       # The version of the archive-tar-external library.
-      VERSION = '1.3.2'
+      VERSION = '1.5.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".
+      # 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
+      # The format of the archive file. The default is "pax".
+      attr_reader :format
+
+      # 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
+      # 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)
+      # You may also specify an archive format. As of version 1.5, the
+      # default is 'pax'. Previous versions used whatever your tar program
+      # used by default.
+      #
+      def initialize(archive_name, file_pattern = nil, program = nil, format = 'pax')
         @archive_name            = archive_name.to_s
         @compressed_archive_name = nil
         @tar_program             = 'tar'
+        @format                  = 'pax'
 
-        if file_pattern
-           create_archive(file_pattern)
-        end
-
-        if program
-           compress_archive(program)
-        end
+        create_archive(file_pattern) if file_pattern
+        compress_archive(program) if program
       end
 
       # Assign a compressed archive name.  This autogenerates the archive_name
@@ -62,9 +65,9 @@ module 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))
+      def compressed_archive_name=(name, ext = File.extname(name))
         if ext.downcase == '.tgz'
-          @archive_name = File.basename(name, ext.downcase) + '.tar'
+          @archive_name = File.basename(name, ext.downcase) << '.tar'
         else
           @archive_name = File.basename(name, ext)
         end
@@ -72,24 +75,23 @@ module Archive
       end
 
       # Creates the archive using +file_pattern+ using +options+ or 'cf'
-      # (create file) by default.
+      # (create file) by default. The 'f' option should always be present
+      # and always be last.
       #
       # Raises an Archive::Tar::Error if a failure occurs.
       #
       def create_archive(file_pattern, options = 'cf')
-        cmd = "#{@tar_program} #{options} #{@archive_name} #{file_pattern}"
+        cmd = "#{@tar_program} --format #{@format} -#{options} #{@archive_name} #{file_pattern}"
 
-        Open3.popen3(cmd){ |tar_in, tar_out, tar_err|
+        Open3.popen3(cmd) do |_tar_in, _tar_out, tar_err|
           err = tar_err.gets
-          if err
-            raise Error, err.chomp
-          end
-        }
+          raise Error, err.chomp if err
+        end
 
         self
       end
 
-      alias :create :create_archive
+      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
@@ -97,10 +99,10 @@ module Archive
       #
       # Any errors that occur here will raise a Tar::CompressError.
       #
-      def compress_archive(program='gzip')
+      def compress_archive(program = 'gzip')
         cmd = "#{program} #{@archive_name}"
 
-        Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
+        Open3.popen3(cmd) do |_prog_in, _prog_out, prog_err|
           err = prog_err.gets
           raise CompressError, err.chomp if err
 
@@ -108,12 +110,12 @@ module Archive
           # 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
-        }
+        end
 
         self
       end
 
-      alias :compress :compress_archive
+      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
@@ -125,33 +127,31 @@ module Archive
       #
       # 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
+      def uncompress_archive(program = 'gunzip')
+        raise CompressError, 'no compressed file found' unless @compressed_archive_name
 
         cmd = "#{program} #{@compressed_archive_name}"
 
-        Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
+        Open3.popen3(cmd) do |_prog_in, _prog_out, prog_err|
           err = prog_err.gets
           raise CompressError, err.chomp if err
           @compressed_archive_name = nil
-        }
+        end
         self
       end
 
-      alias :uncompress :uncompress_archive
+      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')
+      def self.uncompress_archive(archive, program = 'gunzip')
         cmd = "#{program} #{archive}"
 
-        Open3.popen3(cmd){ |prog_in, prog_out, prog_err|
+        Open3.popen3(cmd) do |_prog_in, _prog_out, prog_err|
           err = prog_err.gets
           raise CompressError, err.chomp if err
-        }
+        end
       end
 
       class << self
@@ -164,58 +164,54 @@ module Archive
       def archive_info
         result = []
         cmd = "#{@tar_program} tf #{@archive_name}"
-        Open3.popen3(cmd){ |ain, aout, aerr|
+
+        Open3.popen3(cmd) do |_ain, aout, aerr|
           err = aerr.gets
-          if err
-            raise Error, err.chomp
-          end
+          raise Error, err.chomp if err
 
-          while output = aout.gets
+          while (output = aout.gets)
             result << output.chomp
           end
-        }
+        end
+
         result
       end
 
-      alias :info :archive_info
+      alias info archive_info
 
       # 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
+        raise Error, 'there must be at least one file specified' if files.empty?
 
-        cmd = "#{@tar_program} rf #{@archive_name} #{files.join(" ")}"
+        cmd = "#{@tar_program} rf #{@archive_name} #{files.join(' ')}"
 
-        Open3.popen3(cmd){ |ain, aout, aerr|
+        Open3.popen3(cmd) do |_ain, _aout, aerr|
           err = aerr.gets
           raise Error, err.chomp if err
-        }
+        end
         self
       end
 
-      alias :add :add_to_archive
+      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
+        raise Error, 'there must be at least one file specified' if files.empty?
 
-        cmd = "#{@tar_program} uf #{@archive_name} #{files.join(" ")}"
+        cmd = "#{@tar_program} uf #{@archive_name} #{files.join(' ')}"
 
-        Open3.popen3(cmd){ |ain, aout, aerr|
+        Open3.popen3(cmd) do |_ain, _aout, aerr|
           err = aerr.gets
           raise Error, err.chomp if err
-        }
+        end
 
         self
       end
 
-      alias :update :update_archive
+      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.
@@ -227,22 +223,19 @@ module Archive
       #
       def extract_archive(*files)
         cmd = "#{@tar_program} xf #{@archive_name}"
+        cmd = "#{cmd} #{files.join(' ')}" unless files.empty?
 
-        unless files.empty?
-          cmd << " " << files.join(" ")
-        end
-
-        Open3.popen3(cmd){ |ain, aout, aerr|
+        Open3.popen3(cmd) do |_ain, _aout, aerr|
           err = aerr.gets
           raise Error, err.chomp if err
-        }
+        end
 
         self
       end
 
-      alias :expand_archive :extract_archive
-      alias :extract :extract_archive
-      alias :expand :extract_archive
+      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
@@ -250,15 +243,12 @@ module Archive
       #
       def self.extract_archive(archive, *files)
         cmd = "tar xf #{archive}"
+        cmd = "#{cmd} #{files.join(' ')}" unless files.empty?
 
-        unless files.empty?
-          cmd << " " << files.join(" ")
-        end
-
-        Open3.popen3(cmd){ |ain, aout, aerr|
+        Open3.popen3(cmd) do |_ain, _aout, aerr|
           err = aerr.gets
           raise Error, err.chomp if err
-        }
+        end
 
         self
       end