imw 0.2.18 → 0.3.0

data/spec/imw/utils/paths_spec.rb

@@ -1,10 +0,0 @@
-require File.join(File.dirname(__FILE__),'../../spec_helper')
-require File.join(File.dirname(__FILE__), '/shared_paths_spec')
-
-describe IMW do
-  before do
-    @path_manager = IMW
-  end
-  it_should_behave_like "an object that manages paths"
-end
-

data/spec/imw/utils/shared_paths_spec.rb

@@ -1,29 +0,0 @@
-require File.join(File.dirname(__FILE__),'../../spec_helper')
-
-share_examples_for "an object that manages paths" do
-  before do
-    @path_manager.add_path :testing, '/testing'
-    @path_manager.add_path :first,   '/1'
-  end
-  
-  it 'returns a string when given a string' do
-    @path_manager.path_to('hi').should == 'hi'
-  end
-
-  it 'returns a path when given a registered symbol' do
-    @path_manager.path_to(:testing).should == '/testing'
-  end
-
-  it 'raises an error when given a unregistered symbol' do
-    lambda { @path_manager.path_to(:foobar) }.should raise_error(IMW::PathError)
-  end
-  
-  it 'returns a constructed path when passed a mixture of symbols, strings, and arrays ' do
-    @path_manager.path_to( [:testing, 'hi'], [[['there']]]).should == '/testing/hi/there'
-  end
-  
-  it 'will correctly expand paths themselves defined via symbols' do
-    @path_manager.add_path(:first, :testing, '1')
-    @path_manager.path_to(:first).should == '/testing/1'
-  end
-end

data/spec/imw_spec.rb

@@ -1,14 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe IMW do
-
-  # FIXME
-
-  describe 'when opening files' do
-  end
-
-  describe 'when opening directories' do
-  end
-  
-end
-

data/spec/rcov.opts

@@ -1 +0,0 @@
---exclude "bin/*,etc/*,meta/*,gems/*,old/*,spec/*" 

data/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-IMW_ROOT_DIR = File.join(File.expand_path(File.dirname(__FILE__)), '..') unless defined? IMW_ROOT_DIR
-IMW_SPEC_DIR = File.join(IMW_ROOT_DIR, 'spec')                           unless defined? IMW_SPEC_DIR
-IMW_LIB_DIR  = File.join(IMW_ROOT_DIR, 'lib')                            unless defined? IMW_LIB_DIR
-$: << IMW_LIB_DIR
-
-require 'imw'
-require 'spec'
-
-Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |path| require path }
-
-module IMWTest
-  TMP_DIR   = "/tmp/imwtest" unless defined?(TMP_DIR)
-  DATA_DIR  = File.join(IMW_SPEC_DIR, 'data') unless defined?(DATA_DIR)
-end
-
-Spec::Runner.configure do |config|
-
-  config.include IMWTest::CustomMatchers
-  
-  config.before do
-    FileUtils.mkdir_p IMWTest::TMP_DIR
-    FileUtils.cd IMWTest::TMP_DIR
-  end
-  
-  config.after do
-    FileUtils.rm_rf IMWTest::TMP_DIR
-  end
-end
-
-  
-

data/spec/support/custom_matchers.rb

@@ -1,28 +0,0 @@
-module IMWTest
-  module CustomMatchers
-
-    # Check to see whether the given directory (a String) contains the
-    # given +paths+
-    #
-    # @param [Array<String>] paths
-    def contain *paths
-      paths = paths.flatten
-      simple_matcher("contain #{paths.inspect}") do |given, matcher|
-        given_contents = Dir[given + "/**/*"].map do |abs_path|
-          abs_path[(given.length + 1)..-1]
-        end
-        matcher.failure_message = "expected #{given} to contain #{paths.inspect}, instead it contained #{given_contents.inspect}"
-        matcher.negative_failure_message = "expected #{given} not to contain #{paths.inspect}"
-        paths.all? { |path| given_contents.include?(path.gsub(/\/+$/,'')) }
-      end
-    end
-
-    def exist
-      simple_matcher("exist") do |given, matcher|
-        matcher.failure_message = "expected #{given} to exist on disk"
-        matcher.failure_message = "expected #{given} not to exist on disk"
-        File.exist?(given)
-      end
-    end
-  end
-end

data/spec/support/file_contents_matcher.rb

