drip 0.0.1 → 0.0.2

data/sample/demo4book/query2.rb

@@ -0,0 +1,47 @@
+require 'rbtree'
+require 'nkf'
+
+class Query2
+  def initialize
+    @tree = RBTree.new
+  end
+  
+  def push(word, fname, lineno)
+    @tree[[word, fname, lineno]] = true
+  end
+
+  def fwd(w1, fname, lineno)
+    k, v = @tree.lower_bound([w1, fname, lineno])
+    return nil unless k
+    return nil unless k[0] == w1
+    k[1..2]
+  end
+
+  def query2(w1, w2)
+    f1 = fwd(w1, '', 0)
+    f2 = fwd(w2, '', 0)
+    while f1 && f2
+      cmp = f1 <=> f2
+      if cmp > 0
+        f2 = fwd(w2, *f1)
+      elsif cmp < 0
+        f1 = fwd(w1, *f2)
+      else
+        yield(f1)
+        f1 = fwd(w1, f1[0], f1[1] + 1)
+        f2 = fwd(w2, f2[0], f2[1] + 1)
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  q2 = Query2.new
+  while line = ARGF.gets
+    NKF.nkf('-w', line).scan(/\w+/) do |word|
+      q2.push(word, ARGF.filename, ARGF.lineno)
+    end
+  end
+  q2.query2('def', 'initialize') {|x| p x}
+end
+

data/sample/demo4book/query2_test.rb

@@ -0,0 +1,18 @@
+class Foo
+  # initialize foo
+  def initialize(name)
+    @foo = name
+  end
+
+  def foo; end
+  def baz; end
+end
+
+class Bar < Foo
+  # initialize bar and foo
+  def initialize(name)
+    super("bar #{name}")
+  end
+  def bar; end
+end
+

data/test/basic.rb

@@ -119,6 +119,11 @@ class TestDrip < Test::Unit::TestCase
     assert_raise(RuntimeError) {@drip.write_at(Time.at(6), 8)}
     assert_equal(@drip.write_after(Time.at(5), 8), 6000001)
   end
+  
+  def test_duplicate_tags
+    oid = @drip.write('dup', 'hello', 'hello', 'hello')
+    assert_equal(@drip[oid], ['dup', 'hello'])
+  end
 end
 
 class TestDripUsingStorage < TestDrip
@@ -153,4 +158,130 @@ class TestDripUsingStorage < TestDrip
     ary = drip.read(ary[2][0], 3)
     assert_equal(ary.size, 2)
   end
