daybreak 0.2.1 → 0.2.2

data/README

@@ -1,7 +1,7 @@
-             ^^            |
-  daybreak     ^^        \ _ /
-                      -= /   \ =-
-~^~ ^ ^~^~ ~^~ ~ ~^~~^~^-=~=~=-~^~^~^~
+               ^^            |
+    daybreak     ^^        \ _ /
+                        -= /   \ =-
+  ~^~ ^ ^~^~ ~^~ ~ ~^~~^~^-=~=~=-~^~^~^~
 
 Daybreak is a simple key value store for ruby. It has user defined persistence,
 and all data is stored in a table in memory so ruby niceties are available.
@@ -9,4 +9,4 @@ Daybreak is faster than any other ruby options like pstore and dbm.
 
 $ gem install daybreak
 
-Docs: http://propublica.github.com/daybreak/
+You find a detailed documentation at http://propublica.github.com/daybreak.

data/Rakefile

@@ -24,10 +24,7 @@ end
 
 desc "Publish the docs to gh-pages"
 task :publish do |t|
-  `git checkout gh-pages`
-  `git merge master`
-  `git push`
-  `git checkout master`
+  system('git push -f origin master:gh-pages')
 end
 
 task :default => :test

data/lib/daybreak.rb

@@ -4,4 +4,5 @@ require 'daybreak/version'
 require 'daybreak/serializer'
 require 'daybreak/format'
 require 'daybreak/queue'
+require 'daybreak/journal'
 require 'daybreak/db'

data/lib/daybreak/db.rb

@@ -5,88 +5,75 @@ module Daybreak
   class DB
     include Enumerable
 
-    # Database file name
-    attr_reader :file
-
-    # Counter of how many records are in
-    attr_reader :logsize
-
     # Set default value, can be a callable
     attr_writer :default
 
-    @@databases = []
-    @@databases_mutex = Mutex.new
-
-    # A handler that will ensure that databases are closed and synced when the
-    # current process exits.
-    # @api private
-    def self.exit_handler
-      loop do
-        db = @@databases_mutex.synchronize { @@databases.first }
-        break unless db
-        warn "Daybreak database #{db.file} was not closed, state might be inconsistent"
-        begin
-          db.close
-        rescue Exception => ex
-          warn "Failed to close daybreak database: #{ex.message}"
-        end
-      end
-    end
-
-   at_exit { Daybreak::DB.exit_handler }
-
     # Create a new Daybreak::DB. The second argument is the default value
     # to store when accessing a previously unset key, this follows the
     # Hash standard.
     # @param [String] file the path to the db file
-    # @param [Hash] options a hash that contains the options for creating a new
-    #  database. You can pass in :serializer, :format or :default.
+    # @param [Hash] options a hash that contains the options for creating a new database
+    # @option options [Class] :serializer Serializer class
+    # @option options [Class] :format Format class
+    # @option options [Object] :default Default value
     # @yield [key] a block that will return the default value to store.
     # @yieldparam [String] key the key to be stored.
     def initialize(file, options = {}, &block)
-      @file = file
       @serializer = (options[:serializer] || Serializer::Default).new
-      @format = (options[:format] || Format).new
-      @queue = Queue.new
-      @table = Hash.new(&method(:hash_default))
+      @table = Hash.new &method(:hash_default)
+      @journal = Journal.new(file, (options[:format] || Format).new, @serializer) do |record|
+        if !record
+          @table.clear
+        elsif record.size == 1
+          @table.delete(record.first)
+        else
+          @table[record.first] = @serializer.load(record.last)
+        end
+      end
       @default = block ? block : options[:default]
-      open
-      @mutex = Mutex.new # Mutex to make #lock thread safe
-      @worker = Thread.new(&method(:worker))
-      @worker.priority = -1
-      load
+      @mutex = Mutex.new # Mutex used by #synchronize and #lock
       @@databases_mutex.synchronize { @@databases << self }
     end
 
+    # Database file name
+    # @return [String] database file name
+    def file
+      @journal.file
+    end
+
     # Return default value belonging to key
