okuyama 0.2.1 → 0.2.2

data/History.rdoc

@@ -0,0 +1,22 @@
+=== Version 0.2.2 / 2012-03-27
+
+This release adds send_* methods to Okuyama::Client.
+
+* removes unnecessary method definition.
+* define similar methods with eval
+
+=== Version 0.2.1 / 2012-03-26
+
+This release improves errors.
+
+=== Version 0.2.0 / 2012-03-26
+
+This release adds recv_* methods to Okuyama::Client.
+
+=== Version 0.1.0 / 2012-03-25
+
+This release adds implements all protocol messages.
+
+=== Version 0.0.1 / 2012-03-24
+
+This is the first preview release of okuyama client for Ruby.

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.2

data/lib/okuyama/client.rb

@@ -7,7 +7,7 @@ module Okuyama
     end
     
     
-    def set_value(key, val, *args)
+    def send_set_value(key, val, *args)
       tag_list = nil
       options = nil
       
@@ -26,12 +26,12 @@ module Okuyama
         tag_list = args
       end
 
-      Okuyama.logger.debug "Okuyama::FastClient.set_value(key=#{key.inspect},val=#{val.inspect},tag_list=#{tag_list.inspect})" if @debug
+      Okuyama.logger.debug "Okuyama::Client.send_set_value(key=#{key.inspect},tag_list=#{tag_list.inspect},val=#{val.inspect})" if @debug
 
-      super(key, val, tag_list)
+      super(key, tag_list, val)
     end
     
-    def set_new_value(key, val, *args)
+    def send_set_new_value(key, val, *args)
       tag_list = nil
       options = nil
       
@@ -50,12 +50,12 @@ module Okuyama
         tag_list = args
       end
 
-      Okuyama.logger.debug "Okuyama::FastClient.set_value(key=#{key.inspect},val=#{val.inspect},tag_list=#{tag_list.inspect})" if @debug
+      Okuyama.logger.debug "Okuyama::Client.send_set_value(key=#{key.inspect},tag_list=#{tag_list.inspect},val=#{val.inspect})" if @debug
 
-      return super(key, val, tag_list)
+      return super(key, tag_list, val)
     end
     
-    def set_value_version_check(key, val, version, *args)
+    def send_set_value_version_check(key, val, version, *args)
       tag_list = nil
       options = nil
       
@@ -74,12 +74,10 @@ module Okuyama
         tag_list = args
       end
 
-      Okuyama.logger.debug "Okuyama::FastClient.set_value(key=#{key.inspect},val=#{val.inspect},tag_list=#{tag_list.inspect})" if @debug
-
-      return super(key, val, version, tag_list)
+      return super(key, tag_list, val, version)
     end
     
-    def get_tag_keys(tag, *args, &block)
+    def send_get_tag_keys(tag, *args, &block)
       flag = 'false'
       options = nil
       argc = args.length
@@ -88,8 +86,49 @@ module Okuyama
       elsif 0 < argc then
         flag = args[0]
       end
-      return super(tag, flag)
+      return super(tag, flag, &block)
+    end
+
+    def send_incr_value(key, val)
+      super(key, val.to_s)
+    end
+    
+    def send_decr_value(key, val)
+      super(key, val.to_s)
     end
 
+    def send_set_value_and_create_index(key, val, options=nil)
+      if options then
+        tag_list = options[:tags]
+        group = options[:group]
+        min_n = options[:min_n]
+        max_n = options[:max_n]
+        min_n = min_n.to_s if min_n
+        max_n = max_n.to_s if max_n
+      end
+      
+      super(key, val, tag_list, group, min_n, max_n)
+    end
+    
+    def send_search_value(query_list, options=nil)
+      if ! query_list.is_a? Array then
+        query_list = [query_list.to_s]
+      end
+      
+      if options then
+        condition = options[:condition]
+        group = options[:group]
+        nsize = options[:nsize]
+        nsize = nsize.to_s if nsize
+        case condition
+        when :and
+          condition = '1'
+        else :or
+          condition = '2'
+        end
+      end
+
+      super(query_list, condition, group, nsize)
+    end
   end
 end

