jruby-memcached 0.3.0 → 0.4.0

data/src/main/java/com/openfeint/memcached/MemcachedService.java

@@ -0,0 +1,34 @@
+package com.openfeint.memcached;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import java.io.IOException;
+
+public class MemcachedService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby ruby) throws IOException {
+        RubyClass memcached = ruby.defineClass("Memcached", ruby.getObject(), new ObjectAllocator() {
+            public IRubyObject allocate(Ruby ruby, RubyClass klazz) {
+                return new Memcached(ruby, klazz);
+            }
+        });
+        memcached.defineAnnotatedMethods(Memcached.class);
+
+        RubyClass rails = memcached.defineClassUnder("Rails", memcached, new ObjectAllocator() {
+            public IRubyObject allocate(Ruby ruby, RubyClass klazz) {
+                return new Rails(ruby, klazz);
+            }
+        });
+        rails.defineAnnotatedMethods(Rails.class);
+
+        RubyClass runtimeError = ruby.getRuntimeError();
+        RubyClass memcachedError = memcached.defineClassUnder("Error", runtimeError, runtimeError.getAllocator());
+        memcached.defineClassUnder("NotFound", memcachedError, memcachedError.getAllocator());
+        memcached.defineClassUnder("NotStored", memcachedError, memcachedError.getAllocator());
+        memcached.defineClassUnder("NotSupport", memcachedError, memcachedError.getAllocator());
+        return true;
+    }
+}

data/src/main/java/com/openfeint/memcached/Rails.java

@@ -0,0 +1,238 @@
+package com.openfeint.memcached;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@JRubyClass(name = "Memcached::Rails", parent = "Memcached")
+public class Rails extends Memcached {
+    private boolean stringReturnTypes;
+
+    public Rails(final Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+
+        stringReturnTypes = false;
+    }
+
+    @JRubyMethod(name = "initialize", rest = true)
+    public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        RubyHash opts;
+        if (args[args.length - 1] instanceof RubyHash) {
+            opts = (RubyHash) args[args.length - 1];
+        } else {
+            opts = new RubyHash(ruby);
+        }
+        List<String> servers = new ArrayList<String>();
+        for (IRubyObject arg : args) {
+            if (arg instanceof RubyString) {
+                servers.add(arg.toString());
+            } else if (arg instanceof RubyArray) {
+                servers.addAll((List<String>) arg.convertToArray());
+            }
+        }
+        if (servers.isEmpty()) {
+            IRubyObject serverNames = (IRubyObject) opts.get(ruby.newSymbol("servers"));
+            servers.addAll((List<String>) serverNames.convertToArray());
+        }
+        if (opts.containsKey(ruby.newSymbol("namespace"))) {
+            opts.put(ruby.newSymbol("prefix_key"), opts.get(ruby.newSymbol("namespace")));
+        }
+        if (opts.containsKey(ruby.newSymbol("namespace_separator"))) {
+            opts.put(ruby.newSymbol("prefix_delimiter"), opts.get(ruby.newSymbol("namespace_separator")));
+        }
+        if (opts.containsKey(ruby.newSymbol("string_return_types"))) {
+            stringReturnTypes = true;
+        }
+        return super.init(context, servers, opts);
+    }
+
+    @JRubyMethod(name = "active?")
+    public IRubyObject active_p(ThreadContext context) {
+        Ruby ruby = context.getRuntime();
+        if (((RubyArray) super.servers(context)).isEmpty()) {
+            return ruby.getFalse();
+        }
+        return ruby.getTrue();
+    }
+
+    @JRubyMethod(name = { "get", "[]" }, required = 1, optional = 1)
+    public IRubyObject get(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        IRubyObject key = args[0];
+        RubyBoolean notRaw = notRaw(context, args, 1);
+        try {
+            return super.get(context, new IRubyObject[] { key, notRaw });
+        } catch (RaiseException e) {
+            if ("NotFound".equals(e.getException().getMetaClass().getBaseName())) {
+                return context.nil;
+            }
+            throw e;
+        }
+    }
+
+    @JRubyMethod(name = "read", required = 1, optional = 1)
+    public IRubyObject read(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        RubyBoolean not_raw = ruby.getTrue();
+        IRubyObject key = args[0];
+        RubyBoolean notRaw = notRaw(context, args, 1);
+        return get(context, new IRubyObject[] { key, notRaw });
+    }
+
+    @JRubyMethod(name = "exist?", required = 1, optional = 1)
+    public IRubyObject exist_p(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        try {
+            super.get(context, args);
+            return ruby.getTrue();
+        } catch (RaiseException e) {
+            return ruby.getFalse();
+        }
+    }
+
+    @JRubyMethod(name = "get_multi", required = 1, optional = 1)
+    public IRubyObject getMulti(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        IRubyObject keys = args[0];
+        RubyBoolean notRaw = notRaw(context, args, 1);
+        return super.get(context, new IRubyObject[] { keys, notRaw });
+    }
+
+    @JRubyMethod(name = { "set", "[]=" }, required = 2, optional = 2)
+    public IRubyObject set(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        IRubyObject key = args[0];
+        IRubyObject value = args[1];
+        RubyFixnum ttl = getTTL(context, args, 2);
+        RubyBoolean notRaw = notRaw(context, args, 3);
+        try {
+            super.set(context, new IRubyObject[] { key, value, ttl, notRaw });
+            return ruby.getTrue();
+        } catch (RaiseException e) {
+            return ruby.getFalse();
+        }
+    }
+
+    @JRubyMethod(name = "write", required = 2, optional = 1)
+    public IRubyObject write(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        IRubyObject key = args[0];
+        IRubyObject value = args[1];
+        RubyFixnum ttl = getTTL(context, args, 2);
+        RubyBoolean notRaw = notRaw(context, args, 2);
+        return set(context, new IRubyObject[] { key, value, ttl, notRaw });
+    }
+
+    @JRubyMethod(name = "fetch", required = 1, optional = 1)
+    public IRubyObject fetch(ThreadContext context, IRubyObject[] args, Block block) {
+        Ruby ruby = context.getRuntime();
+        IRubyObject key = args[0];
+        RubyHash options;
+        if (args.length > 1) {
+            options = (RubyHash) args[1];
+        } else {
+            options = new RubyHash(ruby);
+        }
+        IRubyObject value = read(context, args);
+        if (value.isNil()) {
+            value = block.call(context);
+            write(context, new IRubyObject[] { key, value, options });
+        }
+        return value;
+    }
+
+    @JRubyMethod(name = "add", required = 2, optional = 2)
+    public IRubyObject add(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        if (args.length > 3) {
+            if (ruby.getTrue() == args[3]) {
+                args[3] = ruby.getFalse();
+            } else {
+                args[3] = ruby.getTrue();
+            }
+        }
+        try {
+            super.add(context, args);
+            if (stringReturnTypes) {
+                return ruby.newString("STORED\r\n");
+            } else {
+                return ruby.getTrue();
+            }
+        } catch (RaiseException e) {
+            if (stringReturnTypes) {
+                return ruby.newString("NOT STORED\r\n");
+            } else {
+                return ruby.getFalse();
+            }
+        }
+    }
+
+    @JRubyMethod(name = "delete", required = 1, optional = 1)
+    public IRubyObject delete(ThreadContext context, IRubyObject[] args) {
+        try {
+            super.delete(context, args[0]);
+        } catch(RaiseException e) { }
+
+        return context.nil;
+    }
+
+    @JRubyMethod(name = { "flush", "flush_all", "clear" })
+    public IRubyObject flush(ThreadContext context) {
+        return super.flush(context);
+    }
+
+    @JRubyMethod(name = "read_multi", rest = true)
+    public IRubyObject readMulti(ThreadContext context, IRubyObject[] args) {
+        Ruby ruby = context.getRuntime();
+        if (args.length == 0) {
+            return new RubyHash(ruby);
+        } else {
+            return getMulti(context, args);
+        }
+    }
+
+    private RubyFixnum getTTL(ThreadContext context, IRubyObject[] args, int index) {
+        Ruby ruby = context.getRuntime();
+        if (args.length > index) {
+            if (args[index] instanceof RubyFixnum) {
+                return (RubyFixnum) args[index];
+            } else if (args[index] instanceof RubyHash) {
+                RubyHash options = (RubyHash) args[index];
+                if (options.containsKey(ruby.newSymbol("ttl"))) {
+                    return (RubyFixnum) options.get(ruby.newSymbol("ttl"));
+                } else if (options.containsKey(ruby.newSymbol("expires_in"))) {
+                    return (RubyFixnum) options.get(ruby.newSymbol("expires_in"));
+                }
+            }
+        }
+        return ruby.newFixnum(super.getDefaultTTL());
+    }
+
+    private RubyBoolean notRaw(ThreadContext context, IRubyObject[] args, int index) {
+        Ruby ruby = context.getRuntime();
+        RubyBoolean notRaw = ruby.getTrue();
+        if (args.length > index) {
+            if (args[index] instanceof RubyBoolean && ruby.getTrue() == (RubyBoolean) args[index]) {
+                notRaw = ruby.getFalse();
+            } else if (args[index] instanceof RubyHash && ruby.getTrue() == ((RubyHash) args[index]).get(ruby.newSymbol("raw"))) {
+                notRaw = ruby.getFalse();
+            }
+        }
+        return notRaw;
+    }
+}

