rufus-tokyo 0.1.4 → 0.1.5

data/CHANGELOG.txt

@@ -2,6 +2,15 @@
 = rufus-tokyo CHANGELOG.txt
 
 
+== rufus-tokyo - 0.1.5    released 2009/02/13
+
+- todo : implemented set_index (cabinet / tyrant tables)
+- todo : namespace simplification (Justin)
+- todo : implemented Rufus::Tokyo::TyrantTable
+- todo : implemented Rufus::Tokyo::Tyrant
+- todo : moved tests to bacon (spec/)
+
+
 == rufus-tokyo - 0.1.4    released 2009/02/02
 
 - todo #23780 : hmethods for Rufus::Tokyo::Table

data/CREDITS.txt

@@ -5,10 +5,6 @@
 == authors
 
 John Mettraux http://jmettraux.wordpress.com
-
-
-== contributors
-
 Justin Reagor http://blog.kineticweb.com/
 
 

data/README.txt

@@ -1,21 +1,24 @@
 
 = rufus-tokyo
 
-ruby-ffi based interface to Tokyo Cabinet.
+ruby-ffi based interface to Tokyo Cabinet and Tokyo Tyrant.
 
 The 'abstract' and the 'table' API are covered for now.
 
 
 == installation
 
-  sudo gem install ffi rufus-tokyo
+  sudo gem install rufus-tokyo
 
-  (see after 'usage' for how to install Tokyo Cabinet if required)
+  (see after 'usage' for how to install Tokyo Cabinet (and Tyrant) if required)
 
 
 == usage
 
-=== Abstract API
+hereafter TC references Tokyo Cabinet, while TT references Tokyo Tyrant.
+
+
+=== TC Abstract API
 
 http://tokyocabinet.sourceforge.net/spex-en.html#tcadbapi
 
@@ -38,12 +41,12 @@ to create a hash (file named 'data.tch')
   db.close
 
 
-=== Table API
+=== TC Table API
 
 http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
 
   require 'rubygems'
-  require 'rufus/tokyo/cabinet/table'
+  require 'rufus/tokyo'
   
   t = Rufus::Tokyo::Table.new('table.tdb', :create, :write)
   
@@ -62,17 +65,62 @@ http://tokyocabinet.sourceforge.net/spex-en.html#tctdbapi
   
   t.close
 
+=== TT remote db
+
+http://tokyocabinet.sourceforge.net/tyrantdoc/
+
+  require 'rubygems'
+  require 'rufus/tokyo'
+
+  db = Rufus::Tokyo::Tyrant.new('tyrant.example.com', 45001)
+
+  db['nada'] = 'surf'
+
+  p db['nada'] # => 'surf'
+  p db['lost'] # => nil
+
+  db.close
+
+
+=== TT remote table
+
+like a local table :
+
+  require 'rubygems'
+  require 'rufus/tokyo'
+  
+  t = Rufus::Tokyo::TyrantTable.new('localhost', 45006)
+  
+  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
+  http://rufus.rubyforge.org/rufus-tokyo/classes/Rufus/Tokyo/Tyrant.html
+  http://rufus.rubyforge.org/rufus-tokyo/classes/Rufus/Tokyo/TyrantTable.html
 
 or directly in the source
 
   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
+  http://github.com/jmettraux/rufus-tokyo/blob/master/lib/rufus/tokyo/tyrant/abstract.rb
+  http://github.com/jmettraux/rufus-tokyo/blob/master/lib/rufus/tokyo/tyrant/table.rb
 
 
 == Tokyo Cabinet install
@@ -86,11 +134,35 @@ 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.2
+  #git checkout 1.4.4
+  ./configure
+  make
+  sudo make install
+
+or get the souce at
+
+  http://sourceforge.net/project/showfiles.php?group_id=200242&package_id=237686
+
+(note : I tend to run rufus-tokyo against the latest version of Tokyo Cabinet)
+
+
+== Tokyo Tyrant install
+
+(Tokyo Tyrant requires Tokyo Cabinet)
+
+If you don't have Tokyo Tyrant on your system, you can get it and compile it :
+
+  git clone git://github.com/etrepum/tokyo-tyrant.git
+  cd tokyo-cabinet
+  #git checkout 1.1.14
   ./configure
   make
   sudo make install
 
