daybreak 0.2.0 → 0.2.1

data/.travis.yml

@@ -11,4 +11,7 @@ env:
   matrix:
     - "TASK=test"
     - "TASK=bench"
+  allowed_failures:
+    env:
+      - "TASK=bench"
 script: "bundle exec rake $TASK"

data/lib/daybreak/db.rb

@@ -5,19 +5,24 @@ module Daybreak
   class DB
     include Enumerable
 
-    # Accessors for the database file, and a counter of how many records are in
-    # sync with the file.
-    attr_reader :file, :logsize
+    # 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
+    @@databases = []
+    @@databases_mutex = Mutex.new
 
     # A handler that will ensure that databases are closed and synced when the
     # current process exits.
-    at_exit do
+    # @api private
+    def self.exit_handler
       loop do
-        db = @databases_mutex.synchronize { @databases.first }
+        db = @@databases_mutex.synchronize { @@databases.first }
         break unless db
         warn "Daybreak database #{db.file} was not closed, state might be inconsistent"
         begin
@@ -28,17 +33,7 @@ module Daybreak
       end
     end
 
-    class << self
-      # @api private
-      def register(db)
-        @databases_mutex.synchronize { @databases << db }
-      end
-
-      # @api private
-      def unregister(db)
-        @databases_mutex.synchronize { @databases.delete(db) }
-      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
@@ -52,21 +47,21 @@ module Daybreak
       @file = file
       @serializer = (options[:serializer] || Serializer::Default).new
       @format = (options[:format] || Format).new
-      @default = block ? block : options[:default]
       @queue = Queue.new
-      @table = {}
+      @table = Hash.new(&method(:hash_default))
+      @default = block ? block : options[:default]
       open
       @mutex = Mutex.new # Mutex to make #lock thread safe
       @worker = Thread.new(&method(:worker))
       @worker.priority = -1
-      update
-      self.class.register(self)
+      load
+      @@databases_mutex.synchronize { @@databases << self }
     end
 
     # Return default value belonging to key
     # @param key the default value to retrieve.
     def default(key = nil)
-      @default.respond_to?(:call) ? @default.call(key) : @default
+      @table.default(key)
     end
 
     # Retrieve a value at key from the database. If the default value was specified
@@ -74,15 +69,7 @@ module Daybreak
     # as <tt>get</tt>.
     # @param key the value to retrieve from the database.
     def [](key)
-      skey = @serializer.key_for(key)
-      value = @table[skey]
-      if value != nil || @table.has_key?(skey)
-        value
-      elsif @default
-        value = default(key)
-        @queue << [skey, value]
-        @table[skey] = value
-      end
+      @table[@serializer.key_for(key)]
     end
     alias_method :get, :'[]'
 
@@ -122,6 +109,23 @@ module Daybreak
       value
     end
 
+    # Update database with hash (Fast batch update)
+    def update(hash)
+      shash = {}
+      hash.each do |key, value|
+        shash[@serializer.key_for(key)] = value
+      end
+      @queue << shash
+      @table.update(shash)
+      self
+    end
+
+    # Updata database and flush data to disk.
+    def update!(hash)
+      update(hash)
+      flush
+    end
+
     # Does this db have a value for this key?
     # @param key the key to check if the DB has a key.
     def has_key?(key)
@@ -143,6 +147,12 @@ module Daybreak
     end
     alias_method :length, :size
 
+    # Utility method that will return the size of the database in bytes,
+    # useful for determining when to compact
+    def bytesize
+      @fd.stat.size unless closed?
+    end
+
     # Return true if database is empty.
     # @return [Boolean]
     def empty?
@@ -166,24 +176,26 @@ module Daybreak
     # Flush all changes to disk.
     def flush
       @queue.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
-      update
+      load
     end
 
     # Lock the database for an exclusive commit accross processes and threads
     # @yield a block where every change to the database is synced
     def lock
       @mutex.synchronize do