data/lib/okuyama/fast_client.rb

@@ -2,15 +2,13 @@ module Okuyama
   class FastClient
     public
     attr_reader :host, :port, :timeout, :retry_max, :protocol
-    attr_accessor :debug, :base64_encode_flag, :to_i_flag, :parse_flag, :recv_flag
+    attr_accessor :base64_encode_flag, :to_i_flag, :parse_flag
     
     def initialize(options)
       @host = options[:host] || 'localhost'
       @port = options[:port] || 8888
       @timeout = options[:timeout] || 10
       @retry_max = options[:retry_max] || 3
-      @recv_flag = true
-      @recv_flag = options[:recv_flag] || @recv_flag
       @to_i_flag = options[:to_i_flag]
       @to_i_flag = true if @to_i_flag.nil?
       @parse_flag = options[:parse_flag]
@@ -25,6 +23,11 @@ module Okuyama
       end
     end
     
+    def debug=(d)
+      @debug = d
+      @protocol.debug = d
+    end
+    
     def protocol_version
       @protocol.version
     end
@@ -43,7 +46,6 @@ module Okuyama
     end
     
     def recvs
-      return if ! @recv_flag
       line = self.socket.gets
       line.chomp!
       # Disable debug message for better performance
@@ -61,125 +63,39 @@ module Okuyama
     end
     
     alias :recv_init_count :recvs    
-    def init_count
-      @protocol.init_count(self.socket)
-      return self.recv_init_count
-    end
-    
-    alias :recv_set_value :recvs
-    def set_value(key, val, tag_list=nil)
-      @protocol.set_value(self.socket, key, val, tag_list)
-      return self.recv_set_value
-    end
-    
+    alias :recv_set_value :recvs    
     alias :recv_get_value :recvs
-    def get_value(key)
-      @protocol.get_value(self.socket, key)
-      return self.recv_get_value
-    end
-    
     alias :recv_get_tag_keys :recvs
-    def get_tag_keys(tag, flag='false')
-      @protocol.get_tag_keys(self.socket, tag, flag)
-      return self.recv_get_tag_keys
-    end
-    
     alias :recv_remove_value :recvs
-    def remove_value(key)
-      @protocol.remove_value(self.socket, key)
-      return self.recv_remove_value
-    end
-    
     alias :recv_set_new_value :recvs
-    def set_new_value(key, val, tag_list=nil)
-      @protocol.set_new_value(self.socket, key, val, tag_list)
-      return self.recv_set_new_value
-    end
-    
     alias :recv_get_value_version_check :recvs
-    def get_value_version_check(key)
-      @protocol.get_value_version_check(self.socket, key)
-      return self.recv_get_value_version_check
-    end
-    
     alias :recv_set_value_version_check :recvs
-    def set_value_version_check(key, val, version, tag_list=nil)
-      @protocol.set_value_version_check(self.socket, key, val, version, tag_list)
-      return self.recv_set_value_version_check
-    end
-    
     alias :recv_incr_value :recvs
-    def incr_value(key, val)
-      @protocol.incr_value(self.socket, key, val.to_s)
-      return self.recv_incr_value
-    end
-    
     alias :recv_decr_value :recvs
-    def decr_value(key, val)
-      @protocol.decr_value(self.socket, key, val.to_s)
-      return self.recv_decr_value
-    end
-    
     alias :recv_get_multi_value :recv_lines
-    def get_multi_value(key_list, &block)
-      Okuyama.logger.debug "send: #{@protocol.message_of_get_multi_value(key_list).inspect}" if @debug
-      @protocol.get_multi_value(self.socket, key_list)
-      return self.recv_get_multi_value(&block)
-    end
-    
     alias :recv_get_tag_values :recv_lines
-    def get_tag_values(tag, &block)
-      @protocol.get_tag_values(self.socket, tag)
-      return self.recv_get_tag_values(&block)
-    end
-
     alias :recv_remove_tag_from_key :recvs
-    def remove_tag_from_key(tag, key)
-      @protocol.remove_tag_from_key(self.socket, tag, key)
-      return self.recv_remove_tag_from_key
-    end
-
     alias :recv_set_value_and_create_index :recvs
-    def set_value_and_create_index(key, val, options=nil)
-      if options then
-        tag_list = options[:tags]
-        group = options[:group]
-        min_n = options[:min_n]
-        max_n = options[:max_n]
-        min_n = min_n.to_s if min_n
-        max_n = max_n.to_s if max_n
-      end
-      
-      @protocol.set_value_and_create_index(self.socket, key, val, tag_list, group, min_n, max_n)
-      return self.recv_set_value_and_create_index
-    end
-
     alias :recv_search_value :recvs
-    def search_value(query_list, options=nil)
-      if ! query_list.is_a? Array then
-        query_list = [query_list.to_s]
-      end
-      
-      if options then
-        condition = options[:condition]
-        group = options[:group]
-        nsize = options[:nsize]
-        nsize = nsize.to_s if nsize
-        case condition
-        when :and
-          condition = '1'
-        else :or
-          condition = '2'
-        end
-      end
 
-      @protocol.search_value(self.socket, query_list, condition, group, nsize)
-      return self.recv_search_value
+    [ :init_count, :set_value, :get_value, :get_tag_keys,
+      :remove_value, :set_new_value, :get_value_version_check, :set_value_version_check,
+      :incr_value, :decr_value, :get_multi_value, :get_tag_values, :remove_tag_from_key,
+      :set_value_and_create_index, :search_value].each do |name|
+      eval <<-EOF
+        def send_#{name}(*args)
+          @protocol.#{name}(self.socket, *args)
+        end
+        def #{name}(*args, &block)
+          self.send_#{name}(*args)
+          self.recv_#{name}(&block)
+        end
+      EOF
     end
+
     
     protected
     def each(&block)
-      return if ! @recv_flag
       while result = socket.gets do
         result.chomp!
         if result == "END" then
@@ -192,7 +108,6 @@ module Okuyama
     end
 
     def readlines
-      return if ! @recv_flag
       ret = []
       while result = socket.gets do
         result.chomp!

data/lib/okuyama/protocol/version1.rb

@@ -1,6 +1,7 @@
 module Okuyama
   module Protocol
     class Version1 < AbstractProtocol
+      attr_accessor :debug
       def initialize(options=nil)
         if options then
           @base64_encode_flag = options[:base64_encode_flag]
@@ -22,66 +23,21 @@ module Okuyama
         return Base64.decode64(text)
       end
       
-      def init_count(socket)
-        socket.puts '0'
-      end
-      
-      def set_value(socket, key, val, tag_list=nil)
-        return self.send_key_tags_value_message(socket, '1', key, tag_list, val)
-      end
-      
-      def get_value(socket, key)
-        return self.send_key_message(socket, '2', key)
-      end
-
-      def get_tag_keys(socket, tag, flag)
-        return self.send_tag_flag_message(socket, '3', tag, flag)
-      end
-  
-      def remove_value(socket, key)
-        return self.send_key_dlock_message(socket, '5', key, '0')
-      end
-  
-      def set_new_value(socket, key, val, tag_list=nil)
-        return self.send_key_tags_value_message(socket, '6', key, tag_list, val)
-      end
-      
-      def get_value_version_check(socket, key)
-        return self.send_key_message(socket, '15', key)
-      end
-      
-      def set_value_version_check(socket, key, val, version, tag_list=nil)
-        return self.send_key_tags_value_message(socket, '16', key, tag_list, val, version)
-      end
-  
-      def incr_value(socket, key, val)
-        return self.send_key_value_message(socket, '13', key, val)
-      end
-      
-      def decr_value(socket, key, val)
-        return self.send_key_value_message(socket, '14', key, val)
-      end
-      
-      def get_multi_value(socket, key_list)
-        return self.send_keys_message(socket, '22', key_list)
-      end
-      
-      def get_tag_values(socket, tag)
-        return self.send_tag_message(socket, '23', tag)
-      end
-      
-      def remove_tag_from_key(socket, tag, key)
-        return self.send_tag_key_message(socket, '40', tag, key)
-      end
-
-      def set_value_and_create_index(socket, key, val, tag_list=nil, group=nil, min_index_n='1', max_index_n='3')
-        return self.send_key_tags_value_group_index_message(socket, '42', key, tag_list, val, group, min_index_n, max_index_n)
-      end
-      
-      def search_value(socket, query_list, condition='1', group=nil, nsize='3')
-        return self.send_query_condition_group_index_message(socket, '43', query_list, condition, group, nsize)
+      [
+        [:init_count, 0], [:set_value, 1], [:get_value, 2], [:get_tag_keys, 3],
+        [:remove_value, '5'], [:set_new_value, '6'], [:get_value_version_check, '15'], [:set_value_version_check, '16'],
+        [:incr_value, 13], [:decr_value, 14], [:get_multi_value, 22], [:get_tag_values, 23], [:remove_tag_from_key, 40],
+        [:set_value_and_create_index, 42], [:search_value, 43]
+      ].each do |pair|
+        name = pair[0]
+        opcode = pair[1]
+        eval <<-EOF
+          def #{name}(socket, *args)
+            Okuyama.logger.debug "send: #{"#"}{self.message_of_send_#{name}("#{opcode}", *args).inspect}" if @debug
+            self.send_#{name}(socket, "#{opcode}", *args)
+          end
+        EOF
       end
-
       def parse_line_result(result, to_i_flag=nil)
         record = result.split(/,/)
         
@@ -147,109 +103,86 @@ module Okuyama
       end
 
       protected
-      def send_key_message(socket, opcode, key)
+      def send_init_count(socket, opcode)
+        socket.puts opcode
+      end
+      def send_set_value(socket, opcode, key, tag_list, val, version=nil)
         key_base64 = self.encode(key)
+        val_base64 = self.encode(val)
+        dlock = '0'
         socket.print opcode
         socket.print ","
         socket.print  key_base64
+        socket.print ","
+        self.print_tag_list socket, tag_list
+        socket.print ","
+        socket.print  dlock
+        socket.print ","
+        socket.print  val_base64
+
+        if version then
+          socket.print ","
+          socket.print  version
+        end
         socket.puts
       end
-
-      def send_key_dlock_message(socket, opcode, key, dlock)
+      
+      def send_get_value(socket, opcode, key)
         key_base64 = self.encode(key)
         socket.print opcode
         socket.print ","
         socket.print  key_base64
-        socket.print ","
-        socket.print  dlock
         socket.puts
       end
-
-      def send_keys_message(socket, opcode, key_list)
-        keys_base64 = key_list.map{|key|self.encode(key)}.join(',')
+      
+      def send_get_tag_keys(socket, opcode, tag, flag)
         socket.print opcode
         socket.print ","
-        socket.print  keys_base64
+        socket.print  self.encode(tag)
+        socket.print ","
+        socket.print  flag
         socket.puts
-     end
+      end
 
-      def send_key_value_message(socket, opcode, key, val)
+      def send_remove_value(socket, opcode, key, dlock='0')
         key_base64 = self.encode(key)
-        val_base64 = self.encode(val)
-        dlock = '0'
         socket.print opcode
         socket.print ","
         socket.print  key_base64
         socket.print ","
         socket.print  dlock
-        socket.print ","
-        socket.print  val_base64
         socket.puts
       end