+or get the souce at
+
+  http://sourceforge.net/project/showfiles.php?group_id=200242&package_id=237686
+
 
 == dependencies
 
@@ -101,7 +173,7 @@ If you don't have Tokyo Cabinet on your system, you can get it and compile it :
 
 On the rufus-ruby list[http://groups.google.com/group/rufus-ruby] :
 
-    http://groups.google.com/group/rufus-ruby
+  http://groups.google.com/group/rufus-ruby
 
 
 == issue tracker
@@ -118,7 +190,7 @@ irc.freenode.net #ruote
 
 http://github.com/jmettraux/rufus-tokyo
 
-    git clone git://github.com/jmettraux/rufus-tokyo.git
+  git clone git://github.com/jmettraux/rufus-tokyo.git
 
 
 == credits
@@ -129,10 +201,10 @@ many thanks to the author of Tokyo Cabinet, Mikio Hirabayashi, and to the author
   http://kenai.com/projects/ruby-ffi
 
 
-== author
+== authors
 
-John Mettraux, jmettraux@gmail.com
-http://jmettraux.wordpress.com
+John Mettraux, jmettraux@gmail.com, http://jmettraux.wordpress.com
+Justin Reagor, http://blog.kineticweb.com/
 
 
 == the rest of Rufus

data/lib/rufus/tokyo.rb

@@ -22,6 +22,24 @@
 #++
 #
 
+require 'ffi' # sudo gem install ffi
+
+
+module Rufus
+  module Tokyo
+
+    VERSION = '0.1.5'
+
+    #
+    # A common error class
+    #
+    class TokyoError < RuntimeError; end
+
+  end
+end
+
+require File.dirname(__FILE__) + '/tokyo/hmethods'
 require File.dirname(__FILE__) + '/tokyo/cabinet'
-#require 'rufus/tokyo/cabinet'
+require File.dirname(__FILE__) + '/tokyo/tyrant'
+require File.dirname(__FILE__) + '/tokyo/dystopia'
 

data/lib/rufus/tokyo/cabinet.rb

@@ -1,3 +1,6 @@
 
-require 'rufus/tokyo/cabinet/abstract'
+require File.dirname(__FILE__) + '/cabinet/lib'
+require File.dirname(__FILE__) + '/cabinet/util'
+require File.dirname(__FILE__) + '/cabinet/table'
+require File.dirname(__FILE__) + '/cabinet/abstract'
 

data/lib/rufus/tokyo/cabinet/abstract.rb

@@ -28,209 +28,214 @@
 # jmettraux@gmail.com
 #
 
-require 'rufus/tokyo/hmethods'
-require 'rufus/tokyo/cabinet/lib'
-
-
-module Rufus::Tokyo
-
-  #
-  # A 'cabinet', ie a Tokyo Cabinet [abstract] 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 CabinetLibMixin
-    include HashMethods
+module Rufus
+  module Tokyo
 
     #
-    # Creates/opens the cabinet, raises an exception in case of
-    # creation/opening failure.
+    # A 'cabinet', ie a Tokyo Cabinet [abstract] database.
     #
-    # This method accepts a 'name' parameter and an optional 'params' hash
-    # parameter.
-    #
-    # 'name' follows the syntax described at
+    # Follows the abstract API 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 = lib.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('')
-
-      (lib.tcadbopen(@db, name) == 1) ||
-        raise("failed to open/create db '#{name}'")
-
-      self.default = params[:default]
-      @default_proc ||= params[:default_proc]
-    end
-
-    #
-    # Returns a new in-memory hash. Accepts the same optional params hash
-    # as new().
-    #
-    def self.new_hash (params={})
-      self.new(:hash, params)
+    # 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 HashMethods
+
+      #
+      # 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 = lib.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('')
+
+        (lib.tcadbopen(@db, name) == 1) ||
+          raise("failed to open/create db '#{name}'")
+
+        self.default = params[:default]
+        @default_proc ||= params[:default_proc]
+      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
+
+      #
+      # using the cabinet lib
+      #
+      def lib
+        CabinetLib
+      end
+
+      #
+      # No comment
+      #
+      def []= (k, v)
+        lib.abs_put2(@db, k, v)
+      end
+
+      #
+      # (The actual #[] method is provided by HashMethods
+      #
+      def get (k)
+        lib.abs_get2(@db, k) rescue nil
+      end
+      protected :get
+
+      #
+      # Removes a record from the cabinet, returns the value if successful
+      # else nil.
+      #
+      def delete (k)
+        v = self[k]
+        (lib.abs_out2(@db, k) == 1) ? v : nil
+      end
+
+      #
+      # Returns the number of records in the 'cabinet'
+      #
+      def size
+        lib.abs_rnum(@db)
+      end
+
+      #
+      # Removes all the records in the cabinet (use with care)
+      #
+      # Returns self (like Ruby's Hash does).
+      #
+      def clear
+        lib.abs_vanish(@db)
+        self
+      end
+
+      #
+      # Returns the 'weight' of the db (in bytes)
+      #
+      def weight
+        lib.abs_size(@db)
+      end
+
+      #
+      # Closes the cabinet (and frees the datastructure allocated for it),
+      # returns true in case of success.
+      #
+      def close
+        result = lib.abs_close(@db)
+        lib.abs_del(@db)
+        (result == 1)
+      end
+
+      #
+      # Copies the current cabinet to a new file.
+      #
+      # Returns true if it was successful.
+      #
+      def copy (target_path)
+        (lib.abs_copy(@db, target_path) == 1)
+      end
+
+      #
+      # Copies the current cabinet to a new file.
+      #
+      # Does it by copying each entry afresh to the target file. Spares some
+      # space, hence the 'compact' label...
+      #
+      def compact_copy (target_path)
+        @other_db = Cabinet.new(target_path)
+        self.each { |k, v| @other_db[k] = v }
+        @other_db.close
+      end
+
+      #
+      # "synchronize updated contents of an abstract database object with
+      # the file and the device"
+      #
+      def sync
+        (lib.abs_sync(@db) == 1)
+      end
+
+      #
+      # Returns an array with all the keys in the databse
+      #
+      def keys
+        a = []
+        lib.abs_iterinit(@db)
+        while (k = (lib.abs_iternext2(@db) rescue nil)); a << k; end
+        a
+      end
     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
-
-    #
-    # No comment
-    #
-    def []= (k, v)
-      lib.tcadbput2(@db, k, v)
-    end
-
-    #
-    # (The actual #[] method is provided by HashMethods
-    #
-    def get (k)
-      lib.tcadbget2(@db, k) rescue nil
-    end
-    protected :get
-
-    #
-    # Removes a record from the cabinet, returns the value if successful
-    # else nil.
-    #
-    def delete (k)
-      v = self[k]
-      (lib.tcadbout2(@db, k) == 1) ? v : nil
-    end
-
-    #
-    # Returns the number of records in the 'cabinet'
-    #
-    def size
-      lib.tcadbrnum(@db)
-    end
-
-    #
-    # Removes all the records in the cabinet (use with care)
-    #
-    # Returns self (like Ruby's Hash does).
-    #
-    def clear
-      lib.tcadbvanish(@db)
-      self
-    end
-
-    #
-    # Returns the 'weight' of the db (in bytes)
-    #
-    def weight
-      lib.tcadbsize(@db)
-    end
-
-    #
-    # Closes the cabinet (and frees the datastructure allocated for it),
-    # returns true in case of success.
-    #
-    def close
-      result = lib.tcadbclose(@db)
-      lib.tcadbdel(@db)
-      (result == 1)
-    end
-
-    #
-    # Copies the current cabinet to a new file.
-    #
-    # Returns true if it was successful.
-    #
-    def copy (target_path)
-      (lib.tcadbcopy(@db, target_path) == 1)
-    end
-
-    #
-    # Copies the current cabinet to a new file.
-    #
-    # Does it by copying each entry afresh to the target file. Spares some
-    # space, hence the 'compact' label...
-    #
-    def compact_copy (target_path)
-      @other_db = Rufus::Tokyo::Cabinet.new(target_path)
-      self.each { |k, v| @other_db[k] = v }
-      @other_db.close
-    end
-
-    #
-    # "synchronize updated contents of an abstract database object with
-    # the file and the device"
-    #
-    def sync
-      (lib.tcadbsync(@db) == 1)
-    end
-
-    #
-    # Returns an array with all the keys in the databse
-    #
-    def keys
-      a = []
-      lib.tcadbiterinit(@db)
-      while (k = (lib.tcadbiternext2(@db) rescue nil)); a << k; end
-      a
-    end
   end
 end
-