ruby_protobuf 0.2.0 → 0.3.0

data/lib/protobuf/compiler/template/rpc_bin.erb

@@ -0,0 +1,4 @@
+#!/usr/bin/ruby
+require '<%= underscored_name %>'
+
+<%= module_name %>::<%= service_name %>.new(:port => <%= default_port %>).start

data/lib/protobuf/compiler/template/rpc_client.erb

@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+require 'protobuf/rpc/client'
+require '<%= required_file %>'
+
+# build request
+request = <%= message_module %>::<%= request %>.new
+# TODO: setup a request
+raise StandardError.new('setup a request')
+
+# create blunk response
+response = <%= message_module %>::<%= response %>.new
+
+# execute rpc
+Protobuf::Rpc::Client.new('localhost', <%= default_port %>).call :<%= underscore name %>, request, response
+
+# show response
+puts response
+

data/lib/protobuf/compiler/template/rpc_service.erb

@@ -0,0 +1,25 @@
+require 'protobuf/rpc/server'
+require 'protobuf/rpc/handler'
+require '<%= required_file %>'
+
+<%- rpcs.each do |name, request, response| -%>
+class <%= module_name %>::<%= name %>Handler < Protobuf::Rpc::Handler
+  request <%= module_name %>::<%= request %>
+  response <%= module_name %>::<%= response %>
+  
+  def self.process_request(request, response)
+    # TODO: edit this method
+  end
+end
+
+<%- end -%>
+class <%= module_name %>::<%= service_name %> < Protobuf::Rpc::Server
+  def setup_handlers
+    @handlers = {
+      <%- rpcs.each do |name, | -%>
+      :<%= underscore name %> => <%= module_name %>::<%= name %>Handler,
+      <%- end -%>
+    } 
+  end
+end
+

data/lib/protobuf/compiler/visitors.rb

@@ -0,0 +1,132 @@
+require 'erb'
+
+module Protobuf
+  module Visitor
+    class CreateMessageVisitor
+      attr_accessor :indent, :context
+
+      def initialize(proto_dir='.', out_dir='.')
+        @proto_dir, @out_dir = proto_dir, out_dir
+        @indent = 0
+        @context = []
+      end
+
+      def write(str)
+        ruby << "#{'  ' * @indent}#{str}"
+      end
+
+      def increment
+        @indent += 1
+      end
+
+      def decrement
+        @indent -= 1
+      end
+
+      def close_ruby
+        while 0 < indent
+          decrement
+          write 'end'
+        end
+      end
+
+      def ruby
+        @ruby ||= []
+      end
+
+      def to_s
+        @ruby.join "\n"
+      end
+
+      def in_context(klass, &block)
+        increment
+        context.push klass
+        block.call
+        context.pop
+        decrement
+      end
+
+      def visit(node)
+        node.accept_message_creator self 
+        self
+      end
+
+      def required_message_from_proto(proto_file)
+        rb_path = proto_file.sub(/\.proto$/, '.rb')
+        unless File.exist?("#{@out_dir}/#{rb_path}")
+          Compiler.compile proto_file, @proto_dir, @out_dir
+        end
+        rb_path.sub /\.rb$/, ''
+      end
+    end
+
+    class CreateRpcVisitor
+      attr_accessor :package, :services, :current_service, :file_contents
+
+      def initialize
+        @services = {}
+        @create_file = true
+        @file_contents = {}
+      end
+
+      def visit(node)
+        node.accept_rpc_creator self
+        self
+      end
+
+      def add_rpc(name, request, response)
+        (@services[@current_service] ||= []) << [name, request.first, response.first]
+      end
+
+      #def create_files(message_file, out_dir, create_file=true)
+      def create_files(message_file, out_dir, create_file=false)
+        @create_file = create_file
+        default_port = 9999
+        @services.each do |service_name, rpcs|
+          underscored_name = underscore service_name.to_s
+          message_module = package.map{|p| p.to_s.capitalize}.join('::')
+          required_file = message_file.sub(/^\.\//, '').sub(/\.rb$/, '')
+
+          create_bin out_dir, underscored_name, message_module, service_name, default_port
+          create_service message_file, out_dir, underscored_name, message_module, 
+            service_name, default_port, rpcs, required_file
+          rpcs.each do |name, request, response|
+            create_client out_dir, underscored_name, default_port, name, request, response, message_module, required_file
+          end
+        end
+        @file_contents
+      end
+
+      def create_bin(out_dir, underscored_name, module_name, service_name, default_port)
+        bin_filename = "#{out_dir}/start_#{underscored_name}"
+        bin_contents = template_erb('rpc_bin').result binding
+        File.open(bin_filename, 'w') {|f| f.write bin_contents} if @create_file
+        @file_contents[bin_filename] = bin_contents
+      end
+
+      def create_service(message_file, out_dir, underscored_name, module_name, service_name, default_port, rpcs, required_file)
+        service_filename = "#{out_dir}/#{underscored_name}.rb"
+        service_contents = template_erb('rpc_service').result binding
+        File.open(service_filename, 'w') {|f| f.write service_contents} if @create_file
+        @file_contents[service_filename] = service_contents
+      end
+
+      def create_client(out_dir, underscored_name, default_port, name, request, response, message_module, required_file)
+        client_filename = "#{out_dir}/client_#{underscore name}.rb"
+        client_contents = template_erb('rpc_client').result binding
+        File.open(client_filename, 'w') {|f| f.write client_contents} if @create_file
+        @file_contents[client_filename] = client_contents
+      end
+
+      private
+
+      def underscore(str)
+        str.to_s.gsub(/\B[A-Z]/, '_\&').downcase
+      end
+
+      def template_erb(template)
+        ERB.new File.read("#{File.dirname(__FILE__)}/template/#{template}.erb"), nil, '-'
+      end
+    end
+  end
+end

data/lib/protobuf/message/decoder.rb

@@ -42,10 +42,15 @@ module Protobuf
     protected
 
     def read_key(stream)
+      # TODO is there more clear way to do this?
+      bits = 0
       bytes = read_varint stream
-      #TODO 1 < bytes.size のときエラー
-      wire_type = bytes[0] & 0b00000111
-      tag = bytes[0] >> 3 # TODO
+      bytes.each_with_index do |byte, index|
+        byte &= 0b01111111
+        bits |= byte << (7 * index)
+      end
+      wire_type = bits & 0b00000111
+      tag = bits >> 3
       [tag, wire_type]
     end
 

data/lib/protobuf/message/enum.rb

@@ -13,6 +13,10 @@ module Protobuf
         not get_name_by_tag(tag).nil?
       end
 
+      def name_by_value(value)
+        constants.find {|c| const_get(c) == value}
+      end
+
       def descriptor
         @descriptor ||= Protobuf::Descriptor::EnumDescriptor.new(self)
       end

data/lib/protobuf/message/field.rb

@@ -31,18 +31,41 @@ module Protobuf
       end
 
       def initialize(message_class, rule, type, name, tag, opts={})
-        @message_class, @rule, @type, @name, @tag, @default = 
-          message_class, rule, type, name, tag, opts[:default]
+        @message_class, @rule, @type, @name, @tag, @default, @extension = 
+          message_class, rule, type, name, tag, opts[:default], opts[:extension]
         @error_message = 'Type invalid'
       end
 
       def ready?; true end
 
+      def initialized?(message)
+        case rule
+        when :required
+          return false if message[name].nil?
+          return false if is_a?(Protobuf::Field::MessageField) and not message[name].initialized?
+        when :repeated
+          return message[name].inject(true) do |result, msg|
+            result and msg.initialized?
+          end
+        end
+        true
+      end
+
+      def clear(message)
+        if repeated?
+          message[name].clear
+        else
+          message[name] = default_value
+        end
+      end
+
       def default_value
         case rule
         when :repeated
           FieldArray.new self
-        when :required, :optional
+        when :required
+          nil
+        when :optional
           typed_default_value default
         else
           raise InvalidRuleError
@@ -68,10 +91,13 @@ module Protobuf
       end
 
       def define_setter(message_instance)
+        extension = @extension
         message_instance.instance_eval %Q{
           def #{name}=(val)
-            field = get_field_by_name #{name.inspect}
-            if field.acceptable? val
+            field = get_#{extension ? 'ext_' : ''}field_by_name #{name.inspect}
+            if val.nil?
+              @#{name} = field.default_value
+            elsif field.acceptable? val
               @#{name} = val
             end
           end

data/lib/protobuf/message/message.rb

@@ -1,3 +1,4 @@
+require 'pp'
 require 'stringio'
 require 'protobuf/message/decoder'
 require 'protobuf/message/encoder'
@@ -7,12 +8,28 @@ require 'protobuf/descriptor/descriptor'
 module Protobuf
   OPTIONS = {}
 
+
   class Message
+    class ExtensionFields < Hash
+      def initialize(key_range=0..-1)
+        @key_range = key_range
+      end
+
+      def []=(key, value)
+        raise RangeError.new("#{key} is not in #{@key_range}") unless @key_range.include? key
+        super
+      end
+
+      def include_tag?(tag)
+        @key_range.include? tag
+      end
+    end
+
     class <<self
       attr_reader :fields
 
       def extensions(range)
-        raise NotImplementedError('TODO')
+        @extension_fields = ExtensionFields.new range
       end
 
       def required(type, name, tag, opts={})
@@ -28,25 +45,51 @@ module Protobuf
       end
 
       def define_field(rule, type, name, tag, opts={})
-        (@fields ||= {})[tag] = Protobuf::Field.build self, rule, type, name, tag, opts
+        field_hash = opts[:extension] ? extension_fields : (@fields ||= {})
+        field_hash[tag] = Protobuf::Field.build self, rule, type, name, tag, opts
+        #(@fields ||= {})[tag] = Protobuf::Field.build self, rule, type, name, tag, opts
+      end
+
+      def extension_tag?(tag)
+        extension_fields.include_tag? tag
+      end
+
+      def extension_fields
+        @extension_fields ||= ExtensionFields.new
       end
 
       def get_field_by_name(name)
-        @fields.values.find {|field| field.name == name.to_sym}
+        fields.values.find {|field| field.name == name.to_sym}
       end
 
       def get_field_by_tag(tag)
-        @fields[tag]
+        fields[tag]
       end
 
       def get_field(tag_or_name)
         case tag_or_name
-        when Integer
-          get_field_by_tag tag_or_name
-        when String, Symbol
-          get_field_by_name tag_or_name
-        else
-          raise TypeError
+        when Integer; get_field_by_tag tag_or_name
+        when String, Symbol; get_field_by_name tag_or_name
+        else; raise TypeError
+        end
+      end
+
+      #TODO merge to get_field_by_name
+      def get_ext_field_by_name(name)
+        extension_fields.values.find {|field| field.name == name.to_sym}
+      end
+
+      #TODO merge to get_field_by_tag
+      def get_ext_field_by_tag(tag)
+        extension_fields[tag]
+      end
+
+      #TODO merge to get_field
+      def get_ext_field(tag_or_name)
+        case tag_or_name
+        when Integer; get_ext_field_by_tag tag_or_name
+        when String, Symbol; get_ext_field_by_name tag_or_name
+        else; raise TypeError
         end
       end
 
@@ -63,6 +106,69 @@ module Protobuf
         end
         field.define_accessor self
       end
+
+      # TODO
+      self.class.extension_fields.each do |tag, field|
+        unless field.ready?
+          field = field.setup
+          self.class.class_eval {@extension_fields[tag] = field}
+        end
+        field.define_accessor self
+      end
+    end
+
+    def initialized?
+      fields.to_a.inject(true) do |result, (tag, field)|
+        result and field.initialized?(self)
+      end and
+      extension_fields.to_a.inject(true) do |result, (tag, field)|
+        result and field.initialized?(self)
+      end
+    end
+
+    def clear!
+      each_field do |field, value|
+        field.clear self
+      end
+    end
+
+    def dup
+      ret = self.class.new
+      each_field do |field, value|
+        if field.repeated?
+          value.each do |v|
+            ret[field.name] << (v.is_a?(Numeric) ? v : v.dup)
+          end
+        else
+          ret[field.name] = value.is_a?(Numeric) ? value : value.dup
+        end
+      end
+      ret
+    end
+
+    def to_s(indent=0)
+      ret = ''
+      i = '  ' * indent
+      field_value_to_string = lambda do |field, value|
+        ret +=
+          if field.is_a? Protobuf::Field::MessageField
+            "#{i}#{field.name} {\n#{value.to_s(indent + 1)}#{i}}\n"
+          elsif field.is_a? Protobuf::Field::EnumField
+            "#{i}#{field.name}: #{field.type.name_by_value(value)}\n"
+          else
+            "#{i}#{field.name}: #{value.inspect}\n"
+          end
+      end
+      each_field do |field, value|
+        if field.repeated?
+          value.each do |v| 
+            field_value_to_string.call field, v
+          end
+        else 
+          field_value_to_string.call field, value
+        end
+      end
+      ret
     end
 
     def parse_from_string(string)
@@ -104,7 +210,8 @@ module Protobuf
     end
 
     def set_field(tag, bytes)
-      get_field_by_tag(tag).set self, bytes
+      #get_field_by_tag(tag).set self, bytes
+      (get_field_by_tag(tag) or get_ext_field_by_tag(tag)).set self, bytes
     end
     
     def merge_field(tag, value)
@@ -115,16 +222,20 @@ module Protobuf
     def [](tag_or_name)
       if field = get_field(tag_or_name)
         send field.name
+      elsif field = get_ext_field(tag_or_name)
+        send field.name
       else
-        raise NoMethodError.new("No such method: #{tag_or_name}")
+        raise NoMethodError.new("No such method: #{tag_or_name.inspect}")
       end
     end
 
     def []=(tag_or_name, value)
       if field = get_field(tag_or_name) and not field.repeated?
         send "#{field.name}=", value
+      elsif field = get_ext_field(tag_or_name) and not field.repeated?
+        send "#{field.name}=", value
       else
-        raise NoMethodError.new("No such method: #{tag_or_name}=")
+        raise NoMethodError.new("No such method: #{tag_or_name.inspect}")
       end
     end
 
@@ -133,8 +244,13 @@ module Protobuf
     def get_field_by_tag(tag); self.class.get_field_by_tag(tag) end
     def get_field(tag_or_name); self.class.get_field(tag_or_name) end
 
+    def extension_fields; self.class.extension_fields end
+    def get_ext_field_by_name(name); self.class.get_ext_field_by_name(name) end
+    def get_ext_field_by_tag(tag); self.class.get_ext_field_by_tag(tag) end
+    def get_ext_field(tag_or_name); self.class.get_ext_field(tag_or_name) end
+
     def each_field(&block)
-      fields.to_a.sort{|(t1, f1), (t2, f2)| t1 <=> t2}.each do |tag, field|
+      (fields.merge extension_fields).to_a.sort{|(t1, f1), (t2, f2)| t1 <=> t2}.each do |tag, field|
         block.call field, self[tag]
       end
     end

data/lib/protobuf/rpc/client.rb

@@ -0,0 +1,19 @@
+require 'socket'
+
+module Protobuf
+  module Rpc
+    class Client
+      def initialize(host, port)
+        @host, @port = host, port
+      end
+
+      def call(name, request, response)
+        socket = TCPSocket.open @host, @port
+        socket.write "#{name}\n"
+        request.serialize_to socket
+        socket.close_write
+        response.parse_from socket
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/handler.rb

@@ -0,0 +1,17 @@
+module Protobuf
+  module Rpc
+    class Handler
+      class <<self
+        attr_reader :request_class, :response_class
+
+        def request(request_class)
+          @request_class = request_class
+        end
+        
+        def response(response_class)
+          @response_class = response_class
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/server.rb

@@ -0,0 +1,39 @@
+require 'webrick/config'
+require 'webrick/server'
+
+module Protobuf
+  module Rpc
+    class Server < WEBrick::GenericServer
+      def initialize(config={:Port => 9999}, default=WEBrick::Config::General)
+        super config, default
+        setup_handlers
+      end
+
+      def setup_handlers
+        @handlers = {}
+      end
+
+      def get_handler(socket)
+        @handlers[socket.readline.strip.to_sym]
+      end
+
+      def run(socket)
+        handler = get_handler socket
+        request = handler.request_class.new
+        request.parse_from socket
+        response = handler.response_class.new
+        begin
+          handler.process_request request, response
+        rescue StandardError => ex
+          @logger.error ex
+        ensure
+          begin
+            response.serialize_to socket
+          rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN => ex
+            @logger.error ex
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_protobuf.rb

@@ -1,22 +1,3 @@
-require 'protobuf/compiler'
-
 class RubyProtobuf
-  VERSION = '0.2.0'
-
-  def start(proto_file, options)
-    unless File.exist?(proto_file)
-      if File.exist? "#{proto_file}.proto"
-        proto_file = "#{proto_file}.proto"
-      else
-        raise ArgumentError.new("#{proto_file} does not exist.")
-      end
-    end
-    rb_filename = File.basename proto_file.dup
-    rb_filename += '.rb' unless rb_filename.sub!(/.\w+$/, '.rb')
-    rb_filepath = "#{options[:out] || '.'}/#{rb_filename}"
-    puts "#{rb_filepath} writting..."
-    File.open(rb_filepath, 'w') do |f|
-      f.write Protobuf::Compiler.compile(proto_file)
-    end
-  end
+  VERSION = '0.3.0'
 end

data/test/addressbook.proto

@@ -17,6 +17,12 @@ message Person {
   }
 
   repeated PhoneNumber phone = 4;
+
+  extensions 100 to 200;
+}
+
+extend Person {
+  optional int32 age = 100;
 }
 
 message AddressBook {

data/test/addressbook.rb

@@ -4,36 +4,39 @@ require 'protobuf/message/service'
 require 'protobuf/message/extend'
 
 module Tutorial
-  class Person < Protobuf::Message
+  
+  class Person < ::Protobuf::Message
     required :string, :name, 1
     required :int32, :id, 2
     optional :string, :email, 3
-
-    class PhoneType < Protobuf::Enum
+    
+    class PhoneType < ::Protobuf::Enum
       MOBILE = 0
       HOME = 1
       WORK = 2
     end
-
-    class PhoneNumber < Protobuf::Message
+    
+    class PhoneNumber < ::Protobuf::Message
       required :string, :number, 1
       optional :PhoneType, :type, 2, {:default => :HOME}
     end
-
+    
     repeated :PhoneNumber, :phone, 4
-
-    #extensions 100..199
-    #class Foo < Protobuf::Extend
-    #  optional :int32, :bar, 126
-    #end
+    
+    #extensions 100..200
   end
-
-  class AddressBook < Protobuf::Message
+  
+  # see: addressbool_ext.rb
+  #class Person < ::Protobuf::Message
+  #  optional :int32, :age, 100, :extension => true
+  #end
+  
+  class AddressBook < ::Protobuf::Message
     repeated :Person, :person, 1
   end
 
   #class SearchService < Protobuf::Service
-  #  rpc :Search => :SearchRequest, :returns => :SearchResponse
+  #  rpc :Search, :request => :SearchRequest, :response => :SearchResponse
   #end
 
   #Protobuf::OPTIONS[:optimize_for] = :SPEED

data/test/addressbook_base.proto

@@ -0,0 +1,26 @@
+package tutorial;
+
+message Person {
+  required string name = 1;
+  required int32 id = 2;
+  optional string email = 3;
+
+  enum PhoneType {
+    MOBILE = 0;
+    HOME = 1;
+    WORK = 2;
+  }
+
+  message PhoneNumber {
+    required string number = 1;
+    optional PhoneType type = 2 [default = HOME];
+  }
+
+  repeated PhoneNumber phone = 4;
+
+  extensions 100 to 200;
+}
+
+message AddressBook {
+  repeated Person person = 1;
+}