-      
-      def send_key_tags_value_message(socket, opcode, key, tag_list, val, version=nil)
+
+      alias :send_set_new_value :send_set_value
+      alias :send_get_value_version_check :send_get_value
+      alias :send_set_value_version_check :send_set_value
+
+      def send_incr_value(socket, opcode, key, val)
         key_base64 = self.encode(key)
         val_base64 = self.encode(val)
-        tags = nil
-        if tag_list then
-          tags = tag_list.map{|t|self.encode(t)}.join(':')
-        end
-        tags ||= "(B)"
         dlock = '0'
         socket.print opcode
         socket.print ","
         socket.print  key_base64
         socket.print ","
-        socket.print  tags
-        socket.print ","
         socket.print  dlock
         socket.print ","
         socket.print  val_base64
-
-        if version then
-          socket.print ","
-          socket.print  version
-        end
         socket.puts
       end
       
-      def send_key_tags_value_group_index_message(socket, opcode, key, tag_list, val, group, min_index_n, max_index_n)
-        key_base64 = self.encode(key)
-        val_base64 = self.encode(val)
-
-        tags = nil
-        if tag_list then
-          tags = tag_list.map{|t|self.encode(t)}.join(':')
-        end
-        tags ||= "(B)"
-
-        dlock = '0'
-
-        group_base64 = nil
-        if group then
-          group_base64 = self.encode(group)
-        end
-        group_base64 ||= "(B)"
-
+      alias :send_decr_value :send_incr_value
+      
+      def send_get_multi_value(socket, opcode, key_list)
+        keys_base64 = key_list.map{|key|self.encode(key)}.join(',')
         socket.print opcode
         socket.print ","
-        socket.print  key_base64
-        socket.print ","
-        socket.print  tags
-        socket.print ","
-        socket.print  dlock
-        socket.print ","
-        socket.print  val_base64
-        socket.print ","
-        socket.print  group_base64
-        socket.print ","
-        socket.print  min_index_n
-        socket.print ","
-        socket.print  max_index_n
+        socket.print  keys_base64
         socket.puts
       end
 
-      def send_tag_message(socket, opcode, tag)
+      def send_get_tag_values(socket, opcode, tag)
         tag_base64 = self.encode(tag)
         socket.print opcode
         socket.print ","
@@ -257,49 +190,84 @@ module Okuyama
         socket.puts
       end
 
-      def send_tag_flag_message(socket, opcode, tag, flag)
+      def send_remove_tag_from_key(socket, opcode, tag, key)
         tag_base64 = self.encode(tag)
+        key_base64 = self.encode(key)
+        dlock = '0'
         socket.print opcode
         socket.print ","
         socket.print  tag_base64
         socket.print ","
-        socket.print  flag
+        socket.print  key_base64
+        socket.print ","
+        socket.print  dlock
         socket.puts
       end
 
-      def send_tag_key_message(socket, opcode, tag, key)
-        tag_base64 = self.encode(tag)
+      def send_set_value_and_create_index(socket, opcode, key, val, tag_list=nil, group=nil, min_index_n='1', max_index_n='3')
         key_base64 = self.encode(key)
+        val_base64 = self.encode(val)
+
         dlock = '0'
+
         socket.print opcode
         socket.print ","
-        socket.print  tag_base64
-        socket.print ","
         socket.print  key_base64
         socket.print ","
+        self.print_tag_list socket, tag_list
+        socket.print ","
         socket.print  dlock
+        socket.print ","
+        socket.print  val_base64
+        socket.print ","
+        self.print_group socket, group
+        socket.print ","
+        socket.print  min_index_n
+        socket.print ","
+        socket.print  max_index_n
         socket.puts
       end
 
-      def send_query_condition_group_index_message(socket, opcode, query_list, condition, group, nsize)
-        queries = query_list.map{|q|self.encode(q)}.join(':')
+      def send_search_value(socket, opcode, query_list, condition='1', group=nil, nsize='3')
         
-        group_base64 = nil
-        if group then
-          group_base64 = self.encode(group)
-        end
-        group_base64 ||= "(B)"
         socket.print opcode
         socket.print ","
