drip 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 029a7c4fb43e4852aca41b6f1a2ba481062cec47
+  data.tar.gz: d1c6ca3d3291e2cf73171e345125bfb11e06b8dc
+SHA512:
+  metadata.gz: 4c0c2bf53465abe23f7b56b51172d0a107477882f037ecb2dddc75bd18d1f94e34797983fd51bf3b99495175b464fb6699f924f15955b7a5645d83e3780071ef
+  data.tar.gz: 9e057c27351793c8f95efc022c64baa52faca161cfec6048dca62c37f14ad574ffcd722497a6afad4b89e05f4b19fb92980357048506c613a4c7e4213d559aba

data/lib/drip.rb

@@ -5,135 +5,16 @@ require 'enumerator'
 
 class Drip
   include DRbUndumped
-  def inspect; to_s; end
-
-  class ImmutableDrip
-    class Generator
-      def initialize
-        @pool = []
-        @tag = []
-        @shared = Hash.new {|h, k| h[k] = k; k}
-      end
-
-      def add(key, value, *tag)
-        @pool << [key, value]
-        idx = @pool.size - 1
-        tag.uniq.each do |t|
-          @tag << [[@shared[t], key], idx]
-        end
-      end
-      
-      def generate
-        tag = @tag.sort
-        tag.inject(nil) do |last, kv|
-          k = kv[0]
-          k[0] = last if k[0] == last
-          k[0]
-        end
-        ImmutableDrip.new(@pool.sort, tag)
-      end
-    end
-
-    INF = 1.0/0
-
-    def initialize(pool=[], tag=[])
-      @pool = pool
-      @tag = tag
-    end
-
-    def fetch(key)
-      idx = lower_boundary(@pool, key)
-      k, v = @pool[idx]
-      k == key ? v.to_a : nil
-    end
-
-    def read(key, n=1)
-      idx = lower_boundary(@pool, key + 1)
-      return [] unless idx
-      @pool[idx, n].collect {|kv|
-        [kv[0], *kv[1].to_a]
-      }
-    end
-
-    def read_tag(key, tag, n=1)
-      idx = lower_boundary(@tag, [tag, key + 1])
-      return [] unless idx
-      @tag[idx, n].find_all {|kv| kv[0][0] == tag}.collect {|kv| 
-        [kv[0][1], *@pool[kv[1]][1].to_a]
-      }
-    end
-
-    def head_tag(n, tag)
-      lower = lower_boundary(@tag, [tag, 0])
-      upper = upper_boundary(@tag, [tag, INF])
-      lower = [lower, upper - n].max
-      @tag[lower ... upper].collect {|kv|
-        [kv[0][1], *@pool[kv[1]][1].to_a]
-      }
-    end
-
-    def head(n=1, tag=nil)
-      return head_tag(n, tag) if tag
-      n = @pool.size < n ? @pool.size : n
-      @pool[-n, n].collect {|kv|
-        [kv[0], *kv[1].to_a]
-      }
-    end
-
-    def older_tag(key, tag)
-      idx = upper_boundary(@tag, [tag, key-1])
-      k, v = @tag[idx - 1]
-      k && k[0] == tag ? [k[1], *@pool[v][1].to_a] : nil
-    end
-
-    def older(key, tag=nil)
-      key = @pool[-1][0] + 1 unless key
-      return older_tag(key, tag) if tag
-      idx = upper_boundary(@pool, key - 1)
-      k, v = @pool[idx - 1]
-      k && k < key ? [k, *v.to_a] : nil
-    end
-
-    def newer(key, tag=nil)
-      return read(key, 1)[0] unless tag
-      read_tag(key, tag, 1)[0]
-    end
-    
-    def lower_boundary(ary, key)
-      lower = -1
-      upper = ary.size
-      while lower + 1 != upper
-        mid = (lower + upper).div(2)
-        if (ary[mid][0] <=> key) < 0
-          lower = mid
-        else
-          upper = mid
-        end
-      end
-      return upper
-    end
-    
-    def upper_boundary(ary, key)
-      lower = -1
-      upper = ary.size
-      while lower + 1 != upper
-        mid = (lower + upper).div(2)
-        if (ary[mid][0] <=> key) <= 0
-          lower = mid
-        else
-          upper = mid
-        end
-      end
-      return lower + 1
-    end
-  end
+  INF = 1.0/0.0
 
