rufus-tokyo 0.1.2 → 0.1.3

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

@@ -0,0 +1,322 @@
+#
+#--
+# 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
+#
+
+require 'rufus/tokyo/hmethods'
+require 'rufus/tokyo/cabinet/lib'
+
+
+module Rufus::Tokyo
+
+  #
+  # A Tokyo Cabinet in-memory (tcutil.h) map
+  #
+  # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
+  #
+  class Map
+    include CabinetLibMixin
+    include HashMethods
+    include Enumerable
+
+    #
+    # Creates an empty instance of a Tokyo Cabinet in-memory map
+    #
+    # (It's OK to pass the pointer of a C map directly, this is in fact
+    # used in rufus/tokyo/table when retrieving entries)
+    #
+    def initialize (pointer = nil)
+      @map = pointer || lib.tcmapnew
+    end
+
+    #
+    # Inserts key/value pair
+    #
+    def []= (k, v)
+      lib.tcmapput2(m, k, v)
+      v
+    end
+
+    #
+    # Deletes an entry
+    #
+    def delete (k)
+      v = self[k]
+      return nil unless v
+      (lib.tcmapout2(m, k) == 1) || raise("failed to remove key '#{k}'")
+      v
+    end
+
+    #
+    # Empties the map
+    #
+    def clear
+      lib.tcmapclear(m)
+    end
+
+    #
+    # (the actual #[] method is provided by HashMethods)
+    #
+    def get (k)
+      m; lib.tcmapget2(m, k) rescue nil
+    end
+    protected :get
+
+    #
+    # Returns an array of all the keys in the map
+    #
+    def keys
+      a = []
+      lib.tcmapiterinit(m)
+      while (k = (lib.tcmapiternext2(m) rescue nil)); a << k; end
+      a
+    end
+
+    #
+    # Returns the count of entries in the map
+    #
+    def size
+      lib.tcmaprnum(m)
+    end
+
+    alias :length :size
+
+    #
+    # Frees the map (nukes it from memory)
+    #
+    def free
+      lib.tcmapdel(@map)
+      @map = nil
+    end
+
+    alias :destroy :free
+    alias :close :free
+
+    #
+    # Returns the pointer to the underlying Tokyo Cabinet map
+    #
+    def pointer
+      @map || raise('map got freed, cannot use anymore')
+    end
+
+    alias :m :pointer
+
+    #
+    # Turns a given Tokyo map structure into a Ruby Hash. By default
+    # (free = true) will dispose of the map before replying with the Ruby Hash.
+    #
+    def self.to_h (map_pointer, free = true)
+      m = self.new(map_pointer)
+      h = m.to_h
+      m.free if free
+      h
+    end
+
+    #
+    # Turns a Ruby hash into a Tokyo Cabinet Map and returns it
+    #
+    def self.from_h (h)
+      h.inject(Map.new) { |m, (k, v)| m[k] = v; m }
+    end
+  end
+
+  #
+  # A Tokyo Cabinet in-memory (tcutil.h) list
+  #
+  # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
+  #
+  class List
+    include CabinetLibMixin
+    include Enumerable
+
+    #
+    # Creates a new Tokyo Cabinet list.
+    #
+    # (by passing a list pointer, one can wrap an existing list pointer
+    # into a handy instance of this class)
+    #
+    def initialize (list_pointer = nil)
+      @list = list_pointer || lib.tclistnew
+    end
+
+    def << (s)
+      #raise 'cannot insert nils into Tokyo Cabinet lists' unless s
+      lib.tclistpush2(@list, s)
+      self
+    end
+
+    #
+    # Pushes an argument or a list of arguments to this list
+    #
+    def push (*args)
+      args.each { |a| self << a }
+    end
+
+    #
+    # Pops the last element in the list
+    #
+    def pop
+      lib.tclistpop2(@list) rescue nil
+    end
+
+    #
+    # Removes and returns the first element in a list
+    #
+    def shift
+      lib.tclistshift2(@list) rescue nil
+    end
+
+    #
+    # Inserts a string at the beginning of the list
+    #
+    def unshift (s)
+      lib.tclistunshift2(@list, s)
+      self
+    end
+
+    def []= (a, b, c=nil)
+
+      i, s = c.nil? ? [ a, b ] : [ [a, b], c ]
+
+      range = if i.is_a?(Range)
+        i
+      elsif i.is_a?(Array)
+        start, count = i
+        (start..start + count - 1)
+      else
+        [ i ]
+      end
+
+      range = norm(range)
+
+      values = s.is_a?(Array) ? s : [ s ]
+        # not "values = Array(s)"
+
+      range.each_with_index do |offset, index|
+        val = values[index]
+        if val
+          lib.tclistover2(@list, offset, val)
+        else
+          lib.tclistremove2(@list, values.size)
+        end
+      end
+
+      self
+    end
+
+    #
+    # Removes the value at a given index and returns the value
+    # (returns nil if no value available)
+    #
+    def delete_at (i)
+      lib.tclistremove2(@list, i)
+    end
+
+    def delete_if
+      # TODO
+    end
+
+    def slice
+      # TODO
+    end
+    def slice!
+      # TODO
+    end
+
+    #
+    # Returns the size of this Tokyo Cabinet list
+    #
+    def size
+      lib.tclistnum(@list)
+    end
+
+    alias :length :size
+
+    #
+    # The equivalent of Ruby Array#[]
+    #
+    def [] (i, count=nil)
+
+      return nil if (count != nil) && count < 1
+
+      len = self.size
+
+      range = if count.nil?
+        i.is_a?(Range) ? i : [i]
+      else
+        (i..i + count - 1)
+      end
+
+      r = norm(range).collect { |i| lib.tclistval2(@list, i) rescue nil }
+
+      range.first == range.last ? r.first : r
+    end
+
+    def clear
+      lib.tclistclear(@list)
+    end
+
+    def each
+      (0..self.size - 1).each { |i| yield self[i] }
+    end
+
+    #
+    # Turns this Tokyo Cabinet list into a Ruby array
+    #
+    def to_a
+      self.collect { |e| e }
+    end
+
+    #
+    # Closes (frees) this list
+    #
+    def close
+      lib.tclistdel(@list)
+      @list = nil
+    end
+
+    alias :free :close
+    alias :destroy :close
+
+    protected
+
+    #
+    # Makes sure this offset/range fits the size of the list
+    #
+    def norm (i)
+      l = self.length
+      case i
+        when Range then ((i.first % l)..(i.last % l))
+        when Array then [ i.first % l ]
+        else i % l
+      end
+    end
+
+  end
+end
+

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