@@ -1,30 +0,0 @@
-module IMWTest
-  module CustomMatchers
-
-    class FileContentsMatcher
-      def initialize orig
-        @orig = File.expand_path orig
-      end
-
-      def matches? copy
-        @copy = File.expand_path copy
-        File.compare(@orig,@copy)
-      end
-
-      def failure_message
-        "files #{@orig} and #{@copy} are different"
-      end
-
-      def negative_failure_message
-        "expected files #{@orig} and #{@copy} to differ"
-      end
-    end
-
-    # Matches the contents of one file against another using
-    # File.compare.
-    def have_contents_matching_those_of path
-      FileContentsMatcher.new(path)
-    end
-    
-  end
-end

data/spec/support/paths_matcher.rb

@@ -1,66 +0,0 @@
-require 'set'
-
-module IMWTest
-
-  module CustomMatchers
-
-    class PathsMatcher
-
-      attr_accessor :given, :given_contents, :given_base, :to_match, :to_match_contents, :to_match_base
-
-      def initialize given, options={}
-        @given_base     = options[:given_base] || options[:relative_to]
-        @to_match_base  = options[:to_match_base]
-        @given          = given
-        @given_contents = get_contents(given, given_base)
-      end
-      
-      def matches? to_match
-        @to_match          = to_match
-        @to_match_contents = get_contents(to_match, to_match_base)
-        to_match_contents == given_contents
-      end
-
-      def failure_message
-        given_string    = given_contents.to_a.join("\n\t")
-        to_match_string = to_match_contents.to_a.join("\n\t")          
-        "expected contents to be identical.\n\ngiven #{given.inspect}:\n\t#{given_string}\n\nto match #{to_match}:\n\t#{to_match_string}"
-      end
-
-      def negative_failure_message
-        "expected contents of #{given} and #{to_match} to be different"
-      end
-
-      protected
-      def get_contents obj, base=nil
-        if obj.is_a?(String) || obj.is_a?(Array)
-          contents = [obj].flatten.map do |raw_path|
-            path = File.expand_path(raw_path)
-            if File.directory?(path)
-              Dir[path + "/**/*"]
-            else
-              path
-            end
-          end.flatten
-        else
-          # obj is an IMW obj (archive or directory) so it has a
-          # contents method
-          contents = obj.send(obj.respond_to?(:all_contents) ? :all_contents : :contents)
-        end
-        if base
-          contents.map do |path|
-            new_path = path[base.length + 1..-1]
-            new_path = nil if !new_path.nil? && new_path.size == 0
-            new_path
-          end.compact.to_set
-        else
-          contents.to_set
-        end
-      end
-    end
-    
-    def contain_paths_like given, options={}
-      PathsMatcher.new(given, options)
-    end
-  end
-end

data/spec/support/random.rb

