frugal_timeout 0.0.13 → 0.0.14

data/README.md

@@ -15,20 +15,20 @@ alternative that uses only 1 thread.
 
 Also, there's a race condition in the 1.9-2.0 stock timeout. Consider the
 following code:
-```
+```ruby
 timeout(0.02) {
   timeout(0.01, IOError) { sleep }
 }
 ```
 
-In this case, the stock timeout will most likely rise IOError, but, given the
-race condition, sometimes it can also rise Timeout::Error. Just put `sleep 0.1'
+In this case, the stock timeout will most likely raise IOError, but, given the
+race condition, sometimes it can also raise Timeout::Error. Just put `sleep 0.1'
 inside stock timeout ensure to trigger that. As of version 0.0.9, frugal_timeout
-will always rise IOError.
+will always raise IOError.
 
 ## Example
 
-```
+```ruby
 require 'frugal_timeout'
 
 begin
@@ -50,8 +50,7 @@ end
 
 ## Installation
 
-Tested on Ruby 1.9.3 and 2.0.0, but may work on 1.8 as well (tests will not work
-though).
+Tested on Ruby 1.9.3 and 2.0.0.
 
 ```
 gem install frugal_timeout

data/TODO

@@ -1,22 +1 @@
-# * Add more comments.
-# * Add docs like in null_object gem.
-
-require 'frugal_timeout'
-
-FrugalTimeout.dropin!
-
-timeout(1.0, Timeout::Error) {
-  begin
-    sleep 0.8;
-    timeout(0.3, Timeout::Error) {
-      begin
-	sleep 0.2;
-      rescue Timeout::Error;
-	puts "0.3 expired"
-      end
-    };
-    sleep 86400;
-  rescue Timeout::Error;
-    puts "1.0 expired"
-  end
-}
+* Add more comments.

data/frugal_timeout.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'frugal_timeout'
-  s.version     = '0.0.13'
-  s.date        = '2014-01-08'
+  s.version     = '0.0.14'
+  s.date        = '2014-02-02'
   s.summary     = 'Timeout.timeout replacement'
   s.description = 'Timeout.timeout replacement that uses only 1 thread'
   s.authors     = ['Dmitry Maksyoma']
@@ -12,5 +12,5 @@ Gem::Specification.new do |s|
   s.homepage    = 'https://github.com/ledestin/frugal_timeout'
 
   s.add_development_dependency 'rspec', '>= 2.13'
-  s.add_runtime_dependency 'hitimes', '~> 1.2'
+  s.add_runtime_dependency 'monotonic_time', '~> 0.0'
 end

data/lib/frugal_timeout.rb

@@ -1,9 +1,10 @@
 # Copyright (C) 2013, 2014 by Dmitry Maksyoma <ledestin@gmail.com>
 
-require 'hitimes'
 require 'monitor'
+require 'monotonic_time'
 require 'thread'
 require 'timeout'
+require 'frugal_timeout/support'
 
 #--
 # {{{1 Rdoc
@@ -31,28 +32,14 @@ require 'timeout'
 #--
 # }}}1
 module FrugalTimeout
-  DO_NOTHING = proc {}
-
   # {{{1 Error
   class Error < Timeout::Error #:nodoc:
   end
 
-  # {{{1 MonotonicTime
-  class MonotonicTime #:nodoc:
-    NANOS_IN_SECOND = 1_000_000_000
-
-    def self.measure
-      start = now
-      yield
-      now - start
-    end
-
-    def self.now
-      Hitimes::Interval.now.start_instant.to_f/NANOS_IN_SECOND
-    end
-  end
-
   # {{{1 Request
+  # Timeout request, holding expiry time, what exception to raise and in which
+  # thread. It is active by default, but can be defused. If it's defused, then
+  # timeout won't be enforced when #enforce is called.
   class Request #:nodoc:
     include Comparable
     @@mutex = Mutex.new
@@ -68,7 +55,7 @@ module FrugalTimeout
       @at <=> other.at
     end
 
