rufus-tokyo 1.0.3 → 1.0.4

data/spec/edo_table_spec.rb

@@ -0,0 +1,292 @@
+
+#
+# Specifying rufus-tokyo
+#
+# Mon Feb 23 11:11:10 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'spec_base')
+require File.join(File.dirname(__FILE__), 'shared_table_spec')
+
+begin
+  require 'rufus/edo'
+rescue LoadError
+end
+
+if defined?(TokyoCabinet)
+
+  FileUtils.mkdir('tmp') rescue nil
+
+
+  describe Rufus::Edo::Table do
+
+    it 'should open in write/create mode by default' do
+
+      t = Rufus::Edo::Table.new('tmp/default.tct')
+      t.close
+      File.exist?('tmp/default.tct').should.equal(true)
+      FileUtils.rm('tmp/default.tct')
+    end
+
+    it 'should raise an error when file is missing' do
+
+      lambda {
+        Rufus::Edo::Table.new('tmp/missing.tct', :mode => 'r')
+      }.should.raise(
+        Rufus::Edo::EdoError).message.should.equal('(err 3) file not found')
+    end
+  end
+  
+  describe Rufus::Edo::Table do
+
+    it 'should use open with a block will auto close the db correctly' do
+
+      res = Rufus::Edo::Table.open('tmp/spec_source.tct') do |table|
+        10.times { |i| table["key #{i}"] = {:val => i} }
+        table.size.should.equal(10)
+        :result
+      end
+
+      res.should.equal(:result)
+
+      table = Rufus::Edo::Table.new('tmp/spec_source.tct')
+      10.times do |i|
+        table["key #{i}"].should.equal({"val" => i.to_s})
+      end
+      table.close
+
+      FileUtils.rm('tmp/spec_source.tct')
+    end
+
+
+    it 'should use open without a block just like calling new correctly' do
+
+      table = Rufus::Edo::Table.open('tmp/spec_source.tct')
+      10.times { |i| table["key #{i}"] = {:val => i} }
+      table.size.should.equal(10)
+      table.close
+
+      table = Rufus::Edo::Table.new('tmp/spec_source.tct')
+      10.times do |i|
+        table["key #{i}"].should.equal({"val" => i.to_s})
+      end
+      table.close
+
+      FileUtils.rm('tmp/spec_source.tct')
+    end
+  end
+
+  describe Rufus::Edo::Table do
+
+    before do
+      @t = Rufus::Edo::Table.new('tmp/table.tct')
+      @t.clear
+    end
+    after do
+      @t.close
+    end
+
+    it 'should return its path' do
+
+      @t.path.should.equal('tmp/table.tct')
+    end
+
+    behaves_like 'table'
+  end
+
+  describe Rufus::Edo::Table do
+
+    before do
+      @t = Rufus::Edo::Table.new('tmp/table.tct')
+      @t.clear
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'table with transactions'
+  end
+
+  # DONE
+
+  describe 'Rufus::Edo::Table #keys' do
+
+    before do
+      @n = 50
+      @t = Rufus::Edo::Table.new('tmp/test_new.tct')
+      @t.clear
+      @n.times { |i| @t["person#{i}"] = { 'name' => 'whoever' } }
+      @n.times { |i| @t["animal#{i}"] = { 'name' => 'whichever' } }
+      @t["toto#{0.chr}5"] = { 'name' => 'toto' }
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'table #keys'
+  end
+
+
+  def prepare_table_with_data
+
+    t = Rufus::Edo::Table.new('tmp/test_new.tct')
+    t.clear
+    t['pk0'] = { 'name' => 'jim', 'age' => '25', 'lang' => 'ja,en' }
+    t['pk1'] = { 'name' => 'jeff', 'age' => '32', 'lang' => 'en,es' }
+    t['pk2'] = { 'name' => 'jack', 'age' => '44', 'lang' => 'en' }
+    t['pk3'] = { 'name' => 'jake', 'age' => '45', 'lang' => 'en,li' }
+    t
+  end
+
+  describe 'Rufus::Edo::Table' do
+
+    before do
+      @t = prepare_table_with_data
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'table indexes'
+  end
+
+  describe 'Rufus::Edo::Table#lget' do
+
+    before do
+      @t = prepare_table_with_data
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'table lget'
+  end
+
+  describe 'Rufus::Edo::Table, like a Ruby Hash,' do
+
+    before do
+      @t = prepare_table_with_data
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'table like a hash'
+  end
+
+  describe 'queries on Rufus::Edo::Table' do
+
+    before do
+      @t = prepare_table_with_data
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'table query'
+
+    #if TokyoCabinet::TDBQRY.public_instance_methods.collect { |e|
+    #  e.to_s }.include?('setlimit')
+
+    #  it 'can be limited and have an offset' do
+
+    #    @t.query { |q|
+    #      q.add 'lang', :includes, 'en'
+    #      q.order_by 'name', :desc
+    #      q.limit 2, 0
+    #    }.collect { |e| e['name'] }.should.equal(%w{ jim jeff })
+    #    @t.query { |q|
+    #      q.add 'lang', :includes, 'en'
+    #      q.order_by 'name', :desc
+    #      q.limit 2, 2
+    #    }.collect { |e| e['name'] }.should.equal(%w{ jake jack })
+    #  end
+    #end
+  end
+
+  describe 'Queries on Tokyo Tyrant tables (via Rufus::Edo)' do
+
+    before do
+      @t = Rufus::Edo::Table.new('tmp/test_new.tct')
+      @t.clear
+      [
+        "consul readableness choleric hopperdozer juckies",
+        "fume overharshness besprinkler whirling erythrene",
+        "trumper defiable detractively cattiness superioress",
+        "vivificative consul agglomerated Peterloo way",
+        "unkilned bituminate antimatrimonial uran polyphony",
+        "kurumaya unannexed renownedly apetaloid consul",
+        "overdare nescience seronegative nagster overfatten",
+      ].each_with_index { |w, i|
+        @t["pk#{i}"] = { 'name' => "lambda#{i}", 'words' => w }
+      }
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'table query (fts)'
+  end
+
+  describe 'Rufus::Tokyo::TableQuery#process' do
+
+    before do
+      @t = prepare_table_with_data
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'table query #process'
+  end
+
+  describe 'results from Rufus::Edo::Table queries' do
+
+    before do
+      @t = prepare_table_with_data
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'table query results'
+  end
+
+  describe Rufus::Edo::Table do
+
+    before do
+      @t = Rufus::Edo::Table.new('tmp/table.tct')
+      @t.clear
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'a table structure flattening keys and values'
+  end
+
+  describe 'Rufus::Edo::Table\'s queries' do
+
+    before do
+      @t = prepare_table_with_data
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'a table structure to_s-ing query stuff'
+  end
+
+  describe 'Rufus::Edo::Table and metasearch' do
+
+    before do
+      @t = prepare_table_with_data
+    end
+    after do
+      @t.close
+    end
+
+    behaves_like 'table query metasearch'
+  end
+end
+