+  def inspect; to_s; end
   def initialize(dir, option={})
-    @pool = RBTree.new
+    @past = prepare_store(dir, option)
+    @fence = (@past.head[0][0] rescue 0) || 0
+    @pool = Drip::SortedArray.new([])
     @tag = RBTree.new
     @event = Rinda::TupleSpace.new(5)
-    @event.write([:last, 0])
-    prepare_store(dir, option)
+    @event.write([:last, @fence])
   end
 
   def write(obj, *tags)
@@ -143,19 +24,30 @@ class Drip
   def write_after(at, *value)
     make_key(at) do |key|
       value = do_write(key, value)
-      @pool[key] = @store.write(key, value)
+      @pool.push([key, @store.write(key, value)])
     end
   end
   
   def write_at(at, *value)
     make_key_at(at) do |key|
       value = do_write(key, value)
-      @pool[key] = @store.write(key, value)
+      @pool.push([key, @store.write(key, value)])
+    end
+  end
+
+  def write_if_latest(cond, *value)
+    make_key(Time.now) do |key|
+      cond.each {|it|
+        return nil unless latest?(it[1], it[0])
+      }
+      value = do_write(key, value)
+      @pool.push([key, @store.write(key, value)])
     end
   end
 
   def fetch(key)
-    @pool[key].to_a
+    return @past.fetch(key) if @fence >= key 
+    @pool.fetch(key)
   end
   alias [] fetch
 
@@ -171,6 +63,52 @@ class Drip
   end
   
   def read(key, n=1, at_least=1, timeout=nil)
+    return curr_read(key, n, at_least, timeout) if key > @fence
+    ary = @past.read(key, n)
+    return ary if ary.size >= n
+    ary + curr_read(key, n - ary.size, at_least - ary.size, timeout)
+  end
+
+  def read_tag(key, tag, n=1, at_least=1, timeout=nil)
+    return curr_read_tag(key, tag, n, at_least, timeout) if key > @fence
+    ary = @past.read_tag(key, tag, n)
+    return ary if ary.size >= n
+    ary + curr_read_tag(key, tag, n - ary.size, at_least - ary.size, timeout)
+  end
+
+  def head(n=1, tag=nil)
+    unless tag
+      ary = @pool.head(n)
+      return @past.head(n - ary.size) + ary
+    end
+    ary = curr_head(n, tag)
+    return ary if ary.size == n
+    @past.head(n - ary.size, tag) + ary
+  end
+
+  def latest?(key, tag=nil)
+    now = time_to_key(Time.now)
+    if tag
+      it ,= @tag.upper_bound([tag, now])
+      if it && it[0] == tag
+        return true if it[1] == key
+        return false if it[1] > key
+      end
+    else
+      return true if @pool.latest?(key)
+    end
+    @past.latest?(key, tag)
+  end
+
+  def older(key, tag=nil)
+    curr_older(key, tag) || @past.older(key, tag)
+  end
+  
+  def newer(key, tag=nil)
+    @past.newer(key, tag) || curr_newer(key, tag)
+  end
+
+  def curr_read(key, n=1, at_least=1, timeout=nil)
     renewer = make_renewer(timeout)
     key = time_to_key(Time.now) unless key
     ary = []
@@ -180,14 +118,14 @@ class Drip
       rescue Rinda::RequestExpiredError
         return ary
       end
-      key, value = @pool.lower_bound(key + 1)
+      key, value, *tags = @pool.read(key)[0]
       return ary unless key
-      ary << [key] + value.to_a
+      ary << [key] + [value, *tags]
     end
     ary
   end
 
-  def read_tag(key, tag, n=1, at_least=1, timeout=nil)
+  def curr_read_tag(key, tag, n=1, at_least=1, timeout=nil)
     renewer = make_renewer(timeout)
     key = time_to_key(Time.now) unless key
     ary = []
@@ -205,10 +143,10 @@ class Drip
     ary
   end
 
-  def head(n=1, tag=nil)
+  def curr_head(n=1, tag=nil)
     ary = []
     key = nil
-    while it = older(key, tag)
+    while it = curr_older(key, tag)
       break if n <= 0
       ary.unshift(it)
       key = it[0]
@@ -217,27 +155,29 @@ class Drip
     ary
   end
 
-  def older(key, tag=nil)
+  def curr_older(key, tag=nil)
     key = time_to_key(Time.now) unless key
