jruby-memcached 0.5.0 → 0.5.1

data/.gitignore

@@ -1,3 +1,4 @@
+Gemfile.lock
 *.gem
 *.rbc
 .bundle
@@ -23,3 +24,8 @@ target/surefire
 target/dependency-reduced-pom.xml
 target/original-spymemcached-ext-0.0.1.jar
 target/original-xmemcached-ext-0.0.1.jar
+
+.idea/
+out/
+spymemcached-ext.iml
+src/main/Main.iml

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.5.0 (Aug 22, 2012)
+
+Bugfixes:
+
+  - fix Memcached increment/decrement, which works with MarshalTranscoder
+now
+
+Features:
+
+  - update spymemcached to 2.8.3, which set shouldOptimize as false by
+default
+  - add Memcached::ATimeoutOccurred exception
+  - accept exception_retry_limit option
+
 ## 0.4.1 (Aug 17, 2012)
 
 Bugfixes:

data/README.md

@@ -35,6 +35,17 @@ You can get multiple values at once:
     $cache.get ['test', 'test2', 'missing']
       #=> {"test" => "hello", "test2" => "hello"}
 
+You can set a counter and increment it. Note that you must initialize it
+with an integer, encoded as an unmarshalled ASCII string:
+
+    $cache.increment 'counter' #=> 1
+    $cache.increment 'counter' #=> 2
+    $cache.get('counter').to_i #=> 2
+
+You can get some server stats:
+
+    $cache.stats #=> {..., :bytes_written=>[62], :version=>["1.2.4"] ...}
+
 ## Rails
 
   # config/environment.rb

data/lib/memcached/version.rb

@@ -1,3 +1,3 @@
 class Memcached
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/pom.xml

@@ -1,66 +1,81 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
 
-  <groupId>net.spy</groupId>
-  <artifactId>spymemcached-ext</artifactId>
-  <version>0.0.1</version>
-  <packaging>jar</packaging>
+    <groupId>net.spy</groupId>
+    <artifactId>spymemcached-ext</artifactId>
+    <version>0.0.1</version>
+    <packaging>jar</packaging>
 
-  <name>spymemcached-ext</name>
-  <url>http://maven.apache.org</url>
+    <name>spymemcached-ext</name>
+    <url>http://maven.apache.org</url>
 
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-  </properties>
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
 
-  <repositories>
-    <repository>
-      <id>spymemcached</id>
-      <name>spymemcached extention</name>
-      <layout>default</layout>
-      <url>http://files.couchbase.com/maven2/</url>
-      <snapshots>
-        <enabled>false</enabled>
-      </snapshots>
-    </repository>
-  </repositories>
+    <repositories>
+        <repository>
+            <id>spymemcached</id>
+            <name>spymemcached extention</name>
+            <layout>default</layout>
+            <url>http://files.couchbase.com/maven2/</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+        </repository>
+    </repositories>
 
-  <dependencies>
-    <dependency>
-      <groupId>org.jruby</groupId>
-      <artifactId>jruby</artifactId>
-      <version>1.6.7.2</version>
-    </dependency>
-    <dependency>
-      <groupId>spy</groupId>
-      <artifactId>spymemcached</artifactId>
-      <version>2.8.3</version>
-    </dependency>
-  </dependencies>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.10</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jruby</groupId>
+            <artifactId>jruby</artifactId>
+            <version>1.6.7.2</version>
+        </dependency>
+        <dependency>
+            <groupId>spy</groupId>
+            <artifactId>spymemcached</artifactId>
+            <version>2.8.3</version>
+        </dependency>
+    </dependencies>
 
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-shade-plugin</artifactId>
-        <version>1.6</version>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>shade</goal>
-            </goals>
-            <configuration>
-              <artifactSet>
-                <excludes>
-                  <exclude>org.jruby:jruby</exclude>
-                </excludes>
-              </artifactSet>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-    </plugins>
-  </build>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.12.2</version>
+                <configuration>
+                    <parallel>methods</parallel>
+                    <threadCount>10</threadCount>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>1.6</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <artifactSet>
+                                <excludes>
+                                    <exclude>org.jruby:jruby</exclude>
+                                </excludes>
+                            </artifactSet>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
 </project>

data/spec/memcached_spec.rb

@@ -19,11 +19,15 @@ describe Memcached do
       end
 
       it "should raise error with unsupported option hash" do
-        lambda { Memcached.new("127.0.0.1:11211", :hash => :unknown) }.should raise_error(Memcached::NotSupport)
+        expect { Memcached.new("127.0.0.1:11211", :hash => :unknown) }.to raise_error(Memcached::NotSupport)
       end
 
       it "should raise error with unsupported option distribution" do
-        lambda { Memcached.new("127.0.0.1:11211", :distribution => :unknown) }.should raise_error(Memcached::NotSupport)
+        expect { Memcached.new("127.0.0.1:11211", :distribution => :unknown) }.to raise_error(Memcached::NotSupport)
+      end
+
+      it "should ignore nil value" do
+        expect { Memcached.new("127.0.0.1:11211", :prefix => nil) }.not_to raise_error
       end
     end
 
@@ -47,7 +51,7 @@ describe Memcached do
 
       it "should get missing" do
         @memcached.delete "key" rescue nil
-        lambda { @memcached.get "key" }.should raise_error(Memcached::NotFound)
+        expect { @memcached.get "key" }.to raise_error(Memcached::NotFound)
       end
 
       context "multiget" do
@@ -74,7 +78,7 @@ describe Memcached do
         @memcached.set "key", "value", 1
         @memcached.get("key").should == "value"
         sleep 1
-        lambda { @memcached.get("key") }.should raise_error(Memcached::NotFound)
+        expect { @memcached.get("key") }.to raise_error(Memcached::NotFound)
       end
     end
 
@@ -87,7 +91,7 @@ describe Memcached do
 
       it "should not add existing key" do
         @memcached.set "key", "value"
-        lambda { @memcached.add "key", "value" }.should raise_error(Memcached::NotStored)
+        expect { @memcached.add "key", "value" }.to raise_error(Memcached::NotStored)
       end
 
       it "should add expiry" do
@@ -95,7 +99,7 @@ describe Memcached do
         @memcached.add "key", "value", 1
         @memcached.get "key"
         sleep 1
-        lambda { @memcached.get "key" }.should raise_error(Memcached::NotFound)
+        expect { @memcached.get "key" }.to raise_error(Memcached::NotFound)
       end
     end
 
@@ -108,8 +112,8 @@ describe Memcached do
 
       it "should not replace with new key" do
         @memcached.delete "key" rescue nil
-        lambda { @memcached.replace "key", "value" }.should raise_error(Memcached::NotStored)
-        lambda { @memcached.get "key" }.should raise_error(Memcached::NotFound)
+        expect { @memcached.replace "key", "value" }.to raise_error(Memcached::NotStored)
+        expect { @memcached.get "key" }.to raise_error(Memcached::NotFound)
       end
     end
 
@@ -117,12 +121,12 @@ describe Memcached do
       it "should delete with existing key" do
         @memcached.set "key", "value"
         @memcached.delete "key"
-        lambda { @memcached.get "key" }.should raise_error(Memcached::NotFound)
+        expect { @memcached.get "key" }.to raise_error(Memcached::NotFound)
       end
 
       it "should not delete with new key" do
         @memcached.delete "key" rescue nil
-        lambda { @memcached.delete "key" }.should raise_error(Memcached::NotFound)
+        expect { @memcached.delete "key" }.to raise_error(Memcached::NotFound)
       end
     end
 
@@ -176,8 +180,8 @@ describe Memcached do
         @memcached.set "key1", "value2"
         @memcached.set "key2", "value2"
         @memcached.flush
-        lambda { @memcached.get "key1" }.should raise_error(Memcached::NotFound)
-        lambda { @memcached.get "key2" }.should raise_error(Memcached::NotFound)
+        expect { @memcached.get "key1" }.to raise_error(Memcached::NotFound)
+        expect { @memcached.get "key2" }.to raise_error(Memcached::NotFound)
       end
     end
 
