gmalamid-key_value_store 0.0.1

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2009 nutrun.com, George Malamidis, Andy Kent, Mike Jones
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,42 @@
+= KeyValueStore - Simple Tokyo Cabinet interface
+
+== Dependencies
+
+KeyValueStore Depends on Tokyo Cabinet ( http://tokyocabinet.sourceforge.net/index.html ) and the Tokyo Cabinet Ruby bindings ( http://tokyocabinet.sourceforge.net/rubypkg ). Also, the json gem ( http://json.rubyforge.org ).
+
+== Usage
+
+KeyValueStore is a minimal interface for persisting Ruby objects in Tokyo Cabinet key-value
+stores. Objects are serialized in JSON on storage and deserialized on retrieval. An object needs to implement three methods in order to be successfully stored and retrieved : <tt>storage_key</tt>, <tt>to_storage_hash</tt> and <tt>self.from_storage_hash(h)</tt>.
+
+== Usage example
+
+  class Guitar
+    def initialize(model, color)
+      @model, @color = model, color
+    end
+
+    def storage_key
+      @model
+    end
+
+    def to_storage_hash
+      {'model' => @model, 'color' => @color}
+    end
+
+    def self.from_storage_hash(h)
+      self.new(h['model'], h['color'])
+    end
+  end
+
+  store = KeyValueStore::Hash.new('guitars', Guitar)
+  les_paul = Guitar.new('les_paul', 'sunburst')
+  
+  #store
+  store.put(les_paul)
+
+  #retrieve
+  les_paul = store.get('les_paul')
+
+  #iterate
+  store.each {|guitar| puts guitar.color}

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'rake/testtask'
+
+task :default => :test
+Rake::TestTask.new { |t| t.pattern = 'test/*_test.rb' }

data/key_value_store.gemspec

@@ -0,0 +1,14 @@
+GEMSPEC =Gem::Specification.new do |s|
+  s.name = 'key_value_store'
+  s.version = '0.0.1'
+  s.platform = Gem::Platform::RUBY
+  s.rubyforge_project = "key_value_store"
+  s.summary, s.description = 'Simple Tokyo Cabinet interface'
+  s.authors = 'Mike Jones, Andy Kent, George Malamidis'
+  s.email = 'george@nutrun.com'
+  s.homepage = 'http://nutrun.com'
+  s.has_rdoc = true
+  s.rdoc_options += ['--quiet', '--title', 'Datastore', '--main', 'README.rdoc', '--inline-source']
+  s.extra_rdoc_files = ['README.rdoc', 'COPYING']
+  s.files = ["COPYING","Rakefile","README.rdoc","key_value_store.gemspec","lib/key_value_store.rb"]
+end

data/lib/key_value_store.rb

@@ -0,0 +1,251 @@
+require 'tokyocabinet'
+require 'fileutils'
+require 'rubygems'
+require 'json'
+
+module KeyValueStore
+  def self.datadir=(datadir)
+    @datadir = datadir
+  end
+
+  def self.datadir
+    if @datadir
+      "#{@datadir}/#{environment}" 
+    else
+      "#{ENV['HOME']}/.data/#{environment}"
+    end
+  end
+
+  def self.environment=(environment)
+    @environment = environment
+  end
+
+  def self.environment
+    @environment || :development
+  end
+
+  module API
+    def initialize(store_name, type, permission = :write)
+      @store_name, @type, @permission = store_name, type, permission
+    end
+
+    def delete(key)
+      connection.out(key)
+    end
+
+    def clear
+      connection.vanish
+    end
+
+    def count
+      connection.rnum
+    end
+
+    alias size count
+
+    def connection
+      return @connection if @connection && @connection.path
+      @connection = Connections.connection(@store_name, @permission, extension)
+    end
+
+    def close
+      connection.close
+    end
+
+    def sync
+      connection.sync
+    end
+
+    def rm_f
+      path = connection.path
+      if path 
+        close
+        FileUtils.rm_f(path)
+      end
+    end
+    
+    def rename(new_name)
+      path = connection.path
+      return nil unless path
+      close
+      FileUtils.cp(path, File.join(File.dirname(path), "#{new_name}.#{extension}"))
+      @store_name = new_name
+      connection
+      FileUtils.rm(path)
+    end
+  end
+
+  class Hash
+    include API
+    
+    def put(obj)
+      connection[obj.storage_key.to_s] = JSON.dump(obj.to_storage_hash)
+    end
+
+    def get(key)
+      retval = connection[key.to_s]
+      if retval
+        @type.from_storage_hash(JSON.load(retval))
+      else
+        nil
+      end
+    end
+    
+    def get_raw(key)
+      connection[key.to_s]
+    end
+    
+    def each(&block)
+      connection.iterinit
+      while val = connection.iternext
+        yield get(val)
+      end
+    end
+    
+    def each_raw(&block)
+      connection.iterinit
+      while val = connection.iternext
+        yield get_raw(val)
+      end
+    end
+
+    def extension
+      'tch'
+    end
+  end
+
+  class BTree
+    include API
+
+    def get(key)
+      if results = connection.getlist(key)
+        results.map do |e|
+          instance = @type.from_storage_hash(JSON.load(e))
+          instance.instance_variable_set(:@storage_key, key)
+          instance
+        end
+      else
+        nil
+      end
+    end
+    
+    def get_raw(key)
+      connection.getlist(key)
+    end
+
+    def put(obj)
+      connection.putdup(obj.storage_key, JSON.dump(obj.to_storage_hash))
+    end
+    
+    def extension
+      'tcb'
+    end
+  end
+  
+  class MemoryHash
+    def initialize(type)
+      @type = type
+    end
+    
+    def put(obj)
+      store[obj.storage_key] = JSON.dump(obj.to_storage_hash)
+    end
+    
+    def get(key)
+      if found = store[key]
+        @type.from_storage_hash(JSON.load(found))
+      else
+        nil
+      end
+    end
+    
+    def get_raw(key)
+      store[key]
+    end
+    
+    def each(&block)
+      store.each { |k,v| yield @type.from_storage_hash(JSON.load(v)) }
+    end
+    
+    def count
+      store.size
+    end
+
+    alias size count
+    
+    def delete(key)
+      store.delete(key)
+    end
+    
+    def clear
+      store.clear
+    end
+    
+    
+    def store
+      @store ||= {}
+    end
+  end
+
+  class Connections
+    include TokyoCabinet
+    include Enumerable
+
+    STORE_TYPES = {'tch' => TokyoCabinet::HDB, 'tcb' => TokyoCabinet::BDB}
+
+    def initialize
+      @connections = {}
+      trap('INT') do
+        close_all
+        exit
+      end
+    end
+
+    def connection(store, permission, extension)
+      FileUtils.mkdir_p(KeyValueStore.datadir)
+      file = File.join(KeyValueStore.datadir, "#{store}.#{extension}")
+      return @connections[file] if @connections[file] && @connections[file].path
+      @connections[file] = establish_connection(file, permission, STORE_TYPES[extension])
+    end
+
+    def close_all
+      each {|file, connection| connection.close }
+    end
+
+    def sync_all
+      each {|file, connection| connection.sync }
+    end
+
+    def clear_all
+      each {|file, connection| connection.vanish }
+    end
+
+    def each(&blk)
+      @connections.each(&blk)
+    end
+
+    def has_open_connections?
+      find {|file, connection| connection.path != nil }
+    end
+
+    private
+
+    def establish_connection(file, permission, type)
+      conn = type.new
+      conn.setxmsiz(0)
+      permissions = permission == :write ? (HDB::OWRITER | HDB::OCREAT) : HDB::OREADER
+      raise "#{conn.errmsg(conn.ecode)} [#{file}]" unless conn.open(file, permissions)
+      conn
+    end
+
+    class << self
+      def default
+        @connection_pool ||= Connections.new 
+      end
+
+      def method_missing(meth, *args)
+        default.send(meth, *args)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: gmalamid-key_value_store
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mike Jones, Andy Kent, George Malamidis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-01 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: george@nutrun.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- COPYING
+files: 
+- COPYING
+- Rakefile
+- README.rdoc
+- key_value_store.gemspec
+- lib/key_value_store.rb
+has_rdoc: true
+homepage: http://nutrun.com
+post_install_message: 
+rdoc_options: 
+- --quiet
+- --title
+- Datastore
+- --main
+- README.rdoc
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: key_value_store
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Simple Tokyo Cabinet interface
+test_files: []
+