-    unless tag
-      k, v = @pool.upper_bound(key - 1)
-      return k ? [k] + v.to_a : nil
-    end
+
+    return @pool.older(key) unless tag
 
     it ,= @tag.upper_bound([tag, key - 1])
     return nil unless it && it[0] == tag
     [it[1]] + fetch(it[1])
   end
 
-  def newer(key, tag=nil)
+  def curr_newer(key, tag=nil)
     return read(key, 1, 0)[0] unless tag
     read_tag(key, tag, 1, 0)[0]
   end
 
-  def time_to_key(time)
+  def self.time_to_key(time)
     time.tv_sec * 1000000 + time.tv_usec
   end
 
+  def time_to_key(time)
+    self.class.time_to_key(time)
+  end
+
   def key_to_time(key)
     Time.at(*key.divmod(1000000))
   end
@@ -314,7 +254,7 @@ class Drip
   def prepare_store(dir, option={})
     if dir.nil?
       @store = SimpleStore.new(nil, option)
-      return
+      return ImmutableDrip.new
     end
 
     Dir.mkdir(dir) rescue nil
@@ -322,26 +262,31 @@ class Drip
       File.basename(fn).to_i(36)
     end
     if dump
-      @pool, @tag, last = File.open(dump, 'rb') {|fp| Marshal.load(fp)}
-      @event.take([:last, nil])
-      @event.write([:last, last])
+      pool, tag, _ = File.open(dump, 'rb') {|fp| Marshal.load(fp)}
       File.unlink(dump)
+    else
+      pool = []
+      tag = []
     end
+    gen = ImmutableDrip::Generator.new(pool, tag)
     loaded = dump ? File.basename(dump).to_i(36) : 0
     Dir.glob(File.join(dir, '*.log')) do |fn|
       next if loaded > File.basename(fn).to_i(36)
       begin
-        store = SimpleStore.reader(fn)
-        restore(store)
+        SimpleStore.reader(fn).each do |k, v, attic|
+          obj, *tags = v
+          attic.forget
+          gen.add(k, attic, *tags)
+        end
       rescue
       end
     end
-    name = time_to_key(Time.now).to_s(36)
-    _, last = @event.read([:last, nil])
+    name = Drip.time_to_key(Time.now).to_s(36)
     File.open(File.join(dir, name + '.dump'), 'wb') {|fp|
-      Marshal.dump([@pool, @tag, last], fp)
+      Marshal.dump([gen.pool, gen.tag], fp)
     }
     @store = SimpleStore.new(File.join(dir, name + '.log'))
+    return gen.generate
   end
 
   def shared_text(str)
@@ -361,7 +306,8 @@ class Drip
       tag = shared_text(k)
       @tag[[tag, key]] = key
     end
-    @pool[key] = [obj] + tags
+    # @pool[key] = [obj] + tags
+    [obj] + tags
   end
 
   def restore(store)
@@ -400,7 +346,6 @@ class Drip
     @event.write([:last, last])
   end
   
-  INF = 1.0/0.0
   def wait(key, renewer)
     @event.read([:last, key+1 .. INF], renewer)[1]
   end
@@ -425,6 +370,223 @@ class Drip
   end
 end
 
