rufus-tokyo 0.1.2 → 0.1.3

data/lib/rufus/tokyo/hmethods.rb

@@ -0,0 +1,109 @@
+#
+#--
+# Copyright (c) 2009, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#++
+#
+
+#
+# "made in Japan"
+#
+# jmettraux@gmail.com
+#
+
+
+module Rufus
+module Tokyo
+
+  #
+  # A mixin for Cabinet and Map, gathers all the hash-like methods
+  #
+  module HashMethods
+
+    #
+    # The [] methods
+    #
+    # (assumes there's an underlying get(k) method)
+    #
+    def [] (k)
+      val = get(k)
+      return val unless val.nil?
+      return nil unless @default_proc
+      @default_proc.call(self, k)
+    end
+
+    #
+    # Returns an array of all the values
+    #
+    def values
+      collect { |k, v| v }
+    end
+
+    #
+    # Our classical 'each'
+    #
+    def each
+      keys.each { |k| yield(k, self[k]) }
+    end
+
+    #
+    # Turns this instance into a Ruby hash
+    #
+    def to_h
+      self.inject({}) { |h, (k, v)| h[k] = v; h }
+    end
+
+    #
+    # Turns this instance into an array of [ key, value ]
+    #
+    def to_a
+      self.collect { |e| e }
+    end
+
+    #
+    # Returns a new Ruby hash which is a merge of this Map and the given hash
+    #
+    def merge (h)
+      self.to_h.merge(h)
+    end
+
+    #
+    # Merges the entries in the given hash into this map
+    #
+    def merge! (h)
+      h.each { |k, v| self[k] = v }
+      self
+    end
+
+    def default (key=nil)
+      val = self[key]
+      val.nil? ? @default_proc.call(self, key) : val
+    end
+
+    def default= (val)
+      @default_proc = lambda { |h, k| val }
+    end
+
+    attr_reader :default_proc
+  end
+
+end
+end
+

data/test/{cabinet_0_test.rb → cabinet/abstract_0_test.rb}

@@ -5,11 +5,9 @@
 # Fri Jan 23 08:31:01 JST 2009
 #
 
-require File.dirname(__FILE__) + '/test_base'
+require File.dirname(__FILE__) + '/../test_base'
 
-require 'test/unit'
-
-require 'rufus/tokyo'
+require 'rufus/tokyo/cabinet'
 
 
 class CabinetZero < Test::Unit::TestCase
@@ -25,11 +23,6 @@ class CabinetZero < Test::Unit::TestCase
     @db
   end
 
-  def test_lib
-
-    assert_not_nil Rufus::Tokyo.lib
-  end
-
   def test_basic_workflow
 
     db['pillow'] = 'Shonagon'
@@ -43,18 +36,16 @@ class CabinetZero < Test::Unit::TestCase
 
   def test_clear
 
-    db = Rufus::Tokyo::Cabinet.new('test_data.tch')
-    db.clear
-
     40.times { |i| db[i.to_s] = i.to_s }
     assert_equal 40, db.size
+
+    db.clear
+
+    assert_equal 0, db.size
   end
 
   def test_keys_and_values
 
-    db = Rufus::Tokyo::Cabinet.new('test_data.tch')
-    db.clear
-
     keys = %w{ alpha bravo charly delta echo foxtrott }
 
     keys.each_with_index { |k, i| db[k] = i.to_s }
@@ -63,5 +54,22 @@ class CabinetZero < Test::Unit::TestCase
     assert_equal %w{ 0 1 2 3 4 5 }, db.values
   end
 
+  def test_merge
+
+    db['a'] = 'A'
+
+    assert_equal(
+      { 'a' => 'A', 'b' => 'B', 'c' => 'C' },
+      db.merge({ 'b' => 'B', 'c' => 'C' }))
+
+    assert_equal 1, db.size
+
+    db.merge!({ 'b' => 'B', 'c' => 'C' })
+
+    assert_equal(3, db.size)
+
+    assert_equal({ 'a' => 'A', 'b' => 'B', 'c' => 'C' }, db.to_h)
+  end
+
 end
 

data/test/cabinet/abstract_1_test.rb