-    # @param key the default value to retrieve.
+    # @param [Object] key the default value to retrieve.
+    # @return [Object] value the default value
     def default(key = nil)
-      @table.default(key)
+      @table.default(@serializer.key_for(key))
     end
 
     # Retrieve a value at key from the database. If the default value was specified
     # when this database was created, that value will be set and returned. Aliased
     # as <tt>get</tt>.
-    # @param key the value to retrieve from the database.
+    # @param [Object] key the value to retrieve from the database.
+    # @return [Object] the value
     def [](key)
       @table[@serializer.key_for(key)]
     end
-    alias_method :get, :'[]'
+    alias_method :get, '[]'
 
     # Set a key in the database to be written at some future date. If the data
     # needs to be persisted immediately, call <tt>db.set(key, value, true)</tt>.
-    # @param [#to_s] key the key of the storage slot in the database
-    # @param value the value to store
+    # @param [Object] key the key of the storage slot in the database
+    # @param [Object] value the value to store
+    # @return [Object] the value
     def []=(key, value)
       key = @serializer.key_for(key)
-      @queue << [key, value]
+      @journal << [key, value]
       @table[key] = value
     end
-    alias_method :set, :'[]='
+    alias_method :set, '[]='
 
     # set! flushes data immediately to disk.
-    # @param key the key of the storage slot in the database
-    # @param value the value to store
+    # @param [Object] key the key of the storage slot in the database
+    # @param [Object] value the value to store
+    # @return [Object] the value
     def set!(key, value)
       set(key, value)
       flush
@@ -94,15 +81,17 @@ module Daybreak
     end
 
     # Delete a key from the database
-    # @param key the key of the storage slot in the database
+    # @param [Object] key the key of the storage slot in the database
+    # @return [Object] the value
     def delete(key)
       key = @serializer.key_for(key)
-      @queue << [key]
+      @journal << [key]
       @table.delete(key)
     end
 
     # Immediately delete the key on disk.
-    # @param key the key of the storage slot in the database
+    # @param [Object] key the key of the storage slot in the database
+    # @return [Object] the value
     def delete!(key)
       value = delete(key)
       flush
@@ -110,24 +99,29 @@ module Daybreak
     end
 
     # Update database with hash (Fast batch update)
+    # @param [Hash] hash the key/value hash
+    # @return [DB] self
     def update(hash)
       shash = {}
       hash.each do |key, value|
         shash[@serializer.key_for(key)] = value
       end
-      @queue << shash
+      @journal << shash
       @table.update(shash)
       self
     end
 
     # Updata database and flush data to disk.
+    # @param [Hash] hash the key/value hash
+    # @return [DB] self
     def update!(hash)
       update(hash)
-      flush
+      @journal.flush
     end
 
-    # Does this db have a value for this key?
-    # @param key the key to check if the DB has a key.
+    # Does this db have this key?
+    # @param [Object] key the key to check if the DB has it
+    # @return [Boolean]
     def has_key?(key)
       @table.has_key?(@serializer.key_for(key))
     end
@@ -135,13 +129,16 @@ module Daybreak
     alias_method :include?, :has_key?
     alias_method :member?, :has_key?
 
+    # Does this db have this value?
+    # @param [Object] value the value to check if the DB has it
+    # @return [Boolean]
     def has_value?(value)
       @table.has_value?(value)
     end
     alias_method :value?, :has_value?
 
     # Return the number of stored items.
-    # @return [Integer]
+    # @return [Fixnum]
     def size
       @table.size
     end
@@ -149,8 +146,15 @@ module Daybreak
 
     # Utility method that will return the size of the database in bytes,
     # useful for determining when to compact
+    # @return [Fixnum]
     def bytesize
-      @fd.stat.size unless closed?
+      @journal.bytesize
+    end
+
+    # Counter of how many records are in the journal
+    # @return [Fixnum]
+    def logsize
+      @journal.size
     end
 
     # Return true if database is empty.
@@ -168,232 +172,111 @@ module Daybreak
     end
 
     # Return the keys in the db.