@@ -209,7 +213,7 @@ describe Memcached do
         it "should delete with prefix_key" do
           @prefix_memcached.set "key", "value"
           @prefix_memcached.delete "key"
-          lambda { @memcached.get("jrubykey") }.should raise_error(Memcached::NotFound)
+          expect { @memcached.get("jrubykey") }.to raise_error(Memcached::NotFound)
         end
 
         it "should multiget with prefix_key" do
@@ -227,48 +231,5 @@ describe Memcached do
         end
       end
     end
-
-    context "timeout" do
-      before(:all) do
-        @memcached = Memcached.new("127.0.0.1:11211")
-        @timeout_memcached = Memcached.new("127.0.0.1:11211", :timeout => 1, :exception_retry_limit => 0)
-      end
-      after(:all) do
-        @timeout_memcached.quit
-        @memcached.quit
-      end
-
-      it "should set timeout" do
-        lambda { @timeout_memcached.set "key", "new_value" }.should raise_error(Memcached::ATimeoutOccurred)
-      end
-
-      it "should add timeout" do
-        @memcached.delete "key" rescue nil
-        lambda { @timeout_memcached.add "key", "new_value" }.should raise_error(Memcached::ATimeoutOccurred)
-      end
-
-      it "should replace timeout" do
-        @memcached.set "key", "value"
-        lambda { @timeout_memcached.replace "key", "new_value" }.should raise_error(Memcached::ATimeoutOccurred)
-      end
-
-      it "should delete timeout" do
-        @memcached.set "key", "value"
-        lambda { @timeout_memcached.delete "key" }.should raise_error(Memcached::ATimeoutOccurred)
-      end
-
-      it "should get timeout" do
-        @memcached.set "key", "value"
-        lambda { @timeout_memcached.get "key" }.should raise_error(Memcached::ATimeoutOccurred)
-      end
-
-      it "should increment timeout" do
-        lambda { @timeout_memcached.increment "intkey" }.should raise_error(Memcached::ATimeoutOccurred)
-      end
-
-      it "should decrement timeout" do
-        lambda { @timeout_memcached.decrement "intkey" }.should raise_error(Memcached::ATimeoutOccurred)
-      end
-    end
   end
 end

data/spec/timeout_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+# This is a stupid way to test timeout cases.
+#
+# Originally, I want to mock MemcachedClient methods to throw OperationTimeout, like
+#
+#     MemcachedClient.any_instance.stubs(:get).raises(OperationTimeout)
+#     lambda { @timeout_memcached.get "key" }.should raise_error(Memcached::ATimeoutOccurred)
+#
+# But it doesn't work.
+#
+# The current solution is to call @timeout_memcahced.get in an infinite loop until a
+# Memcached::ATimeoutOccurred raised. It works, but really slow down the tests, I hate it.
+#
+# If you have a better solution, please let me know flyerhzm at gmail dot com, thanks.
+describe Memcached do
+  before(:all) do
+    @memcached = Memcached.new("127.0.0.1:11211")
+    @timeout_memcached = Memcached.new("127.0.0.1:11211", :timeout => 1, :exception_retry_limit => 0)
+  end
+
+  after(:all) do
+    @timeout_memcached.quit
+    @memcached.quit
+  end
+
+  it "should set timeout" do
+    lambda {
+      while true
+        @timeout_memcached.set "key", "new_value"
+      end
+    }.should raise_error(Memcached::ATimeoutOccurred)
+  end
+
+  it "should add timeout" do
+    lambda {
+      while true
+        @memcached.delete "key" rescue nil
+        @timeout_memcached.add "key", "new_value"
+      end
+    }.should raise_error(Memcached::ATimeoutOccurred)
+  end
+
+  it "should replace timeout" do
+    @memcached.set "key", "value"
+    lambda {
+      while true
+        @timeout_memcached.replace "key", "new_value"
+      end
+    }.should raise_error(Memcached::ATimeoutOccurred)
+  end
+
+  it "should delete timeout" do
+    lambda {
+      while true
+        @memcached.set "key", "value"
+        @timeout_memcached.delete "key"
+      end
+    }.should raise_error(Memcached::ATimeoutOccurred)
+  end
+
+  it "should get timeout" do
+    @memcached.set "key", "value"
+    lambda {
+      while true
+        @timeout_memcached.get "key"
+      end
+    }.should raise_error(Memcached::ATimeoutOccurred)
+  end
+
+  it "should increment timeout" do
+    lambda {
+      while true
+        @timeout_memcached.increment "intkey"
+      end
+    }.should raise_error(Memcached::ATimeoutOccurred)
+  end
+
+  it "should decrement timeout" do
+    lambda {
+      while true
+        @timeout_memcached.decrement "intkey"
+      end
+    }.should raise_error(Memcached::ATimeoutOccurred)
+  end
+end

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

