krpc 0.3.2 → 0.4.0.beta1

data/lib/krpc/decoder.rb

@@ -3,49 +3,42 @@ require 'set'
 
 module KRPC
   module Decoder
-    OK_LENGTH = 2
-    OK_MESSAGE = "\x4F\x4B"
-    GUID_LENGTH = 16
-
     class << self
-
+    
       # Given a type object, and serialized data, decode the ruby value/object
       def decode(data, type, client)
-        if type.is_a?(Types::MessageType) then decode_message(data, type)
+        if type.is_a?(Types::MessageType) then type.ruby_type.decode(data)
         elsif type.is_a?(Types::ValueType) then decode_value(data, type)
         elsif type.is_a?(Types::EnumType)
-          v = decode_value(data, TypeStore["int32"])
+          v = decode_value(data, 'sint32')
           type.ruby_type.key(v)
         elsif type.is_a?(Types::ClassType)
-          remote_oid = decode_value(data, TypeStore["uint64"])
+          remote_oid = decode_value(data, 'uint64')
           if remote_oid != 0
             type.ruby_type.new(client, remote_oid)
           else nil end
         elsif type.is_a?(Types::ListType)
-          msg = decode_message(data, TypeStore["KRPC.List"])
+          msg = PB::List.decode(data)
           msg.items.map{|x| decode(x, type.value_type, client)}.to_a
         elsif type.is_a?(Types::DictionaryType)
-          msg = decode_message(data, TypeStore["KRPC.Dictionary"])
+          msg = PB::Dictionary.decode(data)
           msg.entries.map{|e| [decode(e.key,   type.key_type,   client),
                                decode(e.value, type.value_type, client)]}.to_h
         elsif type.is_a?(Types::SetType)
-          msg = decode_message(data, TypeStore["KRPC.Set"])
+          msg = PB::Set.decode(data)
           Set.new(msg.items.map{|x| decode(x, type.value_type, client)}.to_a)
         elsif type.is_a?(Types::TupleType)
-          msg = decode_message(data, TypeStore["KRPC.Tuple"])
+          msg = PB::Tuple.decode(data)
           msg.items.zip(type.value_types).map{|x,t| decode(x, t, client)}.to_a
-        else raise RuntimeError.new("Cannot decode type #{type} from data: #{data}")
+        else raise(RuntimeError, "Cannot decode type #{type} from data: #{data}")
         end
       end
-
+      
       def decode_value(data, type)
-        ProtobufUtils::Decoder.decode(data, type.protobuf_type)
+        type_string = type.is_a?(String) ? type : type.protobuf_type.code.to_s.downcase
+        ProtobufUtils::Decoder.decode(data, type_string) 
       end
-
-      def decode_message(data, type)
-        type.ruby_type.decode(data.to_s)
-      end
-
+      
     end
   end
 end

data/lib/krpc/doc.rb

@@ -7,7 +7,7 @@ module KRPC
     @docstr_infos = {}
     @procedure_docstr_infos = {}
     class << self
-
+      
       def docstring_for_method(method_owner, method_name, is_print_xmldoc_summary = true)
         is_static, class_cls = method_owner.class == Class ? [true, method_owner] : [false, method_owner.class]
         service_module_name, class_name = ruby_class_to_pb_module_class_pair(class_cls)
@@ -16,10 +16,10 @@ module KRPC
           construct_docstring(*@docstr_infos[key], true, is_static, is_print_xmldoc_summary)
         else
           "No docstring for #{class_cls.name}#{calc_separator(is_static)}#{method_name.to_s} method" +
-            (method_owner.respond_to?(method_name) ? "" : "\nThere is no such method -- maybe a typo?")
+            (method_owner.respond_to?(method_name) ? "" : "\nThere is no such method -- maybe a typo")
         end
       end
-
+      
       def docstring_for_procedure(service_name, procedure_name, is_print_xmldoc_summary = true)
         key = [service_name, procedure_name].hash
         if @procedure_docstr_infos.has_key? key
@@ -40,30 +40,30 @@ module KRPC
           @docstr_infos[key2] = val
         end
       end