-    # @return [Array]
+    # @return [Array<String>]
     def keys
       @table.keys
     end
 
     # Flush all changes to disk.
+    # @return [DB] self
     def flush
-      @queue.flush
+      @journal.flush
       self
     end
 
     # Sync the database with what is on disk, by first flushing changes, and
-    # then reading the file if necessary.
-    def sync
-      flush
-      load
+    # then loading the new records if necessary.
+    # @return [DB] self
+    def load
+      @journal.load
+      self
     end
+    alias_method :sunrise, :load
 
-    # Lock the database for an exclusive commit accross processes and threads
+    # Lock the database for an exclusive commit across processes and threads
+    # @note This method performs an expensive locking over process boundaries.
+    #       If you want to synchronize only between threads, use #synchronize.
+    # @see #synchronize
     # @yield a block where every change to the database is synced
+    # @yieldparam [DB] db
+    # @return result of the block
     def lock
-      @mutex.synchronize do
-        # Flush everything to start with a clean state
-        # and to protect the @locked variable
-        flush
-
-        with_flock(File::LOCK_EX) do
-          load
-          result = yield
-          flush
-          result
-        end
-      end
+      @mutex.synchronize { @journal.lock { yield self } }
+    end
+
+    # Synchronize access to the database from multiple threads
+    # @note Daybreak is not thread safe, if you want to access it from
+    #       multiple threads, all accesses have to be in the #synchronize block.
+    # @see #lock
+    # @yield a block where every change to the database is synced
+    # @yieldparam [DB] db
+    # @return result of the block
+    def synchronize
+      @mutex.synchronize { yield self }
     end
 
     # Remove all keys and values from the database.
+    # @return [DB] self
     def clear
-      flush
-      with_tmpfile do |path, file|
-        file.write(@format.header)
-        file.close
-        # Clear acts like a compactification
-        File.rename(path, @file)
-      end
       @table.clear
-      open
+      @journal.clear
       self
     end
 
     # Compact the database to remove stale commits and reduce the file size.
+    # @return [DB] self
     def compact
-      sync
-      with_tmpfile do |path, file|
-        # Compactified database has the same size -> return
-        return self if @pos == file.write(dump)
-        with_flock(File::LOCK_EX) do
-          # Database was compactified in the meantime
-          if @pos != nil
-            # Append changed journal records if the database changed during compactification
-            file.write(read)
-            file.close
-            File.rename(path, @file)
-          end
-        end
-      end
-      open
-      load
+      @journal.compact { @table }
+      self
     end
 
     # Close the database for reading and writing.
+    # @return nil
     def close
-      @queue << nil
-      @worker.join
-      @fd.close
-      @queue.stop if @queue.respond_to?(:stop)
+      @journal.close
       @@databases_mutex.synchronize { @@databases.delete(self) }
       nil
     end
 
     # Check to see if we've already closed the database.
+    # @return [Boolean]
     def closed?
-      @fd.closed?
+      @journal.closed?
     end
 
     private
 
-    # The block used in @table for new entries
-    def hash_default(_, key)
-      if @default != nil
-        value = @default.respond_to?(:call) ? @default.call(key) : @default
-        @queue << [key, value]
-        @table[key] = value
-      end
-    end
-
-    # Update the @table with records
-    def load
-      buf = read
-      until buf.empty?
-        record = @format.parse(buf)
-        if record.size == 1
-          @table.delete(record.first)
-        else
-          @table[record.first] = @serializer.load(record.last)
-        end
-        @logsize += 1
-      end
-      self
-    end
-
-    # Open or reopen file
-    def open
-      @fd.close if @fd
-      @fd = File.open(@file, 'ab+')
-      @fd.advise(:sequential) if @fd.respond_to? :advise
-      stat = @fd.stat
-      @inode = stat.ino
-      @logsize = 0
-      write(@format.header) if stat.size == 0
-      @pos = nil
-    end
-
-    # Read new file content
-    def read
-      with_flock(File::LOCK_SH) do
-        # File was opened
-        unless @pos
-          @fd.pos = 0
-          @format.read_header(@fd)
-        else
-          @fd.pos = @pos
-        end
-        buf = @fd.read
-        @pos = @fd.pos
-        buf
-      end
-    end
+    # @private
+    @@databases = []
 
