imw 0.1.0

data/spec/imw/workflow/rip_spec.rb

@@ -0,0 +1,27 @@
+#
+# h2. spec/imw/workflow/rip_spec.rb -- spec for rip.rb
+#
+# == About
+#
+# 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/
+#
+require File.join(File.dirname(__FILE__),'../../spec_helper')
+
+# require 'imw/workflow/rip'
+#
+# describe Source do
+#
+#   before(:all) do
+#     @source = IMW::Source.new(:fake_source)
+#     @source.stub("returns path to ripd directory",:path_to => IMW::DIRECTORIES[:dump] + "/source_rip_spec")
+#   end
+#
+#   it "should raise an error when asked to rip in an unknown way" do
+#     @source.rip_from :silly_way
+#   end
+# end
+
+# puts "#{File.basename(__FILE__)}: Bending over, you hear a thunderous RRRRRRRIIIIIP and then scuttle off to check your pants..." # at bottom

data/spec/rcov.opts

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

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+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 'rubygems'
+require 'spec'
+require 'fileutils'
+require 'imw'
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |path| require path }
+
+module IMWTest
+  TMP_DIR = "/tmp/imwtest"
+end
+
+Spec::Runner.configure do |config|
+
+  config.include 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/archive_contents_matcher.rb

@@ -0,0 +1,94 @@
+#
+# h2. spec/matchers/archive_contents_matcher.rb -- matches contents of archive to disk
+#
+# == About
+#
+# An RSpec matcher which tests that an archive of files has the same
+# contents as various paths on disk.
+#
+# 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/
+# 
+
+require 'find'
+
+module Spec
+  module Matchers
+    module IMW
+
+      # Match the contents of the archive against files or directories
+      # in +paths+.
+      #
+      # Options include:
+      # 
+      # <tt>:relative_to</tt>:: a leading path which will be stripped
+      # from all +paths+ before comparison with the contents of the
+      # directory.
+      class ArchiveContentsMatchPaths
+
+        private
+        def initialize paths,opts = {}
+          opts.reverse_merge!({:relative_to => nil})
+          paths = [paths] if paths.class == String
+          @paths = paths
+          @relative_to = opts[:relative_to]
+          find_paths_contents
+        end
+
+        def find_paths_contents
+          # find all the files
+          contents = []
+          @paths.each do |path|
+            path = File.expand_path path
+            if File.file? path then
+              contents << path
+            elsif File.directory? path then
+              contents += Find.files_in_directory(path)
+            end
+          end
+
+          # strip leading path
+          contents.map! do |path|
+            # the +1 is because we want a relative path
+            path = path[@relative_to.length + 1,path.size]
+          end
+
+          @paths_contents = contents.to_set
+        end
+
+        def pretty_print set
+          set.to_a.join("\n\t")
+        end
+        
+        public
+        def matches? archive
+          @archive = archive
+          @archive_contents = @archive.contents.to_set
+          @archive_contents == @paths_contents
+        end
+
+        def failure_message
+          missing_from_archive = "missing from archive:\n\t#{pretty_print(@paths_contents - @archive_contents)}\n"
+          missing_from_paths = "missing from paths:\n\t#{pretty_print(@archive_contents - @paths_contents)}\n"
+          common = "common to both:\n\t#{pretty_print(@archive_contents & @paths_contents)}\n"
+          "expected contents of archive (#{@archive.path}) and paths (#{@paths.join(", ")}) to be identical.\n#{missing_from_archive}\n#{missing_from_paths}\n#{common}"
+        end
+
+        def negative_failure_message
+          "expected contents of archive (#{@archive.path}) and paths (#{@paths.join(", ")}) to differ."
+        end
+        
+      end
+
+      # Invokes the matcher <tt>Spec::Matchers::IMW::ArchiveContentsMatchPaths
+      def contain_paths_like paths, opts = {}
+        ArchiveContentsMatchPaths.new(paths,opts)
+      end
+      
+    end
+  end
+end
+
+# puts "#{File.basename(__FILE__)}: An archive is something that is bigger on the inside than it is on the outside." # at bottom

data/spec/support/custom_matchers.rb

@@ -0,0 +1,21 @@
+module CustomMatchers
+  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) }
+    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

data/spec/support/directory_contents_matcher.rb