-        # We need a flush before exclusive
-        # so that @exclusive is not modified by the worker
+        # Flush everything to start with a clean state
+        # and to protect the @locked variable
         flush
-        exclusive do
-          update
+
+        with_flock(File::LOCK_EX) do
+          load
           result = yield
           flush
           result
@@ -209,13 +221,11 @@ module Daybreak
     def compact
       sync
       with_tmpfile do |path, file|
-        compactsize = file.write(dump)
-        exclusive do
-          stat = @fd.stat
-          # Check if database was compactified at the same time
-          if stat.nlink > 0 && stat.ino == @inode
-            # Compactified database has the same size -> return
-            return self if stat.size == compactsize
+        # 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
@@ -224,8 +234,7 @@ module Daybreak
         end
       end
       open
-      update
-      self
+      load
     end
 
     # Close the database for reading and writing.
@@ -234,7 +243,7 @@ module Daybreak
       @worker.join
       @fd.close
       @queue.stop if @queue.respond_to?(:stop)
-      self.class.unregister(self)
+      @@databases_mutex.synchronize { @@databases.delete(self) }
       nil
     end
 
@@ -245,9 +254,18 @@ module Daybreak
 
     private
 
-    # Update the @table with records read from the file, and increment @logsize
-    def update
-      buf = new_records
+    # 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
@@ -257,29 +275,10 @@ module Daybreak
         end
         @logsize += 1
       end
+      self
     end
 
-    # Read new records from journal log and return buffer
-    def new_records
-      loop do
-        unless @exclusive
-          # 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(File::LOCK_SH)
-        end
-        # Check if database was compactified in the meantime
-        # break if not
-        stat = @fd.stat
-        break if stat.nlink > 0 && stat.ino == @inode
-        open
-      end
-
-      # Read new journal records
-      read
-    ensure
-      @fd.flock(File::LOCK_UN) unless @exclusive
-    end
-
+    # Open or reopen file
     def open
       @fd.close if @fd
       @fd = File.open(@file, 'ab+')
@@ -287,24 +286,24 @@ module Daybreak
       stat = @fd.stat
       @inode = stat.ino
       @logsize = 0
-      if stat.size == 0
-        @fd.write(@format.header)
-        @fd.flush
-      end
+      write(@format.header) if stat.size == 0
       @pos = nil
     end
 
+    # Read new file content
     def read
-      # File was opened
-      unless @pos
-        @fd.pos = 0
-        @format.read_header(@fd)
-      else
-        @fd.pos = @pos
+      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
-      buf = @fd.read
-      @pos = @fd.pos
-      buf
     end
 
     # Return database dump as string
@@ -321,49 +320,69 @@ module Daybreak
     # Worker thread
     def worker
       loop do
-        record = @queue.next
-        write_record(record) if record
+        case record = @queue.next
+        when Hash
+          write_batch(record)
+        when nil
+          @queue.pop
+          break
+        else
+          write_record(record)
+        end
         @queue.pop
-        break unless record
       end
     rescue Exception => ex
       warn "Daybreak worker: #{ex.message}"
       retry
     end
 
-    # Write record to output stream and
-    # advance input stream
+    # 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
+
+    # Write single record
     def write_record(record)
       record[1] = @serializer.dump(record.last) if record.size > 1
-      record = @format.dump(record)
-      exclusive do
-        @fd.write(record)
+      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 + record.bytesize
-      @logsize += 1
+      @pos = @fd.pos if @pos && @fd.pos == @pos + dump.bytesize
     end
 
-    # Lock database exclusively
-    def exclusive
-      return yield if @exclusive
+    # 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(File::LOCK_EX)
+          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
-        @exclusive = true
+        @locked = true
         yield
       ensure
         @fd.flock(File::LOCK_UN)
-        @exclusive = false
+        @locked = false
       end
     end
 

data/lib/daybreak/format.rb

@@ -1,6 +1,6 @@
 module Daybreak
   # Database format serializer and deserializer. You can create
-  # your own implementations of this classes method and define
+  # your own implementation of this class and define
   # your own database format!
   # @api public
   class Format