+
+  def ignore_test_huge
+    str = File.read(__FILE__)
+
+    10.times do 
+      1000.times do |n|
+        @drip.write(str, "n=#{n}")
+      end
+      @drip = Drip.new('test_db')
+    end
+
+    assert_equal(10000, @drip.read(0, 12000, 10000).size)
+  end
+end
+
+class TestImmutableDrip < Test::Unit::TestCase
+  def test_bsearch
+    im = Drip::ImmutableDrip.new
+
+    assert_equal(0, im.lower_boundary([], 'c'))
+    assert_equal(0, im.upper_boundary([], 'c'))
+
+    ary = %w(a b c c c d e f).collect {|x| [x]}
+
+    assert_equal(0, im.lower_boundary(ary, ''))
+    assert_equal(0, im.lower_boundary(ary, 'a'))
+    assert_equal(1, im.lower_boundary(ary, 'b'))
+    assert_equal(2, im.lower_boundary(ary, 'c'))
+    assert_equal(5, im.lower_boundary(ary, 'd'))
+    assert_equal(6, im.lower_boundary(ary, 'e'))
+    assert_equal(7, im.lower_boundary(ary, 'f'))
+    assert_equal(8, im.lower_boundary(ary, 'g'))
+
+    assert_equal(0, im.upper_boundary(ary, ''))
+    assert_equal(1, im.upper_boundary(ary, 'a'))
+    assert_equal(2, im.upper_boundary(ary, 'b'))
+    assert_equal(5, im.upper_boundary(ary, 'c'))
+    assert_equal(6, im.upper_boundary(ary, 'd'))
+    assert_equal(7, im.upper_boundary(ary, 'e'))
+    assert_equal(8, im.upper_boundary(ary, 'f'))
+    assert_equal(8, im.upper_boundary(ary, 'g'))
+  end
+
+  def add_to_gen(gen, key, value, *tag)
+    gen.add(key, [value, *tag], *tag)
+  end
+
+  def test_fetch_and_read_wo_tag
+    gen = Drip::ImmutableDrip::Generator.new
+    add_to_gen(gen, 21, 'a')
+    add_to_gen(gen, 99, 'd', 'tag')
+    add_to_gen(gen, 39, 'b')
+    add_to_gen(gen, 60, 'c', 'tag')
+
+    im = gen.generate
+
+    assert_equal(nil, im.fetch(20))
+    assert_equal(['a'], im.fetch(21))
+    assert_equal(nil, im.fetch(23))
+    assert_equal(['b'], im.fetch(39))
+    assert_equal(['d', 'tag'], im.fetch(99))
+    assert_equal(nil,  im.fetch(990))
+    
+    assert_equal([[21, 'a']], im.read(0))
+    assert_equal([[39, 'b']], im.read(21))
+    assert_equal([[60, 'c', 'tag']], im.read(39))
+    assert_equal([[99, 'd', 'tag']], im.read(60))
+    assert_equal([], im.read(99))
+    
+    assert_equal([[21, 'a'], [39, 'b']], im.read(0, 2))
+    assert_equal([[60, 'c', 'tag'], [99, 'd', 'tag']], im.read(39, 10))
+    
+    assert_equal([[99, 'd', 'tag']], im.head)
+    assert_equal([[60, 'c', 'tag'], [99, 'd', 'tag']], im.head(2))
+    assert_equal([[21, 'a'], [39, 'b'], [60, 'c', 'tag'], [99, 'd', 'tag']],
+                 im.head(10))
+    
+    assert_equal([99, 'd', 'tag'], im.older(nil))
+    assert_equal([60, 'c', 'tag'], im.older(99))
+    assert_equal([39, 'b'], im.older(60))
+    assert_equal([21, 'a'], im.older(39))
+    assert_equal(nil, im.older(21))
+    
+    assert_equal([21, 'a'], im.newer(0))
+    assert_equal([39, 'b'], im.newer(21))
+    assert_equal([60, 'c', 'tag'], im.newer(39))
+    assert_equal([99, 'd', 'tag'], im.newer(60))
+    assert_equal(nil, im.newer(99))
+  end
+
+  def test_read_w_tag
+    gen = Drip::ImmutableDrip::Generator.new
+    add_to_gen(gen, 21, 'a')
+    add_to_gen(gen, 39, 'b', 'b', 'tag')
+    add_to_gen(gen, 60, 'c', 'c', 'tag')
+    add_to_gen(gen, 99, 'd', 'tag', 'd')
+    add_to_gen(gen, 159, 'e', 'tag2', 'e')
+    im = gen.generate
+    
+    assert_equal([[99, 'd', 'tag', 'd']], im.head(1, 'tag'))
+    assert_equal([[99, 'd', 'tag', 'd']], im.head(1, 'd'))
+    assert_equal([[60, 'c', 'c', 'tag'], [99, 'd', 'tag', 'd']],
+                 im.head(2, 'tag'))
+    
+    assert_equal([[159, 'e', 'tag2', 'e']], im.read_tag(1, 'tag2'))
+    assert_equal([[99, 'd', 'tag', 'd']], im.read_tag(60, 'tag', 3))
+    assert_equal([[60, 'c', 'c', 'tag'], [99, 'd', 'tag', 'd']],
+                 im.read_tag(39, 'tag', 3))
+    assert_equal([[39, 'b', 'b', 'tag'],
+                  [60, 'c', 'c', 'tag'],
+                  [99, 'd', 'tag', 'd']],
+                 im.read_tag(21, 'tag', 5))
+    assert_equal([[39, 'b', 'b', 'tag'],
+                  [60, 'c', 'c', 'tag']],
+                  im.read_tag(21, 'tag', 2))
+    assert_equal([[39, 'b', 'b', 'tag'],
+                  [60, 'c', 'c', 'tag']],
+                  im.read_tag(38, 'tag', 2))
+    
+    assert_equal([99, 'd', 'tag', 'd'], im.older(nil, 'tag'))
+    assert_equal([60, 'c', 'c', 'tag'], im.older(99, 'tag'))
+    assert_equal(nil, im.older(21), 'tag')
+
+    assert_equal([60, 'c', 'c', 'tag'], im.newer(39, 'tag'))
+    assert_equal(nil, im.newer(99, 'tag'))
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: drip
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Masatoshi Seki
@@ -10,9 +10,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-04 00:00:00 Z
-dependencies: []
-
+date: 2011-11-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rbtree
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
 description: ""
 email: 
 executables: []
@@ -33,6 +43,12 @@ files:
 - lib/drip/version.rb
 - lib/my_drip.rb
 - sample/copocopo.rb
+- sample/demo4book/crawl.rb
+- sample/demo4book/demo_ui.rb
+- sample/demo4book/demo_ui_webrick.rb
+- sample/demo4book/index.rb
+- sample/demo4book/query2.rb
+- sample/demo4book/query2_test.rb
 - sample/drip_tw.rb
 - sample/gca.rb
 - sample/hello_tw.rb
@@ -63,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: drip
-rubygems_version: 1.8.5
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Simple RD-Stream for Rinda::TupleSpace lovers.