-    # Return database dump as string
-    def dump
-      dump = @format.header
-      # each is faster than inject
-      @table.each do |record|
-        record[1] = @serializer.dump(record.last)
-        dump << @format.dump(record)
-      end
-      dump
-    end
+    # @private
+    @@databases_mutex = Mutex.new
 
-    # Worker thread
-    def worker
+    # A handler that will ensure that databases are closed and synced when the
+    # current process exits.
+    # @private
+    def self.exit_handler
       loop do
-        case record = @queue.next
-        when Hash
-          write_batch(record)
-        when nil
-          @queue.pop
-          break
-        else
-          write_record(record)
+        db = @@databases_mutex.synchronize { @@databases.first }
+        break unless db
+        warn "Daybreak database #{db.file} was not closed, state might be inconsistent"
+        begin
+          db.close
+        rescue Exception => ex
+          warn "Failed to close daybreak database: #{ex.message}"
         end
-        @queue.pop
       end
-    rescue Exception => ex
-      warn "Daybreak worker: #{ex.message}"
-      retry
     end
 
-    # Write batch update
-    def write_batch(records)
-      dump = ''
-      records.each do |record|
-        record[1] = @serializer.dump(record.last)
-        dump << @format.dump(record)
-      end
-      write(dump)
-      @logsize += records.size
-    end
+    at_exit { Daybreak::DB.exit_handler }
 
-    # Write single record
-    def write_record(record)
-      record[1] = @serializer.dump(record.last) if record.size > 1
-      write(@format.dump(record))
-      @logsize += 1
-    end
-
-    # Write data to output stream and advance @pos
-    def write(dump)
-      with_flock(File::LOCK_EX) do
-        @fd.write(dump)
-        # Flush to make sure the file is really updated
-        @fd.flush
-      end
-      @pos = @fd.pos if @pos && @fd.pos == @pos + dump.bytesize
-    end
-
-    # Block with file lock
-    def with_flock(mode)
-      return yield if @locked
-      begin
-        loop do
-          # HACK: JRuby returns false if the process is already hold by the same process
-          # see https://github.com/jruby/jruby/issues/496
-          Thread.pass until @fd.flock(mode)
-          # Check if database was compactified in the meantime
-          # break if not
-          stat = @fd.stat
-          break if stat.nlink > 0 && stat.ino == @inode
-          open
-        end
-        @locked = true
-        yield
-      ensure
-        @fd.flock(File::LOCK_UN)
-        @locked = false
+    # The block used in @table for new records
+    def hash_default(_, key)
+      if @default != nil
+        value = @default.respond_to?(:call) ? @default.call(key) : @default
+        @journal << [key, value]
+        @table[key] = value
       end
     end
-
-    # Open temporary file and pass it to the block
-    def with_tmpfile
-      path = [@file, $$.to_s(36), Thread.current.object_id.to_s(36)].join
-      file = File.open(path, 'wb')
-      yield(path, file)
-    ensure
-      file.close unless file.closed?
-      File.unlink(path) if File.exists?(path)
-    end
   end
 end

data/lib/daybreak/format.rb

@@ -6,6 +6,7 @@ module Daybreak
   class Format
     # Read database header from input stream
     # @param [#read] input the input stream
+    # @return void
     def read_header(input)
       raise 'Not a Daybreak database' if input.read(MAGIC.bytesize) != MAGIC
       ver = input.read(2).unpack('n').first
@@ -13,13 +14,14 @@ module Daybreak
     end
 
     # Return database header as string
+    # @return [String] database file header
     def header
       MAGIC + [VERSION].pack('n')
     end
 
     # Serialize record and return string
-    # @param [Array] record an array with [key, value] or [key] if the record is
-    # deleted
+    # @param [Array] record an array with [key, value] or [key] if the record is deleted
+    # @return [String] serialized record
     def dump(record)
       data =
         if record.size == 1
