rufus-tokyo 1.0.3 → 1.0.4

data/spec/cabinetconfig_spec.rb

@@ -0,0 +1,82 @@
+
+#
+# Specifying rufus-tokyo
+#
+# Sun Feb  8 16:01:51 JST 2009
+#
+
+require File.dirname(__FILE__) + '/spec_base'
+
+require 'rufus/tokyo'
+
+
+describe 'Rufus::Tokyo::CabinetConfig' do
+
+  before do
+    @c = Object.new
+    @c.extend(Rufus::Tokyo::CabinetConfig)
+    class << @c
+      public :determine_open_mode, :determine_conf
+    end
+  end
+
+  it 'should open with mode=cw by default' do
+
+    @c.determine_open_mode({ :mode => ''}).should.equal(6)
+    @c.determine_open_mode({ 'mode' => '' }).should.equal(6)
+  end
+
+  it 'should determine mode flags correctly' do
+
+    @c.determine_open_mode( :mode => 'e').should.equal(16)
+    @c.determine_open_mode( :mode => 're').should.equal(17)
+    @c.determine_open_mode( :mode => 'ce').should.equal(20)
+  end
+
+  it 'should separate path from params' do
+
+    @c.determine_conf(
+      'nada.tdb#mode=r', {}, '.tdb')[:path].should.equal('nada.tdb')
+  end
+
+  it 'should not accept suffixes else than .tdb' do
+
+    lambda {
+      @c.determine_conf('nada.tcx', {}, '.tdb').should.be.nil
+    }.should.raise(RuntimeError)
+
+    lambda {
+      @c.determine_conf('nada.tcx#mode=r', {}, '.tdb').should.be.nil
+    }.should.raise(RuntimeError)
+  end
+
+  it 'should grant write/create by default' do
+
+    @c.determine_conf('nada.tdb', {}, '.tdb')[:mode].should.equal(6)
+  end
+
+  it 'should respect :mutex' do
+
+    @c.determine_conf(
+      'nada.tdb#mutex=true', {}, '.tdb')[:mutex].should.equal(true)
+    @c.determine_conf(
+      'nada.tdb', { :mutex => true}, '.tdb')[:mutex].should.equal(true)
+  end
+
+  it 'should compute opts correctly' do
+
+    @c.determine_conf('nada.tdb', {}, '.tdb')[:opts].should.equal(0)
+    @c.determine_conf('nada.tdb#opts=ld', {}, '.tdb')[:opts].should.equal(3)
+    @c.determine_conf('nada.tdb', { :opts => 'ld' }, '.tdb')[:opts].should.equal(3)
+    @c.determine_conf('nada.tdb#opts=lb', {}, '.tdb')[:opts].should.equal(5)
+  end
+
+  it 'should accept :dfunit (TC 1.4.21)' do
+
+    @c.determine_conf('nada.tdb', {}, '.tdb')[:dfunit].should.equal(0)
+    @c.determine_conf('nada.tch#dfunit=8', {}, '.tch')[:dfunit].should.equal(8)
+    @c.determine_conf('nada.tct#dfunit=8', {}, '.tdb')[:dfunit].should.equal(8)
+  end
+
+end
+

data/spec/dystopia_core_spec.rb