data/src/main/java/com/openfeint/memcached/error/Error.java

@@ -0,0 +1,27 @@
+package com.openfeint.memcached.error;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.anno.JRubyClass;
+import org.jruby.exceptions.RaiseException;
+
+@JRubyClass(name = "Memcached::Error", parent = "RuntimeError")
+public class Error {
+    public static RaiseException newNotFound(Ruby ruby, String message) {
+        return newMemcachedError(ruby, "NotFound", message);
+    }
+
+    public static RaiseException newNotStored(Ruby ruby, String message) {
+        return newMemcachedError(ruby, "NotStored", message);
+    }
+
+    public static RaiseException newNotSupport(Ruby ruby, String message) {
+        return newMemcachedError(ruby, "NotSupport", message);
+    }
+
+    private static RaiseException newMemcachedError(Ruby ruby, String klass, String message) {
+        RubyClass errorClass = ruby.getModule("Memcached").getClass(klass);
+        return new RaiseException(RubyException.newException(ruby, errorClass, message), true);
+    }
+}

data/src/main/java/com/openfeint/memcached/error/NotFound.java

@@ -0,0 +1,7 @@
+package com.openfeint.memcached.error;
+
+import org.jruby.anno.JRubyClass;
+
+@JRubyClass(name="Memcached::NotFound", parent="Memcached::Error")
+public class NotFound extends Error {
+}

data/src/main/java/com/openfeint/memcached/error/NotStored.java

@@ -0,0 +1,7 @@
+package com.openfeint.memcached.error;
+
+import org.jruby.anno.JRubyClass;
+
+@JRubyClass(name="Memcached::NotStored", parent="Memcached::Error")
+public class NotStored extends Error {
+}

data/src/main/java/com/openfeint/memcached/error/NotSupport.java

@@ -0,0 +1,7 @@
+package com.openfeint.memcached.error;
+
+import org.jruby.anno.JRubyClass;
+
+@JRubyClass(name="Memcached::NotSupport", parent="Memcached::Error")
+public class NotSupport extends Error {
+}

data/src/main/java/com/openfeint/memcached/{MarshalTranscoder.java → transcoder/MarshalTranscoder.java}

@@ -1,8 +1,5 @@
-package com.openfeint.memcached;
+package com.openfeint.memcached.transcoder;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
 import net.spy.memcached.CachedData;
 import net.spy.memcached.transcoders.Transcoder;
 import org.jruby.Ruby;
