kyotocabinet-java 0.2.0-java → 0.3.0-java

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+before_install:
+  - sudo ./travis-ci/install_kc
+bundler_args: --without development
+script: "bundle exec rake spec"
+rvm:
+  - jruby-19mode # JRuby in 1.9 mode

data/Gemfile

@@ -6,10 +6,15 @@ source "http://rubygems.org"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "shoulda", ">= 0"
   gem "rdoc", "~> 3.12"
-  gem "bundler", "~> 1.1.3"
-  gem "jeweler", "~> 1.8.4"
   gem "simplecov", ">= 0"
   gem "jruby-openssl", ">= 0", :platforms => :jruby
 end
+
+group :test do
+  gem "rake", ">= 0.9"
+  gem "bundler", "~> 1.1.3"
+  gem "rspec", "~> 2.10.0"
+  gem "jeweler", "~> 1.8.4"
+  gem "kyotocabinet-ruby", "~> 1.27.1", :platforms => :mri
+end

data/README.md

@@ -0,0 +1,95 @@
+# kyotocabinet-java
+
+[![Build Status](https://secure.travis-ci.org/csw/kyotocabinet-java.png)](http://travis-ci.org/csw/kyotocabinet-java)
+
+
+This is a Ruby gem providing a JRuby interface for the
+[Kyoto Cabinet][] database library. It aims to provide an identical
+interface to the official [Ruby library][]. However, that library uses
+Ruby's C extension API and thus does not work under JRuby. This is
+instead implemented atop Kyoto Cabinet's [Java API][], with a minimal
+Ruby adaptation layer to compensate for interface differences.
+
+[Kyoto Cabinet]: http://fallabs.com/kyotocabinet/
+[Ruby library]: http://fallabs.com/kyotocabinet/rubydoc/
+[Java API]: http://fallabs.com/kyotocabinet/javadoc/
+
+## Prerequisites
+
+Installation of this gem requires that Kyoto Cabinet (>= 1.2.76)
+already be installed. See the [installation notes][] for
+platform-specific instructions. It also requires a C++ compiler and
+JDK, since it contains a patched copy of the [kyotocabinet-java][]
+library, which will be compiled upon installation. It does not attempt
+to install anything outside the RubyGems directory.
+
+[installation notes]: https://github.com/csw/kyotocabinet-java/wiki/Kyoto-Cabinet-installation
+[kyotocabinet-java]: http://fallabs.com/kyotocabinet/javapkg/
+
+## Installation
+
+```
+$ gem install kyotocabinet-java
+```
+
+Or, if you're using [Bundler][] and want your Ruby code to be able to
+transparently use Kyoto Cabinet under MRI or JRuby, you might want to
+add something like this to your Gemfile:
+
+[Bundler]: http://gembundler.com/
+
+```ruby
+gem "kyotocabinet-ruby", "~> 1.27.1", :platforms => [:mri, :rbx]
+gem "kyotocabinet-java", "~> 0.2.0", :platforms => :jruby
+```
+
+## Usage
+
+This is designed to be a drop-in replacement for `kyotocabinet-ruby`,
+and so usage should be identical:
+
+```ruby
+require 'kyotocabinet'
+db = KyotoCabinet::DB.new
+db.open("%", KyotoCabinet::DB::OWRITER | KyotoCabinet::DB::OCREATE)
+db["hello"] = "world"
+```
+
+## Status
+
+This library was written to maintain indexes for a
+[BioRuby MAF parser][]. It works for that purpose but has not been
+exhaustively tested. Other parts of the Kyoto Cabinet API might need
+some work. The `bioruby-maf` code relies on storing binary data in
+Kyoto Cabinet; this works with the Java API methods accepting or
+returning `byte[]`, but not their `String` counterparts. Some of these
+methods have been wrapped to explicitly convert arguments and return
+values to byte arrays, but not all. See [kyotocabinet.rb][] for
+examples. Feel free to submit pull requests.
+
+[BioRuby MAF parser]: https://github.com/csw/bioruby-maf
+[kyotocabinet.rb]: https://github.com/csw/kyotocabinet-java/blob/master/lib/kyotocabinet.rb
+
+Installation has been tested on Mac OS X 10.7.4 and Debian wheezy, and
+should work on Ubuntu and Fedora as well. Please report build problems
+on other Unix platforms; it should be fairly easy to resolve them.
+
+It's not completely clear what it would take to make this work on
+Windows; shipping a pre-built JAR and the binary DLL provided by FAL
+Labs might do it. Patches would be welcome.
+
+## Contributing to kyotocabinet-java
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2012 Clayton Wheeler (packaging, Ruby library) and
+copyright (c) 2009-2012 FAL Labs. See LICENSE.txt for further details.
+

data/Rakefile

@@ -10,6 +10,7 @@ rescue Bundler::BundlerError => e
   exit e.status_code
 end
 require 'rake'
+require 'rake/clean'
 
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
@@ -33,13 +34,23 @@ file "ext/kyotocabinet-java/configure" => ["ext/kyotocabinet-java/configure.in"]
 end
 task :build => "ext/kyotocabinet-java/configure"
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
+file "test_ext/kyotocabinet.jar" => ["ext/kyotocabinet-java/configure"] do
+  sh "cd ext/kyotocabinet-java; ./configure --prefix=#{File.expand_path('../test_ext', __FILE__)} && make && make install && make clean"
 end
 
+CLEAN.include("ext/kyotocabinet-java/Makefile")
+CLEAN.include("test_ext/*")
+
+CLOBBER.include("ext/kyotocabinet-java/config.status")
+CLOBBER.include("ext/kyotocabinet-java/config.tmp")
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+task :spec => "test_ext/kyotocabinet.jar"
+
 # XXX: using simplecov instead
 # require 'rcov/rcovtask'
 # Rcov::RcovTask.new do |test|

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/ext/kyotocabinet-java/.gitignore

@@ -1 +1,4 @@
 autom4te.cache/*
+Makefile
+config.status
+config.tmp

data/kyotocabinet-java.gemspec

@@ -5,24 +5,25 @@
 
 Gem::Specification.new do |s|
   s.name = "kyotocabinet-java"
-  s.version = "0.2.0"
+  s.version = "0.3.0"
   s.platform = "java"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["FAL Labs", "Clayton Wheeler"]
-  s.date = "2012-06-26"
+  s.date = "2012-07-12"
   s.description = "Wrapper for Kyoto Cabinet's Java library for use with JRuby, to provide the same interface as the native kyotocabinet-ruby gem for MRI."
   s.email = "cswh@umich.edu"
   s.extensions = ["ext/kyotocabinet-java/configure"]
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     ".document",
+    ".travis.yml",
     "Gemfile",
     "LICENSE.txt",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "VERSION",
     "ext/kyotocabinet-java/.gitignore",
@@ -91,7 +92,13 @@ Gem::Specification.new do |s|
     "ext/kyotocabinet-java/kyotocabinet_ValueIterator.h",
     "ext/kyotocabinet-java/overview.html",
     "kyotocabinet-java.gemspec",
-    "lib/kyotocabinet.rb"
+    "lib/kyotocabinet.rb",
+    "spec/kyotocabinet_spec.rb",
+    "spec/spec_helper.rb",
+    "test/.gitignore",
+    "test/kctest.rb",
+    "test/test.rb",
+    "travis-ci/install_kc"
   ]
   s.homepage = "http://github.com/csw/kyotocabinet-java"
   s.licenses = ["GPL"]
@@ -103,25 +110,16 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.1.3"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
       s.add_development_dependency(%q<jruby-openssl>, [">= 0"])
     else
-      s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_dependency(%q<bundler>, ["~> 1.1.3"])
-      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
       s.add_dependency(%q<simplecov>, [">= 0"])
       s.add_dependency(%q<jruby-openssl>, [">= 0"])
     end
   else
-    s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<rdoc>, ["~> 3.12"])
-    s.add_dependency(%q<bundler>, ["~> 1.1.3"])
-    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
     s.add_dependency(%q<simplecov>, [">= 0"])
     s.add_dependency(%q<jruby-openssl>, [">= 0"])
   end

data/lib/kyotocabinet.rb

@@ -24,7 +24,7 @@ unless Java.const_defined? :Kyotocabinet
   # need to require kyotocabinet.jar
   soname = java.lang.System.mapLibraryName("jkyotocabinet")
   jdir = $LOAD_PATH.find { |d| File.exist? "#{d}/kyotocabinet.jar" }
-  raise "Could not find kyotocabinet.jar on $LOAD_PATH!" unless jdir
+  raise "Could not find kyotocabinet.jar on $LOAD_PATH (#{$LOAD_PATH.join(':')})!" unless jdir
   sopath = "#{jdir}/#{soname}"
   unless File.exist? sopath
     raise "JNI library #{soname} not installed in #{jdir}!"
@@ -42,25 +42,149 @@ module KyotoCabinet
   module Adaptation
     BYTE_ARRAY = [1].to_java(:byte).java_class
 
+    def conv_string_array(a)
+      ba = Java::byte[a.size, 0].new
+      a.each_with_index do |k, i|
+        ba[i] = k.to_java_bytes
+      end
+      ba
+    end
+
+    def to_string_array(ba)
+      ba.collect { |e| String.from_java_bytes(e) }
+    end
+
     def self.included(mod)
       super(mod)
-      mod.class_eval do
-        def self.with_method_handle(mname, *args)
-          $stderr.puts "in #{self}.with_method_handle(#{mname.inspect}, #{args.inspect})"
+      mod.instance_eval do
+        def with_java_method(mname, args)
           mh = self.java_method(mname, args)
-          $stderr.puts "got method handle #{mh}"
           yield mh
         end
+        def convert_args(mname, args)
+          indices = []
+          args.each_with_index do |a, i|
+            if a == BYTE_ARRAY
+              indices << i
+            end
+          end
+          mh = self.java_method(mname, args)
+          self.send(:define_method, mname) do |*argv|
+            indices.each { |i| argv[i] = argv[i].to_java_bytes }
+            mh.bind(self).call(*argv)
+          end
+        end
+
+        def convert_args_ret(mname, args)
+          indices = []
+          args.each_with_index do |a, i|
+            if a == BYTE_ARRAY
+              indices << i
+            end
+          end
+          mh = self.java_method(mname, args)
+          self.send(:define_method, mname) do |*argv|
+            indices.each { |i| argv[i] = argv[i].to_java_bytes }
+            rv = mh.bind(self).call(*argv)
+            if rv
+              String.from_java_bytes(rv)
+            end
+          end
+        end
       end
     end
 
+    def ret_bytes(v)
+      if v
+        String.from_java_bytes(v)
+      end
+    end
+  end
+
+  class VisitorProxy
+    include Java::Kyotocabinet::Visitor
+    
+    def initialize(v, readonly=false)
+      @v = v
+      @readonly = readonly
+    end
+
+    def visit_empty(key)
+      rv = @v.visit_empty(String.from_java_bytes(key))
+      rv && (! @readonly) ? rv.to_java_bytes : Visitor::NOP
+    end
+
+    def visit_full(key, value)
+      rv = @v.visit_full(String.from_java_bytes(key),
+                         String.from_java_bytes(value))
+      rv && (! @readonly) ? rv.to_java_bytes : Visitor::NOP
+    end
   end
+
+  class BlockVisitor
+
+    def self.wrap(proc, ro=false)
+      VisitorProxy.new(self.new(proc), ro)
+    end
+
+    def self.wrap_nop(proc)
+      NOPVisitor.new(self.wrap(proc, true))
+    end
+
+    def initialize(proc)
+      @proc = proc
+    end
+
+    def visit_empty(key)
+      @proc.call(key)
+    end
+
+    def visit_full(key, value)
+      @proc.call(key, value)
+    end
+    
+  end
+
+  class NOPVisitor
+    def initialize(base)
+      @base = base
+    end
+
+    def visit_empty(key)
+      @base.visit_empty(key)
+      Visitor::NOP
+    end
+
+    def visit_full(key, value)
+      @base.visit_full(key, value)
+      Visitor::NOP
+    end
+  end
+
 end
 
 module Java::Kyotocabinet
+  VisitorProxy = KyotoCabinet::VisitorProxy
+  BlockVisitor = KyotoCabinet::BlockVisitor
+
   class Cursor
     include KyotoCabinet::Adaptation
 
+    alias_method :_accept, :accept
+    def accept(visitor=nil, writable=true, step=false)
+      vp = if visitor
+             VisitorProxy.new(visitor, !writable)
+           else
+             if writable
+               BlockVisitor.wrap(blk)
+             else
+               BlockVisitor.wrap_nop(blk)
+             end
+           end
+      _accept(vp, writable, step)
+    end
+
+
     alias_method :_get, :get
     def get(step=false)
       r = self._get(step)
@@ -74,39 +198,188 @@ module Java::Kyotocabinet
 
     alias_method :_get_key, :get_key
     def get_key(step=false)
-      r = self._get_key(step)
-      if r
-        return String.from_java_bytes(r)
+      ret_bytes(_get_key(step))
+    end
+
+    alias_method :_get_value, :get_value
+    def get_value(step=false)
+      ret_bytes(_get_value(step))
+    end
+
+
+    alias_method :_jump, :jump
+    def jump(key=nil)
+      if key
+        _jump(key.to_java_bytes)
       else
-        return nil
+        _jump()
       end
     end
 
-    alias_method :_jump, :jump
-    def jump(key)
-      self._jump(key.to_java_bytes)
+    alias_method :_jump_back, :jump_back
+    def jump_back(key=nil)
+      if key
+        _jump_back(key.to_java_bytes)
+      else
+        _jump_back()
+      end
+    end
+
+    alias_method :_seize, :seize
+    def seize()
+      to_string_array(_seize())
+    end
+
+
+    alias_method :_set_value, :set_value
+    def set_value(value, step=false)
+      _set_value(value ? value.to_java_bytes : nil,
+                 step)
     end
+
+
   end # class Cursor
 
   class DB
     include KyotoCabinet::Adaptation
 
-    alias_method :_match_prefix, :match_prefix
-    def match_prefix(prefix, limit=-1)
-      self._match_prefix(prefix, limit)
+    # The Java API is thread-safe so this can be a no-op
+    GCONCURRENT = 0
+
+    alias_method :_accept, :accept
+    def accept(key, visitor=nil, writable=true, &blk)
+      vp = if visitor
+             VisitorProxy.new(visitor, !writable)
+           else
+             if writable
+               BlockVisitor.wrap(blk)
+             else               
+               BlockVisitor.wrap_nop(blk)
+             end
+           end
+      self._accept(key.to_java_bytes, vp, writable)
+    end
+
+    alias_method :_accept_bulk, :accept_bulk
+    def accept_bulk(keys, visitor=nil, writable=true, &blk)
+      vp = if visitor
+             VisitorProxy.new(visitor, !writable)
+           else
+             if writable
+               BlockVisitor.wrap(blk)
+             else               
+               BlockVisitor.wrap_nop(blk)
+             end
+           end
+      self._accept_bulk(conv_string_array(keys), vp, writable)
+    end
+
+    convert_args :add, [BYTE_ARRAY, BYTE_ARRAY]
+    convert_args :append, [BYTE_ARRAY, BYTE_ARRAY]
+    convert_args :cas, [BYTE_ARRAY, BYTE_ARRAY, BYTE_ARRAY]
+    convert_args :check, [BYTE_ARRAY]
+
+    def each(&blk)
+      _iterate(BlockVisitor.wrap_nop(blk), false)
+    end
+
+    def each_key
+      _iterate(BlockVisitor.wrap_nop(lambda { |k, v| yield [k] }),
+               false)
+    end
+
+    def each_value
+      _iterate(BlockVisitor.wrap_nop(lambda { |k, v| yield [v] }),
+               false)
     end
 
     alias_method :_get, :get
     def get(key)
-      String.from_java_bytes(self._get(key.to_java_bytes))
+      ret_bytes(self._get(key.to_java_bytes))
     end
     alias_method :[], :get
 
+    alias_method :_get_bulk, :get_bulk
+    def get_bulk(keys, atomic=true)
+      ra = _get_bulk(conv_string_array(keys), atomic)
+      h = {}
+      i = 0
+      while i < ra.size
+        h[String.from_java_bytes(ra[i])] = String.from_java_bytes(ra[i + 1])
+        i += 2
+      end
+      h
+    end
+
+    alias_method :_increment, :increment
+    def increment(key, num=0, orig=0)
+      self._increment(key.to_java_bytes, num, orig)
+    end
+
+    alias_method :_increment_double, :increment_double
+    def increment_double(key, num=0, orig=0)
+      _increment_double(key.to_java_bytes, num, orig)
+    end
+
+    alias_method :_iterate, :iterate
+    def iterate(visitor=nil, writable=true, &blk)
+      if visitor
+        _iterate(VisitorProxy.new(visitor),
+                 writable)
+      else
+        _iterate(BlockVisitor.wrap(blk),
+                 writable)
+      end
+    end
+
+    alias_method :_match_prefix, :match_prefix
+    def match_prefix(prefix, max=-1)
+      _match_prefix(prefix, max)
+    end
+
+    alias_method :_match_regex, :match_regex
+    def match_regex(regex, max=-1)
+      _match_regex(regex, max)
+    end
+
+    alias_method :_match_similar, :match_similar
+    def match_similar(origin, range=1, utf=false, max=-1)
+      _match_similar(origin, range, utf, max)
+    end
+
+    alias_method :_merge, :merge
+    def merge(srcary, mode=DB::MSET)
+      _merge(srcary.to_java(DB), mode)
+    end
+
+    alias_method :_occupy, :occupy
+    def occupy(writable=false, proc=nil)
+      _occupy(writable, proc)
+    end
+
+    alias_method :_open, :open
+    def open(path=':', mode=DB::OWRITER|DB::OCREATE)
+      _open(path, mode)
+    end
+
+    convert_args :remove, [BYTE_ARRAY]
+    alias_method :delete, :remove
+
+    alias_method :_remove_bulk, :remove_bulk
+    def remove_bulk(keys, atomic=true)
+      _remove_bulk(conv_string_array(keys), atomic)
+    end
+
+    convert_args :replace, [BYTE_ARRAY, BYTE_ARRAY]
+
+    convert_args_ret :seize, [BYTE_ARRAY]
+
     alias_method :_set, :set
     def set(k, v)
       self._set(k.to_java_bytes, v.to_s.to_java_bytes)
     end
     alias_method :[]=, :set
+    alias_method :store, :set
 
     alias_method :_set_bulk, :set_bulk
     def set_bulk(rec_h, atomic)
@@ -120,11 +393,25 @@ module Java::Kyotocabinet
       self._set_bulk(ba, atomic)
     end
 
+    ## TODO: store?
+
     alias_method :_synchronize, :synchronize
     def synchronize(hard=false, proc=nil)
       self._synchronize(hard, proc)
     end
 
+    def transaction(hard=false)
+      begin_transaction(hard)
+      commit = false
+      begin
+        commit = yield
+      ensure
+        end_transaction(commit)
+      end
+      commit
+    end
+
+
     def cursor_process
       cur = self.cursor()
       begin
@@ -137,5 +424,9 @@ module Java::Kyotocabinet
 end
 
 module KyotoCabinet
-  import Java::Kyotocabinet
+  java_import Java::Kyotocabinet::Cursor
+  java_import Java::Kyotocabinet::DB
+  java_import Java::Kyotocabinet::Error
+  java_import Java::Kyotocabinet::FileProcessor
+  java_import Java::Kyotocabinet::Visitor
 end