@@ -1,7 +1,6 @@
 package com.openfeint.memcached;
 
 import com.openfeint.memcached.error.Error;
-import com.openfeint.memcached.error.NotFound;
 import com.openfeint.memcached.transcoder.MarshalTranscoder;
 import com.openfeint.memcached.transcoder.MarshalZlibTranscoder;
 import net.spy.memcached.AddrUtil;
@@ -30,6 +29,7 @@ import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
 
@@ -59,11 +59,14 @@ public class Memcached extends RubyObject {
     @JRubyMethod(name = "initialize", optional = 2)
     public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
         Ruby ruby = context.getRuntime();
-        RubyHash options;
+        Map<String, String> options = new HashMap<String, String>();
         if (args.length > 1) {
-            options = args[1].convertToHash();
-        } else {
-            options = new RubyHash(ruby);
+            RubyHash arguments = args[1].convertToHash();
+            for (Object key : arguments.keySet()) {
+                if (arguments.get(key) != null) {
+                    options.put(key.toString(), arguments.get(key).toString());
+                }
+            }
         }
         List<String> servers = new ArrayList<String>();
         if (args.length > 0) {
@@ -102,8 +105,8 @@ public class Memcached extends RubyObject {
         int retry = 0;
         while (true) {
             try {
-                boolean result = (Boolean) client.add(key, expiry, value, transcoder).get();
-                if (result == false) {
+                Boolean result = (Boolean) client.add(key, expiry, value, transcoder).get();
+                if (!result) {
                     throw Error.newNotStored(ruby, "not stored");
                 }
                 return context.nil;
@@ -115,7 +118,6 @@ public class Memcached extends RubyObject {
                         throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
                     }
                     retry++;
-                    continue;
                 } else {
                     throw ruby.newRuntimeError(e.getLocalizedMessage());
                 }
@@ -126,7 +128,6 @@ public class Memcached extends RubyObject {
                         throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
                     }
                     retry++;
-                    continue;
                 } else {
                     throw ruby.newRuntimeError(e.getLocalizedMessage());
                 }
@@ -145,8 +146,8 @@ public class Memcached extends RubyObject {
         int retry = 0;
         while (true) {
             try {
-                boolean result = (Boolean) client.replace(key, expiry, value, transcoder).get();
-                if (result == false) {
+                Boolean result = (Boolean) client.replace(key, expiry, value, transcoder).get();
+                if (!result) {
                     throw Error.newNotStored(ruby, "not stored");
                 }
                 return context.nil;
@@ -158,7 +159,6 @@ public class Memcached extends RubyObject {
                         throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
                     }
                     retry++;
-                    continue;
                 } else {
                     throw ruby.newRuntimeError(e.getLocalizedMessage());
                 }
@@ -169,7 +169,6 @@ public class Memcached extends RubyObject {
                         throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
                     }
                     retry++;
-                    continue;
                 } else {
                     throw ruby.newRuntimeError(e.getLocalizedMessage());
                 }
@@ -188,8 +187,8 @@ public class Memcached extends RubyObject {
         int retry = 0;
         while (true) {
             try {
-                boolean result = (Boolean) client.set(key, expiry, value, transcoder).get();
-                if (result == false) {
+                Boolean result = (Boolean) client.set(key, expiry, value, transcoder).get();
+                if (!result) {
                     throw Error.newNotStored(ruby, "not stored");
                 }
                 return context.nil;
@@ -201,7 +200,6 @@ public class Memcached extends RubyObject {
                         throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
                     }
                     retry++;
-                    continue;
                 } else {
                     throw ruby.newRuntimeError(e.getLocalizedMessage());
                 }
@@ -212,7 +210,6 @@ public class Memcached extends RubyObject {
                         throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
                     }
                     retry++;
-                    continue;
                 } else {
                     throw ruby.newRuntimeError(e.getLocalizedMessage());
                 }
@@ -244,10 +241,10 @@ public class Memcached extends RubyObject {
                 } else if (keys instanceof RubyArray) {
                     RubyHash results = RubyHash.newHash(ruby);
 
-                    Map<String, IRubyObject> bulkResults = client.getBulk(getFullKeys(keys.convertToArray()), transcoder);
+                    Map<String, IRubyObject> bulkResults = (Map<String, IRubyObject>) client.getBulk(getFullKeys(keys.convertToArray()), transcoder);
                     for (String key : (List<String>) keys.convertToArray()) {
                         if (bulkResults.containsKey(getFullKey(key))) {
-                            results.put(key, (IRubyObject) bulkResults.get(getFullKey(key)));
+                            results.put(key, bulkResults.get(getFullKey(key)));
                         }
                     }
                     return results;
@@ -255,11 +252,13 @@ public class Memcached extends RubyObject {
             } catch (RaiseException e) {
                 throw e;
             } catch (OperationTimeoutException e) {
-                throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                if (retry == exceptionRetryLimit) {
+                    throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
+                }
+                retry++;
             } catch (RuntimeException e) {
                 throw ruby.newRuntimeError(e.getLocalizedMessage());
             }
-            return context.nil;
         }
     }
 
@@ -279,7 +278,6 @@ public class Memcached extends RubyObject {
                     throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
                 }
                 retry++;
-                continue;
             }
         }
     }
@@ -300,7 +298,6 @@ public class Memcached extends RubyObject {
                     throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
                 }
                 retry++;
-                continue;
             }
         }
     }
@@ -312,7 +309,7 @@ public class Memcached extends RubyObject {
         while (true) {
             try {
                 boolean result = client.delete(getFullKey(key.toString())).get();
-                if (result == false) {
+                if (!result) {
                     throw Error.newNotFound(ruby, "not found");
                 }
                 return context.nil;
@@ -324,7 +321,6 @@ public class Memcached extends RubyObject {
                         throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
                     }
                     retry++;
-                    continue;
                 } else {
                     throw ruby.newRuntimeError(e.getLocalizedMessage());
                 }
@@ -335,7 +331,6 @@ public class Memcached extends RubyObject {
                         throw Error.newATimeoutOccurred(ruby, e.getLocalizedMessage());
                     }
                     retry++;
-                    continue;
                 } else {
                     throw ruby.newRuntimeError(e.getLocalizedMessage());
                 }
@@ -385,7 +380,7 @@ public class Memcached extends RubyObject {
         return ttl;
     }
 
-    protected IRubyObject init(ThreadContext context, List<String> servers, RubyHash options) {
+    protected IRubyObject init(ThreadContext context, List<String> servers, Map<String, String> opts) {
         Ruby ruby = context.getRuntime();
         List<InetSocketAddress> addresses = AddrUtil.getAddresses(servers);
         try {
@@ -393,40 +388,39 @@ public class Memcached extends RubyObject {
 
             String distributionValue = "ketama";
             String hashValue = "fnv1_32";
-            RubyBoolean binaryValue = ruby.getFalse();
-            RubyBoolean shouldOptimize = ruby.getFalse();
+            boolean binaryValue = false;
+            boolean shouldOptimize = false;
             String transcoderValue = null;
-            if (!options.isEmpty()) {
-                RubyHash opts = options.convertToHash();
-                if (opts.containsKey(ruby.newSymbol("distribution"))) {
-                    distributionValue = opts.get(ruby.newSymbol("distribution")).toString();
+            if (!opts.isEmpty()) {
+                if (opts.containsKey("distribution")) {
+                    distributionValue = opts.get("distribution");
                 }
-                if (opts.containsKey(ruby.newSymbol("hash"))) {
-                    hashValue = opts.get(ruby.newSymbol("hash")).toString();
+                if (opts.containsKey("hash")) {
+                    hashValue = opts.get("hash");
                 }
-                if (opts.containsKey(ruby.newSymbol("binary_protocol"))) {
-                    binaryValue = (RubyBoolean) opts.get(ruby.newSymbol("binary_protocol"));
+                if (opts.containsKey("binary_protocol")) {
+                    binaryValue = Boolean.parseBoolean(opts.get("binary_protocol"));
                 }
-                if (opts.containsKey(ruby.newSymbol("should_optimize"))) {
-                    shouldOptimize = (RubyBoolean) opts.get(ruby.newSymbol("should_optimize"));
+                if (opts.containsKey("should_optimize")) {
+                    shouldOptimize = Boolean.parseBoolean(opts.get("should_optimize"));
                 }
-                if (opts.containsKey(ruby.newSymbol("default_ttl"))) {
-                    ttl = Integer.parseInt(opts.get(ruby.newSymbol("default_ttl")).toString());
+                if (opts.containsKey("default_ttl")) {
+                    ttl = Integer.parseInt(opts.get("default_ttl"));
                 }
-                if (opts.containsKey(ruby.newSymbol("timeout"))) {
-                    timeout = Integer.parseInt(opts.get(ruby.newSymbol("timeout")).toString());
+                if (opts.containsKey("timeout")) {
+                    timeout = Integer.parseInt(opts.get("timeout"));
                 }
-                if (opts.containsKey(ruby.newSymbol("exception_retry_limit"))) {
-                    exceptionRetryLimit = Integer.parseInt(opts.get(ruby.newSymbol("exception_retry_limit")).toString());
+                if (opts.containsKey("exception_retry_limit")) {
+                    exceptionRetryLimit = Integer.parseInt(opts.get("exception_retry_limit"));
                 }
-                if (opts.containsKey(ruby.newSymbol("namespace"))) {
-                    prefixKey = opts.get(ruby.newSymbol("namespace")).toString();
+                if (opts.containsKey("namespace")) {
+                    prefixKey = opts.get("namespace");
                 }
-                if (opts.containsKey(ruby.newSymbol("prefix_key"))) {
-                    prefixKey = opts.get(ruby.newSymbol("prefix_key")).toString();
+                if (opts.containsKey("prefix_key")) {
+                    prefixKey = opts.get("prefix_key");
                 }
-                if (opts.containsKey(ruby.newSymbol("transcoder"))) {
-                    transcoderValue = opts.get(ruby.newSymbol("transcoder")).toString();
+                if (opts.containsKey("transcoder")) {
+                    transcoderValue = opts.get("transcoder");
                 }
             }
 
@@ -455,10 +449,10 @@ public class Memcached extends RubyObject {
                 throw Error.newNotSupport(ruby, "hash not support");
             }
 
-            if (ruby.getTrue() == binaryValue) {
+            if (binaryValue) {
                 builder.setProtocol(Protocol.BINARY);
             }
-            if (ruby.getTrue() == shouldOptimize) {
+            if (shouldOptimize) {
                 builder.setShouldOptimize(true);
             }
 
@@ -474,11 +468,11 @@ public class Memcached extends RubyObject {
             builder.setTranscoder(transcoder);
 
             client = new MemcachedClient(builder.build(), addresses);
-        } catch (IOException ioe) {
-            throw ruby.newIOErrorFromException(ioe);
-        }
 
-        return context.nil;
+            return context.nil;
+        } catch (IOException e) {
+            throw ruby.newIOErrorFromException(e);
+        }
     }
 
     private int getExpiry(IRubyObject[] args) {

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

@@ -6,7 +6,6 @@ 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;
@@ -17,6 +16,8 @@ import org.jruby.runtime.builtin.IRubyObject;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
 
 @JRubyClass(name = "Memcached::Rails", parent = "Memcached")
 public class Rails extends Memcached {
@@ -31,12 +32,7 @@ public class Rails extends Memcached {
     @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) {
@@ -45,20 +41,30 @@ public class Rails extends Memcached {
                 servers.addAll((List<String>) arg.convertToArray());
             }
         }
-        if (servers.isEmpty()) {
-            IRubyObject serverNames = (IRubyObject) opts.get(ruby.newSymbol("servers"));
-            servers.addAll((List<String>) serverNames.convertToArray());
+
+        Map<String, String> options = new HashMap<String, String>();
+        if (args[args.length - 1] instanceof RubyHash) {
+            RubyHash arguments = args[args.length - 1].convertToHash();
+            for (Object key : arguments.keySet()) {
+                if (!"servers".equals(key.toString())) {
+                    options.put(key.toString(), arguments.get(key).toString());
+                }
+            }
+            if (servers.isEmpty()) {
+                IRubyObject serverNames = (IRubyObject) arguments.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 (options.containsKey("namespace")) {
+            options.put("prefix_key", options.get("namespace"));
         }
-        if (opts.containsKey(ruby.newSymbol("namespace_separator"))) {
-            opts.put(ruby.newSymbol("prefix_delimiter"), opts.get(ruby.newSymbol("namespace_separator")));
+        if (options.containsKey("namespace_separator")) {
+            options.put("prefix_delimiter", options.get("namespace_separator"));
         }
-        if (opts.containsKey(ruby.newSymbol("string_return_types"))) {
+        if (options.containsKey("string_return_types")) {
             stringReturnTypes = true;
         }
-        return super.init(context, servers, opts);
+        return super.init(context, servers, options);
     }
 
     @JRubyMethod(name = "active?")
@@ -72,7 +78,6 @@ public class Rails extends Memcached {
 
     @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 {
@@ -87,8 +92,6 @@ public class Rails extends Memcached {
 
     @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 });
@@ -107,7 +110,6 @@ public class Rails extends Memcached {
 
     @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 });
@@ -130,7 +132,6 @@ public class Rails extends Memcached {
 
     @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);
@@ -229,9 +230,8 @@ public class Rails extends Memcached {
         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"))) {
+            if ((args[index] instanceof RubyBoolean && ruby.getTrue() == args[index]) ||
+                (args[index] instanceof RubyHash && ruby.getTrue() == ((RubyHash) args[index]).get(ruby.newSymbol("raw")))) {
                 notRaw = ruby.getFalse();
             }
         }

data/src/main/java/com/openfeint/memcached/transcoder/MarshalZlibTranscoder.java

@@ -1,21 +1,17 @@
 package com.openfeint.memcached.transcoder;
 
-import com.jcraft.jzlib.ZOutputStream;
-import com.jcraft.jzlib.ZInputStream;
 import com.jcraft.jzlib.JZlib;
+import com.jcraft.jzlib.ZInputStream;
+import com.jcraft.jzlib.ZOutputStream;
 import net.spy.memcached.CachedData;
-import net.spy.memcached.transcoders.Transcoder;
 import org.jruby.Ruby;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.marshal.MarshalStream;
 import org.jruby.runtime.marshal.UnmarshalStream;
-import org.jruby.util.ByteList;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
 import java.io.IOException;
 
 /**
@@ -36,6 +32,7 @@ public class MarshalZlibTranscoder extends MarshalTranscoder {
 
     public CachedData encode(Object o) {
         if (o instanceof IRubyObject) {
+            ZOutputStream zout = null;
             try {
                 ByteArrayOutputStream out1 = new ByteArrayOutputStream();
                 MarshalStream marshal = new MarshalStream(ruby, out1, Integer.MAX_VALUE);
@@ -44,9 +41,10 @@ public class MarshalZlibTranscoder extends MarshalTranscoder {
                 byte[] bytes;
                 if (getFlags() == COMPRESS_FLAG) {
                     ByteArrayOutputStream out2 = new ByteArrayOutputStream();
-                    ZOutputStream zout = new ZOutputStream(out2, JZlib.Z_DEFAULT_COMPRESSION);
+                    zout = new ZOutputStream(out2, JZlib.Z_DEFAULT_COMPRESSION);
                     zout.write(out1.toByteArray());
-                    zout.close();
+                    zout.flush();
+                    zout.end();
                     bytes = out2.toByteArray();
                 } else {
                     bytes = out1.toByteArray();
@@ -55,6 +53,13 @@ public class MarshalZlibTranscoder extends MarshalTranscoder {
                 return new CachedData(super.getFlags(), bytes, bytes.length);
             } catch (IOException e) {
                 throw ruby.newIOErrorFromException(e);
+            } finally {
+                if (zout != null) {
+                    try {
+                        zout.close();
+                    } catch (IOException e) {}
+                    zout = null;
+                }
             }
         } else {
             return super.encodeNumber(o);
@@ -62,11 +67,12 @@ public class MarshalZlibTranscoder extends MarshalTranscoder {
     }
 
     public Object decode(CachedData d) {
+        ZInputStream zin = null;
         try {
             byte[] bytes;
             if (d.getFlags() == COMPRESS_FLAG) {
                 ByteArrayInputStream in = new ByteArrayInputStream(d.getData());
-                ZInputStream zin = new ZInputStream(in);
+                zin = new ZInputStream(in);
 
                 ByteArrayOutputStream buffer = new ByteArrayOutputStream();
                 int nRead;
@@ -76,7 +82,6 @@ public class MarshalZlibTranscoder extends MarshalTranscoder {
                 }
                 buffer.flush();
                 bytes = buffer.toByteArray();
-                zin.close();
             } else {
                 bytes = d.getData();
             }
@@ -86,6 +91,13 @@ public class MarshalZlibTranscoder extends MarshalTranscoder {
             return super.decodeNumber(d, e);
         } catch (IOException e) {
             return super.decodeNumber(d, e);
+        } finally {
+            if (zin != null) {
+                try {
+                    zin.close();
+                } catch (IOException e) {}
+                zin = null;
+            }
         }
     }
 }

metadata

@@ -1,106 +1,122 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: jruby-memcached
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.5.0
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.5.1
 platform: ruby
-authors: 
-  - Richard Huang
-autorequire: 
+authors:
+- Richard Huang
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2012-08-22 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-11-10 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
-  - .travis.yml
-  - 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/ATimeoutOccurred.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
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- 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
+- spec/timeout_spec.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/ATimeoutOccurred.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
+      segments:
+      - 0
+      hash: 2
+      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
+      segments:
+      - 0
+      hash: 2
+      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/rails_spec.rb
-  - spec/spec_helper.rb
+test_files:
+- spec/memcached_spec.rb
+- spec/rails_spec.rb
+- spec/spec_helper.rb
+- spec/timeout_spec.rb

data/Gemfile.lock

@@ -1,30 +0,0 @@
-PATH
-  remote: .
-  specs:
-    jruby-memcached (0.5.0)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    diff-lcs (1.1.3)
-    metaclass (0.0.1)
-    mocha (0.12.1)
-      metaclass (~> 0.0.1)
-    rake (0.9.2.2)
-    rspec (2.11.0)
-      rspec-core (~> 2.11.0)
-      rspec-expectations (~> 2.11.0)
-      rspec-mocks (~> 2.11.0)
-    rspec-core (2.11.1)
-    rspec-expectations (2.11.1)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.11.1)
-
-PLATFORMS
-  java
-
-DEPENDENCIES
-  jruby-memcached!
-  mocha
-  rake
-  rspec