@@ -0,0 +1,71 @@
+#
+#--
+# 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
+#
+
+require 'rufus/tokyo/base'
+
+
+module Rufus::Tokyo
+
+  #
+  # The libtokyodystopia.so methods get bound to this module
+  #
+  module DystopiaLib #:nodoc#
+    extend FFI::Library
+
+    Rufus::Tokyo.generate_lib_mixin(self)
+      # module Rufus::Tokyo::DystopiaLibMixin
+
+    #
+    # 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
+    })
+
+    ffi_lib(paths.find { |path| File.exist?(path) })
+
+    #
+    # tcwdb functions
+    #
+    # http://tokyocabinet.sourceforge.net/dystopiadoc/#tcwdbapi
+
+    attach_function :tcwdbnew, [], :pointer
+
+    attach_function :tcwdbopen, [ :pointer, :string, :int ], :int
+    attach_function :tcwdbclose, [ :pointer ], :int
+
+    attach_function :tcwdbecode, [ :pointer ], :int
+
+    attach_function :tcwdbput2, [ :pointer, :int64, :string, :string ], :pointer
+  end
+end
+

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

@@ -0,0 +1,87 @@
+#
+#--
+# 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
+#
+
+require 'rufus/tokyo/dystopia/lib'
+
+
+module Rufus::Tokyo
+
+  class DystopianError < RuntimeError
+    def new (error_code)
+      super("tokyo dystopia error #{error_code}")
+    end
+  end
+
+  #
+  # Tokyo Dystopia words database.
+  #
+  # http://tokyocabinet.sourceforge.net/dystopiadoc/
+  #
+  class Words
+    include DystopiaLibMixin
+
+    #
+    # TODO : continue me
+    #
+
+    #
+    # Opens/create a Tokyo Dystopia words database.
+    #
+    def initialize (path, opts={})
+
+      # 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
+
+      @db = lib.tcwdbnew
+
+      (lib.tcwdbopen(@db, path, mode) == 1) || raise_error
+    end
+
+    protected
+
+    #
+    # Raises a dystopian error (asks the db which one)
+    #
+    def raise_error
+      raise DystopianError.new(lib.tcwdbecode(@db))
+    end
+  end
+end
+