data/spec/hmethods_spec.rb

@@ -0,0 +1,73 @@
+
+#
+# Specifying rufus-tokyo
+#
+# Sun Feb  8 14:15:31 JST 2009
+#
+
+require File.dirname(__FILE__) + '/spec_base'
+
+require 'rufus/tokyo/hmethods'
+
+
+class MyHash
+  include Rufus::Tokyo::HashMethods
+
+  def initialize
+    super
+    @default_proc = nil
+  end
+
+  def get (k)
+    k.to_i % 2 == 0 ? k : nil
+  end
+end
+
+describe 'an instance that include HashMethods' do
+
+  before do
+    @h = MyHash.new
+  end
+
+  it 'should be ready for testing' do # :(
+    @h[1].should.be.nil
+    @h[2].should.equal(2)
+  end
+
+  it 'should accept a default value' do
+    @h.default = :default
+    @h.default.should.equal(:default)
+  end
+end
+
+describe 'an instance that has a default proc' do
+
+  before do
+    @h = MyHash.new
+  end
+
+  it 'should accept a default_proc' do
+    @h.default_proc = lambda { |h, k| k * 2 }
+    @h[1].should.equal(2)
+    @h[2].should.equal(2)
+    @h[3].should.equal(6)
+  end
+
+  it 'should respond nil to #default(k) when no default proc' do
+    @h.default.should.be.nil
+    @h.default(2).should.be.nil
+  end
+
+  it 'should respond to #default(k) with the correct default' do
+    @h.default = 'cat'
+    @h.default.should.equal('cat')
+    @h.default(2).should.equal('cat')
+  end
+
+  it 'should respond to #default(k) with the correct default (2)' do
+    @h.default_proc = lambda { |h, k| k * 3 }
+    @h.default.should.be.nil
+    @h.default(2).should.equal(6)
+  end
+end
+