@@ -32,6 +34,7 @@ module Daybreak
 
     # Deserialize record from buffer
     # @param [String] buf the buffer to read from
+    # @return [Array] deserialized record [key, value] or [key] if the record is deleted
     def parse(buf)
       key_size, value_size = buf[0, 8].unpack('NN')
       data = buf.slice!(0, 8 + key_size + (value_size == DELETE ? 0 : value_size))
@@ -41,10 +44,18 @@ module Daybreak
 
     protected
 
+    # Magic string of the file header
     MAGIC = 'DAYBREAK'
+
+    # Database file format version
     VERSION = 1
+
+    # Special value size used for deleted records
     DELETE = (1 << 32) - 1
 
+    # Compute crc32 of string
+    # @param [String] s a string
+    # @return [Fixnum]
     def crc32(s)
       [Zlib.crc32(s, 0)].pack('N')
     end

data/lib/daybreak/journal.rb

@@ -0,0 +1,205 @@
+module Daybreak
+  # Daybreak::Journal handles background io, compaction and is the arbiter
+  # of multiprocess safety
+  # @api private
+  class Journal < Queue
+    attr_reader :size, :file
+
+    def initialize(file, format, serializer, &block)
+      super()
+      @file, @format, @serializer, @emit = file, format, serializer, block
+      open
+      @worker = Thread.new(&method(:worker))
+      @worker.priority = -1
+      load
+    end
+
+    # Is the journal closed?
+    def closed?
+      @fd.closed?
+    end
+
+    # Clear the queue and close the file handler
+    def close
+      self << nil
+      @worker.join
+      @fd.close
+      super
+    end
+
+    # Load new journal entries
+    def load
+      flush
+      replay
+    end
+
+    # Lock the logfile across thread and process boundaries
+    def lock
+      # Flush everything to start with a clean state
+      # and to protect the @locked variable
+      flush
+
+      with_flock(File::LOCK_EX) do
+        replay
+        result = yield
+        flush
+        result
+      end
+    end
+
+    # Clear the database log and yield
+    def clear
+      flush
+      with_tmpfile do |path, file|
+        file.write(@format.header)
+        file.close
+        # Clear replaces the database file like a compactification does
+        with_flock(File::LOCK_EX) do
+          File.rename(path, @file)
+        end
+      end
+      open
+    end
+
+    # Compact the logfile to represent the in-memory state
+    def compact
+      load
+      with_tmpfile do |path, file|
+        # Compactified database has the same size -> return
+        return self if @pos == file.write(dump(yield, @format.header))
+        with_flock(File::LOCK_EX) do
+          # Database was replaced (cleared or compactified) in the meantime
+          if @pos != nil
+            # Append changed journal records if the database changed during compactification
+            file.write(read)
+            file.close
+            File.rename(path, @file)
+          end
+        end
+      end
+      open
+      replay
+    end
+
+    # Return byte size of journal
+    def bytesize
+      @fd.stat.size
+    end
+
+    private
+
+    # Emit records as we parse them
+    def replay
+      buf = read
+      until buf.empty?
+        @emit.call(@format.parse(buf))
+        @size += 1
+      end
+    end
+
+    # Open or reopen file
+    def open
+      @fd.close if @fd
+      @fd = File.open(@file, 'ab+')
+      @fd.advise(:sequential) if @fd.respond_to? :advise
+      stat = @fd.stat
+      @inode = stat.ino
+      write(@format.header) if stat.size == 0
+      @pos = nil
+    end
+
+    # Read new file content
+    def read
+      with_flock(File::LOCK_SH) do
+        # File was opened
+        unless @pos
+          @fd.pos = 0
+          @format.read_header(@fd)
+          @size = 0
+          @emit.call(nil)
+        else
+          @fd.pos = @pos
+        end
+        buf = @fd.read
+        @pos = @fd.pos
+        buf
+      end
+    end
+
+    # Return database dump as string
+    def dump(records, dump = '')
+      # each is faster than inject
+      records.each do |record|
+        record[1] = @serializer.dump(record.last)
+        dump << @format.dump(record)
+      end
+      dump
+    end
+
+    # Worker thread
+    def worker
+      loop do
+        case record = first
+        when Hash
+          # Write batch update
+          write(dump(record))
+          @size += record.size
+        when nil
+          pop
+          break
+        else
+          # Write single record
+          record[1] = @serializer.dump(record.last) if record.size > 1
+          write(@format.dump(record))
+          @size += 1
+        end
+        pop
+      end
+    rescue Exception => ex
+      warn "Daybreak worker: #{ex.message}"
+      retry
+    end
+
+    # Write data to output stream and advance @pos
+    def write(dump)
+      with_flock(File::LOCK_EX) do
+        @fd.write(dump)
+        # Flush to make sure the file is really updated
+        @fd.flush
+      end
+      @pos = @fd.pos if @pos && @fd.pos == @pos + dump.bytesize
+    end
+
+    # Block with file lock
+    def with_flock(mode)
+      return yield if @locked
+      begin
+        loop do
+          # HACK: JRuby returns false if the process is already hold by the same process
+          # see https://github.com/jruby/jruby/issues/496
+          Thread.pass until @fd.flock(mode)
+          # Check if database was replaced (cleared or compactified) in the meantime
+          # break if not
+          stat = @fd.stat
+          break if stat.nlink > 0 && stat.ino == @inode
+          open
+        end
+        @locked = true
+        yield
+      ensure
+        @fd.flock(File::LOCK_UN)
+        @locked = false
+      end
+    end
+
+    # Open temporary file and pass it to the block
+    def with_tmpfile
+      path = [@file, $$.to_s(36), Thread.current.object_id.to_s(36)].join
+      file = File.open(path, 'wb')
+      yield(path, file)
+    ensure
+      file.close unless file.closed?
+      File.unlink(path) if File.exists?(path)
+    end
+  end
+end

