rufus-tokyo 0.1.7 → 0.1.8

data/lib/rufus/tokyo/config.rb

@@ -0,0 +1,163 @@
+#
+#--
+# 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"
+#
+# jmettraux@gmail.com
+#
+
+module Rufus
+module Tokyo
+
+  #
+  # Methods for setting up / tuning a Cabinet.
+  #
+  module CabinetConfig
+
+    protected
+
+    #
+    # Given a path, a hash of parameters and a suffix,
+    #
+    # a) makes sure that the path has the given suffix or raises an exception
+    # b) gathers params found in the path (#) or in params
+    # c) determines the config as set by the parameters
+    #
+    # Suffix is optional, if present, it will be enforced.
+    #
+    def determine_conf (path, params, required_type=nil)
+
+      if path.index('#')
+
+        ss = path.split('#')
+        path = ss.shift
+
+        ss.each { |p| pp = p.split('='); params[pp[0]] = pp[1] }
+      end
+
+      params = params.inject({}) { |h, (k, v)| h[k.to_sym] = v; h }
+
+      [
+        {
+          :params => params,
+          :mode => determine_open_mode(params),
+          :mutex => (params[:mutex].to_s == 'true'),
+          #:indexes => params[:idx] || params[:indexes],
+          :xmsiz => (params[:xmsiz] || 67108864).to_i,
+        },
+        determine_type_and_path(path, params, required_type),
+        determine_tuning_values(params),
+        determine_cache_values(params)
+
+      ].inject({}) { |h, hh| h.merge(hh) }
+    end
+
+    def determine_open_mode (params) #:nodoc#
+
+      mode = params[:mode].to_s
+      mode = 'wc' if mode.size < 1
+
+      {
+        'r' => (1 << 0), # open as a reader
+        'w' => (1 << 1), # open as a writer
+        'c' => (1 << 2), # writer creating
+        't' => (1 << 3), # writer truncating
+        'e' => (1 << 4), # open without locking
+        'f' => (1 << 5), # lock without blocking
+        's' => (1 << 6), # synchronize every transaction (tctdb.h)
+
+      }.inject(0) { |r, (c, v)|
+
+        r = r | v if mode.index(c); r
+      }
+    end
+
+    def determine_tuning_values (params) #:nodoc#
+
+      o = params[:opts] || ''
+      o = {
+        'l' => 1 << 0, # large
+        'd' => 1 << 1, # deflate
+        'b' => 1 << 2, # bzip2
+        't' => 1 << 3, # tcbs
+        'x' => 1 << 4
+      }.inject(0) { |i, (k, v)| i = i | v if o.index(k); i }
+
+      {
+        :bnum => (params[:bnum] || 131071).to_i,
+        :apow => (params[:apow] || 4).to_i,
+        :fpow => (params[:fpow] || 10).to_i,
+        :opts => o,
+
+        :lmemb => (params[:lmemb] || 128).to_i,
+          # number of members in each leaf page (:btree)
+        :nmemb => (params[:nmemb] || 256).to_i,
+          # number of members in each non-leaf page (:btree)
+
+        :width => (params[:width] || 255).to_i,
+          # width of the value of each record (:fixed)
+        :limsiz => (params[:limsiz] || 26_8435_456).to_i
+          # limit size of the database file (:fixed)
+      }
+    end
+
+    def determine_cache_values (params) #:nodoc#
+
+      {
+        :rcnum => params[:rcnum].to_i,
+        :lcnum => (params[:lcnum] || 2048).to_i,
+        :ncnum => (params[:ncnum] || 512).to_i
+      }
+    end
+
+    CABINET_SUFFIXES = {
+      :hash => '.tch', :btree => '.tcb', :fixed => '.tcf', :table => '.tct'
+    }
+
+    CABINET_TYPES = CABINET_SUFFIXES.invert
+
+    def determine_type_and_path (path, params, required_type) #:nodoc#
+
+      type = required_type || params[:type]
+      ext = File.extname(path)
+
+      if ext == ''
+        suffix = CABINET_SUFFIXES[type]
+        path = path + suffix
+      else
+        suffix = ext
+        type ||= CABINET_TYPES[ext]
+      end
+
+      raise "path '#{path}' must be suffixed with #{suffix}" \
+        if suffix and File.extname(path) != suffix
+
+      { :path => path, :type => type }
+    end
+  end
+
+end
+end
+

data/lib/rufus/tokyo/dystopia.rb

@@ -22,18 +22,24 @@
 #++
 #
 
