imw 0.1.0

data/lib/imw/files/archive.rb

@@ -0,0 +1,113 @@
+#
+# h2. lib/imw/files/archive.rb -- describes archives of files
+#
+# == About
+#
+# Module for describing known archive types.  An including archive
+# type's class must define an instance variable +archive+ which is a
+# hash with the following required keys:
+#
+# <tt>:program</tt>:: a symbol naming the program to be used.  It
+# should match one of the symbols in <tt>IMW::EXTERNAL_PROGRAMS</tt>
+# 
+# <tt>:create_flags</tt>:: a string of flags to pass to the archiving
+# program when creating the archive
+# 
+# <tt>:append_flags</tt>:: a string of flags to pass to the archiving
+# program when appending files to the archive
+# 
+# <tt>:extract_flags</tt>:: a string of flags to pass to the archiving
+# program when extracting the archive
+# 
+# <tt>:list_flags</tt>:: a string of flags to pass to the archiving
+# program when listing the archive's contents
+#
+# THe +archive+ hash may also contain the entry:
+#
+# <tt>:unarchiving_program</tt>:: a symbol naming the program to be
+# used to list/extract the archive.  Useful only if this program
+# differs from the program used to create the archive in the first
+# place (i.e. - zip & unzip).
+#
+# Author::    (Philip flip Kromer, Dhruv Bansal) for Infinite Monkeywrench Project (mailto:coders@infochimps.org)
+# Copyright:: Copyright (c) 2008 infochimps.org
+# License::   GPL 3.0
+# Website::   http://infinitemonkeywrench.org/
+# 
+# puts "#{File.basename(__FILE__)}: Put it all in one place so that when something goes wrong you'll know it immediately.  You'll regret it, but at least you'll know." # at bottom
+module IMW
+  module Files
+
+    module BasicFile
+
+      # Is this file an archive?
+      def archive?
+        false
+      end
+    end
+    
+    module Archive
+
+      attr_reader :archive
+
+      # Is this file an archive?
+      def archive?
+        true
+      end
+
+      public
+      # Create this archive containing the given +paths+, which can be
+      # either a string or list of strings to be interpreted as paths
+      # to files/directories by the shell.
+      #
+      # Options:
+      # <tt>:force</tt> (false):: overwrite any existing archive at this path.
+      def create paths, opts = {}
+        opts = opts.reverse_merge({:force => false})
+        raise IMW::Error.new("An archive already exists at #{@path}.") if exist? and not opts[:force]
+        raise IMW::Error.new("Cannot create an archive of type #{@extname}") unless @archive[:create_flags]
+        paths = [paths] if paths.class == String
+        IMW.system IMW::EXTERNAL_PROGRAMS[@archive[:program]], @archive[:create_flags], @path, *paths
+        self
+      end
+
+      # Append to this archive the given +paths+, which can be
+      # either a string or list of strings to be interpreted as paths
+      # to files/directories by the shell.
+      def append paths
+        raise IMW::Error.new("Cannot append to an archive of type #{@archive[:program]}.") unless @archive[:append_flags]
+        paths = [paths] if paths.class == String
+        IMW.system IMW::EXTERNAL_PROGRAMS[@archive[:program]], @archive[:append_flags], @path, *paths
+        self
+      end
+
+      # Extract the files from this archive to the current directory.
+      def extract
+        raise IMW::Error.new("Cannot extract, #{@path} does not exist.") unless exist?
+        program = (@archive[:unarchiving_program] or @archive[:program])
+        IMW.system IMW::EXTERNAL_PROGRAMS[program], @archive[:extract_flags], @path
+      end
+
+      # Return a (sorted) list of contents in this archive.
+      def contents
+        raise IMW::Error.new("Cannot list contents, #{@path} does not exist.") unless exist?
+        program = (@archive[:unarchiving_program] or @archive[:program])
+        output = ''
+        command = [IMW::EXTERNAL_PROGRAMS[program], @archive[:list_flags], @path].join ' '
+        output += `#{command}`
+        archive_contents_string_to_array(output)
+      end
+
+      # Parse and format the output from the archive program's "list"
+      # command into an array of filenames.
+      #
+      # An including class can customize this method to match the
+      # output from the archiving program of that class.
+      def archive_contents_string_to_array string
+        string.split("\n")
+      end
+    end
+  end
+end
+
+

data/lib/imw/files/basicfile.rb