data/lib/daybreak/queue/mri.rb

@@ -1,8 +1,12 @@
 module Daybreak
+  # A queue for ruby implementations with a GIL
+  #
+  # HACK: Dangerous optimization on MRI which has a
+  # global interpreter lock and makes the @queue array
+  # thread safe.
+  #
+  # @api private
   class Queue
-    # HACK: Dangerous optimization on MRI which has a
-    # global interpreter lock and makes the @queue array
-    # thread safe.
     def initialize
       @queue, @full, @empty = [], [], []
       @stop = false
@@ -24,7 +28,7 @@ module Daybreak
       end
     end
 
-    def next
+    def first
       while @queue.empty?
         begin
           @full << Thread.current
@@ -49,7 +53,7 @@ module Daybreak
       end
     end
 
-    def stop
+    def close
       @stop = true
       @heartbeat.join
     end
@@ -66,4 +70,4 @@ module Daybreak
       end
     end
   end
-end
+end

data/lib/daybreak/queue/threaded.rb

@@ -23,7 +23,7 @@ module Daybreak
       end
     end
 
-    def next
+    def first
       @mutex.synchronize do
         @full.wait(@mutex) while @queue.empty?
         @queue.first
@@ -35,5 +35,8 @@ module Daybreak
         @empty.wait(@mutex) until @queue.empty?
       end
     end
+
+    def close
+    end
   end
-end
+end

data/lib/daybreak/serializer.rb

@@ -4,17 +4,23 @@ module Daybreak
     # keys to strings and marshalls values
     # @api public
     class Default
-      # Return the value of the key to insert into the database
+      # Transform the key to a string
+      # @param [Object] key
+      # @return [String] key transformed to string
       def key_for(key)
         key.to_s
       end
 
       # Serialize a value
+      # @param [Object] value
+      # @return [String] value transformed to string
       def dump(value)
         Marshal.dump(value)
       end
 
       # Parse a value
+      # @param [String] value
+      # @return [Object] deserialized value
       def load(value)
         Marshal.load(value)
       end
@@ -23,14 +29,17 @@ module Daybreak
     # Serializer which does nothing
     # @api public
     class None
+      # (see Daybreak::Serializer::Default#key_for)
       def key_for(key)
         key
       end
 