-        socket.print  queries
+        self.print_query_list(socket, query_list)
         socket.print ","
-        socket.print  condition
+        socket.print condition
         socket.print ","
-        socket.print  group_base64
+        self.print_group socket, group
         socket.print ","
         socket.print  nsize
         socket.puts
       end
+      
+      def print_group(socket, group)
+        if group then
+          socket.print self.encode(group)
+        else
+          socket.print  "(B)"
+        end
+      end
+      
+      def print_tag_list(socket, tag_list)
+        if tag_list then
+          self.print_key_list(socket, tag_list)
+        else
+          socket.print "(B)"
+        end
+      end
+
+      def print_key_list(socket, key_list)
+        lsize = key_list.size
+        k = key_list[0]
+        socket.print self.encode(k) if k
+        (lsize-1).times do |i|
+          socket.print ':'
+          socket.print self.encode(key_list[i+1])
+        end
+      end
+      alias :print_query_list :print_key_list
 
     end
   end

data/okuyama.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "okuyama"
-  s.version = "0.2.1"
+  s.version = "0.2.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kenji Hara"]
-  s.date = "2012-03-26"
+  s.date = "2012-03-27"
   s.description = "okuyama client for Ruby"
   s.email = "haracane@gmail.com"
   s.extra_rdoc_files = [
@@ -21,6 +21,7 @@ Gem::Specification.new do |s|
     ".rspec",
     "Gemfile",
     "Gemfile.lock",
+    "History.rdoc",
     "LICENSE.txt",
     "README.rdoc",
     "Rakefile",

data/spec/okuyama/client/search_spec.rb

@@ -65,14 +65,12 @@ describe Okuyama::Client do
       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
-            Okuyama.logger.debug("send: #{@client.protocol.message_of_set_value_and_create_index(@testkey1, @testval1, @testtag, @testgroup, '1', '3').inspect}")
             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
-            Okuyama.logger.debug("send: #{@client.protocol.message_of_set_value_and_create_index(@testnewkey, @testnewval, @testnewtag, @testnewgroup, '1', '3').inspect}")
             result = @client.set_value_and_create_index(@testnewkey, @testnewval, :tags=>[@testnewtag], :group=>@testnewgroup, :min_n=>1, :max_n=>3)
             result.should be_true
           end
@@ -82,7 +80,6 @@ describe Okuyama::Client do
       describe "search_value(query)" do
         describe "when key exists," do
           it "should return keys" do
-            Okuyama.logger.debug("send: #{@client.protocol.message_of_search_value([@testquery1]).inspect}")
             result = @client.search_value(@testquery1)
             result.sort!
             result.should == [@testkey1]
@@ -100,7 +97,6 @@ describe Okuyama::Client do
         if false then
           describe "when key exists," do
             it "should return keys" do
-              Okuyama.logger.debug("send: #{@client.protocol.message_of_search_value([@testquery1, @testquery2], '1', @testgroup, '3').inspect}")
               result = @client.search_value([@testquery1, @testquery2], :condition=>:and, :group=>@testgroup, :nsize=>3)
               result.sort!
               result.should == ['testkey1']
@@ -119,7 +115,6 @@ describe Okuyama::Client do
         if false then
           describe "when key exists," do
             it "should return keys" do
-              Okuyama.logger.debug("send: #{@client.protocol.message_of_search_value([@testquery1, @testquery2], '2', @testgroup, '3').inspect}")
               result = @client.search_value([@testquery1, @testquery2], :condition=>:or, :group=>@testgroup, :nsize=>3)
               result.sort!
               result.should == ['testkey1']

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: okuyama
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - Kenji Hara
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-26 00:00:00 Z
+date: 2012-03-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   type: :development
@@ -108,6 +108,7 @@ files:
 - .rspec
 - Gemfile
 - Gemfile.lock
+- History.rdoc
 - LICENSE.txt
 - README.rdoc
 - Rakefile