@@ -0,0 +1,124 @@
+
+#
+# Specifying rufus-tokyo
+#
+require File.dirname(__FILE__) + '/spec_base'
+
+require 'rufus/tokyo/dystopia'
+
+FileUtils.mkdir('tmp') rescue nil
+
+describe Rufus::Tokyo::Dystopia::Core do
+  after do
+    FileUtils.rm_rf( 'tmp/dystopia' )
+  end
+  
+  it 'should use open with a block will auto close the db correctly' do
+    res = Rufus::Tokyo::Dystopia::Core.open('tmp/dystopia') do |index|
+      index.store( 1, "John Adams" )
+      index.store( 3, "George Washington" )
+      index.count.should.equal( 2 )
+      :result
+    end
+
+    res.should.equal(:result)
+
+    index = Rufus::Tokyo::Dystopia::Core.new('tmp/dystopia')
+    r = index.search( "John" )
+    r.size.should.equal( 1 )
+    r.should.equal( [ 1 ] )
+    index.close
+  end
+
+  it 'should use open without a block just like calling new correctly' do
+    index = Rufus::Tokyo::Dystopia::Core.open('tmp/dystopia')
+    index.store( 1, "John Adams" )
+    index.store( 3, "George Washington" )
+    index.count.should.equal( 2 )
+    index.close
+
+    index = Rufus::Tokyo::Dystopia::Core.new('tmp/dystopia')
+    r = index.search( "John" )
+    r.size.should.equal( 1 )
+    r.should.equal( [ 1 ] )
+    index.close
+  end
+end
+
+describe 'Rufus::Tokyo::Dystopia::Core' do
+  before do
+    @db = Rufus::Tokyo::Dystopia::Core.new( 'tmp/dystopia' )
+    @db.clear
+  end
+
+  after do
+    @db.close
+    FileUtils.rm_rf( 'tmp/dystopia' )
+  end
+
+  it 'creates a new directory when started' do
+    File.directory?( 'tmp/dystopia' ).should.equal( true )
+  end
+
+  it 'knows its own full path' do
+    p = @db.path
+    File.directory?( p ).should.equal( true )
+    p.should.equal( File.expand_path( "tmp/dystopia" ) )
+  end
+
+  it "knows its record count" do
+    @db.count.should.equal( 0 )
+    @db.store( 1, "John Adams" )
+    @db.count.should.equal( 1 )
+  end
+
+  it "knows how much drive space it takes up in bytes" do
+    b = @db.fsize
+    @db.store( 1, "John Adams" )
+    @db.store( 3, "George Washington" )
+    @db.fsize.should > b
+  end
+
+  it "can add records" do
+    @db.count.should.equal(0)
+    @db.store( 1, "John Adams" )
+    @db.store( 3, "George Washington" )
+    @db.count.should.equal( 2 )
+  end
+
+  it "can remove records" do
+    @db.count.should.equal(0)
+    @db.store( 1, "John Adams" )
+    @db.store( 3, "George Washington" )
+    @db.count.should.equal( 2 )
+    @db.delete( 3 )
+    @db.count.should.equal( 1 )
+  end
+
+  it "retrieves the whole record of items it has stored" do
+    @db.store( 1, "John Adams" )
+    @db.store( 3, "George Washington" )
+
+    @db.fetch( 3 ).should.equal( "George Washington" )
+    @db.fetch( 1 ).should.equal( "John Adams" )
+  end
+
+  it "returns nil when the fetched document does not exist" do
+    @db.store( 1, "John Adams" )
+    @db.count.should.equal( 1 )
+    @db.fetch( 3 ).should.be.nil
+  end
+
+  it "searches for text in the database" do
+    [ 'John Adams', 'George Washington', 'Thomas Jefferson' ].each_with_index do |e, idx|
+      @db.store( idx + 1, e )
+    end
+    r = @db.search( "on" )
+    r.size.should.equal( 2 )
+    r.sort.should.equal( [ 2, 3 ] )
+
+    r = @db.search( "John" )
+    r.size.should.equal( 1 )
+    r.should.equal( [ 1 ] )
+  end
+end

data/spec/edo_cabinet_btree_spec.rb

