vex 0.2

data/lib/vex/base/filesystem/grep.rb

@@ -0,0 +1,34 @@
+module File::Grep
+  def grep(rex, *files)
+    files = files.flatten
+    
+    unless block_given?
+      results = []
+      grep(rex, files) do |line, file, *args|
+        results << [ line, file ]
+      end
+      return results
+    end
+    
+    files.each do |file|
+      File.readlines(file).each do |line|
+        next unless matches = (rex.match(line))
+        yield line, file, matches 
+      end
+    end
+  end
+end
+
+File.extend File::Grep
+
+module File::Grep::Etest
+  def test_grep
+    assert_equal 4, File.grep(/Etest/, __FILE__).length
+    assert_equal 5, File.grep(/ETEST/i, __FILE__).length
+  end
+  
+  def test_greps
+    assert_equal 8, File.grep(/Etest/, [ __FILE__, __FILE__ ]).length
+    assert_equal 8, File.grep(/Etest/, __FILE__, __FILE__ ).length
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/filesystem/lock.rb

@@ -0,0 +1,43 @@
+module File::Lock
+  #
+  # File.locked implements recursive locking based on lock files. 
+  def locked(path, &block)
+    file = File.open "#{path}.lck", "w+"
+    begin
+      # First try to lock the file nonblockingly.
+      # Failing that it might be already locked by *this* process. 
+      # Otherwise it is locked by someone else.
+      if locked = file.flock(File::LOCK_EX | File::LOCK_NB)
+        File.write("#{path}.pid", Thread.uid)
+      elsif File.read("#{path}.pid") == Thread.uid
+        # already locked by us.
+      else
+        locked = file.flock(File::LOCK_EX)
+      end
+
+      yield
+    ensure
+      file.flock(File::LOCK_UN) if locked
+    end
+  end
+end
+
+File.extend File::Lock
+
+module File::Lock::Etest
+  TESTFILE = "#{__FILE__}.test"
+
+  def test_lock
+    i = 1
+    File.locked TESTFILE do
+      File.locked TESTFILE do
+        i = 2
+      end
+    end
+    
+    assert_equal(2, i)
+  end
+
+  def test_lock_unsuccessful
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/filesystem/lock.rb.test.pid

@@ -0,0 +1 @@
+7394.106710

data/lib/vex/base/filesystem/make_dirs.rb

@@ -0,0 +1,94 @@
+module Dir::MakeDirs
+  def exists?(path)
+    begin
+      Dir.open(path) && true
+    rescue Errno::ENOENT, Errno::ENOTDIR
+      false
+    end
+  end
+  
+  def mkdirs(path)
+    paths = path.split("/")
+    paths.each_with_index do |path, idx|
+      p = paths[0..idx].join("/")
+      next if p.empty?      # This is root
+      next if exists?(p)
+      mkdir(p)
+    end
+  end
+
+  def rmdirs(path)
+    Dir.glob("#{path}/**/*", File::FNM_DOTMATCH).sort.reverse.each do |file|
+      if File.directory?(file)
+        next if file =~ /\/\.\.?$/
+        Dir.rmdir(file)
+      else
+        File.unlink(file)
+      end
+    end
+
+    Dir.rmdir(path)
+  end
+
+  def tmp(do_unlink = true, &block)
+    path = "#{App.tmpdir}/#{$$}_#{Thread.current.object_id}"
+    Dir.mkdirs path
+    
+    r = yield(path)
+  ensure
+    Dir.rmdirs(path) if path && do_unlink
+  end
+end
+
+Dir.extend Dir::MakeDirs
+
+module Dir::MakeDirs::Etest
+  def test_mkdirs
+    base = File.dirname(__FILE__) + "/dirtest"
+    
+    assert !Dir.exists?(base)
+    Dir.mkdirs "#{base}/a/b/c"
+    Dir.mkdirs "#{base}/a/b/.dot"
+    assert Dir.exists?(base)
+    assert Dir.exists?("#{base}/a/b/c")
+
+    File.touch "#{base}/a/b/x.y"
+    File.touch "#{base}/a/b/.x.y"
+    File.touch "#{base}/a/b/..x.y"
+    File.touch "#{base}/a/b/.dot/a"
+
+    Dir.rmdirs("#{base}")
+    assert !Dir.exists?(base)
+    assert !Dir.exists?("#{base}/a/b/c")
+  end
+
+  def test_exists
+    assert Dir.exists?(File.dirname(__FILE__))
+    assert !Dir.exists?(__FILE__)
+    assert !Dir.exists?(__FILE__ + ".unknown")
+    assert !Dir.exists?(__FILE__ + ":invalid")
+  end
+
+  def test_tmpdir
+    p = nil
+    Dir.tmp do |pdir|
+      p = pdir
+    end
+    
+    assert p.starts_with?("#{App.tmpdir}/")
+    assert_file_doesnt_exist p
+  end
+
+  def test_tmpdir_unlinks_on_raise
+    p = nil
+    assert_raise(RuntimeError) {  
+      Dir.tmp do |pdir|
+        p = pdir
+        raise RuntimeError
+      end
+    }
+    
+    assert p.starts_with?("#{App.tmpdir}/")
+    assert_file_doesnt_exist p
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/filesystem/parse_filename.rb

@@ -0,0 +1,36 @@
+class File
+  def self.basename_wo_ext(s)
+    bn = File.basename(s)
+    if bn =~ /^(.*)\.([^.]*)$/
+      $1
+    else
+      bn
+    end
+  end
+
+  #
+  # File.extname_wo_dot("x.y") => "y"
+  # File.extname_wo_dot("x.") => ""
+  # File.extname_wo_dot(".y") => ""
+  # File.extname_wo_dot("x") => ""
+  #
+  def self.extname_wo_dot(s)
+    File.extname(s) =~ /^\.([^.]*)$/ ? $1 : ""
+  end
+end
+
+module File::Etest
+  def test_extname_wo_dot
+    assert_equal "y", File.extname_wo_dot("x.y")
+    assert_equal "", File.extname_wo_dot("x.")
+    assert_equal "", File.extname_wo_dot(".y")
+    assert_equal "", File.extname_wo_dot("x")
+  end
+
+  def test_basename_wo_ext
+    assert_equal "x", File.basename_wo_ext("x.y")
+    assert_equal "x", File.basename_wo_ext("x.")
+    assert_equal "", File.basename_wo_ext(".y")
+    assert_equal "x", File.basename_wo_ext("x")
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/filesystem/tmp_file.rb

@@ -0,0 +1,87 @@
+module FileUtils::TmpFile
+  def self.counter
+    Thread.current["tmpfiles"] ||= 0
+    Thread.current["tmpfiles"] += 1
+  end
+  
+  #
+  # tmpfile("xx.jpg") do |dest|
+  #   Net.download("http://xx.yy.zz/a.jpg", dest)
+  # end
+  #
+  # the block gets the temp file name, which is guaranteed to be
+  # unique amongst all running processes.
+  #
+  # If the path parameter is set the temporary file will be fastcopied 
+  # to that output file.
+  def tmpfile(path=nil, &block)
+    raise ArgumentError, "This no longer supports Symbol parameters" if path.is_a?(Symbol)
+    ext = "#{Thread.uid}_#{FileUtils::TmpFile.counter}"
+    
+    case path
+    when nil    
+      tmp = "#{App.tmpdir}/data.#{ext}"
+    else
+      Dir.mkdirs(File.dirname(path))
+      tmp = "#{path}.tmp#{ext}"
+    end
+    
+    begin
+      result = yield(tmp)
+      if result != false && path && File.exist?(tmp)
+        FileUtils.fast_copy(tmp, path)
+      end
+      return result
+    ensure
+      File.unlink(tmp) if File.exists?(tmp)
+    end
+  end
+end
+
+FileUtils.extend FileUtils::TmpFile
+
+module FileUtils::TmpFile::Etest
+  def test_tmpfile
+    assert File.exist?(__FILE__)
+
+    # so something successfully via a tmp file
+    FileUtils.fast_copy __FILE__, "tmp/copy.dat"
+    assert File.exist?("tmp/copy.dat")
+    
+    FileUtils.tmpfile "tmp/copy.dat" do |dest|
+      false
+    end
+
+    assert_equal File.size(__FILE__), File.size("tmp/copy.dat")
+
+    FileUtils.tmpfile "tmp/copy.dat" do |dest|
+      File.write(dest, "hey")
+    end
+
+    assert_equal 3, File.size("tmp/copy.dat")
+
+    FileUtils.fast_copy __FILE__, "tmp/copy.dat"
+    assert_equal File.size(__FILE__), File.size("tmp/copy.dat")
+
+    FileUtils.tmpfile "tmp/copy.dat" do |dest|
+      File.write(dest, "hey")
+      false
+    end
+    
+    assert_equal File.size(__FILE__), File.size("tmp/copy.dat")
+
+    FileUtils.tmpfile "tmp/copy.dat" do |dest|
+      File.write(dest, "hey")
+      nil
+    end
+
+    assert_equal 3, File.size("tmp/copy.dat")
+
+    r = FileUtils.tmpfile "tmp/copy.dat" do |dest|
+      File.write(dest, "hey")
+      "fourfour"
+    end
+
+    assert_equal "fourfour", r
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/filesystem/write.rb

@@ -0,0 +1,43 @@
+module File::Write
+  def touch(*files)
+    files.each do |file|
+      File.open(file, "w") do |f|
+      end
+    end
+  end
+
+  def write(path, data)
+    File.open(path, "w+") do |file|
+      file.write(data)
+    end
+    path
+  end
+end
+
+File.extend File::Write
+
+module File::Write::Etest
+  TESTFILE = "#{__FILE__}.test"
+  
+  def test_touches
+    assert !File.exist?(TESTFILE)
+    File.touch TESTFILE
+    assert File.exist?(TESTFILE)
+    File.touch TESTFILE
+    assert File.exist?(TESTFILE)
+    File.unlink TESTFILE
+    assert !File.exist?(TESTFILE)
+  end
+
+  def test_writes
+    assert !File.exist?(TESTFILE)
+    File.write TESTFILE, "blabber"
+    assert_equal("blabber", File.read(TESTFILE))
+    File.write TESTFILE, "bla"
+    assert_equal("bla", File.read(TESTFILE))
+    File.write TESTFILE, ""
+    assert_equal("", File.read(TESTFILE))
+    File.unlink TESTFILE
+    assert !File.exist?(TESTFILE)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/hash/compact.rb

@@ -0,0 +1,38 @@
+module Hash::Compact
+  def compact
+    dup.compact!
+  end
+
+  def compact!
+    empty = []
+    each { |k,v| empty << k if v.nil? }
+    empty.each do |k| delete(k) end
+    self
+  end
+end
+
+class Hash
+  include Compact
+end
+
+module Hash::Compact::Etest
+  def test_compact_no
+    h = { 1 => 2 }
+    assert_equal(h.compact, h)
+    assert_not_equal(h.compact.object_id, h.object_id)
+    assert_equal(h.compact!.object_id, h.object_id)
+    assert_equal(h.compact!, h.compact)
+  end
+
+  def test_compact
+    h = { 1 => nil }
+    assert_equal(h.compact, {})
+    h.compact!
+    assert_equal(h, {})
+  end
+
+  def test_compact_2
+    h = { nil => 1 }
+    assert_equal(h.compact, { nil => 1})
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/hash/cross.rb