-
+      
       def add_special_docstring_info(key, value)
         @docstr_infos[key] = value
       end
-
+      
       private #----------------------------------
-
+      
       def ruby_class_to_pb_module_class_pair(ruby_class)
         return ["", Client.class_name] if ruby_class == Client
         rest, _, pb_class_name = ruby_class.name.rpartition("::")
         _, _, pb_service_name = rest.rpartition("::")
         [pb_service_name, pb_class_name]
       end
-
+      
       def calc_separator(is_static)
         is_static ? '.' : '#'
       end
-
+      
       def construct_docstring(namespace, separator, name, param_names, param_types, param_default, return_type, xmldoc, is_hide_this_param, is_prepend_client_param,  is_print_xmldoc_summary)
         xmldoc = Nokogiri::XML(xmldoc)
         xmldoc_summary = xmlElements2str(xmldoc.xpath("doc/summary").children, :light_blue, :light_green, :light_red)
 
         xmldoc_returns = xmlElements2str(xmldoc.xpath("doc/returns").children, :blue, :green, :light_red)
-        xmldoc_returns = "- ".blue + xmldoc_returns unless xmldoc_returns.empty?
+        xmldoc_returns = "- ".blue + xmldoc_returns unless xmldoc_returns.empty? 
 
         xmldoc_params = {}
         xmldoc.xpath("doc/param").each do |e|
@@ -76,10 +76,10 @@ module KRPC
             end
           end
         end
-
+        
         param_infos = param_names.zip(param_types.map{|x| type2str(x)}, param_default)
         param_infos.shift if is_hide_this_param && param_names[0] == "this"
-        param_infos.unshift ["client", "Client", :no_default_value] if is_prepend_client_param
+        param_infos.unshift ["client", "Client", :no_default_value] if is_prepend_client_param 
         if param_infos.empty?
           params = ""
         else
@@ -92,14 +92,14 @@ module KRPC
         "#{namespace.cyan}#{separator.cyan}#{name.bold}(#{params}) :#{type2str(return_type).light_red} #{xmldoc_returns}" \
           + (is_print_xmldoc_summary ? "\n\n#{xmldoc_summary}" : "")
       end
-
+      
       def type2str(type)
         return "nil" if type.nil?
         return type.class_name if type.class == Class
         rt = type.ruby_type
         if type.is_a?(Types::EnumType) then "Enum" + rt.keys.to_s
         elsif type.is_a?(Types::ListType) ||
