kyotocabinet-ffi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7a217d689172b77a9ed48327116644b3d5d2e8bb
+  data.tar.gz: f7777511183cac42863b3ab84035d932c36ad5cd
+SHA512:
+  metadata.gz: 6f8c12f2f832e8d849bc3587e3d8fcb285adf4bebdd0fa12d77beb97d6ac24da0961768351d5931e80d06e561adb1a4ac8ee557dc200b2be9c744b43433f6c4a
+  data.tar.gz: 10fbcc82c5907afe1c6c509942d59c72b4e1a1d05c19fe3c9e8f1afe7c3ab7d5360272cfb26c2f475c91f252b846c1d83fac07573d072f93dcb40c792410258b

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 Anthony Bargnesi
+
+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.

data/lib/kyotocabinet_ffi.rb

@@ -0,0 +1,6 @@
+require_relative 'kyotocabinet_ffi/libkyotocabinet_ffi'
+require_relative 'kyotocabinet_ffi/db/db'
+require_relative 'kyotocabinet_ffi/db/polymorphic_db'
+require_relative 'kyotocabinet_ffi/db/memory_hash_db'
+require_relative 'kyotocabinet_ffi/db/file_hash_db'
+require_relative 'kyotocabinet_ffi/version'

data/lib/kyotocabinet_ffi/db/db.rb

@@ -0,0 +1,120 @@
+require_relative '../libkyotocabinet_ffi'
+
+module KyotoCabinet
+
+  # in-memory (or prototype) database types
+  MEMORY_HASH       = :-
+  MEMORY_TREE       = :+
+  MEMORY_STASH      = :':'
+  MEMORY_CACHE_HASH = :*
+  MEMORY_CACHE_TREE = :%
+
+  # on-disk database types
+  FILE_HASH         = :".kch"
+  FILE_TREE         = :".kct"
+  FILE_PLAIN_TEXT   = :".kcx"
+  DIR_HASH          = :".kcd"
+  DIR_TREE          = :".kcf"
+
+  MEMORY_DB_TYPE = [
+    MEMORY_HASH,
+    MEMORY_TREE,
+    MEMORY_STASH,
+    MEMORY_CACHE_HASH,
+    MEMORY_CACHE_TREE
+  ]
+
+  FILE_DB_TYPE = [
+    FILE_HASH,
+    FILE_TREE,
+    FILE_PLAIN_TEXT,
+    DIR_HASH,
+    DIR_TREE
+  ]
+
+  DEFAULT_TEMP_PREFIX = 'kyoto-db'
+
+  def self.match_memorydb_type? value
+    return false unless value
+    value_s = value.to_s
+    MEMORY_DB_TYPE.any? { |ext| value_s == ext.to_s }
+  end
+
+  def self.match_filedb_type? value
+    return false unless value
+    value_s = value.to_s
+    FILE_DB_TYPE.any? { |ext| value_s.end_with? ext.to_s }
+  end
+
+  module Db
+
+    def new
+      @kc_db_pointer = LibKyotoCabinet::kcdbnew
+    end
+
+    def last_error_code
+      LibKyotoCabinet::kcdbecode(@kc_db_pointer)
+    end
+
+    def last_error_message
+      LibKyotoCabinet::kcdbemsg(@kc_db_pointer)
+    end
+
+    def last_error
+      SystemCallError.new(last_error_message, last_error_code)
+    end
+
+    def open(path, *options)
+      mode = (options & LibKyotoCabinet::MODES.keys).map { |k|
+        LibKyotoCabinet::MODES[k]
+      }.reduce(0, :|)
+      bool_return(LibKyotoCabinet::kcdbopen(@kc_db_pointer, path.to_s, mode))
+    end
+
+    def open!(path, *options)
+      fail last_error if not open(path, *options)
+    end
+
+    def size
+      LibKyotoCabinet::kcdbcount(@kc_db_pointer)
+    end
+
+    def get(key)
+      key_string = key.to_s
+      value_size_ptr = LibKyotoCabinet::FFI::MemoryPointer.new :pointer
+      LibKyotoCabinet::kcdbget(@kc_db_pointer, key_string, key_string.length, value_size_ptr)
+    end
+
+    def set(key, value)
+      key_string = key.to_s
+      value_string = value.to_s
+      bool_return(LibKyotoCabinet::kcdbset(@kc_db_pointer, key_string, key_string.length, value_string, value_string.length))
+    end
+
+    def set!(key, value)
+      fail last_error if not set(key, value)
+    end
+
+    def clear
+      bool_return(LibKyotoCabinet::kcdbclear(@kc_db_pointer))
+    end
+
+    def clear!
+      fail last_error if not clear
+    end
+
+    def close
+      bool_return(LibKyotoCabinet::kcdbclose(@kc_db_pointer))
+    end
+
+    def close!
+      fail last_error if not close
+    end
+
+    private
+
+    def bool_return(int_value)
+      int_value != 0
+    end
+  end
+end