@@ -0,0 +1,122 @@
+#
+# h2. lib/imw/files/file.rb -- base class for files 
+#
+# == About
+#
+# Defines a base class for classes for specific filetypes to subclass.
+#
+# Author::    (Philip flip Kromer, Dhruv Bansal) for Infinite Monkeywrench Project (mailto:coders@infochimps.org)
+# Copyright:: Copyright (c) 2008 infochimps.org
+# License::   GPL 3.0
+# Website::   http://infinitemonkeywrench.org/
+#
+# puts "#{File.basename(__FILE__)}: At the very bottom of the office building, wedged between a small boulder and a rotting log you see a weathered manilla file folder.  The writing on the tab is too faded to make out." # at bottom
+module IMW
+  module Files
+    module BasicFile
+
+      attr_reader :uri, :host, :path, :dirname, :basename, :extname, :name
+
+      protected
+
+      def uri= uri
+        @uri      = URI.parse(uri) if uri.is_a?(String)
+        @host     = self.uri.host
+        @path     = local? ? ::File.expand_path(self.uri.path) : self.uri.path
+        @dirname  = ::File.dirname path
+        @basename = ::File.basename path
+        @extname  = find_extname
+        @name     = @basename[0,@basename.length - @extname.length]
+      end
+
+      # Some files (like <tt>.tar.gz</tt>) have an "extra" extension.
+      # Classes in the <tt>IMW::Files</tt> module should define a
+      # class method <tt>extname</tt> which returns the their full
+      # extension.
+      def find_extname
+        self.class.respond_to?(:extname) ? self.class.extname(path) : ::File.extname(path)
+      end
+
+      public
+
+      # Is this file on the local machine (the scheme of the file's URI is nil or 
+      def local?
+        host == 'file' || host.nil?
+      end
+
+      # Is this file on a remote machine?
+      def remote?
+        (! local?)
+      end
+
+      # Steal a bunch of class methods from File which only take a
+      # path as a first argument.
+      [:executable?, :executable_real?, :file?, :directory?, :ftype, :owned?, :pipe?, :readable?, :readable_real?, :setgid?, :setuid?, :size, :size?, :socket?, :split, :stat, :sticky?, :writable?, :writable_real?, :zero?].each do |class_method|
+        define_method class_method do
+          File.send(class_method, path) if local?
+        end
+      end
+
+      # Is there a real file at the path of this File?  Will attempt
+      # to open files online too to check.
+      def exist?
+        if local?
+          ::File.exist?(path) ? true : false
+        else
+          begin
+            true if open(uri)
+          rescue SocketError
+            false
+          end
+        end
+      end
+      alias_method :exists?, :exist?
+
+      # Delete this file.
+      def rm
+        raise IMW::PathError.new("cannot delete remote file #{uri}")     unless local?
+        raise IMW::PathError.new("cannot delete #{uri}, doesn't exist!") unless exist?
+        FileUtils.rm path
+      end
+      alias_method :rm!, :rm
+
+      # Copy this file to +new_path+.
+      def cp new_path
+        raise IMW::PathError.new("cannot copy from #{path}, doesn't exist!") unless exist?
+        if local?
+          FileUtils.cp path, new_path
+        else
+          # FIXME better way to do this?
+          File.open(new_path,'w') { |f| f.write(open(uri).read) }
+        end
+        self.class.new(new_path)
+      end
+
+      # Copy this file to +dir+.
+      def cp_to_dir dir
+        cp File.join(File.expand_path(dir),basename)
+      end
+
+      # Move this file to +new_path+.
+      def mv new_path
+        raise IMW::PathError.new("cannot move from #{path}, doesn't exist!") unless exist?
+        if local?
+          FileUtils.mv path, new_path
+        else
+          # FIXME better way to do this?
+          File.open(new_path,'w') { |f| f.write(open(uri).read) }
+        end
+        self.class.new(new_path)
+      end
+      alias_method :mv!, :mv
+
+      # Move this file to +dir+.
+      def mv_to_dir dir
+        mv File.join(File.expand_path(dir),basename)
+      end
+      alias_method :mv_to_dir!, :mv_to_dir
+    end
+  end
+end
+
+

data/lib/imw/files/binary.rb