data/spec/incr.lua

@@ -0,0 +1,23 @@
+
+--
+-- Taken from http://tokyocabinet.sourceforge.net/tyrantdoc/#luaext
+--
+
+function incr (key, value)
+  value = tonumber(value)
+  if not value then
+    return nil
+  end
+  local old = tonumber(_get(key))
+  if old then
+    value = value + old
+  end
+  if not _put(key, value) then
+    return nil
+  end
+  return value
+end
+
+function hi()
+   return "Hi!"
+end

data/spec/openable_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/spec_base'
+
+require 'rufus/tokyo/openable'
+
+
+class MyOpenable
+  extend Rufus::Tokyo::Openable
+
+  def initialize(*args)
+    @args   = args
+    @closed = false
+  end
+  
+  attr_reader :args
+
+  def close
+    @closed = true
+  end
+  
+  def closed?
+    @closed
+  end
+end
+openable = lambda { |obj| obj.is_a? MyOpenable }
+
+describe 'an instance that extends Openable' do
+  it 'should pass all arguments from open() down to new()' do
+    MyOpenable.open(1).args.should.equal([1])
+    MyOpenable.open(1, 2).args.should.equal([1, 2])
+  end
+  
+  it 'should pass the constructed object into the block' do
+    MyOpenable.open { |o| o.should.be openable }
+  end
+  
+  it 'should return the last value in the block' do
+    MyOpenable.open { :value }.should.equal(:value)
+  end
+  
+  it 'should return the new object without a block' do
+    MyOpenable.open.should.be openable
+  end
+  
+  it 'should call close after running the block' do
+    MyOpenable.open { |db| db.should.not.be.closed; db }.should.be.closed
+  end
+  
+  it 'should not be closed when opened without a block' do
+    MyOpenable.open.should.not.be.closed
+  end
+end

data/spec/shared_abstract_spec.rb