+      # (see Daybreak::Serializer::Default#dump)
       def dump(value)
         value
       end
 
+      # (see Daybreak::Serializer::Default#load)
       def load(value)
         value
       end

data/lib/daybreak/version.rb

@@ -1,5 +1,5 @@
 module Daybreak
   # Version string updated using SemVer
   # @api public
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 end

data/script/bench

@@ -85,14 +85,14 @@ run db, 'with lock' do
 end
 
 db = Daybreak::DB.new DB_PATH
-run db, 'with sync' do
+run db, 'with load' do
   DATA.each do |i|
     db[i] = i
-    db.sync
+    db.sunrise
   end
   DATA.each do |i|
     $errors += 1 unless db[i] == i
-    db.sync
+    db.sunrise
   end
 end
 

data/test/test.rb

@@ -31,22 +31,22 @@ describe Daybreak::DB do
   it 'should persist values' do
     @db['1'] = '4'
     @db['4'] = '1'
-    assert_equal @db.sync, @db
+    assert_equal @db.sunrise, @db
 
     assert_equal @db['1'], '4'
-    db2 = Daybreak::DB.new DB_PATH
-    assert_equal db2['1'], '4'
-    assert_equal db2['4'], '1'
-    assert_equal db2.close, nil
+    db = Daybreak::DB.new DB_PATH
+    assert_equal db['1'], '4'
+    assert_equal db['4'], '1'
+    assert_equal db.close, nil
   end
 
   it 'should persist after batch update' do
     @db.update!(1 => :a, 2 => :b)
 
-    db2 = Daybreak::DB.new DB_PATH
-    assert_equal db2[1], :a
-    assert_equal db2[2], :b
-    assert_equal db2.close, nil
+    db = Daybreak::DB.new DB_PATH
+    assert_equal db[1], :a
+    assert_equal db[2], :b
+    assert_equal db.close, nil
   end
 
   it 'should persist after clear' do
@@ -84,7 +84,7 @@ describe Daybreak::DB do
     @db['4'] = '1'
     assert_equal @db.flush, @db
 
-    db.sync
+    db.sunrise
     assert_equal db['1'], '4'
     assert_equal db['4'], '1'
     db.close
@@ -100,7 +100,7 @@ describe Daybreak::DB do
     @db['4'] = '1'
     @db.flush
 
-    db.sync
+    db.sunrise
     assert_equal db['1'], '4'
     assert_equal db['4'], '1'
     db.close
@@ -109,7 +109,7 @@ describe Daybreak::DB do
   it 'should compact cleanly' do
     @db[1] = 1
     @db[1] = 1
-    @db.sync
+    @db.sunrise
 
     size = File.stat(DB_PATH).size
     @db.compact
@@ -119,6 +119,7 @@ describe Daybreak::DB do
 
   it 'should allow for default values' do
     db = Daybreak::DB.new(DB_PATH, :default => 0)
+    assert_equal db.default(1), 0
     assert_equal db[1], 0
     assert db.include? '1'
     db[1] = 1
@@ -130,6 +131,7 @@ describe Daybreak::DB do
 
   it 'should handle default values that are procs' do
     db = Daybreak::DB.new(DB_PATH) {|key| set = Set.new; set << key }
+    assert db.default(:test).include? 'test'
     assert db['foo'].is_a? Set
     assert db.include? 'foo'
     assert db['bar'].include? 'bar'
@@ -141,42 +143,56 @@ describe Daybreak::DB do
 
   it 'should be able to sync competing writes' do
     @db.set! '1', 4
-    db2 = Daybreak::DB.new DB_PATH
-    db2.set! '1', 5
-    @db.sync
+    db = Daybreak::DB.new DB_PATH
+    db.set! '1', 5
+    @db.sunrise
     assert_equal @db['1'], 5
-    db2.close
+    db.close
   end
 
   it 'should be able to handle another process\'s call to compact' do
     @db.lock { 20.times {|i| @db[i] = i } }