-module Rufus
-  module Tokyo
+#
+# "made in Japan"
+#
+# jmettraux@gmail.com
+#
 
-    #
-    # An error for Dystopia
-    #
-    class DystopianError < RuntimeError
-      def new (error_code)
-        super("tokyo dystopia error #{error_code}")
-      end
-    end
+require 'rufus/tokyo'
 
+
+module Rufus::Tokyo
+
+  #
+  # An error for Dystopia
+  #
+  class DystopianError < RuntimeError
+    def new (error_code)
+      super("tokyo dystopia error #{error_code}")
+    end
   end
 end
 

data/lib/rufus/tokyo/dystopia/lib.rb

@@ -28,44 +28,43 @@
 # jmettraux@gmail.com
 #
 
-module Rufus
-  module Tokyo
+module Rufus::Tokyo
 
-    #
-    # The libtokyodystopia.so methods get bound to this module
-    #
-    module DystopiaLib #:nodoc#
+  #
+  # The libtokyodystopia.so methods get bound to this module
+  #
+  module DystopiaLib #:nodoc#
 
-      extend FFI::Library
+    extend FFI::Library
 
-      #
-      # find Tokyo Dystopia lib
+    #
+    # find Tokyo Dystopia lib
 
-      paths = Array(ENV['TOKYO_DYSTOPIA_LIB'] || %w{
-        /opt/local/lib/libtokyodystopia.dylib
-        /usr/local/lib/libtokyodystopia.dylib
-        /usr/local/lib/libtokyodystopia.so
-      })
+    paths = Array(ENV['TOKYO_DYSTOPIA_LIB'] || %w{
+      /opt/local/lib/libtokyodystopia.dylib
+      /usr/local/lib/libtokyodystopia.dylib
+      /usr/local/lib/libtokyodystopia.so
+    })
 
-      if path = paths.find { |path| File.exist?(path) }
+    if path = paths.find { |path| File.exist?(path) }
 
-      raise "did not find Tokyo Dystopia libs on your system" unless path
+    raise "did not find Tokyo Dystopia libs on your system" unless path
 
-      ffi_lib(path)
+    ffi_lib(path)
 
-      #
-      # tcwdb functions
-      #
-      # http://tokyocabinet.sourceforge.net/dystopiadoc/#tcwdbapi
+    #
+    # tcwdb functions
+    #
+    # http://tokyocabinet.sourceforge.net/dystopiadoc/#tcwdbapi
 
-      attach_function :tcwdbnew, [], :pointer
+    attach_function :tcwdbnew, [], :pointer
 
-      attach_function :tcwdbopen, [ :pointer, :string, :int ], :int
-      attach_function :tcwdbclose, [ :pointer ], :int
+    attach_function :tcwdbopen, [ :pointer, :string, :int ], :int
+    attach_function :tcwdbclose, [ :pointer ], :int
 
-      attach_function :tcwdbecode, [ :pointer ], :int
+    attach_function :tcwdbecode, [ :pointer ], :int
 
-      attach_function :tcwdbput2, [ :pointer, :int64, :string, :string ], :pointer
-    end
+    attach_function :tcwdbput2, [ :pointer, :int64, :string, :string ], :pointer
   end
 end
+

data/lib/rufus/tokyo/dystopia/words.rb

@@ -28,51 +28,49 @@
 # jmettraux@gmail.com
 #
 
-module Rufus
-  module Tokyo
+module Rufus::Tokyo
+
+  #
+  # Tokyo Dystopia words database.
+  #
+  # http://tokyocabinet.sourceforge.net/dystopiadoc/
+  #
+  class Words
 
     #
-    # Tokyo Dystopia words database.
-    #
-    # http://tokyocabinet.sourceforge.net/dystopiadoc/
+    # TODO : continue me
     #
-    class Words
 
-      #
-      # TODO : continue me
-      #
+    #
+    # Opens/create a Tokyo Dystopia words database.
+    #
+    def initialize (path, opts={})
 
+      # tcwdb.h :
       #
-      # Opens/create a Tokyo Dystopia words database.
-      #
-      def initialize (path, opts={})
+      #   enum {                 /* enumeration for open modes */
+      #     WDBOREADER = 1 << 0, /* open as a reader */
+      #     WDBOWRITER = 1 << 1, /* open as a writer */
+      #     WDBOCREAT = 1 << 2,  /* writer creating */
+      #     WDBOTRUNC = 1 << 3,  /* writer truncating */
+      #     WDBONOLCK = 1 << 4,  /* open without locking */
+      #     WDBOLCKNB = 1 << 5   /* lock without blocking */
+      #   };
 