data/lib/kyotocabinet_ffi/db/file_hash_db.rb

@@ -0,0 +1,22 @@
+module KyotoCabinet
+  module Db
+
+    # deprecated - use PolymorphicDb directly
+    class FileHash < PolymorphicDb
+      attr_reader :file_path
+
+      def initialize(file_path, *options)
+        fail ArgumentError.new('file_path must be set') unless file_path
+
+        if not file_path.end_with? KyotoCabinet::FILE_HASH.to_s
+          file_path << KyotoCabinet::FILE_HASH.to_s
+        end
+
+        @file_path = file_path
+
+        self.new
+        self.open!(@file_path, *options)
+      end
+    end
+  end
+end

data/lib/kyotocabinet_ffi/db/memory_hash_db.rb

@@ -0,0 +1,12 @@
+module KyotoCabinet
+  module Db
+
+    # deprecated - use PolymorphicDb directly
+    class MemoryHash < PolymorphicDb
+      def initialize(*options)
+        self.new
+        self.open!(KyotoCabinet::MEMORY_HASH, *options)
+      end
+    end
+  end
+end

data/lib/kyotocabinet_ffi/db/polymorphic_db.rb

@@ -0,0 +1,69 @@
+require 'pathname'
+require 'fileutils'
+
+module KyotoCabinet
+  module Db
+    class PolymorphicDb
+      include Db
+
+      def initialize(path, options = {})
+        path_s = path.to_s
+        db_options = options.delete(:db_options) || []
+        unless KyotoCabinet::match_filedb_type? (path_s) or
+               KyotoCabinet::match_memorydb_type? (path_s)
+          msg = %Q{
+            The path value \"#{path || '(nil)'}\" does not match one of the memory
+            db types #{KyotoCabinet::MEMORY_DB_TYPE.map(&:to_s).join(', ')} or
+            one of the file db types #{KyotoCabinet::FILE_DB_TYPE.map(&:to_s).join(', ')}.
+          }.gsub(%r{^\s+}, ' ').gsub(%r{\n}, '')
+          fail ArgumentError.new(msg)
+        end
+
+        self.new
+        self.open!(path, *db_options)
+      end
+
+      def self.tmp_filedb(type, options = {})
+        prefix = options[:prefix]
+        path = make_temp(type, prefix)
+
+        self.new(path, {
+          :db_options => [:create, :reader, :writer]
+        })
+      end
+
+      def [](key)
+        self.get(key)
+      end
+
+      def []=(key, value)
+        self.set(key, value)
+      end
+
+      def empty?
+        self.size <= 0
+      end
+
+      def clear
+        super
+      end
+
+      private
+
+      def self.make_temp(ext, prefix)
+          unless KyotoCabinet::match_filedb_type?(ext)
+            msg = %Q{
+              The ext value \"#{ext || '(nil)'}\" does not match one of the file
+              db types #{KyotoCabinet::FILE_DB_TYPE.map(&:to_s).join(', ')}.
+            }.gsub(%r{^\s+}, ' ').gsub(%r{\n}, '')
+            msg = "The extension \"#{ext || '(nil)'}\" does not match one of #{KyotoCabinet::FILE_DB_TYPE}"
+            fail ArgumentError.new(msg)
+          end
+
+          epoch_millis = (Time.now.to_f * 1000).to_i
+          prefix = prefix || DEFAULT_TEMP_PREFIX
+          (Pathname(Dir.tmpdir) + "#{prefix}-#{epoch_millis}#{ext}").to_s
+      end
+    end
+  end
+end