@@ -0,0 +1,69 @@
+
+#
+# Testing rufus-tokyo
+#
+# Sun Jan 25 12:26:48 JST 2009
+#
+
+require File.dirname(__FILE__) + '/../test_base'
+
+require 'fileutils'
+require 'rufus/tokyo/cabinet'
+
+
+class CabinetOne < Test::Unit::TestCase
+
+  def test_copy
+
+    cab = Rufus::Tokyo::Cabinet.new('test_source.tch')
+    5000.times { |i| cab["key #{i}"] = "val #{i}" }
+    2500.times { |i| cab.delete("key #{i}") }
+    assert_equal 2500, cab.size
+    cab.copy('test_target.tch')
+    cab.close
+
+    cab = Rufus::Tokyo::Cabinet.new('test_target.tch')
+    assert_equal 2500, cab.size
+    cab.close
+
+    FileUtils.rm('test_source.tch')
+    FileUtils.rm('test_target.tch')
+  end
+
+  def test_compact_copy
+
+    cab = Rufus::Tokyo::Cabinet.new('test_source.tch')
+    100.times { |i| cab["key #{i}"] = "val #{i}" }
+    50.times { |i| cab.delete("key #{i}") }
+    assert_equal 50, cab.size
+    cab.compact_copy('test_target.tch')
+    cab.close
+
+    cab = Rufus::Tokyo::Cabinet.new('test_target.tch')
+    assert_equal 50, cab.size
+    cab.close
+
+    fs0 = File.size('test_source.tch')
+    fs1 = File.size('test_target.tch')
+    assert (fs0 > fs1)
+
+    FileUtils.rm('test_source.tch')
+    FileUtils.rm('test_target.tch')
+  end
+
+  def test_default
+
+    db = Rufus::Tokyo::Cabinet.new('test_data.tch', :default => 'wrong')
+    db.clear
+
+    db['a'] = 'A'
+
+    assert_equal 'A', db['a']
+    assert_equal 'wrong', db['b']
+
+    assert_equal 1, db.size
+
+    db.close
+  end
+end
+

data/test/cabinet/api_0_test.rb

@@ -0,0 +1,26 @@
+
+#
+# Testing rufus-tokyo
+#
+# Mon Jan 26 15:10:03 JST 2009
+#
+
+require File.dirname(__FILE__) + '/../test_base'
+
+require 'rufus/tokyo/base'
+
+
+class ApiZero < Test::Unit::TestCase
+
+  def test_compute_open_mode
+
+    o = Object.new
+    o.extend(Rufus::Tokyo::TokyoContainerMixin)
+
+    assert_equal 0, o.compute_open_mode({})
+    assert_equal 16, o.compute_open_mode(:no_lock => true)
+    assert_equal 17, o.compute_open_mode([:no_lock, :reader])
+    assert_equal 20, o.compute_open_mode([:no_lock, :create])
+  end
+end
+

data/test/cabinet/hmethods_test.rb

@@ -0,0 +1,52 @@
+
+#
+# Testing rufus-tokyo
+#
+# Thu Jan 29 11:19:25 JST 2009
+#
+
+require File.dirname(__FILE__) + '/../test_base'
+
+require 'rufus/tokyo/hmethods'
+
+
+class HmethodsTest < Test::Unit::TestCase
+
+  class MyHash
+    attr_accessor :default_proc
+    def get (k)
+      k.to_i % 2 == 0 ? k : nil
+    end
+  end
+
+  def setup
+    @h = MyHash.new
+    @h.extend(Rufus::Tokyo::HashMethods)
+  end
+
+  def test_myhash
+
+    assert_equal nil, @h[1]
+    assert_equal 2, @h[2]
+  end
+
+  def test_default
+
+    @h.default = :default
+
+    assert_equal :default, @h.default
+
+    assert_equal :default, @h[1]
+    assert_equal 2, @h[2]
+  end
+
+  def test_default_proc
+
+    @h.default_proc = lambda { |h, k| k * 2 }
+
+    assert_equal 2, @h[1]
+    assert_equal 2, @h[2]
+    assert_equal 6, @h[3]
+  end
+end
+

data/test/cabinet/table_0_test.rb

@@ -0,0 +1,63 @@
+
+#
+# Testing rufus-tokyo
+#
+# Mon Jan 26 15:10:03 JST 2009
+#
+
+require File.dirname(__FILE__) + '/../test_base'
+
+require 'rufus/tokyo/cabinet/table'
+
+
+class TableZero < Test::Unit::TestCase
+
+  def test_open_missing
+
+    e = assert_raises Rufus::Tokyo::TokyoError do
+      Rufus::Tokyo::Table.new('missing.tdb')
+    end
+
+    assert_equal '(err 3) file not found', e.message
+  end
+
+  def test_tabbed_put
+
+    t = Rufus::Tokyo::Table.new('test_new.tdb', :create, :write)
+    t.clear
+
+    assert_equal 0, t.size
+
+    assert t.genuid > 0, 'unique id is 0, bad'
+    assert t.generate_unique_id > 0, 'unique id is 0, bad'
+
+    t.tabbed_put('toto', 'name', 'toto', 'age', '3')
+    t.tabbed_put('fred', 'name', 'fred', 'age', '4')
+
+    assert_equal 2, t.size
+
+    t.close
+  end
+
+  def test_put
+
+    t = Rufus::Tokyo::Table.new('test_new.tdb', :create, :write)
+    t.clear
+
+    t['pk0'] = [ 'name', 'alfred', 'age', '22']
+    t['pk1'] = { 'name' => 'jim', 'age' => '23' }
+
+    assert_equal 2, t.size
+
+    assert_equal({ 'name' => 'jim', 'age' => '23' }, t['pk1'])
+
+    t.delete('pk0')
+
+    assert_equal 1, t.size
+
+    assert_nil t['pk0']
+
+    t.close
+  end
+end
+