@@ -0,0 +1,117 @@
+module Hash::Cross
+  # 
+  # { :a => [ 1, 2], :b => [ "bb", "cc"], :c => :cc }.cross =>
+  #
+  # [
+  #	{ :a => 1, :b => "bb", :c => :cc },
+  #	{ :a => 2, :b => "bb", :c => :cc },
+  #	{ :a => 1, :b => "cc", :c => :cc },
+  #	{ :a => 2, :b => "cc", :c => :cc }
+  # ]
+  #
+  def cross(*keys)
+    dup.send :do_cross, *keys
+  end
+
+  private
+  
+  def do_cross(*keys)
+    keys = self.keys if keys.empty?
+    keys = keys.select { |key| self[key].is_a?(Array) }
+
+    crossing = self.extract! *keys
+    
+    array = [ self ]
+    
+    keys.each do |key|
+      r = []
+
+      values = crossing[key]
+      array.each do |obj|
+        values.each do |value|
+          # Note: the following (instead of the obj.dup.update() results in a ~10% 
+          # faster cross implementation 
+          o = obj.dup   
+          o[key] = value
+          r << o
+        end
+      end
+      array = r
+    end
+
+    array
+  end
+end
+
+class Hash
+  include Cross
+end
+
+module Hash::Cross::Etest
+  def assert_equal_sets(a, b)
+    return assert_equal_sets(Set.new(a), b) unless a.is_a?(Set)
+    return assert_equal_sets(a, Set.new(b)) unless b.is_a?(Set)
+    
+    assert_equal(a, b)
+  end
+
+  def test_cross_1    
+    uncrossed = { :a => [ 1, 2], :b => [ "bb", "cc"], :c => :cc }
+    uncrossed_orig = uncrossed.dup
+
+    crossed = [
+      { :a => [1, 2], :b => "bb", :c => :cc },
+      { :a => [1, 2], :b => "cc", :c => :cc }
+    ]
+
+    assert_equal_sets(crossed, uncrossed.cross(:b))
+    assert_equal(uncrossed_orig, uncrossed)
+  end
+
+  def test_cross_2
+    uncrossed = { :a => [ 1, 2], :b => [ "bb", "cc"], :c => :cc }
+    uncrossed_orig = uncrossed.dup
+
+    crossed = [
+        { :a => 1, :b => "bb", :c => :cc },
+        { :a => 2, :b => "bb", :c => :cc },
+        { :a => 1, :b => "cc", :c => :cc },
+        { :a => 2, :b => "cc", :c => :cc }
+      ]
+
+    assert_equal_sets(crossed, uncrossed.cross)
+    assert_equal(uncrossed_orig, uncrossed)
+  end
+
+  def test_cross_2_w_order
+    uncrossed = { :a => [ 1, 2], :b => [ "bb", "cc"], :c => :cc }
+    uncrossed_orig = uncrossed.dup
+
+    crossed = [
+        { :a => 1, :b => "bb", :c => :cc },
+        { :a => 1, :b => "cc", :c => :cc },
+        { :a => 2, :b => "bb", :c => :cc },
+        { :a => 2, :b => "cc", :c => :cc }
+      ]
+
+    assert_equal(crossed, uncrossed.cross(:a, :b))
+    assert_equal(uncrossed_orig, uncrossed)
+  end
+
+  def test_cross_simple
+    uncrossed = { :a => :b }
+    assert_equal([{:a=>:b}], uncrossed.cross)
+
+    uncrossed = { :a => [ 1, :b ] }
+    assert_equal([{:a=>1}, {:a=>:b}], uncrossed.cross)
+  end
+
+  # def xtest_benchmark_1
+  #   benchmark do
+  #     5000.times do 
+  #       uncrossed = { :a => [ 1, 2], :b => [ "bb", "cc"], :c => :cc }
+  #       uncrossed.cross
+  #     end
+  #   end
+  # end
+end if VEX_TEST == "base"