@@ -1,213 +0,0 @@
-require 'fileutils'
-
-module IMWTest
-  module Random
-
-    STRING_CHARS        = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + [' ',' ',' ',' ',' '] unless defined?(STRING_CHARS)
-    TEXT_CHARS          = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + [' ',' ',' ',' ',' ',"\n"] unless defined?(TEXT_CHARS)
-    FILENAME_CHARS      = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["-","_",' '] unless defined?(FILENAME_CHARS)
-    FILENAME_MAX_LENGTH = 9 unless defined?(FILENAME_MAX_LENGTH)
-    TEXT_MAX_LENGTH     = 1024 unless defined?(TEXT_MAX_LENGTH)
-    EXTENSIONS          = [
-                           [/\.csv$/      , :csv_file],
-                           [/\.xml$/      , :xml_file],
-                           [/\.html$/     , :html_file],
-                           [/\.tar\.gz$/  , :targz_file],
-                           [/\.tar\.bz2$/ , :tarbz2_file],
-                           [/\.bz2$/      , :bz2_file],
-                           [/\.gz$/       , :gz_file],
-                           [/\.tar$/      , :tar_file],                           
-                           [/\.rar$/      , :rar_file],
-                           [/\.zip$/      , :zip_file]
-                         ] unless defined?(EXTENSIONS)
-    # Return a random filename.  Optional +length+ to set the maximum
-    # length of the filename returned.
-    def self.basename options = {}
-      length = (options[:length] or FILENAME_MAX_LENGTH)
-      filename = (1..length).map { |i| FILENAME_CHARS.choice }.join
-
-      # filenames beginning with hyphens suck
-      while (filename[0,1] == '-') do
-        filename[0] = FILENAME_CHARS.choice
-      end
-      filename
-    end
-    
-    # Return a random string of text up.  Control the length with
-    # optional +length+ and also the presence of +newlines+.
-    def self.text options = {}
-      length = (options[:length] or TEXT_MAX_LENGTH)
-      char_pool = options[:newlines] ? TEXT_CHARS : STRING_CHARS
-      (1..length).map { |i| char_pool.choice }.join
-    end
-
-    # Create a random file by matching the extension of the given
-    # +filename+ or a text file if no match is found.
-    def self.file filename
-      match = EXTENSIONS.find { |regex,func| regex.match filename }
-      match ? self.send(match.last,filename) : self.text_file(filename)
-    end        
-
-    # Create a random text file at +filename+ containing a maximum of
-    # +length+ characters.
-    def self.text_file filename, options = {}
-      File.open(filename,'w') { |f| f.write text(:newlines => true) }
-    end
-
-    # Create a comma-separated value file containing random text at
-    # +filename+ with the maximum +num_rows+, the given +num_columns+,
-    # and the maximum +entry_length+.
-    def self.csv_file(filename,num_rows = 500, num_columns = 9, entry_length = 9)
-      f = File.open(filename,'w')
-      rand(num_rows).times do # rows
-        num_columns.times do # columns
-          f.write(text(:length => entry_length)) # entry
-          f.write ','
-        end
-        f.write(text(:length => entry_length)) # last entry
-        f.write("\n")
-      end
-      f.close
-    end
-    
-    # Create an XML file at +filename+ of the maximum +length+.
-    #
-    # At the present moment, this file contains random text in a very
-    # boring single-element XML tree.  Randomizing the tree has not
-    # been implemented.
-    def self.xml_file filename, options = {}
-      options = options.reverse_merge({:max_depth => 5, :starting_depth => 1, :depth => nil, :pretty_print => true})
-      File.open(filename,'w') do |file|
-        file.write "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-        file.write "<xml>" + text + "</xml>"
-        file.close
-      end
-    end
-    
-
-    # Create an HTML file at +filename+ of the maximum +length+.
-    # 
-    # At the present moment, this file contains random text in a very
-    # boring bare-bones HTML with a single element body.  Randomizing
-    # the tree has not been implemented.
-    def self.html_file(filename, title_length = 100, body_length = 5000)
-      f = File.open(filename,'w')
-      f.write "<html><head><title>" + string(title_length) + "</title></head><body>" + string(body_length) + "</body></html>"
-      f.close
-    end
-
-    # Create a tar archive at the given +filename+ containing random
-    # files.
-    def self.tar_file filename
-      tmpd = File.dirname(filename) + '/dir'
-      directory_with_files(tmpd)
-      FileUtils.cd(tmpd) {|dir| system("tar -cf file.tar *") }
-      FileUtils.cp(tmpd + "/file.tar",filename)
-      FileUtils.rm_rf(tmpd)
-    end
-
-    # Create a tar.gz archive at the given +filename+ containing
-    # random files.
-    def self.targz_file filename
-      tar = File.dirname(filename) + "/file.tar"
-      targz = tar + ".gz"
-      tar_file tar
-      system("gzip #{tar}")
-      FileUtils.cp(targz,filename)
-      FileUtils.rm(targz)
-    end
-
-    # Create a tar.bz2 archive at the given +filename+ containing
-    # random files.
-    def self.tarbz2_file filename
-      tar = File.dirname(filename) + "/file.tar"
-      tarbz2 = tar + ".bz2"
-      tar_file tar
-      system("bzip2 #{tar}")
-      FileUtils.cp(tarbz2,filename)
-      FileUtils.rm(tarbz2)
-    end
-
-    # Create a .bz2 file at the given +filename+.
-    def self.bz2_file filename
-      text_path = File.dirname(filename) + "/fake_file"
-      text_file(text_path)
-      system("bzip2 #{text_path}")
-      FileUtils.mv(text_path + ".bz2", filename)
-    end
-
-    # Create a .gz file at the given +filename+.
-    def self.gz_file filename
-      text_path = File.dirname(filename) + "/fake_file"
-      text_file(text_path)
-      system("gzip #{text_path}")
-      FileUtils.mv(text_path + ".gz", filename)
-    end
-    
-
-    # Create a compressed rar archive at the given +filename+
-    # containing random files.
-    def self.rar_file filename
-      tmpd = File.dirname(filename) + '/dir'
-      directory_with_files(tmpd)
-      FileUtils.cd(tmpd) {|dir| system("rar a -o+ -inul file.rar *") }
-      FileUtils.cp(tmpd + "/file.rar",filename)
-      FileUtils.rm_rf(tmpd)
-    end
-
-    # Create a compressed zip archive at the given +filename+
-    # containing random files.
-    def self.zip_file filename
-      tmpd = File.dirname(filename) + '/dir'
-      directory_with_files(tmpd)
-      FileUtils.cd(tmpd) {|dir| system("zip -qqr file.zip *") }
-      FileUtils.cp(tmpd + "/file.zip",filename)
-      FileUtils.rm_rf(tmpd)
-    end
-
-    # Creates +directory+ and fills it with random files containing
-    # random data.
-    #
-    # Options (with their default values in parentheses) include:
-    #
-    # <tt>:extensions</tt> (<tt>[txt,csv,dat,xml]</tt>):: extensions to use.  If an extension is known (see <tt>IMWTest::Random::EXTENSIONS</tt>) then appropriately formatted random data will be used  If an extension is not known, it will be treated as text.  The extension +dir+ will create a directory which will itself be filled with random files in the same way as its parent.
-    # <tt>:max_depth</tt> (3):: maximum depth to nest directories
-    # <tt>:starting_depth</tt> (1):: the default depth the parent directory is assumed to have
-    # <tt>:num_files</tt> (10):: the maximum number of files per directory
-    # <tt>:force</tt> (false):: force overwriting of existing directories
-    def self.directory_with_files(directory,options = {})
-      directory = File.expand_path(directory)
-      options = options.reverse_merge({:extensions => ['txt','csv','dat'],:max_depth => 3,:force => false,:starting_depth => 1, :num_files => 3})
-      depth = options[:starting_depth]
-
-      if File.exist?(directory) then
-        if options[:force] then
-          FileUtils.rm_rf(directory)
-        else
-          raise "#{directory} already exists"
-        end
-      end
-      FileUtils.mkdir_p(directory)
-
-      (rand(options[:num_files]) + 2).times do
-        ext = options[:extensions].choice
-        name = self.basename
-        if ext == 'dir' then
-          if depth <= options[:max_depth] then
-            newd = directory + '/' + name
-            FileUtils.mkdir(newd)
-            directory_with_files(newd,options.merge({:starting_depth => (depth + 1)}))
-          else
-            next
-          end
-        else
-          file(directory + '/' + name + '.' + ext)
-        end
-      end
-    end
-
-  end
-end
-
-
-