data/test/cabinet/table_1_test.rb

@@ -0,0 +1,153 @@
+
+#
+# Testing rufus-tokyo
+#
+# Mon Jan 26 15:10:03 JST 2009
+#
+
+require File.dirname(__FILE__) + '/../test_base'
+
+require 'rufus/tokyo/cabinet/table'
+
+
+class TableOne < Test::Unit::TestCase
+
+  def setup
+    @tdb = Rufus::Tokyo::Table.new('test_new.tdb', :create, :write)
+    @tdb.clear
+    @tdb['pk0'] = { 'name' => 'jim', 'age' => '25', 'lang' => 'ja,en' }
+    @tdb['pk1'] = { 'name' => 'jeff', 'age' => '32', 'lang' => 'en,es' }
+    @tdb['pk2'] = { 'name' => 'jack', 'age' => '44', 'lang' => 'en' }
+    @tdb['pk3'] = { 'name' => 'jake', 'age' => '45', 'lang' => 'en,li' }
+  end
+
+  def teardown
+    @tdb.close
+  end
+
+  def test_prepare_query
+
+    q = @tdb.prepare_query { |q|
+      q.add 'lang', :includes, 'en'
+    }
+    rs = q.run
+
+    assert_equal 4, rs.size
+
+    rs.close
+
+    q.limit 2
+
+    rs = q.run
+
+    assert_equal 2, rs.size
+
+    q.close
+  end
+
+  def test_limit
+
+    rs = @tdb.do_query { |q|
+      q.add 'lang', :includes, 'en'
+      q.order_by 'name', :desc
+      q.limit 2 # set_max
+    }
+
+    assert_equal 2, rs.size
+
+    assert_equal(
+      [
+        {:pk => 'pk0', "name"=>"jim", "lang"=>"ja,en", "age"=>"25"},
+        {:pk => 'pk1', "name"=>"jeff", "lang"=>"en,es", "age"=>"32"}
+      ],
+      rs.to_a)
+
+    rs.free
+  end
+
+  def test_order_strasc
+
+    assert_equal(
+      [
+        {:pk => 'pk2', "name"=>"jack", "lang"=>"en", "age"=>"44"},
+        {:pk => 'pk3', "name"=>"jake", "lang"=>"en,li", "age"=>"45"},
+        {:pk => 'pk1', "name"=>"jeff", "lang"=>"en,es", "age"=>"32"},
+        {:pk => 'pk0', "name"=>"jim", "lang"=>"ja,en", "age"=>"25"}
+      ],
+      @tdb.query { |q|
+        q.add 'lang', :includes, 'en'
+        q.order_by 'name', :asc
+      })
+  end
+
+  def test_order_numasc
+
+    assert_equal(
+      [
+        {:pk => 'pk0', "name"=>"jim", "lang"=>"ja,en", "age"=>"25"},
+        {:pk => 'pk1', "name"=>"jeff", "lang"=>"en,es", "age"=>"32"},
+        {:pk => 'pk2', "name"=>"jack", "lang"=>"en", "age"=>"44"},
+        {:pk => 'pk3', "name"=>"jake", "lang"=>"en,li", "age"=>"45"}
+      ],
+      a = @tdb.query { |q|
+        q.add 'lang', :includes, 'en'
+        q.order_by 'age', :numasc
+      })
+  end
+
+  def test_matches
+
+    assert_equal(
+      [
+        {:pk => 'pk2', "name"=>"jack", "lang"=>"en", "age"=>"44"},
+        {:pk => 'pk3', "name"=>"jake", "lang"=>"en,li", "age"=>"45"}
+      ],
+      a = @tdb.query { |q|
+        q.add 'name', :matches, '^j.+k'
+      })
+  end
+
+  def test_no_pk
+
+    assert_equal(
+      [
+        {"name"=>"jack", "lang"=>"en", "age"=>"44"},
+        {"name"=>"jake", "lang"=>"en,li", "age"=>"45"}
+      ],
+      a = @tdb.query { |q|
+        q.add 'name', :matches, '^j.+k'
+        q.no_pk
+      })
+  end
+
+  def test_pk_only
+
+    assert_equal(
+      [ 'pk2', 'pk3' ],
+      a = @tdb.query { |q|
+        q.add 'name', :matches, '^j.+k'
+        q.pk_only
+      })
+  end
+
+  def test_condition_numerical_gt
+
+    assert_equal(
+      [ 'pk2', 'pk3' ],
+      a = @tdb.query { |q|
+        q.add 'age', :gt, '40'
+        q.pk_only
+      })
+  end
+
+  def test_condition_negate
+
+    assert_equal(
+      [ 'pk0', 'pk1' ],
+      a = @tdb.query { |q|
+        q.add 'age', :gt, '40', false
+        q.pk_only
+      })
+  end
+end
+