data/lib/kyotocabinet_ffi/libkyotocabinet_ffi.rb

@@ -0,0 +1,91 @@
+# @api private
+# FFI bindings
+module LibKyotoCabinet
+
+  class << self
+
+    def mri?
+      defined?(RUBY_DESCRIPTION) && (/^ruby/ =~ RUBY_DESCRIPTION)
+    end
+
+    def jruby?
+      defined?(RUBY_PLATFORM) && ("java" == RUBY_PLATFORM)
+    end
+
+    def rubinius?
+      defined?(RUBY_ENGINE) && ("rbx" == RUBY_ENGINE)
+    end
+
+    # @api_private
+    # Determine FFI constant for this ruby engine.
+    def find_ffi
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+        if const_defined? "::Rubinius::FFI"
+          ::Rubinius::FFI
+        elsif const_defined? "::FFI"
+          ::FFI
+        else
+          require "ffi"
+          ::FFI
+        end
+      else # mri, jruby, etc
+        require "ffi"
+        ::FFI
+      end
+    end
+
+    # @api_private
+    # Extend with the correct ffi implementation.
+    def load_ffi
+      ffi_module = LibKyotoCabinet::find_ffi
+      extend ffi_module::Library
+      ffi_module
+    end
+
+    # @api_private
+    # Loads the libkyotocabinet shared library.
+    def load_libkyotocabinet
+      ffi_module = find_ffi
+      extend ffi_module::Library
+
+      begin
+        ffi_lib "kyotocabinet"
+      rescue LoadError
+        begin
+          ffi_lib "libkyotocabinet.so"
+        rescue LoadError
+          ffi_lib "libkyotocabinet.so.16"
+        end
+      end
+    end
+  end
+
+  # Constant holding the FFI module for this ruby engine.
+  FFI = LibKyotoCabinet::load_ffi
+  LibKyotoCabinet::load_libkyotocabinet
+
+  # mode options
+  MODES = {
+    :reader            => (1 << 0),
+    :writer            => (1 << 1),
+    :create            => (1 << 2),
+    :truncate          => (1 << 3),
+    :auto_transaction  => (1 << 4),
+    :auto_synchronize  => (1 << 5),
+    :no_file_locking   => (1 << 6),
+    :non_blocking_lock => (1 << 7),
+    :no_file_repair    => (1 << 8)
+  }
+
+  attach_function :kcdbecode,   [:pointer],                                     :int32
+  attach_function :kcdbemsg,    [:pointer],                                     :string
+  attach_function :kcdbnew,     [],                                             :pointer
+  attach_function :kcdbopen,    [:pointer, :string, :uint32],                   :int32
+  attach_function :kcdbcount,   [:pointer],                                     :int64
+  attach_function :kcdbset,     [:pointer, :string, :size_t, :string, :size_t], :int32
+  attach_function :kcdbadd,     [:pointer, :string, :size_t, :string, :size_t], :int32
+  attach_function :kcdbget,     [:pointer, :string, :size_t, :pointer],         :string
+  attach_function :kcdbclear,   [:pointer],                                     :int32
+  attach_function :kcdbclose,   [:pointer],                                     :int32
+  attach_function :kcdbdel,     [:pointer],                                     :void
+end

data/lib/kyotocabinet_ffi/version.rb

@@ -0,0 +1,3 @@
+module KyotoCabinet
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: kyotocabinet-ffi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Anthony Bargnesi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+description: Kyoto Cabinet provided DBM interface to efficient key value stores both
+  in-memory and on-disk. This gem wraps Kyoto Cabinet's C API using FFI (foregin function
+  interface) to support MRI, JRuby, and Rubinius.
+email: abargnesi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/kyotocabinet_ffi.rb
+- lib/kyotocabinet_ffi/db/db.rb
+- lib/kyotocabinet_ffi/db/file_hash_db.rb
+- lib/kyotocabinet_ffi/db/memory_hash_db.rb
+- lib/kyotocabinet_ffi/db/polymorphic_db.rb
+- lib/kyotocabinet_ffi/libkyotocabinet_ffi.rb
+- lib/kyotocabinet_ffi/version.rb
+homepage: https://github.com/abargnesi/kyotocabinet-ffi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: FFI wrapper to Kyoto Cabinet's C API.
+test_files: []
+has_rdoc: