rufus-tokyo 0.1.2 → 0.1.3

data/CHANGELOG.txt

@@ -1,6 +1,14 @@
 
 = rufus-tokyo CHANGELOG.txt
 
+== rufus-tokyo - 0.1.3    released 2009/01/29
+
+- todo : implemented Rufus::Tokyo::Table (and query)
+- todo : implemented Rufus::Tokyo::List
+- todo : implemented Rufus::Tokyo::Map
+- todo : implemented Cabinet#compact_copy
+- todo : implemented Cabinet#copy
+
 
 == rufus-tokyo - 0.1.2    released 2009/01/23
 

data/CREDITS.txt

@@ -1,7 +1,20 @@
 
 = CREDITS.txt rufus-tokyo gem
 
-many thanks to the authors of Tokyo Cabinet and ruby-ffi
+
+== authors
+
+John Mettraux http://jmettraux.wordpress.com
+
+
+== contributors
+
+Justin Reagor http://blog.kineticweb.com/
+
+
+== finally
+
+many thanks to the author of Tokyo Cabinet (Mikio Hirabayashi) and of ruby-ffi
 
   http://tokyocabinet.sourceforge.net
   http://kenai.com/projects/ruby-ffi

data/README.txt

@@ -3,7 +3,7 @@
 
 ruby-ffi based interface to Tokyo Cabinet.
 
-It focuses on the abstract API for now (http://tokyocabinet.sourceforge.net/spex-en.html#tcadbapi)
+The 'abstract' and the 'table' API are covered for now.
 
 
 == installation
@@ -15,6 +15,10 @@ It focuses on the abstract API for now (http://tokyocabinet.sourceforge.net/spex
 
 == usage
 
+=== Abstract API
+
+http://tokyocabinet.sourceforge.net/spex-en.html#tcadbapi
+
 to create a hash (file named 'data.tch')
 
   require 'rubygems'
@@ -34,14 +38,41 @@ to create a hash (file named 'data.tch')
   db.close
 
 
+=== Table API
+
+http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
+
+  require 'rubygems'
+  require 'rufus/tokyo/cabinet/table'
+  
+  t = Rufus::Tokyo::Table.new('table.tdb', :create, :write)
+  
+  t['pk0'] = { 'name' => 'alfred', 'age' => '22' }
+  t['pk1'] = { 'name' => 'bob', 'age' => '18' }
+  t['pk2'] = { 'name' => 'charly', 'age' => '45' }
+  t['pk3'] = { 'name' => 'doug', 'age' => '77' }
+  t['pk4'] = { 'name' => 'ephrem', 'age' => '32' }
+  
+  p t.query { |q|
+    q.add_condition 'age', :numge, '32'
+    q.order_by 'age'
+  }
+    # => [ {"name"=>"ephrem", :pk=>"pk4", "age"=>"32"},
+    #      {"name"=>"charly", :pk=>"pk2", "age"=>"45"} ]
+  
+  t.close
+
+
 more in the rdoc
 
   http://rufus.rubyforge.org/rufus-tokyo/
   http://rufus.rubyforge.org/rufus-tokyo/classes/Rufus/Tokyo/Cabinet.html
+  http://rufus.rubyforge.org/rufus-tokyo/classes/Rufus/Tokyo/Table.html
 
 or directly in the source
 
-  http://github.com/jmettraux/rufus-tokyo/blob/master/lib/rufus/tokyo.rb 
+  http://github.com/jmettraux/rufus-tokyo/blob/master/lib/rufus/tokyo/cabinet/abstract.rb
+  http://github.com/jmettraux/rufus-tokyo/blob/master/lib/rufus/tokyo/cabinet/table.rb
 
 
 == Tokyo Cabinet install
@@ -55,12 +86,9 @@ If you don't have Tokyo Cabinet on your system, you can get it and compile it :
 
   git clone git://github.com/etrepum/tokyo-cabinet.git
   cd tokyo-cabinet
-  git checkout 1.4.1
+  git checkout 1.4.2
   ./configure
   make
-
-eventually
-
   sudo make install
 
 
@@ -95,7 +123,7 @@ http://github.com/jmettraux/rufus-tokyo
 
 == credits
 
-many thanks to the authors of Tokyo Cabinet and to the authors of ruby-ffi
+many thanks to the author of Tokyo Cabinet, Mikio Hirabayashi, and to the authors of ruby-ffi
 
   http://tokyocabinet.sourceforge.net
   http://kenai.com/projects/ruby-ffi

data/lib/rufus/tokyo.rb

@@ -22,249 +22,6 @@
 #++
 #
 
-#
-# "made in Japan"
-#
-# jmettraux@gmail.com
-#
-
-require 'rubygems'
-require 'ffi'
-
-module Rufus
-module Tokyo
-
-  VERSION = '0.1.2'
-
-  module Func #:nodoc#
-    extend FFI::Library
-
-    #
-    # find Tokyo Cabinet lib
-
-    paths = Array(ENV['TOKYO_CABINET_LIB'] || %w{
-      /opt/local/lib/libtokyocabinet.dylib
-      /usr/local/lib/libtokyocabinet.dylib
-      /usr/local/lib/libtokyocabinet.so
-    })
-
-    paths.each do |path|
-      if File.exist?(path)
-        ffi_lib(path)
-        @lib = path
-        break
-      end
-    end
-
-    attach_function :tcadbnew, [], :pointer
-
-    attach_function :tcadbopen, [ :pointer, :string ], :int
-    attach_function :tcadbclose, [ :pointer ], :int
-
-    attach_function :tcadbdel, [ :pointer ], :void
-
-    attach_function :tcadbrnum, [ :pointer ], :uint64
-    attach_function :tcadbsize, [ :pointer ], :uint64
-
-    attach_function :tcadbput2, [ :pointer, :string, :string ], :int
-    attach_function :tcadbget2, [ :pointer, :string ], :string
-    attach_function :tcadbout2, [ :pointer, :string ], :int
-
-    attach_function :tcadbiterinit, [ :pointer ], :int
-    attach_function :tcadbiternext2, [ :pointer ], :string
-
-    attach_function :tcadbvanish, [ :pointer ], :int
-
-
-    #def self.method_missing (m, *args)
-    #  mm = "tcadb#{m}"
-    #  self.respond_to?(mm) ? self.send(mm, *args) : super
-    #end
-      #
-      # makes JRuby unhappy, forget it.
-  end
-
-  #
-  # Returns the path to the Tokyo Cabinet dynamic library currently in use
-  #
-  def self.lib
-    Rufus::Tokyo::Func.instance_variable_get(:@lib)
-  end
-
-  #
-  # A 'cabinet', ie a Tokyo Cabinet database.
-  #
-  # Follows the abstract API described at :
-  #
-  #   http://tokyocabinet.sourceforge.net/spex-en.html#tcadbapi
-  #
-  # An usage example :
-  #
-  #   db = Rufus::Tokyo::Cabinet.new('test_data.tch')
-  #   db['pillow'] = 'Shonagon'
-  #
-  #   db.size # => 1
-  #   db['pillow'] # => 'Shonagon'
-  #
-  #   db.delete('pillow') # => 'Shonagon'
-  #   db.size # => 0
-  #
-  #   db.close
-  #
-  class Cabinet
-    include Enumerable
-
-    #
-    # Creates/opens the cabinet, raises an exception in case of
-    # creation/opening failure.
-    #
-    # This method accepts a 'name' parameter and an optional 'params' hash
-    # parameter.
-    #
-    # 'name' follows the syntax described at
-    #
-    #   http://tokyocabinet.sourceforge.net/spex-en.html#tcadbapi
-    #
-    # under tcadbopen(). For example :
-    #
-    #   db = Rufus::Tokyo::Cabinet.new('casket.tch#bnum=100000#opts=ld')
-    #
-    # will open (eventually create) a hash database backed in the file
-    # 'casket.tch' with a bucket number of 100000 and the 'large' and
-    # 'deflate' options (opts) turned on.
-    #
-    # == :hash or :tree
-    #
-    # Setting the name to :hash or :tree simply will create a in-memory hash
-    # or tree respectively (see #new_tree and #new_hash).
-    #
-    # == tuning parameters
-    #
-    # It's ok to use the optional params hash to pass tuning parameters and
-    # options, thus
-    #
-    #   db = Rufus::Tokyo::Cabinet.new('casket.tch#bnum=100000#opts=ld')
-    #
-    # and
-    #
-    #   db = Rufus::Tokyo::Cabinet.new(
-    #     'casket.tch', :bnum => 100000, :opts => 'ld')
-    #
-    # are equivalent.
-    #
-    # == mode
-    #
-    # To open a db in read-only mode :
-    #
-    #   db = Rufus::Tokyo::Cabinet.new('casket.tch#mode=r')
-    #   db = Rufus::Tokyo::Cabinet.new('casket.tch', :mode => 'r')
-    #
-    def initialize (name, params={})
-
-      @db = Rufus::Tokyo::Func.tcadbnew
-
-      name = '*' if name == :hash # in memory hash database
-      name = '+' if name == :tree # in memory B+ tree database
-
-      name = name + params.collect { |k, v| "##{k}=#{v}" }.join('')
-
-      (Rufus::Tokyo::Func.tcadbopen(@db, name) == 1) ||
-        raise("failed to open/create db '#{name}'")
-    end
-
-    #
-    # Returns a new in-memory hash. Accepts the same optional params hash
-    # as new().
-    #
-    def self.new_hash (params={})
-      self.new(:hash, params)
-    end
-
-    #
-    # Returns a new in-memory B+ tree. Accepts the same optional params hash
-    # as new().
-    #
-    def self.new_tree (params={})
-      self.new(:tree, params)
-    end
-
-    def []= (k, v)
-      Rufus::Tokyo::Func.tcadbput2(@db, k, v)
-    end
-
-    def [] (k)
-      Rufus::Tokyo::Func.tcadbget2(@db, k) rescue nil
-    end
-
-    #
-    # Removes a record from the cabinet, returns the value if successful
-    # else nil.
-    #
-    def delete (k)
-      v = self[k]
-      (Rufus::Tokyo::Func.tcadbout2(@db, k) == 1) ? v : nil
-    end
-
-    #
-    # Returns the number of records in the 'cabinet'
-    #
-    def size
-      Rufus::Tokyo::Func.tcadbrnum(@db)
-    end
-
-    #
-    # Removes all the records in the cabinet (use with care)
-    #
-    # Returns self (like Ruby's Hash does).
-    #
-    def clear
-      Rufus::Tokyo::Func.tcadbvanish(@db)
-      self
-    end
-
-    #
-    # Returns the 'weight' of the db (in bytes)
-    #
-    def weight
-      Rufus::Tokyo::Func.tcadbsize(@db)
-    end
-
-    #
-    # Closes the cabinet (and frees the datastructure allocated for it),
-    # returns true in case of success.
-    #
-    def close
-      result = Rufus::Tokyo::Func.tcadbclose(@db)
-      Rufus::Tokyo::Func.tcadbdel(@db)
-      (result == 1)
-    end
-
-    #
-    # Returns an array with all the keys in the databse
-    #
-    def keys
-      a = []
-      Rufus::Tokyo::Func.tcadbiterinit(@db)
-      while (k = (Rufus::Tokyo::Func.tcadbiternext2(@db) rescue nil))
-        a << k
-      end
-      a
-    end
-
-    #
-    # Returns an array with all the values in the database (heavy...)
-    #
-    def values
-      collect { |k, v| v }
-    end
-
-    #
-    # The classical Ruby each (unlocks the power of the Enumerable mixin)
-    #
-    def each
-      keys.each { |k| yield(k, self[k]) }
-    end
-  end
-end
-end
+require File.dirname(__FILE__) + '/tokyo/cabinet'
+#require 'rufus/tokyo/cabinet'
 

data/lib/rufus/tokyo/base.rb

@@ -0,0 +1,123 @@
+#
+#--
+# Copyright (c) 2009, John Mettraux, jmettraux@gmail.com
+#
+# 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 OR COPYRIGHT HOLDERS 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.
+#++
+#
+
+unless defined?(FFI)
+  #
+  # don't require rubygems if not necessary
+  #
+  require 'rubygems'
+  require 'ffi'
+end
+
+module Rufus
+module Tokyo
+
+  VERSION = '0.1.3'
+
+  #
+  # A common error class
+  #
+  class TokyoError < RuntimeError; end
+
+  #
+  # Some constants shared by most of Tokyo Cabinet APIs
+  #
+  # (Used only by rufus/tokyo/cabinet/table for now)
+  #
+  module TokyoContainerMixin
+
+    #
+    # some Tokyo constants
+
+    OREADER = 1 << 0 # open as a reader
+    OWRITER = 1 << 1 # open as a writer
+    OCREAT = 1 << 2 # writer creating
+    OTRUNC = 1 << 3 # writer truncating
+    ONOLCK = 1 << 4 # open without locking
+    OLCKNB = 1 << 5 # lock without blocking
+
+    OTSYNC = 1 << 6 # synchronize every transaction (tctdb.h)
+
+    #
+    # Makes sure that a set of parameters is a hash (will transform an
+    # array into a hash if necessary)
+    #
+    def params_to_h (params)
+
+      params.is_a?(Hash) ?
+        params :
+        Array(params).inject({}) { |h, e| h[e] = true; h }
+    end
+
+    #
+    # Given params (array or hash), computes the open mode (an int)
+    # for the Tokyo Cabinet object.
+    #
+    def compute_open_mode (params)
+
+      params = params_to_h(params)
+
+      {
+        :read => OREADER,
+        :reader => OREADER,
+        :write => OWRITER,
+        :writer => OWRITER,
+        :create => OCREAT,
+        :truncate => OTRUNC,
+        :no_lock => ONOLCK,
+        :lock_no_block => OLCKNB,
+        :sync_every => OTSYNC
+
+      }.inject(0) { |r, (k, v)|
+
+        r = r | v if params[k]; r
+      }
+    end
+  end
+
+  #
+  # Generates a lib mixin from a FFI module.
+  #
+  # Including this mixin will simply bind two #lib methods (call and instance)
+  # returning the FFI module.
+  #
+  def self.generate_lib_mixin (lib_module)
+    eval %{
+      module #{lib_module}Mixin
+        def self.included (target)
+          target.class_eval do
+            def self.lib
+              #{lib_module}
+            end
+            def lib
+              self.class.lib
+            end
+          end
+        end
+      end
+    }
+  end
+end
+end
+