metry 1.0.0

data/vendor/rufus-tokyo/lib/rufus-edo.rb

@@ -0,0 +1,3 @@
+
+require 'rufus/edo'
+

data/vendor/rufus-tokyo/lib/rufus-tokyo.rb

@@ -0,0 +1,3 @@
+
+require 'rufus/tokyo'
+

data/vendor/rufus-tokyo/lib/rufus/edo.rb

@@ -0,0 +1,39 @@
+#--
+# 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.
+#
+# Made in Japan.
+#++
+
+
+begin
+
+  require 'tokyocabinet'
+
+rescue LoadError
+
+  raise LoadError.new(
+    "tokyocabinet 'native' C bindings not present on your system, " +
+    "see http://github.com/jmettraux/rufus-tokyo/tree/master/lib/rufus/edo")
+end
+
+require 'rufus/edo/cabinet/abstract'
+require 'rufus/edo/cabinet/table'
+

data/vendor/rufus-tokyo/lib/rufus/edo/README.txt

@@ -0,0 +1,106 @@
+
+= Rufus::Edo
+
+wrapping Hirabayashi-san's 'native' ruby bindings into a rubiyst-friendly set of Ruby classes.
+
+In order to use Rufus::Edo, you have to have the libtokyocabinet dynamic library installed on your system :
+
+  http://openwferu.rubyforge.org/tokyo.html
+
+Then you can install the 'native' C bindings.
+
+NOTE : I have only tested those native bindings with Ruby 1.8.6. To run them with JRuby, the best option is Rufus::Tokyo and its FFI bindings.
+
+NOTE : the Ruby tyrant library provided by Hirabayashi-san is not a C binding, it's a pure Ruby connector. It is slower than Rufus::Tokyo::Tyrant and Rufus::Tokyo::TyrantTable, but the advantage is that there is no need to install cabinet and tyrant C libraries to connect your Ruby code to your Tokyo Tyrant.
+
+
+== installation of the 'native' C bindings
+
+=== Careo's mirror gem
+
+  sudo gem install careo-tokyocabinet --source http://gems.github.com
+
+
+=== directly from http://sf.net/tokyocabinet
+
+Get the tokyocabinet-ruby package at :
+
+  http://sourceforge.net/project/showfiles.php?group_id=200242
+
+unpack it :
+
+  tar xzvf tokyocabinet-ruby-1.20.tar.gz
+  cd tokyocabinet-ruby-1.20
+
+and then, as described at : http://tokyocabinet.sourceforge.net/rubydoc/
+
+  ruby extconf.rb
+  make
+  sudo make install
+
+
+== Rufus::Edo::Cabinet
+
+  require 'rufus/edo' # sudo gem install rufus-tokyo
+
+  db = Rufus::Edo::Cabinet.new('data.tch')
+
+  db['a'] = 'alpha'
+
+  # ...
+
+  db.close
+
+
+== Rufus::Edo::Table
+
+  require 'rufus/edo'
+
+  db = Rufus::Edo::Table.new('data.tct')
+
+  db['customer1'] = { 'name' => 'Taira no Kyomori', 'age' => '55' }
+
+  # ...
+
+  db.close
+
+
+== tyrant
+
+Hirabayashi-san's pure Ruby gem for accessing Tokyo Tyrant can be installed with :
+
+  sudo gem install careo-tokyotyrant --source http://gems.github.com
+
+It's also available at :
+
+  http://sourceforge.net/project/showfiles.php?group_id=200242
+  http://github.com/careo/tokyotyrant-ruby
+
+
+== Rufus::Edo::NetTyrant
+
+Note : 'NetTyrant' instead of 'Tyrant' to clearly show that this class isn't a C binding but a simple [pure Ruby] network implementation of a connection to a Tyrant.
+
+
+  require 'rufus/edo/ntyrant'
+
+  db = Rufus::Edo::NetTyrant.new('127.0.0.1', 45000)
+
+  db['a'] = 'alpha'
+
+  puts db['a]
+    # => 'alpha'
+
+  db.close
+
+
+== Rufus::Edo::NetTyrantTable
+
+  require 'rufus/edo/ntyrant'
+
+  t = Rufus::Edo::NetTyrantTable.new('127.0.0.1', 44502)
+
+  t['client0'] = { 'name' => 'Heike no Kyomori', 'country' => 'jp' }
+
+  t.close
+

data/vendor/rufus-tokyo/lib/rufus/edo/cabcore.rb

@@ -0,0 +1,333 @@
+#--
+# 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.
+#
+# Made in Japan.
+#++
+
+
+require 'rufus/tokyo/hmethods'
+require 'rufus/tokyo/transactions'
+
+
+module Rufus::Edo
+
+  #
+  # The base cabinet methods are gathered here. They focus on wrapping
+  # Hirabayashi-san's methods.
+  #
+  # This module is included by Edo::Cabinet and Edo::NTyrant. Placing the
+  # methods in this module avoids having to load 'TokyoCabinet' when using
+  # only rufus/edo/ntyrant.
+  #
+  module CabinetCore
+
+    include Rufus::Tokyo::HashMethods
+    include Rufus::Tokyo::Transactions
+
+    def self.included (target_module)
+
+      target_module.module_eval do
+        #
+        # Same args as initialize, but can take a block form that will
+        # close the db when done. Similar to File.open (via Zev)
+        #
+        def self.open (name, params={})
+          db = self.new(name, params)
+          if block_given?
+            yield db
+            nil
+          else
+            db
+          end
+        ensure
+          db.close if block_given? && db
+        end
+      end
+    end
+
+    # Returns the path to this database.
+    #
+    def path
+
+      @path
+    end
+
+    # No comment
+    #
+    def []= (k, v)
+      @db.put(k, v) || raise_error
+    end
+
+    # No comment
+    #
+    def putkeep (k, v)
+      @db.putkeep(k, v)
+    end
+
+    # (The actual #[] method is provided by HashMethods)
+    #
+    def get (k)
+      @db.get(k)
+    end
+    protected :get
+
+    # Removes a record from the cabinet, returns the value if successful
+    # else nil.
+    #
+    def delete (k)
+      v = self[k]
+      @db.out(k) ? v : nil
+    end
+
+    # Returns the number of records in the 'cabinet'
+    #
+    def size
+      @db.rnum
+    end
+
+    # Removes all the records in the cabinet (use with care)
+    #
+    # Returns self (like Ruby's Hash does).
+    #
+    def clear
+      @db.vanish || raise_error
+      self
+    end
+
+    # Returns the 'weight' of the db (in bytes)
+    #
+    def weight
+      @db.fsiz
+    end
+
+    # Closes the cabinet (and frees the datastructure allocated for it),
+    # returns true in case of success.
+    #
+    def close
+      @db.close || raise_error
+    end
+
+    # Copies the current cabinet to a new file.
+    #
+    # Returns true if it was successful.
+    #
+    def copy (target_path)
+      @db.copy(target_path)
+    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 = self.class.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
+      @db.sync || raise_error
+    end
+
+    # Returns an array of all the primary keys in the db.
+    #
+    # With no options given, this method will return all the keys (strings)
+    # in a Ruby array.
+    #
+    #   :prefix --> returns only the keys who match a given string prefix
+    #
+    #   :limit --> returns a limited number of keys
+    #
+    def keys (options={})
+
+      if pref = options[:prefix]
+
+        @db.fwmkeys(pref, options[:limit] || -1)
+
+      else
+
+        limit = options[:limit] || -1
+        limit = nil if limit < 1
+
+        l = []
+
+        @db.iterinit
+
+        while (k = @db.iternext)
+          break if limit and l.size >= limit
+          l << k
+        end
+
+        l
+      end
+    end
+
+    # Deletes all the entries whose keys begin with the given prefix
+    #
+    def delete_keys_with_prefix (prefix)
+
+      # only ADB has the #misc method...
+
+      if @db.respond_to?(:misc)
+        @db.misc('outlist', @db.fwmkeys(prefix, -1))
+      else
+        @db.fwmkeys(prefix, -1).each { |k| self.delete(k) }
+      end
+
+      nil
+    end
+
+    # Given a list of keys, returns a Hash { key => value } of the
+    # matching entries (in one sweep).
+    #
+    # Warning : this is a naive (slow) implementation.
+    #
+    def lget (keys)
+
+      # only ADB has the #misc method...
+
+      if @db.respond_to?(:misc)
+        Hash[*@db.misc('getlist', keys)]
+      else
+        keys.inject({}) { |h, k| v = self[k]; h[k] = v if v; h }
+      end
+    end
+
+    #
+    # default impl provided by HashMethods
+    #
+    def merge! (hash)
+
+      # only ADB has the #misc method...
+
+      if @db.respond_to?(:misc)
+        @db.misc('putlist', hash.to_a.flatten)
+      else
+        super(hash)
+      end
+      self
+    end
+    alias :lput :merge!
+
+    # Given a list of keys, deletes all the matching entries (in one sweep).
+    #
+    # Warning : this is a naive (slow) implementation.
+    #
+    def ldelete (keys)
+
+      # only ADB has the #misc method...
+
+      if @db.respond_to?(:misc)
+        @db.misc('outlist', keys)
+      else
+        keys.each { |k| self.delete(k) }
+      end
+
+      nil
+    end
+
+    # Increments the value stored under the given key with the given increment
+    # (defaults to 1 (integer)).
+    #
+    def incr (key, val=1)
+
+      v = val.is_a?(Fixnum) ? @db.addint(key, val) : @db.adddouble(key, val)
+
+      raise(EdoError.new(
+        "incr failed, there is probably already a string value set " +
+        "for the key '#{key}'"
+      )) unless v
+
+      v
+    end
+    alias :adddouble :incr
+    alias :addint :incr
+    alias :add_double :incr
+    alias :add_int :incr
+
+    # Triggers a defrag (TC >= 1.4.21 only)
+    #
+    def defrag
+
+      raise(NotImplementedError.new(
+        "defrag (misc) only available when opening db with :type => :abstract"
+      )) unless @db.respond_to?(:misc)
+
+      @db.misc('defrag', [])
+    end
+
+    # Returns the underlying 'native' Ruby object (of the class devised by
+    # Hirabayashi-san)
+    #
+    def original
+
+      @db
+    end
+
+    # This is rather low-level, you'd better use #transaction like in
+    #
+    #   db.transaction do
+    #     db['a'] = 'alpha'
+    #     db['b'] = 'bravo'
+    #     db.abort if something_went_wrong?
+    #   end
+    #
+    # Note that fixed-length dbs do not support transactions. It will result
+    # in a NoMethodError.
+    #
+    def tranbegin
+      @db.tranbegin
+    end
+
+    # This is rather low-level use #transaction and a block for a higher-level
+    # technique.
+    #
+    # Note that fixed-length dbs do not support transactions. It will result
+    # in a NoMethodError.
+    #
+    def trancommit
+      @db.trancommit
+    end
+
+    # This is rather low-level use #transaction and a block for a higher-level
+    # technique.
+    #
+    # Note that fixed-length dbs do not support transactions. It will result
+    # in a NoMethodError.
+    #
+    def tranabort
+      @db.tranabort
+    end
+
+    protected
+
+    def raise_error
+      code = @db.ecode
+      message = @db.errmsg(code)
+      raise EdoError.new("(err #{code}) #{message}")
+    end
+  end
+end
+