@@ -0,0 +1,123 @@
+
+#
+# Specifying rufus-tokyo
+#
+# Fri Aug 28 08:58:37 JST 2009
+#
+
+require File.dirname(__FILE__) + '/spec_base'
+
+begin
+  require 'rufus/edo'
+rescue LoadError
+  puts "'TokyoCabinet' ruby bindings not available on this ruby platform"
+end
+
+DB_FILE = "tmp/edo_cabinet_btree_spec.tcb"
+
+if defined?(TokyoCabinet)
+
+  FileUtils.mkdir('tmp') rescue nil
+
+
+  describe 'Rufus::Edo::Cabinet .tcb' do
+
+    before do
+      FileUtils.rm(DB_FILE) if File.exist? DB_FILE
+      @db = Rufus::Edo::Cabinet.new(DB_FILE)
+    end
+    after do
+      @db.close
+    end
+
+    it 'should accept duplicate values' do
+
+      @db.putdup('a', 'a0')
+      @db.putdup('a', 'a1')
+
+      @db.getdup('a').should.equal([ 'a0', 'a1' ])
+    end
+
+    it 'should be able to fetch keys for duplicate values' do
+      [ %w[John  Hornbeck],
+        %w[Tim   Gourley],
+        %w[Grant Schofield],
+        %w[James Gray],
+        %w[Dana  Gray] ].each do |first, last|
+        @db.putdup(last, first)
+      end
+      @db.keys.should.equal(%w[Gourley Gray Hornbeck Schofield])
+      @db.keys(:prefix => "G").should.equal(%w[Gourley Gray])
+    end
+  end
+
+  describe 'Rufus::Edo::Cabinet .tcb methods' do
+
+    it 'should fail on other structures' do
+
+      @db = Rufus::Edo::Cabinet.new(DB_FILE.sub(/\.tcb\z/, ".tch"))
+
+      lambda { @db.putdup('a', 'a0') }.should.raise(NoMethodError)
+
+      @db.close
+    end
+  end
+
+  describe 'Rufus::Edo::Cabinet .tcb order' do
+
+    before do
+      FileUtils.rm(DB_FILE) if File.exist? DB_FILE
+    end
+
+    it 'should default to a lexical order' do
+
+      db = Rufus::Edo::Cabinet.new(DB_FILE)
+      fields = [1, 2, 10, 11, 20, 21]
+      fields.each do |n|
+        db[n] = n
+      end
+      db.keys.should.equal(fields.map { |n| n.to_s }.sort)
+      db.close
+    end
+
+    it 'should allow an explicit :cmpfunc => :lexical' do
+
+      db = Rufus::Edo::Cabinet.new(DB_FILE, :cmpfunc => :lexical)
+      fields = [1, 2, 10, 11, 20, 21]
+      fields.each do |n|
+        db[n] = n
+      end
+      db.keys.should.equal(fields.map { |n| n.to_s }.sort)
+      db.close
+    end
+
+    it 'should allow a :cmpfunc => :decimal' do
+
+      db = Rufus::Edo::Cabinet.new(DB_FILE, :cmpfunc => :decimal)
+      fields = [1, 2, 10, 11, 20, 21]
+      fields.each do |n|
+        db[n] = n
+      end
+      db.keys.should.equal(fields.sort.map { |n| n.to_s })
+      db.close
+    end
+
+    it 'should allow a custom :cmpfunc as a Proc' do
+
+      db = Rufus::Edo::Cabinet.new(
+             DB_FILE,
+             :cmpfunc => lambda { |a, b| [a.size, a] <=> [b.size, b] }
+      )
+      db["one"]   = 1
+      db["two"]   = 2
+      db["three"] = 3
+      db["four"]  = 4
+      db["five"]  = 5
+      db.to_a.should.equal( [ %w[one 1],  %w[two 2],
+                              %w[five 5], %w[four 4],
+                              %w[three 3] ] )
+      db.close
+    end
+  end
+end
+

data/spec/edo_cabinet_fixed_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/spec_base'
+
+begin
+  require 'rufus/edo'
+rescue LoadError
+  puts "'TokyoCabinet' ruby bindings not available on this ruby platform"
+end
+
+if defined?(TokyoCabinet)
+
+  FileUtils.mkdir('tmp') rescue nil
+
+
+  describe 'Rufus::Edo::Cabinet .tcf' do
+
+    before do
+      @db = Rufus::Edo::Cabinet.new( 'tmp/edo_cabinet_fixed_spec.tcf',
+                                     :width => 4 )
+      @db.clear
+    end
+    after do
+      @db.close
+    end
+
+    it 'should support keys' do
+      @db[1] = "one"
+      @db[2] = "two"
+      @db[3] = "three"
+      @db[7] = "seven"
+      @db.keys.should.equal(%w[1 2 3 7])
+    end
+
+    it 'should accept a width at creation' do
+
+      @db[1] = "one"
+      @db[2] = "two"
+      @db[3] = "three"
+      @db.to_a.should.equal([%w[1 one], %w[2 two], %w[3 thre]])
+    end
+  end
+end
+

data/spec/edo_cabinet_spec.rb