@@ -35,7 +35,7 @@ module Daybreak
     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))
-      raise 'CRC mismatch' unless buf.slice!(0, 4) == crc32(data)
+      raise 'CRC mismatch: your data might be corrupted!' unless buf.slice!(0, 4) == crc32(data)
       value_size == DELETE ? [data[8, key_size]] : [data[8, key_size], data[8 + key_size, value_size]]
     end
 

data/lib/daybreak/queue.rb

@@ -1,107 +1,5 @@
-module Daybreak
-  # Thread safe job queue
-  # @api private
-  class Queue
-    # HACK: Dangerous optimization on MRI which has a
-    # global interpreter lock and makes the @queue array
-    # thread safe.
-    if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
-      def initialize
-        @queue, @full, @empty = [], [], []
-        @stop = false
-        @heartbeat = Thread.new(&method(:heartbeat))
-        @heartbeat.priority = -9
-      end
-
-      def <<(x)
-        @queue << x
-        thread = @full.first
-        thread.wakeup if thread
-      end
-
-      def pop
-        @queue.shift
-        if @queue.empty?
-          thread = @empty.first
-          thread.wakeup if thread
-        end
-      end
-
-      def next
-        while @queue.empty?
-          begin
-            @full << Thread.current
-            # If a push happens before Thread.stop, the thread won't be woken up
-            Thread.stop while @queue.empty?
-          ensure
-            @full.delete(Thread.current)
-          end
-        end
-        @queue.first
-      end
-
-      def flush
-        until @queue.empty?
-          begin
-            @empty << Thread.current
-            # If a pop happens before Thread.stop, the thread won't be woken up
-            Thread.stop until @queue.empty?
-          ensure
-            @empty.delete(Thread.current)
-          end
-        end
-      end
-
-      def stop
-        @stop = true
-        @heartbeat.join
-      end
-
-      private
-
-      # Check threads 10 times per second to avoid deadlocks
-      # since there is a race condition below
-      def heartbeat
-        until @stop
-          @empty.each(&:wakeup)
-          @full.each(&:wakeup)
-          sleep 0.1
-        end
-      end
-    else
-      def initialize
-        @mutex = Mutex.new
-        @full = ConditionVariable.new
-        @empty = ConditionVariable.new
-        @queue = []
-      end
-
-      def <<(x)
-        @mutex.synchronize do
-          @queue << x
-          @full.signal
-        end
-      end
-
-      def pop
-        @mutex.synchronize do
-          @queue.shift
-          @empty.signal if @queue.empty?
-        end
-      end
-
-      def next
-        @mutex.synchronize do
-          @full.wait(@mutex) while @queue.empty?
-          @queue.first
-        end
-      end
-
-      def flush
-        @mutex.synchronize do
-          @empty.wait(@mutex) until @queue.empty?
-        end
-      end
-    end
-  end
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+  require 'daybreak/queue/mri'
+else
+  require 'daybreak/queue/threaded'
 end

data/lib/daybreak/queue/mri.rb

@@ -0,0 +1,69 @@
+module Daybreak
+  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
+      @heartbeat = Thread.new(&method(:heartbeat))
+      @heartbeat.priority = -9
+    end
+
+    def <<(x)
+      @queue << x
+      thread = @full.first
+      thread.wakeup if thread
+    end
+
+    def pop
+      @queue.shift
+      if @queue.empty?
+        thread = @empty.first
+        thread.wakeup if thread
+      end
+    end
+
+    def next
+      while @queue.empty?
+        begin
+          @full << Thread.current
+          # If a push happens before Thread.stop, the thread won't be woken up
+          Thread.stop while @queue.empty?
+        ensure
+          @full.delete(Thread.current)
+        end
+      end
+      @queue.first
+    end
+
+    def flush
+      until @queue.empty?
+        begin
+          @empty << Thread.current
+          # If a pop happens before Thread.stop, the thread won't be woken up
+          Thread.stop until @queue.empty?
+        ensure
+          @empty.delete(Thread.current)
+        end
+      end
+    end
+
+    def stop
+      @stop = true
+      @heartbeat.join
+    end
+
+    private
+
+    # Check threads 10 times per second to avoid deadlocks
+    # since there is a race condition above
+    def heartbeat
+      until @stop
+        @empty.each(&:wakeup)
+        @full.each(&:wakeup)
+        sleep 0.1
+      end
+    end
+  end
+end