-    db2 = Daybreak::DB.new DB_PATH
+    db = Daybreak::DB.new DB_PATH
     @db.lock { 20.times {|i| @db[i] = i } }
     @db.compact
-    db2.sync
-    assert_equal 19, db2['19']
-    db2.close
+    db.sunrise
+    assert_equal 19, db['19']
+    db.close
   end
 
   it 'can empty the database' do
     20.times {|i| @db[i] = i }
     @db.clear
-    db2 = Daybreak::DB.new DB_PATH
-    assert_equal nil, db2['19']
-    db2.close
+    db = Daybreak::DB.new DB_PATH
+    assert_equal nil, db['19']
+    db.close
   end
 
   it 'should handle deletions' do
-    @db[1] = 'one'
-    @db[2] = 'two'
+    @db['one'] = 1
+    @db['two'] = 2
     @db.delete! 'two'
     assert !@db.has_key?('two')
     assert_equal @db['two'], nil
 
-    db2 = Daybreak::DB.new DB_PATH
-    assert !db2.has_key?('two')
-    assert_equal db2['two'], nil
-    db2.close
+    db = Daybreak::DB.new DB_PATH
+    assert !db.has_key?('two')
+    assert_equal db['two'], nil
+    db.close
+  end
+
+  it 'should synchronize deletions after compact' do
+    @db['one'] = 1
+    @db['two'] = 2
+    @db.flush
+    db = Daybreak::DB.new DB_PATH
+    assert db.has_key?('two')
+    @db.delete! 'two'
+    @db.compact
+    db.sunrise
+    assert !db.has_key?('two')
+    assert_equal db['two'], nil
+    db.close
   end
 
   it 'should close and reopen the file when clearing the database' do
@@ -189,7 +205,17 @@ describe Daybreak::DB do
 
   it 'should have threadsafe lock' do
     @db[1] = 0
-    inc = proc { 1000.times { @db.lock { @db[1] += 1 } } }
+    inc = proc { 1000.times { @db.lock {|d| d[1] += 1 } } }
+    a = Thread.new &inc
+    b = Thread.new &inc
+    a.join
+    b.join
+    assert_equal @db[1], 2000
+  end
+
+  it 'should have threadsafe synchronize' do
+    @db[1] = 0
+    inc = proc { 1000.times { @db.synchronize {|d| d[1] += 1 } } }
     a = Thread.new &inc
     b = Thread.new &inc
     a.join
@@ -358,6 +384,10 @@ describe Daybreak::DB do
     db.close
   end
 
+  it 'should report the bytesize' do
+    assert @db.bytesize > 0
+  end
+
   after do
     @db.clear
     @db.close

metadata

@@ -1,62 +1,57 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: daybreak
-version: !ruby/object:Gem::Version 
-  hash: 21
+version: !ruby/object:Gem::Version
+  version: 0.2.2
   prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 1
-  version: 0.2.1
 platform: ruby
-authors: 
+authors:
 - Jeff Larson
 - Daniel Mendler
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-01-16 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: minitest
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Incredibly fast pure-ruby key-value store
-email: 
+email:
 - thejefflarson@gmail.com
 - mail@daniel-mendler.de
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .travis.yml
 - .yardopts
@@ -69,6 +64,7 @@ files:
 - lib/daybreak.rb
 - lib/daybreak/db.rb
 - lib/daybreak/format.rb
+- lib/daybreak/journal.rb
 - lib/daybreak/queue.rb
 - lib/daybreak/queue/mri.rb
 - lib/daybreak/queue/threaded.rb
@@ -80,39 +76,32 @@ files:
 - test/test.rb
 - test/test_helper.rb
 homepage: http://propublica.github.com/daybreak/
-licenses: 
+licenses:
 - MIT
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_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 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Daybreak provides an incredibly fast pure-ruby in memory key-value store, which is multi-process safe and uses a journal log to store the data.
-test_files: 
+summary: Daybreak provides an incredibly fast pure-ruby in memory key-value store,
+  which is multi-process safe and uses a journal log to store the data.
+test_files:
 - test/prof.rb
 - test/test.rb
 - test/test_helper.rb