+class Drip
+  module ArrayBsearch
+    module_function
+    def lower_boundary(ary, key)
+      lower = -1
+      upper = ary.size
+      while lower + 1 != upper
+        mid = (lower + upper).div(2)
+        if (ary[mid][0] <=> key) < 0
+          lower = mid
+        else
+          upper = mid
+        end
+      end
+      return upper
+    end
+    
+    def upper_boundary(ary, key)
+      lower = -1
+      upper = ary.size
+      while lower + 1 != upper
+        mid = (lower + upper).div(2)
+        if (ary[mid][0] <=> key) <= 0
+          lower = mid
+        else
+          upper = mid
+        end
+      end
+      return lower + 1
+    end
+  end
+end
+
+class Drip
+  class FakeRBTree
+    include Drip::ArrayBsearch
+
+    def initialize
+      @tree = Hash.new {|h, k| h[k] = Array.new}
+    end
+    
+    def upper_bound(pair)
+      tag, now = pair
+      return nil unless @tree.include?(tag)
+      ary = @tree[tag]
+      idx = upper_boundary(ary, now)
+      [tag, ary[tag][idx]]
+    end
+    
+    def lower_bound(pair)
+    end
+  end
+end
+
+
+
+class Drip
+  class SortedArray
+    include Drip::ArrayBsearch
+
+    def initialize(ary)
+      @ary = ary
+      @last_key = ary.empty? ? 0 : ary[-1][0]
+    end
+
+    def push(obj)
+      raise 'InvalidTimeError' if obj[0] <= @last_key
+      @last_key = obj[0]
+      @ary << obj
+    end
+
+    def fetch(key)
+      idx = lower_boundary(@ary, key)
+      k, v = @ary[idx]
+      k == key ? v.to_a : nil
+    end
+
+    def read(key, n=1)
+      idx = lower_boundary(@ary, key + 1)
+      return [] unless idx
+      @ary[idx, n].collect {|kv|
+        [kv[0], *kv[1].to_a]
+      }
+    end
+
+    def empty?
+      @ary.empty?
+    end
+
+    def latest?(key)
+      @last_key == key
+    end
+
+    def head(n)
+      n = @ary.size < n ? @ary.size : n
+      @ary[-n, n].collect {|kv|
+        [kv[0], *kv[1].to_a]
+      }
+    end
+
+    def older(key)
+      return nil if @ary.empty?
+      key = @ary[-1][0] + 1 unless key
+      idx = upper_boundary(@ary, key - 1)
+      k, v = @ary[idx - 1]
+      k && k < key ? [k, *v.to_a] : nil
+    end
+
+    def last
+      @ary[-1]
+    end
+    
+    def last_key
+      @ary.empty? ? 0 : last[0]
+    end
+  end
+end
+
+class Drip
+  class ImmutableDrip
+    include Drip::ArrayBsearch
+
+    def initialize(pool=[], tag=[])
+      @pool = Drip::SortedArray.new(pool)
+      @tag = tag
+    end
+
+    def fetch(key)
+      @pool.fetch(key)
+    end
+
+    def read(key, n=1)
+      @pool.read(key, n)
+    end
+
+    def read_tag(key, tag, n=1)
+      idx = lower_boundary(@tag, [tag, key + 1])
+      return [] unless idx
+      @tag[idx, n].find_all {|kv| kv[0][0] == tag}.collect {|kv| 
+        [kv[0][1], *fetch(kv[0][1])]
+      }
+    end
+
+    def latest?(key, tag)
+      return false if @pool.empty?
+      return @pool.latest?(key) unless tag
+
+      lower = lower_boundary(@tag, [tag, key])
+      upper = upper_boundary(@tag, [tag, INF])
+      return lower == upper - 1
+    end
+
+    def head_tag(n, tag)
+      lower = lower_boundary(@tag, [tag, 0])
+      upper = upper_boundary(@tag, [tag, INF])
+      lower = [lower, upper - n].max
+      @tag[lower ... upper].collect {|kv|
+        [kv[0][1], *fetch(kv[0][1])]
+      }
+    end
+
+    def head(n=1, tag=nil)
+      tag ? head_tag(n, tag) : @pool.head(n)
+    end
+
+    def older_tag(key, tag)
+      idx = upper_boundary(@tag, [tag, key-1])
+      k, v = @tag[idx - 1]
+      k && k[0] == tag ? [k[1], *fetch(k[1])] : nil
+    end
+
+    def older(key, tag=nil)
+      return nil if @pool.empty?
+      key = @pool.last_key + 1 unless key
+      return older_tag(key, tag) if tag
+      @pool.older(key)
+    end
+
+    def newer(key, tag=nil)
+      return read(key, 1)[0] unless tag
+      read_tag(key, tag, 1)[0]
+    end
+  end
+end
+
+class Drip
+  class ImmutableDrip
+    class Generator
+      def initialize(pool=[], tag=[])
+        @pool = pool
+        @tag = tag
+        @shared = Hash.new {|h, k| h[k] = k; k}
+        @tag.each {|pair| @shared[pair[0]]}
+      end
+      attr_reader :pool, :tag
+
+      def add(key, value, *tag)
+        @pool << [key, value]
+        idx = @pool.size - 1
+        tag.uniq.each do |t|
+          @tag << [[@shared[t], key]]
+        end
+      end
+      
+      def generate
+        tag = @tag.sort
+        tag.inject(nil) do |last, kv|
+          k = kv[0]
+          k[0] = last if k[0] == last
+          k[0]
+        end
+        ImmutableDrip.new(@pool.sort, tag)
+      end
+    end
+  end
+end
+
 if __FILE__ == $0
   require 'my_drip'
   MyDrip.invoke