@@ -0,0 +1,286 @@
+
+#
+# Specifying rufus-tokyo
+#
+# Sat Feb 21 22:16:23 JST 2009
+#
+
+require File.dirname(__FILE__) + '/spec_base'
+require File.dirname(__FILE__) + '/shared_abstract_spec'
+
+begin
+  require 'rufus/edo'
+rescue LoadError
+  puts "'TokyoCabinet' ruby bindings not available on this ruby platform"
+end
+
+if defined?(TokyoCabinet)
+
+  FileUtils.mkdir('tmp') rescue nil
+
+  describe 'a missing Rufus::Edo::Cabinet' do
+
+    it 'should raise an error' do
+
+      lambda {
+        Rufus::Edo::Cabinet.new('tmp/naidesuyo.tch', :mode => 'r')
+      }.should.raise(Rufus::Edo::EdoError).message.should.equal(
+        '(err 3) file not found')
+    end
+  end
+
+  describe Rufus::Edo::Cabinet do
+
+    before do
+      @db = Rufus::Edo::Cabinet.new('tmp/edo_cabinet_spec.tch')
+      @db.clear
+    end
+    after do
+      @db.close
+    end
+
+    behaves_like "an abstract structure"
+
+    it 'should return its path' do
+
+      @db.path.should.equal('tmp/edo_cabinet_spec.tch')
+    end
+
+    it 'should create its underlying file' do
+
+      File.exist?('tmp/cabinet_spec.tch').should.equal(true)
+    end
+  end
+
+  describe 'Rufus::Edo::Cabinet #keys' do
+
+    before do
+      @n = 50
+      @db = Rufus::Edo::Cabinet.new('tmp/cabinet_spec.tch')
+      @db.clear
+      @n.times { |i| @db["person#{i}"] = 'whoever' }
+      @n.times { |i| @db["animal#{i}"] = 'whichever' }
+      @db["toto#{0.chr}5"] = 'toto'
+    end
+    after do
+      @db.close
+    end
+
+    behaves_like 'abstract structure #keys'
+  end
+
+  describe Rufus::Edo::Cabinet do
+
+    before do
+      @db = Rufus::Edo::Cabinet.new('tmp/edo_cabinet_tran_spec.tch')
+      @db.clear
+    end
+    after do
+      @db.close
+    end
+
+    behaves_like 'abstract structure with transactions'
+  end
+
+  describe Rufus::Edo::Cabinet do
+
+    it 'should accept a default value' do
+
+      cab = Rufus::Edo::Cabinet.new(
+        'tmp/cabinet_spec_default.tch', :default => '@?!')
+      cab['a'] = 'A'
+      cab.size.should.equal(1)
+      cab['b'].should.equal('@?!')
+      cab.close
+    end
+
+    it 'should accept a default value (later)' do
+
+      cab = Rufus::Edo::Cabinet.new('tmp/cabinet_spec_default.tch')
+      cab.default = '@?!'
+      cab['a'] = 'A'
+      cab.size.should.equal(1)
+      cab['b'].should.equal('@?!')
+      cab.close
+    end
+  end
+
+  describe Rufus::Edo::Cabinet do
+
+    before do
+      @db = Rufus::Edo::Cabinet.new('tmp/edo_cabinet_spec.tch')
+      #@db = Rufus::Edo::Cabinet.new('tmp/edo_cabinet_spec.tch', :type => :abstract)
+      @db.clear
+      3.times { |i| @db[i.to_s] = "val#{i}" }
+    end
+    after do
+      @db.close
+    end
+
+    behaves_like 'abstract structure #lget/lput/ldelete'
+  end
+
+  describe Rufus::Edo::Cabinet do
+
+    before do
+      @db = Rufus::Edo::Cabinet.new('tmp/cabinet_spec.tch')
+      @db.clear
+    end
+    after do
+      @db.close
+    end
+
+    behaves_like 'abstract structure #add{int|double}'
+  end
+
+  describe Rufus::Edo::Cabinet do
+
+    before do
+      @db = Rufus::Edo::Cabinet.new('tmp/cabinet_spec.tch')
+      @db.clear
+    end
+    after do
+      @db.close
+    end
+
+    behaves_like 'abstract structure #putkeep'
+    behaves_like 'abstract structure #putcat'
+  end
+
+  describe Rufus::Edo::Cabinet do
+
+    it 'should copy correctly' do
+
+      cab = Rufus::Edo::Cabinet.new('tmp/spec_source.tch')
+      5000.times { |i| cab["key #{i}"] = "val #{i}" }
+      cab.size.should.equal(5000)
+      cab.copy('tmp/spec_target.tch')
+      cab.close
+
+      cab = Rufus::Edo::Cabinet.new('tmp/spec_target.tch')
+      cab.size.should.equal(5000)
+      cab['key 4999'].should.equal('val 4999')
+      cab.close
+
+      FileUtils.rm('tmp/spec_source.tch')
+      FileUtils.rm('tmp/spec_target.tch')
+    end
+
+    it 'should copy compactly' do
+
+      cab = Rufus::Edo::Cabinet.new('tmp/spec_source.tch')
+      100.times { |i| cab["key #{i}"] = "val #{i}" }
+      50.times { |i| cab.delete("key #{i}") }
+      cab.size.should.equal(50)
+      cab.compact_copy('tmp/spec_target.tch')
+      cab.close
+
+      cab = Rufus::Edo::Cabinet.new('tmp/spec_target.tch')
+      cab.size.should.equal(50)
+      cab['key 99'].should.equal('val 99')
+      cab.close
+
+      fs0 = File.size('tmp/spec_source.tch')
+      fs1 = File.size('tmp/spec_target.tch')
+      (fs0 > fs1).should.equal(true)
+
+      FileUtils.rm('tmp/spec_source.tch')
+      FileUtils.rm('tmp/spec_target.tch')
+    end
+
+
+    it 'should use open with a block will auto close the db correctly' do
+
+      res = Rufus::Edo::Cabinet.open('tmp/spec_source.tch') do |cab|
+        10.times { |i| cab["key #{i}"] = "val #{i}" }
+        cab.size.should.equal(10)
+        :result
+      end
+
+      res.should.equal(:result)
+
+      cab = Rufus::Edo::Cabinet.new('tmp/spec_source.tch')
+      10.times do |i|
+        cab["key #{i}"].should.equal("val #{i}")
+      end
+      cab.close
+
+      FileUtils.rm('tmp/spec_source.tch')
+    end
+
+
+    it 'should use open without a block just like calling new correctly' do
+
+      cab = Rufus::Edo::Cabinet.open('tmp/spec_source.tch')
+      10.times { |i| cab["key #{i}"] = "val #{i}" }
+      cab.size.should.equal(10)
+      cab.close
+
+      cab = Rufus::Edo::Cabinet.new('tmp/spec_source.tch')
+      10.times do |i|
+        cab["key #{i}"].should.equal("val #{i}")
+      end
+      cab.close
+
+      FileUtils.rm('tmp/spec_source.tch')
+    end
+
+    it 'should honour the :type parameter' do
+
+      cab = Rufus::Edo::Cabinet.open('tmp/toto.tch')
+      cab.clear
+      cab['hello'] = 'world'
+      cab.close
+
+      cab = Rufus::Edo::Cabinet.open('tmp/toto', :type => :hash)
+      cab['hello'].should.equal('world')
+      cab.close
+
+      FileUtils.rm('tmp/toto.tch')
+    end
+  end
+
+  describe Rufus::Edo::Cabinet do
+
+    before do
+      @db = Rufus::Edo::Cabinet.new('tmp/edo_cabinet_spec.tch')
+      @db.clear
+    end
+    after do
+      @db.close
+    end
+
+    behaves_like 'an abstract structure flattening keys and values'
+  end
+
+  describe 'Rufus::Edo::Cabinet with a default value' do
+
+    before do
+      @db = Rufus::Edo::Cabinet.new('tmp/cabinet_spec.tch', :default => 'Nemo')
+      @db.clear
+      @db['known'] = 'Ulysse'
+    end
+    after do
+      @db.close
+    end
+
+    behaves_like 'an abstract structure with a default value'
+  end
+
+  describe 'Rufus::Edo::Cabinet with a default_proc' do
+
+    before do
+      @db = Rufus::Edo::Cabinet.new(
+        'tmp/cabinet_spec.tch',
+        :default_proc => lambda { |db, k| "default:#{k}" })
+      @db.clear
+      @db['known'] = 'Ulysse'
+    end
+    after do
+      @db.close
+    end
+
+    behaves_like 'an abstract structure with a default_proc'
+  end
+end
+