data/lib/daybreak/queue/threaded.rb

@@ -0,0 +1,39 @@
+module Daybreak
+  # A queue for threaded implementations of ruby without a GIL
+  # @api private
+  class Queue
+    def initialize
+      @mutex = Mutex.new
+      @full = ConditionVariable.new
+      @empty = ConditionVariable.new
+      @queue = []
+    end
+
+    def <<(x)
+      @mutex.synchronize do
+        @queue << x
+        @full.signal
+      end
+    end
+
+    def pop
+      @mutex.synchronize do
+        @queue.shift
+        @empty.signal if @queue.empty?
+      end
+    end
+
+    def next
+      @mutex.synchronize do
+        @full.wait(@mutex) while @queue.empty?
+        @queue.first
+      end
+    end
+
+    def flush
+      @mutex.synchronize do
+        @empty.wait(@mutex) until @queue.empty?
+      end
+    end
+  end
+end

data/lib/daybreak/version.rb

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

data/script/bench

@@ -43,6 +43,7 @@ def run(instance, message = '', &blk)
   report measure(instance, &blk)
   puts '=' * 64
 ensure
+  instance.clear if instance.respond_to? :clear
   instance.close if instance.respond_to? :close
 end
 
@@ -70,7 +71,8 @@ rescue Exception => ex
 end
 
 run Hash.new
-run Daybreak::DB.new DB_PATH
+db = Daybreak::DB.new DB_PATH
+run db
 
 db = Daybreak::DB.new DB_PATH
 run db, 'with lock' do
@@ -93,3 +95,14 @@ run db, 'with sync' do
     db.sync
   end
 end
+
+hash = DATA.reduce({}) {|m, v| m.merge! v => v }
+db = Daybreak::DB.new DB_PATH
+run db, 'bulk updates' do
+  db.update hash
+end
+
+db = Daybreak::DB.new DB_PATH
+run db, 'bulk updates, synced' do
+  db.update! hash
+end

data/test/prof.rb

@@ -4,10 +4,10 @@ require 'ruby-prof'
 
 result = RubyProf.profile do
   db = Daybreak::DB.new './t.db'
-  100000.times {|n| db[n] = n}
-  db.flush!
+  10.times {|n| db[n] = n}
+  db.flush
+  db.close
 end
-
 File.unlink './t.db'
 printer = RubyProf::MultiPrinter.new(result)
 FileUtils.mkdir('./profile') unless File.exists? './profile'

data/test/test.rb

@@ -11,6 +11,8 @@ describe Daybreak::DB do
   end
 
   it 'should insert' do
+    assert_equal @db[1], nil
+    assert_equal @db.include?(1), false
     @db[1] = 1
     assert_equal @db[1], 1
     assert @db.has_key?(1)
@@ -19,24 +21,40 @@ describe Daybreak::DB do
     assert_equal @db.length, 1
   end
 
+  it 'should support batch inserts' do
+    @db.update(1 => :a, 2 => :b)
+    assert_equal @db[1], :a
+    assert_equal @db[2], :b
+    assert_equal @db.length, 2
+  end
+
   it 'should persist values' do
     @db['1'] = '4'
     @db['4'] = '1'
-    @db.sync
+    assert_equal @db.sync, @db
 
     assert_equal @db['1'], '4'
     db2 = Daybreak::DB.new DB_PATH
     assert_equal db2['1'], '4'
     assert_equal db2['4'], '1'
-    db2.close
+    assert_equal db2.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
   end
 
   it 'should persist after clear' do
     @db['1'] = 'xy'