@@ -0,0 +1,61 @@
+#
+# h2. spec/matchers/directory_contents_matcher.rb -- matches files between directories
+#
+# == About
+#
+# An RSpec matcher which tests that two directories share the same set
+# of files.
+#
+# 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/
+# 
+
+require 'set'
+require 'find'
+
+module Spec
+  module Matchers
+    module IMW
+
+      class DirectoryContentsMatcher
+        private
+        def initialize dir
+          @dir = File.expand_path(dir)
+          @dir_files = Find.files_relative_to_directory(@dir).to_set
+        end
+
+        # Pretty print a set of files.
+        def format_files_for_printing files
+          files.to_a.join("\n\t")
+        end
+
+        public
+        def matches? target
+          @target = target
+          @target_files = Find.files_relative_to_directory(@target).to_set
+          @target_files == @dir_files
+        end
+
+        def failure_message
+          files_missing_from_dir = format_files_for_printing(@target_files - @dir_files)
+          files_missing_from_target = format_files_for_printing(@dir_files - @target_files)
+          files_in_common = format_files_for_printing(@dir_files & @target_files)
+          "expected files in #{@dir} and #{@target} to be identical.\n\nfiles missing from #{@dir}:\n\t#{files_missing_from_dir}\n\nfiles missing from #{@target}:\n\t#{files_missing_from_target}\n\nfiles in common:\n\t#{files_in_common}"
+        end
+
+        def negative_failure_message
+          "expected files in #{@dir} and #{@target} to be different"
+        end
+      end
+
+      # Checks that files in one directory match those in another.
+      def contain_files_matching_directory dir
+        DirectoryContentsMatcher.new(dir)
+      end
+    end
+  end
+end
+
+# puts "#{File.basename(__FILE__)}: From far away, the two filing cabinets appear to be identical.  Upon closer inspection, one of them is actually a Maine lobster.  Delicious!" # at bottom

data/spec/support/extensions.rb

@@ -0,0 +1,18 @@
+class Array
+  def random
+    self[rand(length)]
+  end
+end
+
+class Hash
+  # Stolen from ActiveSupport::CoreExtensions::Hash::ReverseMerge.
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+
+  # Stolen from ActiveSupport::CoreExtensions::Hash::ReverseMerge.
+  def reverse_merge!(other_hash)
+    replace(reverse_merge(other_hash))
+  end
+end
+

data/spec/support/file_contents_matcher.rb

@@ -0,0 +1,50 @@
+#
+# h2. spec/imw/matchers/file_contents_matcher.rb -- matches contents of two files
+#
+# == About
+#
+# An RSpec matcher which tests that two files have the same contents
+# on disk.
+#
+# 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/
+# 
+
+require 'ftools'
+
+module Spec
+  module Matchers
+    module IMW
+
+      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
+end
+
+# puts "#{File.basename(__FILE__)}: From far away, the folders appear the same; from up close, they are different." # at bottom

data/spec/support/random.rb

@@ -0,0 +1,210 @@
+require 'fileutils'
+
+module IMWTest
+  module Random
+
+    STRING_CHARS        = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + [' ',' ',' ',' ',' ']
+    TEXT_CHARS          = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + [' ',' ',' ',' ',' ',"\n"]
+    FILENAME_CHARS      = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["-","_"]
+    FILENAME_MAX_LENGTH = 9
+    TEXT_MAX_LENGTH     = 1024
+    EXTENSIONS          = {
+      /\.csv$/      => :csv_file,
+      /\.xml$/      => :xml_file,
+      /\.html$/     => :html_file,
+      /\.tar$/      => :tar_file,
+      /\.tar\.gz$/  => :targz_file,
+      /\.tar\.bz2$/ => :tarbz2_file,
+      /\.rar$/      => :rar_file,
+      /\.zip$/      => :zip_file
+    }
+    EXTERNAL_PROGRAMS = if defined?(IMW) && defined?(IMW::EXTERNAL_PROGRAMS)
+                          IMW::EXTERNAL_PROGRAMS
+                        else
+                          {
+        :tar => "tar",
+        :rar => "rar",
+        :zip => "zip",
+        :unzip => "unzip",
+        :gzip => "gzip",
+        :bzip2 => "bzip2",
+        :wget => "wget"
+      }
+                        end
+
+    private
+    # 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.random }.join
+
+      # filenames beginning with hyphens suck
+      while (filename[0,1] == '-') do
+        filename[0] = FILENAME_CHARS.random
+      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.random }.join
+    end
+
+    public
+    # 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("#{EXTERNAL_PROGRAMS[: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("#{EXTERNAL_PROGRAMS[: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("#{EXTERNAL_PROGRAMS[:bzip2]} #{tar}")
+      FileUtils.cp(tarbz2,filename)
+      FileUtils.rm(tarbz2)
+    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("#{EXTERNAL_PROGRAMS[:rar]} a -r -o+ 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("#{EXTERNAL_PROGRAMS[:zip]} -r 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].random
+        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
+
+
+