data/lib/drip/version.rb

@@ -1,3 +1,3 @@
-module Drip
-  VERSION = "0.0.2"
+class Drip
+  VERSION = "0.0.3"
 end

data/sample/drip_tw.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 require 'simple-oauth'
 require 'drb'
 require 'pp'
@@ -36,6 +37,40 @@ class DripFiber
   end
 end
 
+class DripThread
+  def initialize(app)
+    @app = app
+    @queue = Queue.new
+    Thread.new do
+      story
+    end
+  end
+
+  def story
+    event = @queue.pop
+    pending = []
+    while event['id_str'].nil?
+      pending << event
+      event = @queue.pop
+    end
+    
+    @app.fill_timeline(event['id_str'])
+
+    while event = pending.shift
+      @app.write(event)
+    end
+    
+    while true
+      event = @queue.pop
+      @app.write(event)
+    end
+  end
+  
+  def push(event)
+    @queue.push(event)
+  end
+end
+
 class JSONStream
   def initialize(drip)
     @buf = ''
@@ -49,8 +84,10 @@ class JSONStream
         @buf.sub!(line,"")
         line.strip!
         event = JSON.parse(line)
-      rescue
-        break
+      rescue JSON::ParserError
+        pp $line if $DEBUG
+        pp $! if $DEBUG
+        next
       end
       pp event if $DEBUG
       @drip.push(event)
@@ -147,15 +184,16 @@ class DripDemo
   end
 
   def home_timeline(since_id, max_id)
-    url = "http://api.twitter.com/1/statuses/home_timeline.json?count=200&include_entities=true"
+    url = "https://api.twitter.com/1.1/statuses/home_timeline.json?count=200&include_entities=true"
     url += "&since_id=#{since_id}" if since_id
     url += "&max_id=#{max_id}" if max_id
     r = oauth.request(:GET, url)
-    JSON.parse(r.body)
+    body = r.body
+    JSON.parse(body)
   end
 
   def user_timeline(since_id, max_id)
-    url = "http://api.twitter.com/1/statuses/user_timeline.json?count=200&include_entities=true&trim_user=t"
+    url = "http://api.twitter.com/1.1/statuses/user_timeline.json?count=200&include_entities=true&trim_user=t"
     url += "&since_id=#{since_id}" if since_id
     url += "&max_id=#{max_id}" if max_id
     r = oauth.request(:GET, url)
@@ -225,13 +263,13 @@ class DripDemo
   def update(str, in_reply_to=nil)
     hash = { :status => str }
     hash[:in_reply_to_status_id] = in_reply_to if in_reply_to
-    r = oauth.post('http://api.twitter.com/1/statuses/update.xml',
+    r = oauth.post('http://api.twitter.com/1.1/statuses/update.xml',
                    hash)
     pp r.body if $DEBUG
   end
 
   def test
-    r = oauth.post('http://api.twitter.com/1/statuses/update.xml',
+    r = oauth.post('http://api.twitter.com/1.1/statuses/update.xml',
                    {:status => 'test'})
     pp r.body if $DEBUG
   end

data/test/basic.rb

@@ -124,6 +124,36 @@ class TestDrip < Test::Unit::TestCase
     oid = @drip.write('dup', 'hello', 'hello', 'hello')
     assert_equal(@drip[oid], ['dup', 'hello'])
   end
+
+  def test_latest?
+    key = @drip.write(:start)
+    10.times do |n|
+      @drip.write(n)
+    end
+    assert_equal(@drip.latest?(key), false)
+    key = @drip.write(:stop)
+    assert_equal(@drip.latest?(key), true)
+
+    key = @drip.write(:tag_start, 'tag')
+    @drip.write(:tag, 'ignore tag')
+    assert_equal(@drip.latest?(key, 'tag'), true)
+    @drip.write(:tag, 'tag')
+    assert_equal(@drip.latest?(key, 'tag'), false)
+  end
+
+  def test_write_if_latest
+    t1 = @drip.write('t1', 't1')
+    t2 = @drip.write('t2', 't2')
+    t3 = @drip.write('t3', 't3')
+    assert_equal(@drip.latest?(t1, 't1'), true)
+    assert(@drip.write_if_latest([['t1', t1],
+                                  ['t2', t2],
+                                  ['t3', t3]], 'hello', 't1'))
+    assert_equal(@drip.latest?(t1, 't1'), false)
+    assert_equal(@drip.write_if_latest([['t1', t1],
+                                        ['t2', t2],
+                                        ['t3', t3]], 'hello', 't1'), nil)
+  end
 end
 
 class TestDripUsingStorage < TestDrip
@@ -139,13 +169,36 @@ class TestDripUsingStorage < TestDrip
   def teardown
     remove_drip
   end
+
+  def test_twice_latest?
+    assert_equal(@drip.latest?(1), false)
+    tag1 = @drip.write('tag1', 'tag1')
+    assert_equal(@drip.latest?(tag1), true)
+    @drip.write('nop', 'tag1')
+    @drip.write('nop', 'tag1')
+    tag2 = @drip.write('tag2', 'tag1')
+    assert_equal(@drip.latest?(1), false)
+    drip = Drip.new('test_db')
+    assert_equal(drip.latest?(1), false)
+    assert_equal(drip.latest?(tag1, 'tag1'), false)
+    assert_equal(drip.latest?(tag2, 'tag1'), true)
+    assert_equal(drip.latest?(tag2, 'tag0'), false)
+  end
   
   def test_twice
     11.times do |n|
       @drip.write("n=#{n}" => 'x' * n, n => n, "n" => n, :symbol => n)
     end
-
+    
     drip = Drip.new('test_db')
+    ary = drip.head(3)
+    assert_equal(ary.size, 3)
+    assert_equal(ary[0][1]['n'], 8)
+    assert_equal(ary[1][1]['n'], 9)
+    assert_equal(ary[2][1]['n'], 10)
+    ary = drip.head(1)
+    assert_equal(ary.size, 1)
+    assert_equal(ary[0][1]['n'], 10)
     ary = drip.read(0, 3)
     assert_equal(ary.size, 3)
     assert_equal(ary[0][1]['n'], 0)
@@ -175,30 +228,30 @@ end
 
 class TestImmutableDrip < Test::Unit::TestCase
   def test_bsearch
-    im = Drip::ImmutableDrip.new
+    ab = Drip::ArrayBsearch
 
-    assert_equal(0, im.lower_boundary([], 'c'))
-    assert_equal(0, im.upper_boundary([], 'c'))
+    assert_equal(0, ab.lower_boundary([], 'c'))
+    assert_equal(0, ab.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, ab.lower_boundary(ary, ''))
+    assert_equal(0, ab.lower_boundary(ary, 'a'))
+    assert_equal(1, ab.lower_boundary(ary, 'b'))
+    assert_equal(2, ab.lower_boundary(ary, 'c'))
+    assert_equal(5, ab.lower_boundary(ary, 'd'))
+    assert_equal(6, ab.lower_boundary(ary, 'e'))
+    assert_equal(7, ab.lower_boundary(ary, 'f'))
+    assert_equal(8, ab.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'))
+    assert_equal(0, ab.upper_boundary(ary, ''))
+    assert_equal(1, ab.upper_boundary(ary, 'a'))
+    assert_equal(2, ab.upper_boundary(ary, 'b'))
+    assert_equal(5, ab.upper_boundary(ary, 'c'))
+    assert_equal(6, ab.upper_boundary(ary, 'd'))
+    assert_equal(7, ab.upper_boundary(ary, 'e'))
+    assert_equal(8, ab.upper_boundary(ary, 'f'))
+    assert_equal(8, ab.upper_boundary(ary, 'g'))
   end
 
   def add_to_gen(gen, key, value, *tag)

metadata

@@ -1,38 +1,36 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: drip
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.0.2
+version: !ruby/object:Gem::Version
+  version: 0.0.3
 platform: ruby
-authors: 
+authors:
 - Masatoshi Seki
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-11-16 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2015-12-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rbtree
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-description: ""
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
 email: 
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
 - Gemfile
 - README
 - Rakefile
@@ -58,30 +56,26 @@ files:
 - test/basic.rb
 homepage: https://github.com/seki/Drip
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: drip
-rubygems_version: 1.8.10
+rubygems_version: 2.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Simple RD-Stream for Rinda::TupleSpace lovers.
-test_files: 
+test_files:
 - test/basic.rb