@@ -0,0 +1,426 @@
+
+#
+# Specifying rufus-tokyo
+#
+# Fri Jul 17 15:37:16 JST 2009 #rubykaigi2009
+#
+
+shared 'an abstract structure' do
+
+  it 'should be empty initially' do
+
+    @db.size.should.equal(0)
+    @db['pillow'].should.be.nil
+  end
+
+  it 'should accept values' do
+
+    @db['pillow'] = 'Shonagon'
+    @db.size.should.equal(1)
+  end
+
+  it 'should restitute values' do
+
+    @db['pillow'] = 'Shonagon'
+    @db['pillow'].should.equal('Shonagon')
+  end
+
+  it 'should delete values' do
+
+    @db['pillow'] = 'Shonagon'
+    @db.delete('pillow').should.equal('Shonagon')
+    @db.size.should.equal(0)
+  end
+
+  it 'should accept and restitute \\0 strings' do
+
+    s = "toto#{0.chr}nada"
+    @db[s] = s
+    @db[s].should.equal(s)
+  end
+  
+  it 'should stringify keys and values' do
+    @db[123] = 456
+    @db["123".to_sym].should.equal("456")
+  end
+
+  it 'should reply to #keys and #values' do
+
+    keys = %w{ alpha bravo charly delta echo foxtrott }
+    keys.each_with_index { |k, i| @db[k] = i.to_s }
+    @db.keys.should.equal(keys)
+    @db.values.should.equal(%w{ 0 1 2 3 4 5 })
+  end
+
+  it 'should reply to #keys when there are keys containing \0' do
+
+    s = "toto#{0.chr}nada"
+    @db[s] = s
+    @db.keys.should.equal([ s ])
+  end
+
+  it 'should return a Ruby hash on merge' do
+
+    @db['a'] = 'A'
+
+    @db.merge({ 'b' => 'B', 'c' => 'C' }).should.equal(
+      { 'a' => 'A', 'b' => 'B', 'c' => 'C' })
+
+    @db['b'].should.be.nil
+
+    @db.size.should.equal(1)
+  end
+
+  it 'should have more values in case of merge!' do
+
+    @db['a'] = 'A'
+
+    @db.merge!({ 'b' => 'B', 'c' => 'C' })
+
+    @db.size.should.equal(3)
+    @db['b'].should.equal('B')
+  end
+end
+
+shared 'abstract structure #keys' do
+
+  it 'should return a Ruby Array by default' do
+
+    @db.keys.class.should.equal(::Array)
+  end
+
+  it 'should retrieve keys that contain \0' do
+
+    @db.keys.include?("toto#{0.chr}5").should.be.true
+  end
+
+  it 'should retrieve forward matching keys when key contains \0' do
+
+    @db.keys(:prefix => 'toto').should.equal([ "toto#{0.chr}5" ])
+  end
+
+  it 'should return a limited number of keys when :limit is set' do
+
+    @db.keys(:limit => 20).size.should.equal(20)
+  end
+
+  it 'should delete_keys_with_prefix' do
+
+    @db.delete_keys_with_prefix('animal')
+    @db.size.should.equal(@n + 1)
+    @db.keys(:prefix => 'animal').size.should.equal(0)
+  end
+
+  unless @db.class.name.match(/^Rufus::Edo/)
+
+    it 'should return a Cabinet List when :native => true' do
+
+      l = @db.keys(:native => true)
+      l.class.should.equal(Rufus::Tokyo::List)
+      l.size.should.equal(2 * @n + 1)
+      l.free
+    end
+
+    it 'should retrieve forward matching keys when :prefix => "prefix-"' do
+
+      @db.keys(:prefix => 'person').size.should.equal(@n)
+
+      l = @db.keys(:prefix => 'animal', :native => true)
+      l.size.should.equal(@n)
+      l.free
+    end
+  end
+end
+
+shared 'abstract structure with transactions' do
+
+  #before do
+  #  @db = Rufus::Tokyo::Cabinet.new('tmp/cabinet_spec.tch')
+  #  @db.clear
+  #end
+  #after do
+  #  @db.close
+  #end
+
+  it 'should correctly abort transactions' do
+
+    @db.transaction {
+      @db['pk0'] = 'value0'
+      @db.abort
+    }
+    @db.size.should.be.zero
+  end
+
+  it 'should rollback transactions with errors, and bubble exceptions' do
+
+    begin
+      @db.transaction {
+        @db['pk0'] = 'value0'
+        raise 'something goes wrong'
+      }
+    rescue RuntimeError
+    end
+    @db.size.should.be.zero
+  end
+
+  it 'should rollback transactions with Abort exceptions, and consume exceptions' do
+
+    @db.transaction {
+      @db['pk0'] = 'value0'
+      raise Rufus::Tokyo::Transactions::Abort
+    }
+    @db.size.should.be.zero
+  end
+
+  it 'should commit successful transactions' do
+
+    @db.transaction do
+      @db['pk0'] = 'showanojidaietaminamishima'
+    end
+    @db['pk0'].should.equal('showanojidaietaminamishima')
+  end
+
+  it 'should abort low level transactions' do
+
+    @db.tranbegin
+    @db['pk0'] = 'shikataganai'
+    @db.tranabort
+    @db.size.should.be.zero
+  end
+
+  it 'should commit low level transactions' do
+
+    @db.tranbegin
+    @db['pk0'] = 'shikataganai'
+    @db.trancommit
+    @db['pk0'].should.equal('shikataganai')
+  end
+end
+
+shared 'abstract structure #lget/lput/ldelete' do
+
+  it 'should get multiple values' do
+
+    @db.lget(%w{ 0 1 2 }).should.equal({"0"=>"val0", "1"=>"val1", "2"=>"val2"})
+    @db.mget(%w{ 0 1 2 }).should.equal({"0"=>"val0", "1"=>"val1", "2"=>"val2"})
+    @db.mget(*%w{ 0 1 2 }).should.equal({"0"=>"val0", "1"=>"val1", "2"=>"val2"})
+  end
+
+  it 'should put multiple values' do
+
+    @db.lput('3' => 'val3', '4' => 'val4')
+    @db.lget(%w{ 2 3 }).should.equal({"2"=>"val2", "3"=>"val3"})
+  end
+
+  it 'should delete multiple values' do
+
+    @db.ldelete(%w{ 2 3 })
+    @db.lget(%w{ 0 1 2 }).should.equal({"0"=>"val0", "1"=>"val1"})
+  end
+
+  it 'should delete multiple values' do
+
+    @db.ldelete(*%w{ 2 3 })
+    @db.lget(%w{ 0 1 2 }).should.equal({"0"=>"val0", "1"=>"val1"})
+  end
+end
+
+shared 'abstract structure #add{int|double}' do
+
+  it 'should increment (int)' do
+
+    @db.addint('counter', 1).should.equal(1)
+    @db.incr('counter', 1).should.equal(2)
+    @db.addint('counter', 2).should.equal(4)
+    @db.incr('counter').should.equal(5)
+
+    @db.counter_value('counter').should.equal(5)
+  end
+
+  it 'should fail gracefully if counter has already a [string] value (int)' do
+
+    @db['counter'] = 'a'
+
+    lambda { @db.addint('counter', 1) }.should.raise(
+      @db.class.name.match(/^Rufus::Edo/) ?
+        Rufus::Edo::EdoError : Rufus::Tokyo::TokyoError)
+
+    @db['counter'].should.equal('a')
+  end
+
+  it 'should increment (double)' do
+
+    @db.adddouble('counter', 1.0).should.equal(1.0)
+    @db.incr('counter', 1.5).should.equal(2.5)
+    @db.adddouble('counter', 2.2).should.equal(4.7)
+
+    @db.counter_value('counter').should.equal(4.7)
+  end
+
+  it 'should fail gracefully if counter has already a [string] value (double)' do
+
+    @db['counter'] = 'a'
+
+    lambda {
+      @db.adddouble('counter', 1.0)
+    }.should.raise(
+      @db.class.name.match(/^Rufus::Edo/) ?
+        Rufus::Edo::EdoError : Rufus::Tokyo::TokyoError)
+
+    @db['counter'].should.equal('a')
+  end
+end
+
+shared 'abstract structure #putkeep' do
+
+  it 'should accept values' do
+
+    @db.putkeep('pillow', 'Shonagon')
+    @db.size.should.equal(1)
+  end
+
+  it 'should restitute values' do
+
+    @db.putkeep('pillow', 'Shonagon')
+    @db['pillow'].should.equal('Shonagon')
+  end
+
+  it 'should not overwrite values if already set' do
+
+    @db['pillow'] = 'Shonagon'
+    @db['pillow'].should.equal('Shonagon')
+
+    @db.putkeep('pillow', 'Ruby')
+    @db['pillow'].should.equal('Shonagon')
+  end
+
+  it 'should return true if not yet set' do
+
+    @db.putkeep('pillow', 'Shonagon').should.equal(true)
+  end
+
+  it 'should return false if already set' do
+
+    @db['pillow'] = 'Shonagon'
+    @db.putkeep('pillow', 'Ruby').should.equal(false)
+  end
+
+  it 'should accept binary data \0' do
+
+    s = "Sei#{0.chr}Shonagon"
+
+    @db.putkeep(s, s).should.be.true
+    @db[s].should.equal(s)
+  end
+end
+
+shared 'abstract structure #putcat' do
+
+  it 'should append' do
+
+    @db['heian'] = 'Shonagon'
+    @db.putcat('heian', ', Shikibu')
+    @db.putcat('heian', ', Michitsuna')
+
+    @db['heian'].should.equal('Shonagon, Shikibu, Michitsuna')
+  end
+
+  it 'should create when not present' do
+
+    @db.putcat('regent', 'Fujiwara no Michinaga')
+
+    @db['regent'].should.equal('Fujiwara no Michinaga')
+  end
+end
+
+shared 'tyrant with embedded lua' do
+
+  it 'should call lua extensions' do
+
+    @db['toto'] = '0'
+    3.times { @db.ext(:incr, 'toto', '1') }
+    @db.ext('incr', 'toto', 2) # lax
+
+    @db['toto'].should.equal('5')
+  end
+
+  it 'should return nil when function is missing' do
+
+    @db.ext(:missing, 'nada', 'forever').should.equal(nil)
+  end
+end
+
+shared 'an abstract structure flattening keys and values' do
+
+  it 'should to_s keys and values when #[]=' do
+
+    @db[:hello] = :world
+    @db['hello'].should.equal('world')
+    @db[:hello].should.equal('world')
+    @db.size.should.equal(1)
+  end
+
+  it 'should to_s keys and values when #putkeep' do
+
+    @db.putkeep(:pillow, :shonagon)
+    @db[:pillow].should.equal('shonagon')
+    @db.size.should.equal(1)
+  end
+
+  it 'should to_s keys when #delete' do
+
+    @db['hello'] = 'world'
+    @db.delete(:hello).should.equal('world')
+    @db.size.should.equal(0)
+  end
+
+  it 'should to_s keys when #lget' do
+
+    writers = %w[ shikibu shonagon ]
+    writers.each { |s| @db[s] = s }
+    @db.lget(writers.collect { |w| w.to_sym }).keys.sort.should.equal(writers)
+  end
+
+  it 'should to_s keys when #ldelete' do
+
+    writers = %w[ shonagon shikibu ]
+    writers.each { |s| @db[s] = s }
+
+    @db.ldelete(writers.collect { |w| w.to_sym })
+
+    @db.size.should.equal(0)
+  end
+
+  it 'should to_s keys when #incr' do
+
+    @db.incr(:genji_count, 1).should.equal(1)
+    @db.incr(:genji_count, 1).should.equal(2)
+  end
+
+  it 'should to_s keys and values when #merge!' do
+
+    @db.merge!(:genji => 1, :to_no_chujo => 2)
+
+    @db['genji'].should.equal('1')
+    @db['to_no_chujo'].should.equal('2')
+  end
+end
+
+shared 'an abstract structure with a default value' do
+
+  it 'should restitute the default value' do
+
+    @db['known'].should.equal('Ulysse')
+    @db['unknown'].should.equal('Nemo')
+  end
+end
+
+shared 'an abstract structure with a default_proc' do
+
+  it 'should restitute the value computed by the default_proc' do
+
+    @db['known'].should.equal('Ulysse')
+    @db['unknown'].should.equal('default:unknown')
+  end
+end
+