okuyama 0.2.2 → 0.2.3

data/History.rdoc

@@ -1,3 +1,7 @@
+=== Version 0.2.3 / 2012-03-27
+
+This release fixes bugs of base64 encoding
+
 === Version 0.2.2 / 2012-03-27
 
 This release adds send_* methods to Okuyama::Client.

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

data/lib/okuyama/protocol/version1.rb

@@ -13,9 +13,19 @@ module Okuyama
         return '1.0.0'
       end
       
+      def print_encode(socket, text)
+        if @base64_encode_flag then
+          Base64.encode64(text).split.each do |line|
+            socket.print line
+          end
+        else
+          socket.print text
+        end
+      end
+      
       def encode(text)
         return text if ! @base64_encode_flag
-        return Base64.encode64(text).chomp
+        return Base64.encode64(text).split.join
       end
       
       def decode(text)

data/okuyama.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "okuyama"
-  s.version = "0.2.2"
+  s.version = "0.2.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kenji Hara"]
-  s.date = "2012-03-27"
+  s.date = "2012-03-28"
   s.description = "okuyama client for Ruby"
   s.email = "haracane@gmail.com"
   s.extra_rdoc_files = [
@@ -32,9 +32,6 @@ Gem::Specification.new do |s|
     "lib/okuyama/protocol/abstract_protocol.rb",
     "lib/okuyama/protocol/version1.rb",
     "okuyama.gemspec",
-    "spec/okuyama/client/decr_value_spec.rb",
-    "spec/okuyama/client/incr_value_spec.rb",
-    "spec/okuyama/client/search_spec.rb",
     "spec/okuyama/client_spec.rb",
     "spec/okuyama/protocol/version1_spec.rb",
     "spec/okuyama_spec.rb",

data/spec/okuyama/client_spec.rb

@@ -6,16 +6,18 @@ describe Okuyama::Client do
     describe "when base64_encode_flag = #{base64_encode_flag}" do
         
       before :each do
+        @testnumval_int = 10
+        @testnumval = @testnumval_int.to_s
+
         @testnumkey = 'testnumkey'
-        @testnumval = '10'
-        @testkey1 = 'testkey1'
-        @testval1 = 'testval1'
+        @testkey1 = 'testkey1_0123456789abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz'
+        @testval1 = 'testval1_0123456789abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz'
         @testkey2 = 'testkey2'
         @testval2 = 'testval2'
         @testnewkey = 'testnewkey'
         @testnewval = 'testnewval'
         @testnewval1 = 'testnewval1'
-        @testtag = 'testtag'
+        @testtag = 'testtag_0123456789abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz'
         @testnewtag = 'testnewtag'
         @testgroup = 'testgroup'
         @testnewgroup = 'testnewgroup'
@@ -24,22 +26,23 @@ describe Okuyama::Client do
         @testnewquery = 'testnewval'
         
         if base64_encode_flag == false then 
-          @testnumkey = Base64.encode64(@testnumkey).chomp
-          @testnumval = Base64.encode64(@testnumval).chomp
-          @testkey1 = Base64.encode64(@testkey1).chomp
-          @testval1 = Base64.encode64(@testval1).chomp
-          @testkey2 = Base64.encode64(@testkey2).chomp
-          @testval2 = Base64.encode64(@testval2).chomp
-          @testnewkey = Base64.encode64(@testnewkey).chomp
-          @testnewval = Base64.encode64(@testnewval).chomp
-          @testnewval1 = Base64.encode64(@testnewval1).chomp
-          @testtag = Base64.encode64(@testtag).chomp
-          @testnewtag = Base64.encode64(@testnewtag).chomp
-          @testgroup = Base64.encode64(@testgroup).chomp
-          @testnewgroup = Base64.encode64(@testnewgroup).chomp
-          @testquery1 = Base64.encode64(@testquery1).chomp
-          @testquery2 = Base64.encode64(@testquery2).chomp
-          @testnewquery = Base64.encode64(@testnewquery).chomp
+          protocol = Okuyama::Protocol::Version1.new 
+          @testnumkey = protocol.encode(@testnumkey)
+          @testnumval = protocol.encode(@testnumval)
+          @testkey1 = protocol.encode(@testkey1)
+          @testval1 = protocol.encode(@testval1)
+          @testkey2 = protocol.encode(@testkey2)
+          @testval2 = protocol.encode(@testval2)
+          @testnewkey = protocol.encode(@testnewkey)
+          @testnewval = protocol.encode(@testnewval)
+          @testnewval1 = protocol.encode(@testnewval1)
+          @testtag = protocol.encode(@testtag)
+          @testnewtag = protocol.encode(@testnewtag)
+          @testgroup = protocol.encode(@testgroup)
+          @testnewgroup = protocol.encode(@testnewgroup)
+          @testquery1 = protocol.encode(@testquery1)
+          @testquery2 = protocol.encode(@testquery2)
+          @testnewquery = protocol.encode(@testnewquery)
         end
         
         @client = Okuyama::Client.new(:host=>'localhost', :port=>8888, :base64_encode_flag=>base64_encode_flag)
@@ -499,7 +502,136 @@ describe Okuyama::Client do
         end
       end
 
+      describe "set_value_and_create_index(key, val, :tags=>tags, :group=>group, :min_n=>min_n, :max_n=>max_n)" do
+        describe "when key exists," do
+          it "should success" do
+            result = @client.set_value_and_create_index(@testkey1, @testval1, :tags=>[@testtag], :group=>@testgroup, :min_n=>1, :max_n=>3)
+            result.should be_true
+          end
+        end
+        describe "when key does not exist," do
+          it "should success" do
+            result = @client.set_value_and_create_index(@testnewkey, @testnewval, :tags=>[@testnewtag], :group=>@testnewgroup, :min_n=>1, :max_n=>3)
+            result.should be_true
+          end
+        end
+      end
+
+      describe "search_value(query)" do
+        describe "when key exists," do
+          it "should return keys" do
+            result = @client.search_value(@testquery1)
+            result.sort!
+            result.should == [@testkey1]
+          end
+        end
+        describe "when key does not exist," do
+          it "should return []" do
+            result = @client.search_value(@testnewquery)
+            result.should == []
+          end
+        end
+      end
+
+      describe "search_value(query, :condition=>:and, :group=>group, :nsize=>nsize)" do
+        if false then
+          describe "when key exists," do
+            it "should return keys" do
+              result = @client.search_value([@testquery1, @testquery2], :condition=>:and, :group=>@testgroup, :nsize=>3)
+              result.sort!
+              result.should == ['testkey1']
+            end
+          end
+        end
+        describe "when key does not exist," do
+          it "should return []" do
+            result = @client.search_value([@testquery1, @testnewquery], :condition=>:and, :group=>@testgroup, :nsize=>3)
+            result.should == []
+          end
+        end
+      end
+
+      describe "search_value(query, :condition=>:or, :group=>group, :nsize=>nsize)" do
+        if false then
+          describe "when key exists," do
+            it "should return keys" do
+              result = @client.search_value([@testquery1, @testquery2], :condition=>:or, :group=>@testgroup, :nsize=>3)
+              result.sort!
+              result.should == ['testkey1']
+            end
+          end
+        end
+        describe "when key does not exist," do
+          it "should return []" do
+            result = @client.search_value([@testnewquery, @testnewquery], :condition=>:or, :group=>@testgroup, :nsize=>3)
+            result.should == []
+          end
+        end
+      end
 
+      describe "incr_value(key, val)" do
+        describe "when key exists," do
+          describe "when value is a number" do
+            it "should return incremented value(integer)" do
+              Okuyama.logger.debug("send: #{@client.protocol.message_of_incr_value(@testnumkey, '1').inspect}")
+              result = @client.incr_value(@testnumkey, 1)
+              result.should == (@testnumval_int + 1)
+            end
+            it "should return incremented value(text)" do
+              @client.to_i_flag = false
+              result = @client.incr_value(@testnumkey, 1)
+              expected = (@testnumval_int + 1).to_s
+              expected = Base64.encode64(expected).chomp if base64_encode_flag == false
+              result.should == expected
+            end
+          end
+          describe "when value is not a number" do
+            it "should return 1(integer)" do
+              result = @client.incr_value(@testkey1, 1)
+              result.should == 1
+            end
+          end
+        end
+        describe "when key does not exist," do
+          it "should fail" do
+            Okuyama.logger.debug("send: #{@client.protocol.message_of_incr_value(@testnewkey, '1').inspect}")
+            # result = @client.incr_value(@testnewkey, 1)
+            # result.should be_nil
+          end
+        end
+      end
+      
+      describe "decr_value(key)" do
+        describe "when key exists," do
+          describe "when value is a number" do
+            it "should return decremented value(integer)" do
+              result = @client.decr_value(@testnumkey, 1)
+              result.should == (@testnumval_int - 1)
+            end
+            it "should return decremented value(text)" do
+              @client.to_i_flag = false
+              val = @client.get_value(@testnumkey)
+              result = @client.decr_value(@testnumkey, 1)
+              expected = (@testnumval_int - 1).to_s
+              expected = Base64.encode64(expected).chomp if base64_encode_flag == false
+              result.should == expected
+            end
+          end
+          describe "when value is not a number" do
+            it "should return 1(integer)" do
+              result = @client.decr_value(@testkey1, 1)
+              result.should == 0
+            end
+          end
+        end
+        describe "when key does not exist," do
+          it "should fail" do
+            # result = @client.decr_value(@testnewkey, 1)
+            # result.should be_nil
+          end
+        end
+      end
+      
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: okuyama
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 2
-  - 2
-  version: 0.2.2
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - Kenji Hara
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-27 00:00:00 Z
+date: 2012-03-28 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   type: :development
@@ -119,9 +119,6 @@ files:
 - lib/okuyama/protocol/abstract_protocol.rb
 - lib/okuyama/protocol/version1.rb
 - okuyama.gemspec
-- spec/okuyama/client/decr_value_spec.rb
-- spec/okuyama/client/incr_value_spec.rb
-- spec/okuyama/client/search_spec.rb
 - spec/okuyama/client_spec.rb
 - spec/okuyama/protocol/version1_spec.rb
 - spec/okuyama_spec.rb

data/spec/okuyama/client/decr_value_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-describe Okuyama::Client do
-  
-  [true, false].each do |base64_encode_flag|
-    describe "when base64_encode_flag = #{base64_encode_flag}" do
-        
-      before :each do
-        @testnumval_int = 10
-
-        @testnumkey = 'testnumkey'
-        @testnumval = @testnumval_int.to_s
-        @testkey1 = 'testkey1'
-        @testval1 = 'testval1'
-        @testkey2 = 'testkey2'
-        @testval2 = 'testval2'
-        @testnewkey = 'testnewkey'
-        @testnewval = 'testnewval'
-        @testnewval1 = 'testnewval1'
-        @testtag = 'testtag'
-        @testnewtag = 'testnewtag'
-        @testgroup = 'testgroup'
-        @testnewgroup = 'testnewgroup'
-        @testquery1 = 'testval'
-        @testquery2 = 'val1'
-        @testnewquery = 'testnewval'
-        
-        if base64_encode_flag == false then 
-          @testnumkey = Base64.encode64(@testnumkey).chomp
-          @testnumval = Base64.encode64(@testnumval).chomp
-          @testkey1 = Base64.encode64(@testkey1).chomp
-          @testval1 = Base64.encode64(@testval1).chomp
-          @testkey2 = Base64.encode64(@testkey2).chomp
-          @testval2 = Base64.encode64(@testval2).chomp
-          @testnewkey = Base64.encode64(@testnewkey).chomp
-          @testnewval = Base64.encode64(@testnewval).chomp
-          @testnewval1 = Base64.encode64(@testnewval1).chomp
-          @testtag = Base64.encode64(@testtag).chomp
-          @testnewtag = Base64.encode64(@testnewtag).chomp
-          @testgroup = Base64.encode64(@testgroup).chomp
-          @testnewgroup = Base64.encode64(@testnewgroup).chomp
-          @testquery1 = Base64.encode64(@testquery1).chomp
-          @testquery2 = Base64.encode64(@testquery2).chomp
-          @testnewquery = Base64.encode64(@testnewquery).chomp
-        end
-        
-        
-        @client = Okuyama::Client.new(:host=>'localhost', :port=>8888, :base64_encode_flag=>base64_encode_flag)
-        @client.debug = true
-        @client.remove_value(@testnumkey)
-        @client.remove_value(@testkey1)
-        @client.remove_value(@testkey2)
-        @client.remove_value(@testnewkey)
-        @client.remove_tag_from_key(@testnewtag, @testkey1)
-        @client.set_value(@testnumkey, @testnumval)
-        @client.set_value_and_create_index(@testkey1, @testval1, :tags=>[@testtag], :group=>@testgroup, :min_n=>1, :max_n=>3)
-        @client.set_value(@testkey2, @testval2, @testtag)
-
-      end
-    
-      after :each do 
-        @client.close
-      end
-    
-      describe "decr_value(key)" do
-        describe "when key exists," do
-          describe "when value is a number" do
-            it "should return decremented value(integer)" do
-              result = @client.decr_value(@testnumkey, 1)
-              result.should == (@testnumval_int - 1)
-            end
-            it "should return decremented value(text)" do
-              @client.to_i_flag = false
-              val = @client.get_value(@testnumkey)
-              result = @client.decr_value(@testnumkey, 1)
-              expected = (@testnumval_int - 1).to_s
-              expected = Base64.encode64(expected).chomp if base64_encode_flag == false
-              result.should == expected
-            end
-          end
-          describe "when value is not a number" do
-            it "should return 1(integer)" do
-              result = @client.decr_value(@testkey1, 1)
-              result.should == 0
-            end
-          end
-        end
-        describe "when key does not exist," do
-          it "should fail" do
-            # result = @client.decr_value(@testnewkey, 1)
-            # result.should be_nil
-          end
-        end
-      end
-
-    end
-  end
-end
-

data/spec/okuyama/client/incr_value_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-describe Okuyama::Client do
-  
-  [true,false].each do |base64_encode_flag|
-    describe "when base64_encode_flag = #{base64_encode_flag}" do
-        
-      before :each do
-        @testnumval_int = 10
-
-        @testnumkey = 'testnumkey'
-        @testnumval = @testnumval_int.to_s
-        @testkey1 = 'testkey1'
-        @testval1 = 'testval1'
-        @testkey2 = 'testkey2'
-        @testval2 = 'testval2'
-        @testnewkey = 'testnewkey'
-        @testnewval = 'testnewval'
-        @testnewval1 = 'testnewval1'
-        @testtag = 'testtag'
-        @testnewtag = 'testnewtag'
-        @testgroup = 'testgroup'
-        @testnewgroup = 'testnewgroup'
-        @testquery1 = 'testval'
-        @testquery2 = 'val1'
-        @testnewquery = 'testnewval'
-        
-        if base64_encode_flag == false then 
-          @testnumkey = Base64.encode64(@testnumkey).chomp
-          @testnumval = Base64.encode64(@testnumval).chomp
-          @testkey1 = Base64.encode64(@testkey1).chomp
-          @testval1 = Base64.encode64(@testval1).chomp
-          @testkey2 = Base64.encode64(@testkey2).chomp
-          @testval2 = Base64.encode64(@testval2).chomp
-          @testnewkey = Base64.encode64(@testnewkey).chomp
-          @testnewval = Base64.encode64(@testnewval).chomp
-          @testnewval1 = Base64.encode64(@testnewval1).chomp
-          @testtag = Base64.encode64(@testtag).chomp
-          @testnewtag = Base64.encode64(@testnewtag).chomp
-          @testgroup = Base64.encode64(@testgroup).chomp
-          @testnewgroup = Base64.encode64(@testnewgroup).chomp
-          @testquery1 = Base64.encode64(@testquery1).chomp
-          @testquery2 = Base64.encode64(@testquery2).chomp
-          @testnewquery = Base64.encode64(@testnewquery).chomp
-        end
-        
-        @client = Okuyama::Client.new(:host=>'localhost', :port=>8888, :base64_encode_flag=>base64_encode_flag)
-        @client.debug = true
-        @client.remove_value(@testnumkey)
-        @client.remove_value(@testkey1)
-        @client.remove_value(@testkey2)
-        @client.remove_value(@testnewkey)
-        @client.remove_tag_from_key(@testnewtag, @testkey1)
-        @client.set_value(@testnumkey, @testnumval)
-        @client.set_value_and_create_index(@testkey1, @testval1, :tags=>[@testtag], :group=>@testgroup, :min_n=>1, :max_n=>3)
-        @client.set_value(@testkey2, @testval2, @testtag)
-
-      end
-    
-      after :each do 
-        @client.close
-      end
-    
-      describe "incr_value(key, val)" do
-        describe "when key exists," do
-          describe "when value is a number" do
-            it "should return incremented value(integer)" do
-              Okuyama.logger.debug("send: #{@client.protocol.message_of_incr_value(@testnumkey, '1').inspect}")
-              result = @client.incr_value(@testnumkey, 1)
-              result.should == (@testnumval_int + 1)
-            end
-            it "should return incremented value(text)" do
-              @client.to_i_flag = false
-              result = @client.incr_value(@testnumkey, 1)
-              expected = (@testnumval_int + 1).to_s
-              expected = Base64.encode64(expected).chomp if base64_encode_flag == false
-              result.should == expected
-            end
-          end
-          describe "when value is not a number" do
-            it "should return 1(integer)" do
-              result = @client.incr_value(@testkey1, 1)
-              result.should == 1
-            end
-          end
-        end
-        describe "when key does not exist," do
-          it "should fail" do
-            Okuyama.logger.debug("send: #{@client.protocol.message_of_incr_value(@testnewkey, '1').inspect}")
-            # result = @client.incr_value(@testnewkey, 1)
-            # result.should be_nil
-          end
-        end
-      end
-    
-    end
-  end
-end
-

data/spec/okuyama/client/search_spec.rb

@@ -1,135 +0,0 @@
-require 'spec_helper'
-
-describe Okuyama::Client do
-  
-  [true, false].each do |base64_encode_flag|
-    describe "when base64_encode_flag = #{base64_encode_flag}" do
-        
-      before :each do
-        @testnumval_int = 10
-
-        @testnumkey = 'testnumkey'
-        @testnumval = @testnumval_int.to_s
-        @testkey1 = 'testkey1'
-        @testval1 = 'testval1'
-        @testkey2 = 'testkey2'
-        @testval2 = 'testval2'
-        @testnewkey = 'testnewkey'
-        @testnewval = 'testnewval'
-        @testnewval1 = 'testnewval1'
-        @testtag = 'testtag'
-        @testnewtag = 'testnewtag'
-        @testgroup = 'testgroup'
-        @testnewgroup = 'testnewgroup'
-        @testquery1 = 'testval'
-        @testquery2 = 'val1'
-        @testnewquery = 'testnewval'
-        
-        if base64_encode_flag == false then 
-          @testnumkey = Base64.encode64(@testnumkey).chomp
-          @testnumval = Base64.encode64(@testnumval).chomp
-          @testkey1 = Base64.encode64(@testkey1).chomp
-          @testval1 = Base64.encode64(@testval1).chomp
-          @testkey2 = Base64.encode64(@testkey2).chomp
-          @testval2 = Base64.encode64(@testval2).chomp
-          @testnewkey = Base64.encode64(@testnewkey).chomp
-          @testnewval = Base64.encode64(@testnewval).chomp
-          @testnewval1 = Base64.encode64(@testnewval1).chomp
-          @testtag = Base64.encode64(@testtag).chomp
-          @testnewtag = Base64.encode64(@testnewtag).chomp
-          @testgroup = Base64.encode64(@testgroup).chomp
-          @testnewgroup = Base64.encode64(@testnewgroup).chomp
-          @testquery1 = Base64.encode64(@testquery1).chomp
-          @testquery2 = Base64.encode64(@testquery2).chomp
-          @testnewquery = Base64.encode64(@testnewquery).chomp
-        end
-        
-        
-        @client = Okuyama::Client.new(:host=>'localhost', :port=>8888, :base64_encode_flag=>base64_encode_flag)
-        @client.debug = true
-        @client.remove_value(@testnumkey)
-        @client.remove_value(@testkey1)
-        @client.remove_value(@testkey2)
-        @client.remove_value(@testnewkey)
-        @client.remove_tag_from_key(@testnewtag, @testkey1)
-        @client.set_value(@testnumkey, @testnumval)
-        @client.set_value_and_create_index(@testkey1, @testval1, :tags=>[@testtag], :group=>@testgroup, :min_n=>1, :max_n=>3)
-        @client.set_value(@testkey2, @testval2, @testtag)
-
-      end
-    
-      after :each do 
-        @client.close
-      end
-    
-      describe "set_value_and_create_index(key, val, :tags=>tags, :group=>group, :min_n=>min_n, :max_n=>max_n)" do
-        describe "when key exists," do
-          it "should success" do
-            result = @client.set_value_and_create_index(@testkey1, @testval1, :tags=>[@testtag], :group=>@testgroup, :min_n=>1, :max_n=>3)
-            result.should be_true
-          end
-        end
-        describe "when key does not exist," do
-          it "should success" do
-            result = @client.set_value_and_create_index(@testnewkey, @testnewval, :tags=>[@testnewtag], :group=>@testnewgroup, :min_n=>1, :max_n=>3)
-            result.should be_true
-          end
-        end
-      end
-
-      describe "search_value(query)" do
-        describe "when key exists," do
-          it "should return keys" do
-            result = @client.search_value(@testquery1)
-            result.sort!
-            result.should == [@testkey1]
-          end
-        end
-        describe "when key does not exist," do
-          it "should return []" do
-            result = @client.search_value(@testnewquery)
-            result.should == []
-          end
-        end
-      end
-
-      describe "search_value(query, :condition=>:and, :group=>group, :nsize=>nsize)" do
-        if false then
-          describe "when key exists," do
-            it "should return keys" do
-              result = @client.search_value([@testquery1, @testquery2], :condition=>:and, :group=>@testgroup, :nsize=>3)
-              result.sort!
-              result.should == ['testkey1']
-            end
-          end
-        end
-        describe "when key does not exist," do
-          it "should return []" do
-            result = @client.search_value([@testquery1, @testnewquery], :condition=>:and, :group=>@testgroup, :nsize=>3)
-            result.should == []
-          end
-        end
-      end
-
-      describe "search_value(query, :condition=>:or, :group=>group, :nsize=>nsize)" do
-        if false then
-          describe "when key exists," do
-            it "should return keys" do
-              result = @client.search_value([@testquery1, @testquery2], :condition=>:or, :group=>@testgroup, :nsize=>3)
-              result.sort!
-              result.should == ['testkey1']
-            end
-          end
-        end
-        describe "when key does not exist," do
-          it "should return []" do
-            result = @client.search_value([@testnewquery, @testnewquery], :condition=>:or, :group=>@testgroup, :nsize=>3)
-            result.should == []
-          end
-        end
-      end
-
-    end
-  end
-end
-