@@ -0,0 +1,28 @@
+#
+# h2. lib/imw/files/binary.rb -- binary files
+#
+# == About
+#
+# Class for handling binary data.
+#
+# Author::    (Philip flip Kromer, Dhruv Bansal) for Infinite Monkeywrench Project (mailto:coders@infochimps.org)
+# Copyright:: Copyright (c) 2008 infochimps.org
+# License::   GPL 3.0
+# Website::   http://infinitemonkeywrench.org/
+#
+# puts "#{File.basename(__FILE__)}: Something clever" # at bottom
+module IMW
+  module Files
+
+    class Binary
+      
+      include IMW::Files::BasicFile
+      include IMW::Files::Compressible
+
+      def initialize uri
+        self.uri= uri
+      end
+
+    end
+  end
+end

data/lib/imw/files/compressed_file.rb

@@ -0,0 +1,93 @@
+#
+# h2. lib/imw/files/compressed_file.rb -- class describing compressed files
+#
+# == About
+#
+# Compression of files is handled via the
+# <tt>IMW::Files::Compressible</tt> module which can be included by
+# any object that has a <tt>@path</tt> attribute.  The methods defined
+# there compress files and return this
+# <tt>IMW::Files::CompressedFile</tt> object which has methods for
+# decompression.
+#
+# A subclass of this class must define a +compression+ instance
+# variable which is a hash with the following keys:
+#
+# <tt>:program</tt>:: a symbol naming the program used for
+# compression/decompression which must be one of the symbols in
+# <tt>IMW::EXTERNAL_PROGRAMS</tt>
+#
+# <tt>:decompression_flags</tt>:: a string of flags to pass to the
+# compression program when decompressing the file.
+#
+# A subclass must also define the method +decompressed_path+ which
+# returns the path of the file post-decompression.
+#
+# Author::    (Philip flip Kromer, Dhruv Bansal) for Infinite Monkeywrench Project (mailto:coders@infochimps.org)
+# Copyright:: Copyright (c) 2008 infochimps.org
+# License::   GPL 3.0
+# Website::   http://infinitemonkeywrench.org/
+#
+# puts "#{File.basename(__FILE__)}: Have you ever folded up the wrapper of a soda straw into a little accordian shape and let a drop of water soak into it?" # at bottom
+module IMW
+  module Files
+
+    module BasicFile
+      def compressed?
+        false
+      end
+    end
+    
+    # A module which provides methods for decompressing a compressed
+    # file.  An including should define an instance variable
+    # <tt>@compression</tt> with two keys:
+    #
+    #  <tt>:program</tt>:: a symbol from <tt>IMW::EXTERNAL_PROGRAMS</tt>
+    #  <tt>:decompression_flags</tt>:: a string specifying flags to pass to the decompression program
+    module CompressedFile
+
+      attr_reader :compression
+
+      # Is this file compressed?
+      def compressed?
+        true
+      end
+      
+      # Construct the command passed to the shell to decompress this
+      # file.
+      def decompression_command
+        [IMW::EXTERNAL_PROGRAMS[@compression[:program]],@compression[:decompression_flags],@path].join ' '
+      end
+        
+      public
+      # Decompress this file in its present directory overwriting any
+      # existing files and without saving the original compressed
+      # file.
+      def decompress!
+        raise IMW::PathError.new("cannot decompress #{@path}, doesn't exist!") unless exist?
+        FileUtils.cd(@dirname) { IMW.system decompression_command }
+        IMW.open(decompressed_path)
+      end
+
+      # Decompress this file in its present directory, overwriting any
+      # existing files while keeping the original compressed file.
+      #
+      # The implementation is a little stupid, as the file is
+      # needlessly copied.
+      def decompress
+        raise IMW::PathError.new("cannot decompress #{@path}, doesn't exist!") unless exist?        
+        begin
+          FileUtils.cp(@path,@path + 'copy')
+          decompress!
+        ensure
+          FileUtils.mv(@path + 'copy',@path)
+        end
+        IMW.open(decompressed_path)
+      end
+
+    end
+  end
+end
+
+
+

data/lib/imw/files/compressed_files_and_archives.rb