-    @db.clear
+    assert_equal @db.clear, @db
     @db['1'] = '4'
     @db['4'] = '1'
-    @db.close
+    assert_equal @db.close, nil
 
     @db = Daybreak::DB.new DB_PATH
     assert_equal @db['1'], '4'
@@ -46,10 +64,10 @@ describe Daybreak::DB do
   it 'should persist after compact' do
     @db['1'] = 'xy'
     @db['1'] = 'z'
-    @db.compact
+    assert_equal @db.compact, @db
     @db['1'] = '4'
     @db['4'] = '1'
-    @db.close
+    assert_equal @db.close, nil
 
     @db = Daybreak::DB.new DB_PATH
     assert_equal @db['1'], '4'
@@ -61,10 +79,10 @@ describe Daybreak::DB do
 
     @db['1'] = 'xy'
     @db['1'] = 'z'
-    @db.compact
+    assert_equal @db.compact, @db
     @db['1'] = '4'
     @db['4'] = '1'
-    @db.flush
+    assert_equal @db.flush, @db
 
     db.sync
     assert_equal db['1'], '4'
@@ -100,16 +118,24 @@ describe Daybreak::DB do
   end
 
   it 'should allow for default values' do
-    default_db = Daybreak::DB.new(DB_PATH, :default => 0)
-    assert_equal default_db[1], 0
-    default_db[1] = 1
-    assert_equal default_db[1], 1
-    default_db.close
+    db = Daybreak::DB.new(DB_PATH, :default => 0)
+    assert_equal db[1], 0
+    assert db.include? '1'
+    db[1] = 1
+    assert_equal db[1], 1
+    db.default = 42
+    assert_equal db['x'], 42
+    db.close
   end
 
   it 'should handle default values that are procs' do
-    db = Daybreak::DB.new(DB_PATH) {|key| Set.new }
+    db = Daybreak::DB.new(DB_PATH) {|key| set = Set.new; set << key }
     assert db['foo'].is_a? Set
+    assert db.include? 'foo'
+    assert db['bar'].include? 'bar'
+    db.default = proc {|key| [key] }
+    assert db[1].is_a? Array
+    assert db[2] == ['2']
     db.close
   end
 
@@ -192,8 +218,8 @@ describe Daybreak::DB do
           db["b#{i}"] = i
           sleep 0.01 if i % 100 == 0
         end
-      db.close
-    end
+        db.close
+      end
       Process.wait a
       Process.wait b
       @db = Daybreak::DB.new DB_PATH
@@ -310,13 +336,28 @@ describe Daybreak::DB do
     end
   end
 
-  it 'should support set! in lock' do
+  it 'should support set! and delete! in lock' do
     @db[1] = 2
     @db.lock do
       @db.set!(1, 2)
+      @db.delete!(1)
     end
   end
 
+  it 'should allow for inheritance' do
+    class Subclassed < Daybreak::DB
+      def increment(key, amount = 1)
+        lock { self[key] += amount }
+      end
+    end
+
+    db = Subclassed.new DB_PATH
+    db[1] = 1
+    assert_equal db.increment(1), 2
+    db.clear
+    db.close
+  end
+
   after do
     @db.clear
     @db.close

metadata

@@ -1,57 +1,62 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: daybreak
-version: !ruby/object:Gem::Version
-  version: 0.2.0
+version: !ruby/object:Gem::Version 
+  hash: 21
   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-14 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2013-01-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: rake
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
   prerelease: false
-  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
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: minitest
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 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
@@ -65,6 +70,8 @@ files:
 - lib/daybreak/db.rb
 - lib/daybreak/format.rb
 - lib/daybreak/queue.rb
+- lib/daybreak/queue/mri.rb
+- lib/daybreak/queue/threaded.rb
 - lib/daybreak/serializer.rb
 - lib/daybreak/version.rb
 - script/bench
@@ -73,33 +80,39 @@ 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
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      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
-has_rdoc: