vex 0.2

data/lib/vex/base/array/each_batch.rb

@@ -0,0 +1,32 @@
+module Array::EachBatch
+  def each_batch(batch_size = 1000, &block)
+    raise "Invalid parameter #{batch_size.inspect}, must be a Fixnum" unless batch_size.is_a?(Fixnum)
+
+    data = dup
+    begin
+      batch = data.slice!(0..(batch_size-1))
+      yield batch
+    end until data.empty?
+    self
+  end
+end
+
+Array.send :include, Array::EachBatch
+
+module Array::Cross::Etest
+  def test_each_batch
+    r = []
+    [1,2,3,4,5,6,7,8,9].each_batch 3 do |batch|
+      r << batch
+    end 
+    
+    assert_equal( [[1,2,3],[4,5,6],[7,8,9]], r)
+
+    r = []
+    [1,2,3,4,5,6,7].each_batch 3 do |batch|
+      r << batch
+    end 
+    
+    assert_equal( [[1,2,3],[4,5,6],[7]], r)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/array/parallel_map.rb

@@ -0,0 +1,98 @@
+require "timeout"
+
+#
+# a simple (really really simple) map-in-parallel multithreaded mapper.
+module Array::ParallelMap
+
+  def self.timeout(opts, &block)
+    return yield unless opts[:timeout]
+    begin
+      Timeout.timeout(opts[:timeout], &block)
+    rescue Timeout::Error
+    end
+  end
+
+  def peach_with_index(opts = {}, &block)
+    return [] if empty?
+    
+    threads = []
+    
+    each_with_index do |data, index|
+      threads << Thread.new {
+        Array::ParallelMap.timeout(opts) { yield(data, index) }
+      }
+    end
+    
+    threads.each do |thread| thread.join end
+    self
+  end
+
+  def peach(opts = {}, &block)
+    peach_with_index(opts) do |data, index|
+      yield(data)
+    end
+  end
+
+  def pmap(opts = {}, &block)
+    semaphore = Mutex.new
+    
+    results = []
+
+    peach_with_index(opts) do |data, index|
+      r = yield(data)
+      semaphore.synchronize { results[index] = r } 
+    end
+  
+    results
+  end
+end
+
+Array.send :include, Array::ParallelMap
+
+module Array::ParallelMap::Etest
+  MAX = 1000
+
+  def calculate(repeat, method)
+    (1..repeat).to_a.send(method) do |p| 
+      (1..MAX).inject(0) do |sum, i| 
+        sum + p * i 
+      end 
+    end
+  end
+  
+  def calculate_serial(repeat)
+    calculate(repeat, :map)
+  end
+
+  def calculate_parallel(repeat)
+    calculate(repeat, :pmap)
+  end
+  
+  def test_pmap
+    serial = calculate_serial(4)
+    parallel = calculate_parallel(4)
+    assert_equal(serial, parallel)
+  end
+
+  def test_peach
+    semaphore = Mutex.new
+    
+    results = []
+    
+    array = [ 1, 2, 3, 4]
+    r = array.peach do |p|
+      semaphore.synchronize { results << p }
+    end
+    assert_equal(array, results.sort)
+    assert_equal(array, r)
+  end
+
+  def test_pmap_timeout
+    r = [1, 2].pmap(:timeout => 0.1) do |p|
+      sleep 0.2
+      p * p
+    end
+    
+    assert_equal([], r)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/deprecation.rb

@@ -0,0 +1,41 @@
+#
+# short inspect method on all objects.
+#
+# "abcdefghijklmnopabcdefghijklmnopabcdefghijklmnopabcdefghijklmnop".insp
+#    -> "abcdefghijklmnopabcdefghijk..."
+# Model.find(1).insp 
+#    -> "<Model#1>"
+
+module Deprecation
+  def self.quiet
+    @quiet = true
+    yield
+  ensure
+    @quiet = false
+  end
+
+  def self.seen
+    @seen ||= {}
+  end
+  
+  def self.report(msg, instead=nil)
+    return if App.env == "production"
+    return if @quiet
+    return if seen[[msg, instead]]
+
+    seen[[msg, instead]] = true
+    
+    msg = "#{msg} is deprecated"
+    msg += "; use #{instead} instead" if instead
+    msg += ". From\n\t" + caller[1,4].join("\n\t")
+    STDERR.puts msg
+  end
+end
+
+module Deprecation::Etest
+  def test_report
+    STDERR.expects(:puts)
+    Deprecation.report "Hey"
+    Deprecation.report "Hey"
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/enumerable/deep.rb

@@ -0,0 +1,95 @@
+module Deep
+  KEYS = 0x01
+  VALUES = 0x02
+
+  #
+  # deep mapping
+  def self.map(o, mode, &block)
+    case o
+    when Hash
+      o.inject({}) do |hash, (k,v)|
+        k = yield(k) if (mode & KEYS) != 0
+        v = map(v, mode, &block)
+        hash.update k => v
+        hash
+      end
+    when Array
+      if mode & VALUES
+        o.map do |v|
+          map(v, mode, &block)
+        end
+      else
+        o.dup
+      end
+    else
+      if (mode & VALUES) != 0
+        yield o 
+      else
+        o
+      end
+    end
+  end
+
+  #
+  # deep reject
+  def self.reject(o, mode, &block)
+    case o
+    when Hash
+      o.inject({}) do |hash, (k,v)|
+        next hash if (mode & KEYS) && yield(k)
+        v = reject v, mode, &block
+        next hash if (mode & VALUES) && yield(v)
+        hash.update k => v
+        hash
+      end
+    when Array
+      if mode & VALUES
+        o.inject([]) do |r, v|
+          v = reject(v, mode, &block)
+          r << v unless yield(v)
+        end
+      else
+        o.dup
+      end
+    else
+      o
+    end
+  end
+end
+
+module Enumerable
+  KEYS = Deep::KEYS
+  VALUES = Deep::VALUES
+
+  def reject_blanks
+    Deep.reject(self, KEYS | VALUES) do |s|
+      s.blank?
+    end
+  end
+
+  def camelize
+    Deep.map(self, KEYS) do |s|
+      s.to_s.camelize
+    end
+  end
+end
+
+module Deep::Etest
+  def test_reject_blanks
+    h = { :a => "a", :b_c => { :d => nil, :video_test => "video_test "}, "x" => nil, "y" => [] }
+    expected = { :a=>"a", :b_c => { :video_test => "video_test " }}
+    assert_equal(expected, h.reject_blanks)
+  end
+
+  def test_camelized_keys
+    h = { :a => "a", :b_c => { :d => "dd", :video_test => "video_test "}}
+    expected = { "A"=>"a", "BC" => { "VideoTest" => "video_test ", "D" => "dd" }}
+    assert_equal(expected, h.camelize)
+  end
+
+  def test_missin_block
+    assert_raise(LocalJumpError) {
+      Deep.reject(%w(1 2), 3)
+    }
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/enumerable/enumerable_ext.rb

@@ -0,0 +1,59 @@
+module Enumerable
+  def any_not?(&block)
+    not all? { |e| yield(e) }
+  end
+  
+  def none?(&block)
+    not any? { |e| yield(e) }
+  end
+  
+  def stable_sort_by
+    # NOTE: if soort_by wouldn't enumerate the array members from
+    # the beginning this would fail.
+    i=0
+    sort_by { |x| [ yield(x), i+=1 ] } 
+  end
+
+  def hmap(&block)
+    inject({}) { |hash, obj| hash[obj] = yield(obj); hash }
+  end
+end
+
+module Enumerable::Etest
+  def test_stable_sort_by
+    data = [[1, 'b'], [1, 'c'], [0, 'b'], [0, 'a']]
+
+    # This might or might not fail, but is not guaranteed to do so: 
+    # assert_equal [[0, 'b'], [0, 'a'], [ 1, 'b'], [1, 'c']], data.stable_sort_by { |t| t[0] }
+    assert_equal [[0, 'b'], [0, 'a'], [ 1, 'b'], [1, 'c']], data.stable_sort_by { |t| t[0] }
+  end
+
+  def test_any_none(&block)
+    assert_equal(false, [ 1, 2, true, false ].any?(&:nil?))
+    assert_equal(true, [ 1, 2, true, false ].none?(&:nil?))
+    assert_equal(true, [ 1, 2, true, false, nil ].any?(&:nil?))
+    assert_equal(false, [ 1, 2, true, false, nil ].none?(&:nil?))
+
+    assert_equal(true, [ nil ].any?(&:nil?))
+    assert_equal(false, [ 1 ].any?(&:nil?))
+    assert_equal(false, [ ].any?(&:nil?))
+
+    assert_equal(false, [ nil ].none?(&:nil?))
+    assert_equal(true, [ 1 ].none?(&:nil?))
+    assert_equal(true, [ ].none?(&:nil?))
+  end
+
+  def test_any_not_all(&block)
+    assert_equal(true, [ 1, 2, true, false ].any_not?(&:nil?))
+    assert_equal(true, [ 1, 2, nil ].any_not?(&:nil?))
+    assert_equal(false, [ nil ].any_not?(&:nil?))
+    assert_equal(true, [ 1 ].any_not?(&:nil?))
+    assert_equal(false, [ ].any_not?(&:nil?))
+  end
+
+  def test_hmap
+    h = %w(1 2 3)
+
+    assert_equal({ "1" => 1, "2" => 4, "3" => 9}, h.hmap do |line| line.to_i * line.to_i end)
+  end
+end if VEX_TEST == "base"

data/lib/vex/base/enumerable/progress.rb

@@ -0,0 +1,71 @@
+module Enumerable
+  class Progress
+    def initialize(base, count=nil)
+      @base = base
+      @idx = 0
+      @count = count
+      @count ||= base.is_a?(Range) ? (base.max - base.min + 1) : length
+    end
+
+    def method_missing(sym, *args)
+      return @base.send(sym, *args) unless block_given?
+
+      r = @base.send sym, *args do |*args|
+        begin
+          yield *args
+        ensure
+          @idx += 1
+          on_progress(@idx, @count)
+        end
+      end
+    end
+  end
+  
+  class ConsoleProgress < Progress
+    def initialize(base, count=nil)
+      @start, @last = Time.now, nil
+      super
+    end
+    
+    private
+    
+    def print_line(s)
+      print s
+    end
+    
+    def on_progress(idx, count)
+      if idx == count
+        print_line("\r#{"%.1f%%" % 100}#{" " * 40}\n") 
+        return 
+      end
+      
+      now = Time.now
+      return if @last && now - @last <= 1
+      
+      @last = now
+      span = @last - @start
+      remaining = ((count * 1.0 / idx) - 1) * span
+
+      print_line "\r#{"%.1f%%" % ((100.0 * idx) / count)}\t#{"   %.1f secs remaining            " % remaining}"
+    end
+  end
+
+  class Progress
+    IMPLEMENTATIONS = {
+      :console => ConsoleProgress
+    }
+  end
+  
+  def with_progress(impl = :console)
+    Progress::IMPLEMENTATIONS[impl].new(self)
+  end
+end
+
+module Enumerable::Etest
+  def test_with_progress
+    Enumerable::ConsoleProgress.any_instance.stubs(:print_line).returns(nil)
+    
+    r = [ 1, 2 ].with_progress.map do |s| s * s end
+    assert_equal( [ 1, 4], r)
+  end
+end if VEX_TEST == "base"

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

@@ -0,0 +1,61 @@
+module FileUtils::FastCopy
+  # fast_copy a file: This hardlinks the source file to the destfile,
+  # if possible. src must refer to a file; dest must refer to a file
+  # or not exist at all.
+  def fast_copy(src, dest)
+    src_stat = File.stat(src)
+    invalid_argument!(src) unless src_stat.file?
+    
+    dest_stat = begin
+      File.stat(dest) 
+    rescue Errno::ENOENT
+    end
+    
+    invalid_argument!(dest) unless !dest_stat || dest_stat.file?
+    
+    dest_dev = dest_stat ? dest_stat.dev : begin
+      dest_dir = File.dirname(File.expand_path(dest))
+      File.stat(dest_dir).dev
+    end
+
+    if src_stat.dev == dest_dev
+      File.unlink(dest) if File.exists?(dest)
+      File.link src, dest
+    else
+      FileUtils.copy src, dest
+    end
+  end
+end
+
+FileUtils.extend FileUtils::FastCopy
+
+module FileUtils::FastCopy::Etest
+  def test_fast_copy
+    assert File.exist?(__FILE__)
+    File.unlink("tmp/somedata.dat") if File.exist?("tmp/somedata.dat")
+
+    assert !File.exist?("tmp/somedata.dat")
+    FileUtils.fast_copy __FILE__, "tmp/somedata.dat"
+    assert_equal File.read("tmp/somedata.dat"), File.read(__FILE__)
+
+    File.unlink("tmp/somedata.dat")
+    File.touch("tmp/somedata.dat")
+    assert_not_equal File.size("tmp/somedata.dat"), File.size(__FILE__)
+    FileUtils.fast_copy __FILE__, "tmp/somedata.dat"
+    assert_equal File.size("tmp/somedata.dat"), File.size(__FILE__)
+  end
+
+  def test_fast_copy_failures
+    assert_raise(Errno::ENOENT) {  
+      FileUtils.fast_copy "fixtures/somedata.dat.nonexisting", "tmp/somedata.dat"
+    }
+
+    assert_raise(Errno::ENOENT) {  
+      FileUtils.fast_copy "fixtures/somedata.dat.nonexisting", "tmp"
+    }
+
+    assert_raise(Errno::ENOENT) {  
+      FileUtils.fast_copy __FILE__, "tmp/nonexisting/dir"
+    }
+  end
+end if VEX_TEST == "base"