data/spec/support/without_regard_to_order_matcher.rb

@@ -1,41 +0,0 @@
-require 'set'
-require 'imw/utils'
-
-module IMWTest
-  module CustomMatchers
-
-    # Match the contents of two arrays without regard to the order
-    # of their elements by treating each as a set.
-    class WithoutRegardToOrder
-
-      private
-      def initialize known_array
-        @known_array = known_array.to_set
-      end
-
-      public
-      def matches? array_to_test
-        @array_to_test = array_to_test.to_set
-        @array_to_test == @known_array
-      end
-
-      def failure_message
-        missing_from_array_to_test = "missing from array to test: #{(@known_array - @array_to_test).to_a.quote_items_with "and"}\n"
-        missing_from_known_array = "missing from known array: #{(@array_to_test - @known_array).to_a.quote_items_with "and"}\n"
-        common_to_both = "common to both: #{(@array_to_test & @known_array).to_a.quote_items_with "and"}\n"
-        "expected contents of the arrays to be identical:\n\n#{missing_from_array_to_test}\n#{missing_from_known_array}\n#{common_to_both}"
-      end
-
-      def negative_failure_message
-        "expected contents of the arrays to differ."
-      end
-    end
-
-    # Check that the contents of one array match another without
-    # regard to ordering.
-    def match_without_regard_to_order known_array
-      WithoutRegardToOrder.new(known_array)
-    end
-  end
-end
-