-        # tcwdb.h :
-        #
-        #   enum {                 /* enumeration for open modes */
-        #     WDBOREADER = 1 << 0, /* open as a reader */
-        #     WDBOWRITER = 1 << 1, /* open as a writer */
-        #     WDBOCREAT = 1 << 2,  /* writer creating */
-        #     WDBOTRUNC = 1 << 3,  /* writer truncating */
-        #     WDBONOLCK = 1 << 4,  /* open without locking */
-        #     WDBOLCKNB = 1 << 5   /* lock without blocking */
-        #   };
+      mode = 0
 
-        mode = 0
+      @db = dlib.tcwdbnew
 
-        @db = dlib.tcwdbnew
-
-        (dlib.tcwdbopen(@db, path, mode) == 1) || raise_error
-      end
+      (dlib.tcwdbopen(@db, path, mode) == 1) || raise_error
+    end
 
-      protected
+    protected
 
-      #
-      # Raises a dystopian error (asks the db which one)
-      #
-      def raise_error
-        raise DystopianError.new(dlib.tcwdbecode(@db))
-      end
+    #
+    # Raises a dystopian error (asks the db which one)
+    #
+    def raise_error
+      raise DystopianError.new(dlib.tcwdbecode(@db))
     end
   end
 end

data/lib/rufus/tokyo/hmethods.rb

@@ -29,80 +29,81 @@
 #
 
 module Rufus
-  module Tokyo
+module Tokyo
+
+  #
+  # A mixin for Cabinet and Map, gathers all the hash-like methods
+  #
+  module HashMethods
+    include Enumerable
 
     #
-    # A mixin for Cabinet and Map, gathers all the hash-like methods
+    # The [] methods
     #
-    module HashMethods
-      include Enumerable
-
-      #
-      # The [] methods
-      #
-      # (assumes there's an underlying get(k) method)
-      #
-      def [] (k)
-        val = get(k)
-        return val unless val.nil?
-        return nil unless @default_proc
-        @default_proc.call(self, k)
-      end
-
-      #
-      # Returns an array of all the values
-      #
-      def values
-        collect { |k, v| v }
-      end
+    # (assumes there's an underlying get(k) method)
+    #
+    def [] (k)
+      val = get(k)
+      return val unless val.nil?
+      return nil unless @default_proc
+      @default_proc.call(self, k)
+    end
 
-      #
-      # Our classical 'each'
-      #
-      def each
-        keys.each { |k| yield(k, self[k]) }
-      end
+    #
+    # Returns an array of all the values
+    #
+    def values
+      collect { |k, v| v }
+    end
 
-      #
-      # Turns this instance into a Ruby hash
-      #
-      def to_h
-        self.inject({}) { |h, (k, v)| h[k] = v; h }
-      end
+    #
+    # Our classical 'each'
+    #
+    def each
+      keys.each { |k| yield(k, self[k]) }
+    end
 
-      #
-      # Turns this instance into an array of [ key, value ]
-      #
-      def to_a
-        self.collect { |e| e }
-      end
+    #
+    # Turns this instance into a Ruby hash
+    #
+    def to_h
+      self.inject({}) { |h, (k, v)| h[k] = v; h }
+    end
 
-      #
-      # Returns a new Ruby hash which is a merge of this Map and the given hash
-      #
-      def merge (h)
-        self.to_h.merge(h)
-      end
+    #
+    # Turns this instance into an array of [ key, value ]
+    #
+    def to_a
+      self.collect { |e| e }
+    end
 
-      #
-      # Merges the entries in the given hash into this map
-      #
-      def merge! (h)
-        h.each { |k, v| self[k] = v }
-        self
-      end
+    #
+    # Returns a new Ruby hash which is a merge of this Map and the given hash
+    #
+    def merge (h)
+      self.to_h.merge(h)
+    end
 
-      def default (key=nil)
-        val = self[key]
-        val.nil? ? @default_proc.call(self, key) : val
-      end
+    #
+    # Merges the entries in the given hash into this map
+    #
+    def merge! (h)
+      h.each { |k, v| self[k] = v }
+      self
+    end
 
-      def default= (val)
-        @default_proc = lambda { |h, k| val }
-      end
+    def default (key=nil)
+      val = self[key]
+      val.nil? ? @default_proc.call(self, key) : val
+    end
 
-      attr_reader :default_proc
+    def default= (val)
+      @default_proc = lambda { |h, k| val }
     end
 
+    attr_reader :default_proc
   end
+
+end
 end
+