-    # Timeout won't be enforced if you defuse a request.
+    # Timeout won't be enforced if you defuse the request.
     def defuse!
       @@mutex.synchronize { @defused = true }
     end
@@ -77,80 +64,84 @@ module FrugalTimeout
       @@mutex.synchronize { @defused }
     end
 
-    def enforceTimeout
+    # Enforce this timeout request, unless it's been defused.
+    # Return true if was enforced, false otherwise.
+    def enforce
       @@mutex.synchronize {
-	return if @defused
+	return false if @defused
 
 	@thread.raise @klass, 'execution expired'
+	@defused = true
 	true
       }
     end
   end
 
   # {{{1 RequestQueue
+  # Contains sorted requests to be processed. Calls @onNewNearestRequest when
+  # another request becomes the first in line. Calls @onEnforce when expired
+  # requests are removed and enforced.
+  #
+  # #queue adds requests.
+  # #enforceExpired removes and enforces requests.
   class RequestQueue #:nodoc:
+    include Hookable
     include MonitorMixin
 
     def initialize
       super
-      @onEnforce, @onNewNearestRequest = DO_NOTHING, DO_NOTHING
+      def_hook_synced :onEnforce, :onNewNearestRequest
       @requests, @threadIdx = SortedQueue.new, Storage.new
 
-      @requests.onAdd { |r| @threadIdx.set r.thread, r }
-      @requests.onRemove { |r| @threadIdx.delete r.thread, r }
+      @requests.on_add { |r| @threadIdx.set r.thread, r }
+      @requests.on_remove { |r| @threadIdx.delete r.thread, r }
     end
 
-    def handleExpiry
+    def enforceExpired
       synchronize {
-	purgeAndEnforceExpired
-	sendNearestActiveRequest
+	purgeAndEnforceExpired && sendNearestActive
       }
     end
 
-    def onEnforce &b
-      synchronize { @onEnforce = b || DO_NOTHING }
-    end
-
-    def onNewNearestRequest &b
-      synchronize { @onNewNearestRequest = b || DO_NOTHING }
-    end
-
     def size
       synchronize { @requests.size }
     end
 
     def queue sec, klass
+      request = Request.new(Thread.current, MonotonicTime.now + sec, klass)
       synchronize {
-	@requests << (request = Request.new(Thread.current,
-	  MonotonicTime.now + sec, klass))
-	@onNewNearestRequest.call(request) if @requests.first == request
-	request
+	@requests.push(request) {
+	  @onNewNearestRequest.call request
+	}
       }
+      request
     end
 
     private
 
-    def defuse_thread! thread
-      return unless stored = @threadIdx[thread]
+    # Defuse requests belonging to the passed thread.
+    def defuseForThread! thread
+      return unless request = @threadIdx[thread]
 
-      if stored.is_a? Array
-	stored.each { |r| r.defuse! }
+      if request.respond_to? :each
+	request.each { |r| r.defuse! }
       else
-	stored.defuse!
+	request.defuse!
       end
     end
 
-    # Purge and enforce expired timeouts.
     def purgeAndEnforceExpired
       @onEnforce.call
       now = MonotonicTime.now
-      while !@requests.empty? && @requests.first.at <= now
-	r = @requests.shift
-	r.enforceTimeout && defuse_thread!(r.thread)
-      end
+      @requests.reject_until_mismatch! { |r|
+	if r.at <= now
+	  r.enforce && defuseForThread!(r.thread)
+	  true
+	end
+      }
     end
 
-    def sendNearestActiveRequest
+    def sendNearestActive
       @requests.reject_until_mismatch! { |r| r.defused? }
       @onNewNearestRequest.call @requests.first unless @requests.empty?
     end
@@ -163,25 +154,24 @@ module FrugalTimeout
   # 3. After the expiry time comes, execute the callback.
   #
   # It's possible to set a new expiry time before the time set previously
-  # expires. In this case, processing of the old request stops and the new
-  # request processing starts.
+  # expires. However, if the old request has already expired, @onExpiry will
+  # still be called.
   class SleeperNotifier #:nodoc:
+    include Hookable
     include MonitorMixin
 
     def initialize
       super()
-      @condVar, @expireAt, @onExpiry = new_cond, nil, DO_NOTHING
+      def_hook_synced :onExpiry
+      @condVar, @expireAt = new_cond, nil
 
       @thread = Thread.new {
 	loop {
 	  synchronize { @onExpiry }.call if synchronize {
-	    # Sleep forever until a request comes in.
-	    unless @expireAt
-	      wait
-	      next
-	    end
+	    waitForValidRequest
 
-	    timeLeft = calcTimeLeft
+	    timeLeft = timeLeftUntilExpiry
+	    # Prevent processing of the same request again.
 	    disposeOfRequest
 	    elapsedTime = MonotonicTime.measure { wait timeLeft }
 
@@ -192,10 +182,6 @@ module FrugalTimeout
       ObjectSpace.define_finalizer self, proc { @thread.kill }
     end
 
-    def onExpiry &b
-      synchronize { @onExpiry = b || DO_NOTHING }
-    end
-
     def expireAt time
       synchronize {
 	@expireAt = time
@@ -205,13 +191,6 @@ module FrugalTimeout
 
     private
 
-    def calcTimeLeft
-      synchronize {
-	delay = @expireAt - MonotonicTime.now
-	delay < 0 ? 0 : delay
-      }
-    end
-
     def disposeOfRequest
       @expireAt = nil
     end
@@ -220,129 +199,26 @@ module FrugalTimeout
       @condVar.signal
     end
 
-    def wait sec=nil
-      @condVar.wait sec
+    def timeLeftUntilExpiry
+      delay = @expireAt - MonotonicTime.now
+      delay < 0 ? 0 : delay
     end
-  end
-
-  # {{{1 SortedQueue
-  class SortedQueue #:nodoc:
-    extend Forwardable
-
-    def_delegators :@array, :empty?, :first, :size
 
-    def initialize storage=[]
-      super()
-      @array, @unsorted = storage, false
-      @onAdd = @onRemove = DO_NOTHING
-    end
-
-    def last
-      sort!
-      @array.last
-    end
-
-    def onAdd &b
-      @onAdd = b || DO_NOTHING
-    end
-
-    def onRemove &b
-      @onRemove = b || DO_NOTHING
-    end
-
-    def push *args
-      args.each { |arg|
-	case @array.first <=> arg
-	when -1, 0, nil
-	  @array.push arg
-	when 1
-	  @array.unshift arg
-	end
-      }
-      @unsorted = true
-      args.each { |arg| @onAdd.call arg }
-    end
-    alias :<< :push
-
-    def reject! &b
-      ar = []
-      sort!
-      @array.reject! { |el|
-	ar << el if b.call el
-      }
-      ar.each { |el| @onRemove.call el }
-    end
-
-    def reject_until_mismatch! &b
-      res = []
-      reject! { |el|
-	break unless b.call el
-
-	res << el
-      }
-      res
-    end
-
-    def shift
-      sort!
-      res = @array.shift
-      @onRemove.call res
-      res
-    end
-
-    private
-    def sort!
-      return unless @unsorted
-
-      @array.sort!
-      @unsorted = false
-    end
-  end
-
-  # {{{1 Storage
-  class Storage
-    def initialize
-      @storage = {}
-    end
-
-    def delete key, val=nil
-      return unless stored = @storage[key]
-
-      if val.nil? || stored == val
-	@storage.delete key
-	return
-      end
-
-      stored.delete val
-      @storage[key] = stored.first if stored.size == 1
-    end
-
-    def get key
-      @storage[key]
+    def wait sec=nil
+      @condVar.wait sec
     end
-    alias :[] :get
-
-    def set key, val
-      unless stored = @storage[key]
-	@storage[key] = val
-	return
-      end
 
-      if stored.is_a? Array
-	stored << val
-      else
-	@storage[key] = [stored, val]
-      end
+    def waitForValidRequest
+      wait until @expireAt
     end
   end
 
   # {{{1 Main code
-  @requestQueue = RequestQueue.new
-  sleeper = SleeperNotifier.new
+  @requestQueue, sleeper = RequestQueue.new, SleeperNotifier.new
   @requestQueue.onNewNearestRequest { |request|
     sleeper.expireAt request.at
   }
-  sleeper.onExpiry { @requestQueue.handleExpiry }
+  sleeper.onExpiry { @requestQueue.enforceExpired }
 
   # {{{2 Methods
 
@@ -367,16 +243,26 @@ module FrugalTimeout
     return yield sec if sec.nil? || sec <= 0
 
     innerException = klass || Class.new(Timeout::ExitException)
-    request = @requestQueue.queue(sec, innerException)
     begin
-      yield sec
+      request = @requestQueue.queue(sec, innerException)
+      # Defuse is here only for the case when exception comes from the yield
+      # block. Otherwise, when timeout exception is raised, the request is
+      # defused automatically.
+      #
+      # Now, if in ensure, timeout exception comes, the request has already been
+      # defused automatically, so even if ensure is interrupted, there's no
+      # problem.
+      begin
+	yield sec
+      ensure
+	request.defuse!
+      end
     rescue innerException => e
       raise if klass
 
       raise Error, e.message, e.backtrace
     ensure
       @onEnsure.call if @onEnsure
-      request.defuse!
     end
   end
   # }}}1

data/lib/frugal_timeout/support.rb

@@ -0,0 +1,151 @@
+# Copyright (C) 2013, 2014 by Dmitry Maksyoma <ledestin@gmail.com>
+
+module FrugalTimeout
+  # {{{1 Hookable
+  module Hookable
+    DO_NOTHING = proc {}
+
+    def def_hook *names
+      names.each { |name|
+	eval <<-EOF
+	  def #{name} &b
+	    @#{name} = b || DO_NOTHING
+	  end
+	  #{name}
+	EOF
+      }
+    end
+
+    def def_hook_synced *names
+      names.each { |name|
+	eval <<-EOF
+	  def #{name} &b
+	    synchronize { @#{name} = b || DO_NOTHING }
+	  end
+	  #{name}
+	EOF
+      }
+    end
+  end
+
+  # {{{1 SortedQueue
+  # Array-like structure, providing automatic sorting of elements. When you're
+  # accessing elements via #reject! or #first, the elements you access are
+  # sorted. There are some optimizations to ensure that elements aren't sorted
+  # each time you call those methods.
+  #
+  # Provides hooks: on_add, on_remove.
+  # To setup, do something like this: `queue.on_add { |el| puts "added #{el}" }'.
+  class SortedQueue #:nodoc:
+    extend Forwardable
+    include Hookable
+
+    # I don't sort underlying array before calling #first because:
+    # 1. When a new element is added, it'll be placed correctly at the beginning
+    #    if it should be first.
+    # 2. If items are removed from the underlying array, it'll be in the sorted
+    #    state afterwards. Thus, in this case, #first will behave correctly as
+    #    well.
+    def_delegators :@array, :empty?, :first, :size
+
+    def initialize storage=[]
+      super()
+      @array, @unsorted = storage, false
+      def_hook :on_add, :on_remove
+    end
+
+    def push *args
+      raise ArgumentError, "block can't be given for multiple elements" \
+	if block_given? && args.size > 1
+
+      args.each { |arg|
+	case @array.first <=> arg
+	when -1
+	  @array.push arg
+	  @unsorted = true
+	when 0
+	  @array.unshift arg
+	when 1, nil
+	  @array.unshift arg
+	  yield arg if block_given?
+	end
+	@on_add.call arg
+      }
+    end
+    alias :<< :push
+
+    def reject! &b
+      sort!
+      @array.reject! { |el|
+	if b.call el
+	  @on_remove.call el
+	  true
+	end
+      }
+    end
+
+    def reject_until_mismatch! &b
+      curSize = size
+      reject! { |el|
+	break unless b.call el
+
+	true
+      }
+      curSize == size ? nil : self
+    end
+
+    private
+    def sort!
+      return unless @unsorted
+
+      @array.sort!
+      @unsorted = false
+    end
+  end
+
+  # {{{1 Storage
+  # Stores values for keys, such as:
+  # 1. `set key, val' will store val.
+  # 2. `set key, val2' will store [val, val2].
+  # 3. `delete key, val2' will lead to storing just val again.
+  # I.e. array is used only when it's absolutely necessary.
+  #
+  # While it's harder to write code because of this, we do save memory by not
+  # instantiating all those arrays.
+  class Storage
+    def initialize
+      @storage = {}
+    end
+
+    def delete key, val=nil
+      return unless stored = @storage[key]
+
+      if val.nil? || stored == val
+	@storage.delete key
+	return
+      end
+
+      stored.delete val
+      @storage[key] = stored.first if stored.size == 1
+    end
+
+    def get key
+      @storage[key]
+    end
+    alias :[] :get
+
+    def set key, val
+      unless stored = @storage[key]
+	@storage[key] = val
+	return
+      end
+
+      if stored.is_a? Array
+	stored << val
+      else
+	@storage[key] = [stored, val]
+      end
+    end
+  end
+  # }}}1
+end

data/performance-test

@@ -1,30 +1,43 @@
 #!/usr/bin/ruby
 
+$LOAD_PATH << './lib'
 require './lib/frugal_timeout'
 
 Thread.abort_on_exception = true
 FrugalTimeout.dropin!
 
-def recursive_timeout n
+THREAD_COUNT, TIMES = 150, 100
+
+def recursive_timeout n, delay
   start = FrugalTimeout::MonotonicTime.now
-  timeout(1) {
+  timeout(delay) {
     if n > 1
-      recursive_timeout n -= 1
+      recursive_timeout n -= 1, delay
     else
       sleep
     end
   }
 rescue FrugalTimeout::Error
-  @m.synchronize { @ar << FrugalTimeout::MonotonicTime.now - start }
+  finish = FrugalTimeout::MonotonicTime.now 
+  @m.synchronize { @ar << finish - start - delay }
 end
 
-THREAD_COUNT, TIMES = 150, 100
-@ar, @m = [], Mutex.new
-THREAD_COUNT.times {
-  Thread.new {
-    recursive_timeout TIMES
+def run is_random
+  @ar, @m = [], Mutex.new
+  THREAD_COUNT.times {
+    Thread.new {
+      delay = 0
+      until delay > 0
+	delay = is_random ? rand(10) : 1
+      end
+      recursive_timeout TIMES, delay
+    }
   }
-}
-sleep 0.1 until @m.synchronize { @ar.size == THREAD_COUNT }
+  sleep 0.1 until @m.synchronize { @ar.size == THREAD_COUNT }
+  printf "avg over delay %-14s %s\n", is_random ? '(random)' : '(no random)',
+    @ar.inject(:+)/@ar.size
+end
 
-puts "#{THREAD_COUNT*TIMES} calls\navg: #{@ar.inject(:+)/@ar.size}"
+puts "#{THREAD_COUNT*TIMES} calls"
+run false
+run true

data/spec/frugal_timeout_spec.rb

@@ -6,11 +6,16 @@ require 'frugal_timeout'
 
 FrugalTimeout.dropin!
 Thread.abort_on_exception = true
-MonotonicTime = FrugalTimeout::MonotonicTime
 
 SMALLEST_TIMEOUT = 0.0000001
 
 # {{{1 Helper methods
+class Array
+  def avg
+    inject(:+)/size
+  end
+end
+
 def multiple_timeouts growing, cnt
   res, resMutex = [], Mutex.new
   if growing
@@ -91,14 +96,14 @@ describe FrugalTimeout do
     res, resMutex = [], Mutex.new
     (cnt = 5).times { new_timeout_request 1, res, resMutex }
     sleep 1 until res.size == cnt
-    res.each { |sec| sec.round.should == 1 }
+    res.avg.round.should == 1
   end
 
   it 'handles multiple concurrent same timeouts' do
     res, resMutex = [], Mutex.new
     (cnt = 5).times { new_timeout_request_thread 1, res, resMutex }
     sleep 1 until res.size == cnt
-    res.each { |sec| (sec - 1).should < 0.01 }
+    (res.avg - 1).should < 0.01
   end
 
   context 'recursive timeouts' do
@@ -205,6 +210,16 @@ describe FrugalTimeout do
     sleep 2
   end
 
+  # Actually, there's a race here, but if timeout exception is raised, it's ok,
+  # it just means it was faster than the block exception.
+  it "doesn't raise timeout exception when block raises exception" do
+    FrugalTimeout.on_ensure { sleep 0.02 }
+    expect {
+      timeout(0.01) { raise IOError }
+    }.to raise_error IOError
+    FrugalTimeout.on_ensure
+  end
+
   it 'handles exception within timeout()' do
     begin
       timeout(1) { raise 'lala' }
@@ -231,28 +246,60 @@ describe FrugalTimeout do
   end
 end
 
-# {{{1 MonotonicTime
-describe FrugalTimeout::MonotonicTime do
-  it 'ticks properly' do
-    start = MonotonicTime.now
-    sleep 0.1
-    (MonotonicTime.now - start).round(1).should == 0.1
+# {{{1 Hookable
+describe FrugalTimeout::Hookable do
+  before :all do
+    class Foo
+      include MonitorMixin
+      include FrugalTimeout::Hookable
+
+      def initialize
+	super
+	def_hook :onBar, :onBar2
+	def_hook_synced :onBarSynced, :onBarSynced2
+      end
+
+      def run
+	@onBar.call
+	@onBar2.call
+	@onBarSynced.call
+	@onBarSynced2.call
+      end
+    end
+
+    @foo = Foo.new
   end
 
-  it '#measure works' do
-    sleptFor = MonotonicTime.measure { sleep 0.5 }
-    sleptFor.round(1).should == 0.5
+  it 'works w/o user-defined hook' do
+    expect { @foo.run }.not_to raise_error
+  end
+
+  it 'calls user-defined hook' do
+    called = called2 = nil
+    @foo.onBar { called = true }
+    @foo.onBar2 { called2 = true }
+    @foo.run
+    called.should == true
+    called2.should == true
   end
 end
 
 # {{{1 Request
 describe FrugalTimeout::Request do
-  it '#defuse! and #defused? work' do
-    req = FrugalTimeout::Request.new(Thread.current,
+  before :each do
+    @request = FrugalTimeout::Request.new(Thread.current,
       MonotonicTime.now, FrugalTimeout::Error)
-    req.defused?.should == false
-    req.defuse!
-    req.defused?.should == true
+  end
+
+  it '#defuse! and #defused? work' do
+    @request.defused?.should == false
+    @request.defuse!
+    @request.defused?.should == true
+  end
+
+  it 'is defused after enforcing' do
+    expect { Thread.new { @request.enforce }.join }.to raise_error
+    @request.defused?.should == true
   end
 end
 
@@ -287,12 +334,12 @@ describe FrugalTimeout::RequestQueue do
     end
   end
 
-  context 'after handleExpiry' do
-    it 'invokes onEnforce on handleExpiry' do
+  context 'after enforceExpired' do
+    it 'invokes onEnforce on enforceExpired' do
       called = false
       @requests.onEnforce { called = true }
       @requests.queue(0, FrugalTimeout::Error)
-      expect { @requests.handleExpiry }.to raise_error
+      expect { @requests.enforceExpired }.to raise_error
       called.should == true
     end
 
@@ -301,7 +348,7 @@ describe FrugalTimeout::RequestQueue do
       @requests.queue(0, FrugalTimeout::Error)
       expect {
 	Thread.new {
-	  @requests.handleExpiry
+	  @requests.enforceExpired
 	}.join
       }.to raise_error FrugalTimeout::Error
       req.defused?.should == true
@@ -310,27 +357,37 @@ describe FrugalTimeout::RequestQueue do
     context 'onNewNearestRequest' do
       it 'invokes onNewNearestRequest' do
 	@requests.queue(0, FrugalTimeout::Error)
-	expect { @requests.handleExpiry }.to raise_error
+	expect { @requests.enforceExpired }.to raise_error
 	@ar.size.should == 1
       end
 
       it "doesn't invoke onNewNearestRequest on a defused request" do
 	@requests.queue(0, FrugalTimeout::Error).defuse!
-	expect { @requests.handleExpiry }.not_to raise_error
+	expect { @requests.enforceExpired }.not_to raise_error
 	@requests.size.should == 0
+	@ar.size == 1
+      end
+
+      it "doesn't invoke onNewNearestRequest if no requests expired yet" do
+	@requests.queue(10, FrugalTimeout::Error)
+	expect { @requests.enforceExpired }.not_to raise_error
+	# 1 has been put there by #queue.
+	@ar.size.should == 1
       end
     end
 
     it 'no expired requests are left in the queue' do
       @requests.queue(0, FrugalTimeout::Error)
       @requests.size.should == 1
-      expect { @requests.handleExpiry }.to raise_error
+      expect {
+	Thread.new { @requests.enforceExpired }.join
+      }.to raise_error
       @requests.size.should == 0
     end
 
     it 'a non-expired request is left in the queue' do
       @requests.queue(10, FrugalTimeout::Error)
-      expect { @requests.handleExpiry }.not_to raise_error
+      expect { @requests.enforceExpired }.not_to raise_error
       @requests.size.should == 1
     end
   end
@@ -391,24 +448,99 @@ describe FrugalTimeout::SortedQueue do
     @queue = FrugalTimeout::SortedQueue.new
   end
 
-  it 'allows to push items into queue' do
-    item = 'a'
-    @queue.push item
-    @queue.first.should == item
-  end
+  context '#push' do
+    it 'adds item into queue' do
+      item = 'a'
+      @queue.push item
+      @queue.size.should == 1
+      @queue.first.should == item
+    end
 
-  it 'supports << method' do
-    @queue << 'a'
-    @queue.first.should == 'a'
+    it 'calls block if element is sorted to be first' do
+      called = nil
+      @queue.push(2) { |el| called = el }
+      called.should == 2
+      @queue.push(1) { |el| called = el }
+      called.should == 1
+    end
+
+    it "doesn't call block if the pushed element is the same as first" do
+      @queue.push 1
+      called = nil
+      @queue.push(1) { called = true }
+      called.should be_nil
+    end
+
+    it "doesn't call block if element isn't sorted to be first" do
+      @queue.push 1
+      called = nil
+      @queue.push(3) { |el| called = el }
+      called.should == nil
+    end
+
+    it 'raises exception if block given for multiple pushed elements' do
+      expect {
+	@queue.push(1, 2) { }
+      }.to raise_error ArgumentError
+    end
+
+    context 'sorting' do
+      it 'makes first in order item to be sorted first' do
+	@queue.push 'b', 'a'
+	@queue.first.should == 'a'
+	@queue.reject! { |item| item == 'a' }
+	@queue.first.should == 'b'
+	@queue.size.should == 1
+      end
+
+      context 'works correctly if pushed values are <= the first element' do
+	it 'as a single #push call' do
+	  @queue.push 'c', 'b', 'a'
+	  ar = []
+	  @queue.reject! { |el| ar << el }
+	  ar.should == ['a', 'b', 'c']
+	end
+
+	it 'as multiple push calls' do
+	  @queue.push 'c'
+	  @queue.push 'b'
+	  @queue.push 'a'
+	  ar = []
+	  @queue.reject! { |el| ar << el }
+	  ar.should == ['a', 'b', 'c']
+	end
+      end
+
+      it "doesn't sort underlying array if pushed values are first in order" do
+	class MockArray < Array
+	  def sort!
+	    raise 'not supposed to call sort!'
+	  end
+	end
+	queue = FrugalTimeout::SortedQueue.new MockArray.new
+	expect {
+	  queue.push 'c'
+	  queue.push 'b'
+	  queue.push 'a'
+	  queue.first == 'a'
+	  queue.reject! { true }
+	}.not_to raise_error
+
+	expect {
+	  queue.push 'c', 'b', 'a'
+	  queue.first == 'a'
+	  queue.reject! {}
+	}.not_to raise_error
+      end
+    end
   end
 
-  it 'makes first in order item appear first' do
-    @queue.push 'b', 'a'
+  it '#<< method is supported' do
+    @queue << 'a'
     @queue.first.should == 'a'
-    @queue.last.should == 'b'
   end
 
-  it 'allows removing items from queue' do
+  it '#reject! works' do
     @queue.push 'a', 'b', 'c'
     @queue.reject! { |item|
       next true if item < 'c'
@@ -418,51 +550,36 @@ describe FrugalTimeout::SortedQueue do
     @queue.first.should == 'c'
   end
 
-  it "doesn't sort underlying array if pushed values are first in order" do
-    ar = double
-    class MockArray < Array
-      def sort!
-	raise 'not supposed to call sort!'
-      end
+  context '#reject_until_mismatch!' do
+    it 'removes one of the elements and returns @queue' do
+      @queue.push 'a', 'b'
+      @queue.reject_until_mismatch! { |el| el < 'b' }.should == @queue
+      @queue.size.should == 1
+      @queue.first.should == 'b'
     end
-    @queue = FrugalTimeout::SortedQueue.new MockArray.new
-    expect {
-      @queue.push 'c'
-      @queue.push 'b'
-      @queue.push 'a'
-      @queue.first == 'a'
-    }.not_to raise_error
-  end
 
-  it '#reject_until_mismatch!' do
-    @queue.push 'a'
-    @queue.push 'b'
-    res = @queue.reject_until_mismatch! { |el| el < 'b' }
-    res.size.should == 1
-    res.first.should == 'a'
-  end
-
-  it '#shift calls onRemove' do
-    called = nil
-    @queue.onRemove { |el| called = el }
-    @queue.push 'a'
-    @queue.shift
-    called.should == 'a'
+    it "doesn't remove any elements and returns nil" do
+      @queue.push 'a', 'b'
+      @queue.reject_until_mismatch! { }.should == nil
+      @queue.size.should == 2
+    end
   end
 
-  it 'calls onAdd callback' do
-    called = nil
-    @queue.onAdd { |el| called = el }
-    @queue.push 'a'
-    called.should == 'a'
-  end
+  context 'callbacks' do
+    it 'calls on_add callback' do
+      called = nil
+      @queue.on_add { |el| called = el }
+      @queue.push 'a'
+      called.should == 'a'
+    end
 
-  it 'calls onRemove callback' do
-    called = nil
-    @queue.onRemove { |el| called = el }
-    @queue.push 'a'
-    @queue.reject! { |el| true }
-    called.should  == 'a'
+    it 'calls on_remove callback' do
+      called = nil
+      @queue.on_remove { |el| called = el }
+      @queue.push 'a'
+      @queue.reject! { |el| true }
+      called.should  == 'a'
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: frugal_timeout
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-08 00:00:00.000000000 Z
+date: 2014-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -28,13 +28,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.13'
 - !ruby/object:Gem::Dependency
-  name: hitimes
+  name: monotonic_time
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0.0'
 description: Timeout.timeout replacement that uses only 1 thread
 email: ledestin@gmail.com
 executables: []
@@ -60,6 +60,7 @@ files:
 - TODO
 - frugal_timeout.gemspec
 - lib/frugal_timeout.rb
+- lib/frugal_timeout/support.rb
 - performance-test
 - spec/frugal_timeout_spec.rb
 - spec/spec_helper.rb