@@ -0,0 +1,348 @@
+#
+# h2. lib/imw/files/compressed_files_and_archives.rb -- require farm
+#
+# == About
+#
+# Just required all the archive and compressed formats (+tar+, +bz2+,
+# &c.)
+#
+# Author::    (Philip flip Kromer, Dhruv Bansal) for Infinite Monkeywrench Project (mailto:coders@infochimps.org)
+# Copyright:: Copyright (c) 2008 infochimps.org
+# License::   GPL 3.0
+# Website::   http://infinitemonkeywrench.org/
+#
+# puts "#{File.basename(__FILE__)}: Something clever" # at bottom
+module IMW
+  module Files
+    
+    # A class to wrap a +tar+ archive.
+    #
+    # Creation, appending, listing, and extraction flags are stored in
+    # <tt>IMW::Files::Tar::DEFAULT_FLAGS</tt> and all are passed to
+    # the <tt>:tar</tt> program in <tt>IMW::EXTERAL_PROGRAMS</tt>.
+    class Tar
+      
+      include IMW::Files::BasicFile
+      include IMW::Files::Archive
+      include IMW::Files::Compressible
+      
+      # The default flags used creating, appending to, listing, and
+      # extracting a tar archive.
+      DEFAULT_FLAGS = {
+        :create => "-cf",
+        :append => "-rf",
+        :list => "-tf",
+        :extract => "-xf",
+        :program => :tar
+      }
+      
+      def initialize uri, *args
+        self.uri= uri
+        @archive = {
+          :program => DEFAULT_FLAGS[:program],
+          :create_flags => DEFAULT_FLAGS[:create],
+          :append_flags => DEFAULT_FLAGS[:append],
+          :list_flags => DEFAULT_FLAGS[:list],
+          :extract_flags => DEFAULT_FLAGS[:extract]
+        }
+      end
+    end # Tar
+    
+    # A class to wrap a <tt>tar.gz</tt> archive.
+    #
+    # Creation, appending, listing, and extraction flags are stored in
+    # <tt>IMW::Files::TarGz::DEFAULT_FLAGS</tt> and all are passed to
+    # the <tt>:tar</tt> program in <tt>IMW::EXTERAL_PROGRAMS</tt>.
+    class TarGz
+      
+      include IMW::Files::BasicFile
+      include IMW::Files::Archive
+      include IMW::Files::CompressedFile
+      
+      # The default flags used creating, appending to, listing, and
+      # extracting a <tt>tar.gz</tt> archive.
+      DEFAULT_FLAGS = {
+        :decompression_program => :gzip,
+        :decompression_flags => '-fd',
+        :archive_program => :tar,
+        :archive_list_flags => "-tf",
+        :archive_extract_flags => "-xzf"
+      }
+      
+      def initialize uri, *args
+        self.uri= uri
+        @compression = {
+          :program => DEFAULT_FLAGS[:decompression_program],
+          :decompression_flags => DEFAULT_FLAGS[:decompression_flags]
+        }
+        @archive = {
+          :program => DEFAULT_FLAGS[:archive_program],
+          :list_flags => DEFAULT_FLAGS[:archive_list_flags],
+          :extract_flags => DEFAULT_FLAGS[:archive_extract_flags]
+        }
+      end
+      
+      # Returns the path of the file after decompression.
+      def decompressed_path
+        if /\.tar\.gz$/.match @path then
+          @path.gsub /\.tar\.gz$/, ".tar"
+        elsif /\.tgz$/.match @path then
+          @path.gsub /\.tgz$/, ".tar"
+        end
+      end
+
+      def self.extname path
+        if /\.tar\.gz$/.match path then
+          ".tar.gz"
+        elsif /\.tgz$/.match path then
+          ".tgz"
+        end
+      end
+      
+    end # TarGz
+
+    # A class to wrap a <tt>tar.bz2</tt> archive.
+    #
+    # Creation, appending, listing, and extraction flags are stored in
+    # <tt>IMW::Files::TarBz2::DEFAULT_FLAGS</tt> and all are passed to
+    # the <tt>:tar</tt> program in <tt>IMW::EXTERAL_PROGRAMS</tt>.
+    class TarBz2
+
+      include IMW::Files::BasicFile
+      include IMW::Files::Archive
+      include IMW::Files::CompressedFile
+      
+      # The default flags used creating, appending to, listing, and
+      # extracting a <tt>tar.bz2</tt> archive.
+      DEFAULT_FLAGS = {
+        :decompression_program => :bzip2,
+        :decompression_flags => '-fd',
+        :archive_program => :tar,
+        :archive_create_flags => '-cf',
+        :archive_list_flags => "-tf",
+        :archive_extract_flags => "-xjf"
+      }
+
+      def self.extname path
+        if /\.tar\.bz2$/.match path then
+          ".tar.bz2"
+        elsif /\.tbz2$/.match path then
+          ".tbz2"
+        end
+      end
+      
+      def initialize uri, *args
+        self.uri= uri
+        @compression = {
+          :program => DEFAULT_FLAGS[:decompression_program],
+          :decompression_flags => DEFAULT_FLAGS[:decompression]
+        }
+        @archive = {
+          :program => DEFAULT_FLAGS[:archive_program],
+          :list_flags => DEFAULT_FLAGS[:archive_list_flags],
+          :extract_flags => DEFAULT_FLAGS[:archive_extract_flags],
+          :create_flags  => DEFAULT_FLAGS[:archive_create_flags]
+        }
+      end
+
+      # Returns the path of the file after decompression.
+      def decompressed_path
+        if /\.tar\.bz2$/.match @path then
+          @path.gsub /\.tar\.bz2$/, ".tar"
+        elsif /\.tbz2$/.match @path then
+          @path.gsub /\.tbz2$/, ".tar"
+        end
+      end
+
+      # Overrides default behvaior of IMW::Files::Archive#create to
+      # compress files after creating them.
+      def create paths, opts={}
+        opts = opts.reverse_merge({:force => false})
+        raise IMW::Error.new("An archive already exists at #{@path}.") if exist? and not opts[:force]
+        paths = [paths] if paths.class == String
+        IMW.system IMW::EXTERNAL_PROGRAMS[@archive[:program]], @archive[:create_flags], path_between_archive_and_compression, *paths
+        IMW.open(path_between_archive_and_compression).compress!(:bzip2)
+      end
+
+      protected
+      def path_between_archive_and_compression
+        File.join(dirname,name + '.tar')
+      end
+      
+    end # TarBz2
+    
+    # A class to wrap a +rar+ archive.
+    #
+    # Creation, appending, listing, and extraction flags are stored in
+    # <tt>IMW::Files::Rar::DEFAULT_FLAGS</tt> and all are passed to
+    # the <tt>:rar</tt> program in <tt>IMW::EXTERAL_PROGRAMS</tt>.
+    class Rar
+      
+      include IMW::Files::BasicFile
+      include IMW::Files::Archive
+      
+      # The default flags used creating, appending to, listing, and
+      # extracting a rar archive.
+      DEFAULT_FLAGS = {
+        :create => "a -r -o+ -inul",
+        :append => "a -r -o+ -inul",
+        :list => "vb",
+        :extract => "x -o+ -inul"
+      }
+      
+      def initialize uri, *args
+        self.uri= uri
+        @archive = {
+          :program => :rar,
+          :create_flags => DEFAULT_FLAGS[:create],
+          :append_flags => DEFAULT_FLAGS[:append],
+          :list_flags => DEFAULT_FLAGS[:list],
+          :extract_flags => DEFAULT_FLAGS[:extract]
+        }
+      end
+    end # Rar
+
+    # A class to wrap a +zip+ archive.
+    #
+    # Creation, appending, listing, and extraction flags are stored in
+    # <tt>IMW::Files::Zip::DEFAULT_FLAGS</tt> and all are passed to
+    # the <tt>:zip</tt> and <tt>:unzip</tt> programs in
+    # <tt>IMW::EXTERAL_PROGRAMS</tt>.
+    class Zip
+      
+      include IMW::Files::BasicFile
+      include IMW::Files::Archive
+      
+      # The default flags used creating, appending to, listing, and
+      # extracting a zip archive.
+      DEFAULT_FLAGS = {
+        :create => "-q -r",
+        :append => "-q -g",
+        :list => "-l",
+        :extract => "-q -o",
+        :unarchiving_program => :unzip
+      }
+      
+      def initialize uri, *args
+        self.uri= uri
+        @archive = {
+          :program => :zip,
+          :create_flags => DEFAULT_FLAGS[:create],
+          :append_flags => DEFAULT_FLAGS[:append],
+          :list_flags => DEFAULT_FLAGS[:list],
+          :extract_flags => DEFAULT_FLAGS[:extract],
+          :unarchiving_program => DEFAULT_FLAGS[:unarchiving_program]
+        }
+      end
+      
+      # The `unzip' program outputs data in a very annoying format:
+      #
+      #     Archive:  data.zip
+      #       Length     Date   Time    Name
+      #      --------    ----   ----    ----
+      #         18510  07-28-08 15:58   data/4d7Qrgz7.csv
+      #          3418  07-28-08 15:41   data/7S.csv
+      #         23353  07-28-08 15:41   data/g.csv
+      #           711  07-28-08 15:58   data/g.xml
+      #          1095  07-28-08 15:41   data/L.xml
+      #          2399  07-28-08 15:58   data/mTAu9H3.xml
+      #           152  07-28-08 15:58   data/vaHBS2t5R.dat
+      #      --------                   -------
+      #         49638                   7 files
+      #
+      # which is parsed by this method.
+      def archive_contents_string_to_array string
+        rows = string.split("\n")
+        # ignore the first 3 lines of the output and also discared the
+        # last 2 (5 = 2 + 3)
+        file_rows = rows[3,(rows.length - 5)]
+        file_rows.map! do |row|
+          # discard extra whitespace before after main text
+          row.lstrip!.rstrip!
+          # split the remaining text at spaces...columns beyond the
+          # third are part of the filename and should be joined with a
+          # space again in case of a filename with a space
+          row.split(' ')[3,row.size].join(' ')
+        end
+        file_rows
+      end
+    end # Zip
+
+    # A class to wrap a <tt>gz</tt> compressed file.
+    #
+    # The decompressing flags are stored in
+    # <tt>IMW::Files::Gz::DEFAULT_FLAGS</tt> and all are passed to the
+    # <tt>:gzip</tt> program in <tt>IMW::EXTERAL_PROGRAMS</tt>.
+    class Gz
+
+      include IMW::Files::BasicFile
+      include IMW::Files::CompressedFile
+      
+      # The default flags used in extracting a <tt>gz</tt> file.
+      DEFAULT_FLAGS = {
+        :program => :gzip,
+        :decompression => '-fd'
+      }
+      
+      def initialize uri, *args
+        self.uri= uri
+        @compression = {
+          :program => DEFAULT_FLAGS[:program],
+          :decompression_flags => DEFAULT_FLAGS[:decompression]
+        }
+      end
+
+      def decompressed_path
+        @path.gsub /\.gz$/, ""
+      end
+    end # Gz
+    
+    # A class to wrap a <tt>bz2</tt> compressed file.
+    #
+    # The decompressing flags are stored in
+    # <tt>IMW::Files::Bz2::DEFAULT_FLAGS</tt> and all are passed to
+    # the <tt>:bzip2</tt> program in <tt>IMW::EXTERAL_PROGRAMS</tt>.
+    class Bz2
+      
+      include IMW::Files::BasicFile
+      include IMW::Files::CompressedFile
+      
+      # The default flags used in extracting a <tt>bz2</tt> file.
+      DEFAULT_FLAGS = {
+        :program => :bzip2,
+        :decompression => '-fd'
+      }
+      
+      def initialize uri, *args
+        self.uri= uri
+        raise IMW::Error.new("#{@extname} is not a valid extension for a bzip2 compressed file.") unless @extname == '.bz2'
+        @compression = {
+          :program => DEFAULT_FLAGS[:program],
+          :decompression_flags => DEFAULT_FLAGS[:decompression]
+        }
+      end
+      
+      # Returns the path of the file after decompression.
+      def decompressed_path
+        @path.gsub /\.bz2$/, ""
+      end
+    end # Bz2
+
+
+    # make sure that tar.bz2 precedes bz2 and so on...
+    FILE_REGEXPS << [/\.tar\.bz2$/, IMW::Files::TarBz2]
+    FILE_REGEXPS << [/\.tbz2$/,     IMW::Files::TarBz2]
+    
+    FILE_REGEXPS << [/\.tar\.gz$/,  IMW::Files::TarGz]
+    FILE_REGEXPS << [/\.tgz$/,      IMW::Files::TarGz]
+
+    FILE_REGEXPS << [/\.tar$/,      IMW::Files::Tar]    
+    FILE_REGEXPS << [/\.bz2$/,      IMW::Files::Bz2]    
+    FILE_REGEXPS << [/\.gz$/,       IMW::Files::Gz]    
+    FILE_REGEXPS << [/\.rar$/,      IMW::Files::Rar]
+    FILE_REGEXPS << [/\.zip$/,      IMW::Files::Zip]
+    
+  end # Files
+end # IMW
+
+