-              type.is_a?(Types::SetType)
+              type.is_a?(Types::SetType) 
           "#{rt.class_name}[#{type2str(type.value_type)}]"
         elsif type.is_a?(Types::DictionaryType)
           %Q{#{rt.class_name}[#{type2str(type.key_type)} => #{type2str(type.value_type)}]}
@@ -107,7 +107,7 @@ module KRPC
           %Q{#{rt.class_name}[#{type.value_types.map{|x| type2str(x)}.join(", ")}]}
         else rt.class_name end
       end
-
+        
       def xmlElements2str(elements, main_color, paramref_color, value_color, error_color = :red)
         elements.map do |elem|
           if elem.is_a?(Nokogiri::XML::Text)
@@ -138,13 +138,13 @@ module KRPC
                   elem.text.gsub("null","nil").colorize(value_color)
                 else elem.to_s.colorize(error_color)
               end
-            rescue RuntimeException
+            rescue RuntimeException => exc
               elem.to_s.colorize(error_color)
             end
           end
         end.join.gsub("\n"," ").gsub("!n!","\n").squeeze(' ').strip.gsub("!s!"," ")
       end
-
+      
       def is_method_defined(path_array)
         method_name = path_array[-1].underscore
         begin
@@ -154,18 +154,23 @@ module KRPC
           false
         end
       end
-
+      
     end
-
-
+    
+    
     module SuffixMethods
       DOCSTRING_SUFFIX = "_doc"
       DOCSTRING_SUFFIX_REGEX = /^(.+)(?:#{DOCSTRING_SUFFIX}(=)?)$/
-
+      
       def self.included(base)
-        base.extend self, ClassMethods
+        base.extend self
+        class << base
+          def krpc_name
+            class_name
+          end
+        end
       end
-
+      
       def method_missing(method, *args, &block)
         if DOCSTRING_SUFFIX_REGEX =~ method.to_s
           documented_method_name = $1 + $2.to_s
@@ -175,20 +180,14 @@ module KRPC
         end
         super
       end
-
+      
       def respond_to_missing?(method, *)
         if DOCSTRING_SUFFIX_REGEX =~ method.to_s
           return true if respond_to? ($1 + $2.to_s).to_sym
         end
         super
       end
-
-      module ClassMethods
-        def krpc_name
-          class_name
-        end
-      end
     end
-
+    
   end
 end

data/lib/krpc/encoder.rb

@@ -3,67 +3,55 @@ require 'krpc/types'
 
 module KRPC
   module Encoder
-    RPC_HELLO_MESSAGE = "\x48\x45\x4C\x4C\x4F\x2D\x52\x50\x43\x00\x00\x00"
-    STREAM_HELLO_MESSAGE = "\x48\x45\x4C\x4C\x4F\x2D\x53\x54\x52\x45\x41\x4D"
-    NAME_LENGTH = 32
-
     class << self
-
+      
       # Given a type object, and ruby object, encode the ruby object
       def encode(obj, type)
         if type.is_a?(Types::MessageType) then type.ruby_type.encode(obj)
         elsif type.is_a?(Types::ValueType) then encode_value(obj, type)
         elsif type.is_a?(Types::EnumType)
           enum_value = type.ruby_type[obj]
-          encode_value(enum_value, TypeStore["int32"])
+          encode_value(enum_value, 'sint32')
         elsif type.is_a?(Types::ClassType)
-          remote_oid = if obj == nil then 0 else obj.remote_oid end
-          encode_value(remote_oid, TypeStore["uint64"])
+          remote_oid = obj.nil? ? 0 : obj.remote_oid
+          encode_value(remote_oid, 'uint64')
         elsif type.is_a?(Types::ListType)
-          ruby_type = TypeStore["KRPC.List"].ruby_type
-          msg = ruby_type.new(
+          PB::List.encode(PB::List.new(
             items: obj.map{|x| encode(TypeStore.coerce_to(x, type.value_type), type.value_type)}.to_a
-          )
-          ruby_type.encode(msg)
+          ))
         elsif type.is_a?(Types::DictionaryType)
-          ruby_type = TypeStore["KRPC.Dictionary"].ruby_type
-          entry_type = TypeStore["KRPC.DictionaryEntry"].ruby_type
           entries = obj.map do |k,v|
-            entry_type.new(
+            PB::DictionaryEntry.new(
               key: encode(TypeStore.coerce_to(k, type.key_type), type.key_type),
               value: encode(TypeStore.coerce_to(v, type.value_type), type.value_type)
             )
           end
-          msg = ruby_type.new(entries: entries)
-          ruby_type.encode(msg)
+          PB::Dictionary.encode(PB::Dictionary.new(entries: entries))
         elsif type.is_a?(Types::SetType)
-          ruby_type = TypeStore["KRPC.Set"].ruby_type
-          msg = ruby_type.new(
+          PB::Set.encode(PB::Set.new(
             items: obj.map{|x| encode( TypeStore.coerce_to(x, type.value_type), type.value_type )}.to_a
-          )
-          ruby_type.encode(msg)
+          ))
         elsif type.is_a?(Types::TupleType)
-          ruby_type = TypeStore["KRPC.Tuple"].ruby_type
-          msg = ruby_type.new(
+          PB::Tuple.encode(PB::Tuple.new(
             items: obj.zip(type.value_types).map{|x,t| encode( TypeStore.coerce_to(x, t), t )}.to_a
-          )
-          ruby_type.encode(msg)
+          ))
         else raise(RuntimeError, "Cannot encode object #{obj} of type #{type}")
         end
       end
-
+      
       def encode_value(value, type)
-        ProtobufUtils::Encoder.encode(value, type.protobuf_type)
+        type_string = type.is_a?(String) ? type : type.protobuf_type.code.to_s.downcase
+        ProtobufUtils::Encoder.encode(value, type_string)
       end
-
-      def encode_request(req)
-        data = PB::Request.encode(req)
+      
+      def encode_message_with_size(msg)
+        data = msg.class.encode(msg)
         length = ProtobufUtils::Encoder.encode_nonnegative_varint(data.length)
         length + data
       end
 
       def hash_to_enumeration_values(hash)
-        hash.map {|k,v| PB::EnumerationValue.new(name: k.to_s, value: v) }
+        hash.map {|k,v| PB::EnumerationValue.new(name: k.to_s, value: v)}
       end
 
     end

data/lib/krpc/error.rb

@@ -4,6 +4,7 @@ module KRPC
   class ConnectionError < Exception; end
   class RPCError < Exception; end
   class ValueError < Exception; end
+  class ProcedureNameParserError < Exception; end
 
 
   class ArgumentErrorSig < ArgumentError
@@ -31,7 +32,7 @@ module KRPC
     def with_arguments_count_incremented_by(args_count_increment)
       self.class.new(args_count + args_count_increment, (valid_params_count_range.min + args_count_increment)..(valid_params_count_range.max + args_count_increment), signature)
     end
-
+    
     def with_signature(sig)
       self.class.new(args_count, valid_params_count_range, sig)
     end

data/lib/krpc/gen.rb

@@ -6,10 +6,10 @@ require 'colorize'
 module KRPC
   module Gen
     class << self
-      def service_gen_module(service_name)
+      def service_gen_module(service_name) 
         const_get_or_create(service_name, Module.new)
       end
-
+    
       def generate_class(service_name, class_name)
         mod = service_gen_module(service_name)
         mod.const_get_or_create(class_name) do
@@ -19,7 +19,7 @@ module KRPC
           end
         end
       end
-
+      
       def generate_enum(service_name, enum_name, values)
         mod = service_gen_module(service_name)
         mod.const_get_or_create(enum_name) do
@@ -27,16 +27,18 @@ module KRPC
         end
       end
 
-      def add_rpc_method(cls, method_name, service_name, proc, *switches, **options)
-        is_static = switches.include? :static
-        prepend_self_to_args = switches.include? :prepend_self_to_args
+      def add_rpc_method(cls, service_name, proc, **options)
+        method_name = proc.member_name.underscore
+        method_name += '=' if proc.setter?
+
         param_names, param_types, param_default, return_type = parse_procedure(proc)
-        method_name = method_name.underscore
+        is_static = proc.type == :class_static_method || proc.type == :plain_procedure
+        prepend_self_to_args = proc.class_member? && proc.type != :class_static_method
         args = [cls, method_name, param_default, param_names, param_types, prepend_self_to_args, proc, return_type, service_name]
 
         define_rpc_method(*args)
         define_static_rpc_method(*args) if is_static
-        add_stream_constructing_proc(*args) unless switches.include? :no_stream
+        add_stream_constructing_proc(*args) unless proc.setter?
         Doc.add_docstring_info(is_static, cls, method_name, options[:doc_service_name] || service_name, proc.name, param_names, param_types, param_default, return_type: return_type, xmldoc: proc.documentation)
       end
 
@@ -52,15 +54,15 @@ module KRPC
           raise err.with_signature(Doc.docstring_for_method(method_owner, method_name, false))
         end
       end
-
+      
       private #----------------------------------
-
+      
       def define_static_rpc_method(cls, method_name, param_default, param_names, param_types, prepend_self_to_args, proc, return_type, service_name)
         cls.instance_eval do
           define_singleton_method method_name do |*args|
             Gen.transform_exceptions(cls, method_name, prepend_self_to_args) do
               raise ArgumentErrorSig.new("missing argument for parameter \"client\"") if args.count < 1
-              raise ArgumentErrorSig.new("argument for parameter \"client\" must be a #{::KRPC::Client.name} -- got #{args.first.inspect} of type #{args.first.class}") unless args.first.is_a?(::KRPC::Client)
+              raise ArgumentErrorSig.new("argument for parameter \"client\" must be a #{KRPC::Client.name} -- got #{args.first.inspect} of type #{args.first.class}") unless args.first.is_a?(KRPC::Client)
               client = args.shift
               kwargs = args.extract_kwargs!
               client.execute_rpc(service_name, proc.name, args, kwargs, param_names, param_types, param_default, return_type: return_type)
@@ -85,52 +87,49 @@ module KRPC
         cls.stream_constructors[method_name] = Proc.new do |this, *args, **kwargs|
           Gen.transform_exceptions(this, method_name, prepend_self_to_args) do
             req_args = prepend_self_to_args ? [this] + args : args
-            request = this.client.build_request(service_name, proc.name, req_args, kwargs, param_names, param_types, param_default)
-            this.client.streams_manager.create_stream(request, return_type, this.method(method_name), *args, **kwargs)
+            call = this.client.build_procedure_call(service_name, proc.name, req_args, kwargs, param_names, param_types, param_default)
+            this.client.streams_manager.create_stream(call, return_type, this.method(method_name), *args, **kwargs)
           end
         end
       end
-
+      
       def parse_procedure(proc)
-        param_names = proc.parameters.map{|p| p.name.underscore}
-        param_types = proc.parameters.map.with_index do |p,i|
-          TypeStore.get_parameter_type(i, p.type, proc.attributes)
-        end
+        param_names = proc.parameters.map{|p| p.name.underscore }
+        param_types = proc.parameters.map{|p| TypeStore[p.type] }
         param_default = proc.parameters.zip(param_types).map do |param, type|
-          if param.has_default_value
-            Decoder.decode(param.default_value, type, :clientless)
-          else :no_default_value
-          end
+          param.field_empty?(:default_value) ? :no_default_value : Decoder.decode(param.default_value, type, :clientless)
         end
-        return_type = if proc.has_return_type
-                        TypeStore.get_return_type(proc.return_type, proc.attributes)
-                      else nil end
+        return_type = if proc.field_empty?(:return_type) || proc.return_type.code == :NONE
+                        nil
+                      else
+                        TypeStore[proc.return_type]
+                      end
         [param_names, param_types, param_default, return_type]
       end
     end
-
+    
     module RPCMethodGenerator
-      def include_rpc_method(method_name, service_name, procedure_name, params: [], return_type: nil, attributes: [], xmldoc: "", switches: [], options: {})
-        Gen.add_rpc_method(self.class, method_name, service_name, PB::Procedure.new(name: procedure_name, parameters: params, has_return_type: return_type != nil, return_type: return_type != nil ? return_type : "", attributes: attributes, documentation: xmldoc), *switches, **options)
+      def include_rpc_method(service_name, procedure_name, params: [], return_type: nil, xmldoc: "", **options)
+        Gen.add_rpc_method(self.class, service_name, PB::Procedure.new(name: procedure_name, parameters: params, return_type: return_type, documentation: xmldoc), **options)
       end
     end
-
+    
     ##
     # Base class for service-defined class types.
     class ClassBase
       include Doc::SuffixMethods
       include Streaming::StreamConstructors
-
+      
       attr_reader :client, :remote_oid
-
+      
       def self.krpc_name
         name[11..-1]
       end
-
+      
       def initialize(client, remote_oid)
         @client, @remote_oid = client, remote_oid
       end
-
+      
       alias_method :eql?, :==
       def ==(other)
         other.class == self.class and other.remote_oid == remote_oid
@@ -138,15 +137,15 @@ module KRPC
       def hash
         remote_oid.hash
       end
-
+      
       def to_s
         "#<#{self.class} @remote_oid=#{remote_oid}>"
       end
-
+      
       def inspect
         "#<#{self.class} ".green + "@remote_oid" + "=".green + remote_oid.to_s.bold.blue + ">".green
       end
     end
-
-  end
+    
+  end    
 end