@@ -10,6 +7,10 @@ import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.marshal.MarshalStream;
 import org.jruby.runtime.marshal.UnmarshalStream;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
 /**
  *
  * MarshalTranscoder does marshaling and unmarshaling.

data/src/main/java/com/openfeint/memcached/{MarshalZlibTranscoder.java → transcoder/MarshalZlibTranscoder.java}

@@ -1,10 +1,8 @@
-package com.openfeint.memcached;
+package com.openfeint.memcached.transcoder;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.IOException;
+import com.jcraft.jzlib.ZOutputStream;
+import com.jcraft.jzlib.ZInputStream;
+import com.jcraft.jzlib.JZlib;
 import net.spy.memcached.CachedData;
 import net.spy.memcached.transcoders.Transcoder;
 import org.jruby.Ruby;
@@ -12,9 +10,12 @@ import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.marshal.MarshalStream;
 import org.jruby.runtime.marshal.UnmarshalStream;
 import org.jruby.util.ByteList;
-import com.jcraft.jzlib.ZOutputStream;
-import com.jcraft.jzlib.ZInputStream;
-import com.jcraft.jzlib.JZlib;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.IOException;
 
 /**
  *

metadata

@@ -1,97 +1,113 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: jruby-memcached
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.3.0
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.4.0
 platform: ruby
-authors: 
-  - Richard Huang
-autorequire: 
+authors:
+- Richard Huang
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2012-08-07 00:00:00 Z
-dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: rspec
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: "0"
-    type: :development
-    version_requirements: *id001
-  - !ruby/object:Gem::Dependency 
-    name: mocha
-    prerelease: false
-    requirement: &id002 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: "0"
-    type: :development
-    version_requirements: *id002
+date: 2012-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: mocha
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
 description: jruby memcacached client which is compatible with memcached gem
-email: 
-  - flyerhzm@gmail.com
+email:
+- flyerhzm@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - .gitignore
-  - Gemfile
-  - Gemfile.lock
-  - MIT-LICENSE
-  - README.md
-  - Rakefile
-  - benchmark.rb
-  - jruby_memcached.gemspec
-  - lib/memcached.rb
-  - lib/memcached/exceptions.rb
-  - lib/memcached/version.rb
-  - pom.xml
-  - spec/memcached_spec.rb
-  - spec/spec_helper.rb
-  - src/main/java/com/openfeint/memcached/MarshalTranscoder.java
-  - src/main/java/com/openfeint/memcached/MarshalZlibTranscoder.java
-  - src/main/java/com/openfeint/memcached/Memcached.java
-  - src/main/java/com/openfeint/memcached/MemcachedLibrary.java
-  - src/main/java/net/spy/memcached/KetamaNodeLocator.java
-  - src/main/java/net/spy/memcached/util/DefaultKetamaNodeLocatorConfiguration.java
-  - target/spymemcached-ext-0.0.1.jar
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- Rakefile
+- benchmark.rb
+- jruby_memcached.gemspec
+- lib/memcached.rb
+- lib/memcached/version.rb
+- pom.xml
+- spec/memcached_spec.rb
+- spec/rails_spec.rb
+- spec/spec_helper.rb
+- src/main/java/com/openfeint/memcached/Memcached.java
+- src/main/java/com/openfeint/memcached/MemcachedService.java
+- src/main/java/com/openfeint/memcached/Rails.java
+- src/main/java/com/openfeint/memcached/error/Error.java
+- src/main/java/com/openfeint/memcached/error/NotFound.java
+- src/main/java/com/openfeint/memcached/error/NotStored.java
+- src/main/java/com/openfeint/memcached/error/NotSupport.java
+- src/main/java/com/openfeint/memcached/transcoder/MarshalTranscoder.java
+- src/main/java/com/openfeint/memcached/transcoder/MarshalZlibTranscoder.java
+- src/main/java/net/spy/memcached/KetamaNodeLocator.java
+- src/main/java/net/spy/memcached/util/DefaultKetamaNodeLocatorConfiguration.java
+- target/spymemcached-ext-0.0.1.jar
 homepage: https://github.com/aurorafeint/jruby-memcached
 licenses: []
-
-post_install_message: 
+post_install_message:
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
 requirements: []
-
-rubyforge_project: 
+rubyforge_project:
 rubygems_version: 1.8.24
-signing_key: 
+signing_key:
 specification_version: 3
 summary: jruby compatible memcached client
-test_files: 
-  - spec/memcached_spec.rb
-  - spec/spec_helper.rb
+test_files:
+- spec/memcached_spec.rb
+- spec/rails_spec.rb
+- spec/spec_helper.rb