krpc 0.1.1.1 → 0.2.0

data/lib/krpc/doc.rb

@@ -1,47 +1,48 @@
 require 'krpc/core_extensions'
+require 'nokogiri'
 require 'colorize'
 
 module KRPC
   module Doc
+    @docstr_infos = {}
+    @procedure_docstr_infos = {}
     class << self
-      @@docstr_infos = {}
-      @@procedure_docstr_infos = {}
       
-      def docstring_for_method(method_owner, method_name)
+      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)
         key = [service_module_name, is_static, class_name, method_name.to_s].hash
-        if (@@docstr_infos.has_key? key)
-          construct_docstring(*@@docstr_infos[key], true)
+        if @docstr_infos.has_key? key
+          construct_docstring(*@docstr_infos[key], true, 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)
+      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)
-          construct_docstring(service_name, '.', procedure_name, *@@procedure_docstr_infos[key][3..-1], false)
+        if @procedure_docstr_infos.has_key? key
+          construct_docstring(service_name, '.', procedure_name, *@procedure_docstr_infos[key][3..-1], false, is_print_xmldoc_summary)
         else
           "No docstring for #{service_name}.#{procedure_name} procedure"
         end
       end
 
-      def add_docstring_info(is_static, cls, method_name, service_name="", procedure_name="", param_names=[], param_types=[], param_default=[], return_type: nil)
+      def add_docstring_info(is_static, cls, method_name, service_name="", procedure_name="", param_names=[], param_types=[], param_default=[], return_type: nil, xmldoc: "")
         service_module_name = service_name == cls.class_name ? Services.class_name : service_name
         key0 = [service_name, procedure_name].hash
         key1 = [service_module_name, false, cls.class_name, method_name].hash
-        val = [cls.krpc_name, calc_separator(is_static), method_name, param_names, param_types, param_default, return_type]
-        @@docstr_infos[key1] = @@procedure_docstr_infos[key0] = val
+        val = [cls.krpc_name, calc_separator(is_static), method_name, param_names, param_types, param_default, return_type, xmldoc]
+        @docstr_infos[key1] = @procedure_docstr_infos[key0] = val
         if is_static
           key2 = [service_module_name, true, cls.class_name, method_name].hash
-          @@docstr_infos[key2] = val
+          @docstr_infos[key2] = val
         end
       end
       
       def add_special_docstring_info(key, value)
-        @@docstr_infos[key] = value
+        @docstr_infos[key] = value
       end
       
       private #----------------------------------
@@ -56,36 +57,106 @@ module KRPC
       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_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? 
 
-      def construct_docstring(namespace, separator, name, param_names, param_types, param_default, return_type, is_hide_this_param)
-        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) 
-            "#{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)}]}
-          elsif type.is_a?(Types::TupleType)
-            %Q{#{rt.class_name}[#{type.value_types.map{|x| type2str(x)}.join(", ")}]}
-          else rt.class_name end
+        xmldoc_params = {}
+        xmldoc.xpath("doc/param").each do |e|
+          param_name = e.attr("name")
+          if param_name
+            unless e.text.strip.empty?
+              xmldoc_params[param_name.underscore] = " - ".blue + xmlElements2str(e.children, :blue, :green, :yellow)
+            else
+              xmldoc_params[param_name.underscore] = ""
+            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"
         if param_infos.empty?
           params = ""
         else
-          params = "\n" + param_infos.map do |pi|
-            "\t#{pi[0].light_green} :#{pi[1]}" + (pi[2].nil? ? "" : " = #{pi[2]}".magenta)
-          end.join(",\n") + "\n"
+          params = "\n" + param_infos.map.with_index do |pi, i|
+            "\t#{pi[0].light_green} :#{pi[1]}" + (pi[2].nil? ? "" : " = #{pi[2]}".magenta) \
+              + (param_infos.size == i+1 ? "" : ",") \
+              + xmldoc_params[pi[0]].to_s
+          end.join("\n") + "\n"
+        end
+        "#{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) 
+          "#{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)}]}
+        elsif type.is_a?(Types::TupleType)
+          %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)
+            elem.text.colorize(main_color)
+          else
+            begin
+              case elem.name
+                when "paramref" then elem.attr("name").underscore.colorize(paramref_color)
+                when "a", "math" then elem.text.colorize(main_color)
+                when "see"
+                  type, _, cref = elem.attr("cref").rpartition(':')
+                  cref = cref.split('.')
+                  if type == 'T'
+                    cref.join("::").colorize(value_color)
+                  elsif type == 'M'
+                    begin
+                      val = cref[2].underscore.to_sym
+                      raise RuntimeException unless ::KRPC::Gen.const_get(cref[0], false).const_get(cref[1], false)[val].is_a?(Integer)
+                      (':' + val.to_s).colorize(value_color)
+                    rescue
+                      raise RuntimeException unless is_method_defined(["Services"] + cref) || is_method_defined(["Gen"] + cref)
+                      (cref[0..-2].join("::") + "#").cyan + cref[-1].underscore
+                    end
+                  else raise RuntimeException end
+                when "list"
+                  "!n!" + elem.children.map{|ch| "!s! * ".bold + ch.text}.join("!n!").colorize(main_color)
+                when "c"
+                  elem.text.gsub("null","nil").colorize(value_color)
+                else elem.to_s.colorize(error_color)
+              end
+            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
+          cls = path_array[0..-2].inject(::KRPC){|a,e| a.const_get(e, false) }
+          cls.method_defined?(method_name)
+        rescue NameError
+          false
         end
-        "#{namespace.cyan}#{separator.cyan}#{name.bold}(#{params}) :#{type2str(return_type).light_red}"
       end
       
     end
     
+    
     module SuffixMethods
       DOCSTRING_SUFFIX = "_doc"
       DOCSTRING_SUFFIX_REGEX = /^(.+)(?:#{DOCSTRING_SUFFIX}(=)?)$/
@@ -119,4 +190,3 @@ module KRPC
     
   end
 end
-

data/lib/krpc/encoder.rb

@@ -9,36 +9,36 @@ module KRPC
     class << self
       
       # Given a type object, and ruby object, encode the ruby object
-      def encode(obj, type, type_store)
+      def encode(obj, type)
         if type.is_a?(Types::MessageType) then obj.serialize_to_string
         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, type_store.as_type("int32"))
+          encode_value(enum_value, TypeStore["int32"])
         elsif type.is_a?(Types::ClassType)
           remote_oid = if obj == nil then 0 else obj.remote_oid end
-          encode_value(remote_oid, type_store.as_type("uint64"))
+          encode_value(remote_oid, TypeStore["uint64"])
         elsif type.is_a?(Types::ListType)
-          msg = type_store.as_type("KRPC.List").ruby_type.new
-          msg.items = obj.map{|x| encode(x, type.value_type, type_store)}.to_a
+          msg = TypeStore["KRPC.List"].ruby_type.new
+          msg.items = obj.map{|x| encode(x, type.value_type)}.to_a
           msg.serialize_to_string
         elsif type.is_a?(Types::DictionaryType)
-          entry_type = type_store.as_type("KRPC.DictionaryEntry").ruby_type
-          msg = type_store.as_type("KRPC.Dictionary").ruby_type.new
+          entry_type = TypeStore["KRPC.DictionaryEntry"].ruby_type
+          msg = TypeStore["KRPC.Dictionary"].ruby_type.new
           msg.entries = obj.map do |k,v|
             entry = entry_type.new
-            entry.key = encode(k, type.key_type, type_store)
-            entry.value = encode(v, type.value_type, type_store)
+            entry.key = encode(k, type.key_type)
+            entry.value = encode(v, type.value_type)
             entry
           end
           msg.serialize_to_string
         elsif type.is_a?(Types::SetType)
-          msg = type_store.as_type("KRPC.Set").ruby_type.new
-          msg.items = obj.map{|x| encode(x, type.value_type, type_store)}.to_a
+          msg = TypeStore["KRPC.Set"].ruby_type.new
+          msg.items = obj.map{|x| encode(x, type.value_type)}.to_a
           msg.serialize_to_string
         elsif type.is_a?(Types::TupleType)
-          msg = type_store.as_type("KRPC.Tuple").ruby_type.new
-          msg.items = obj.zip(type.value_types).map{|x,t| encode(x, t, type_store)}.to_a
+          msg = TypeStore["KRPC.Tuple"].ruby_type.new
+          msg.items = obj.zip(type.value_types).map{|x,t| encode(x, t)}.to_a
           msg.serialize_to_string
         else raise(RuntimeError, "Cannot encode object #{obj} of type #{type}")
         end
@@ -50,11 +50,10 @@ module KRPC
       
       def encode_request(req)
         data = req.serialize_to_string
-        length =  ProtobufUtils::Encoder.encode_nonnegative_varint(data.length)
+        length = ProtobufUtils::Encoder.encode_nonnegative_varint(data.length)
         length + data
       end
       
     end
   end
 end
-

data/lib/krpc/error.rb

@@ -8,10 +8,12 @@ module KRPC
 
   class ArgumentErrorSig < ArgumentError
     attr_reader :message_without_signature, :signature
+
     def initialize(msg = nil, sig = nil)
       @message_without_signature, @signature = msg, sig
       super(signature.nil? ? msg : msg + "\n" + signature.to_s)
     end
+
     def with_signature(sig)
       self.class.new(message_without_signature, sig)
     end
@@ -19,15 +21,16 @@ module KRPC
 
   class ArgumentsNumberErrorSig < ArgumentErrorSig
     attr_reader :args_count, :valid_params_count_range
+
     def initialize(args_count, valid_params_count_range, sig = nil)
       @args_count, @valid_params_count_range = args_count, valid_params_count_range
       valid_params_str = (valid_params_count_range.min == valid_params_count_range.max ? valid_params_count_range.min : valid_params_count_range).to_s
       super("wrong number of arguments (#{args_count} for #{valid_params_str})", sig)
     end
+
     def with_signature(sig)
       self.class.new(args_count, valid_params_count_range, sig)
     end
   end
 
 end
-

data/lib/krpc/gen.rb

@@ -1,10 +1,12 @@
 require 'krpc/doc'
+require 'krpc/streaming'
 require 'krpc/core_extensions'
+require 'colorize'
 
 module KRPC
   module Gen
     AvailableToClassAndInstanceModuleName = "AvailableToClassAndInstance"
-  
+    
     class << self
       def service_gen_module(service_name) 
         const_get_or_create(service_name, Module.new)
@@ -14,8 +16,8 @@ module KRPC
         mod = service_gen_module(service_name)
         mod.const_get_or_create(class_name) do
           Class.new(ClassBase) do
-            attr_reader :service_name
             @service_name = service_name
+            class << self; attr_reader :service_name end
           end
         end
       end
@@ -27,56 +29,72 @@ module KRPC
         end
       end
       
-      def add_rpc_method(cls, method_name, service_name, proc, client, *options)
+      def add_rpc_method(cls, method_name, service_name, proc, *options)
         is_static = options.include? :static
         prepend_self_to_args = options.include? :prepend_self_to_args
         target_module = is_static ? cls.const_get_or_create(AvailableToClassAndInstanceModuleName, Module.new) : cls
-        param_names, param_types, required_params_count, param_default, return_type = parse_procedure(proc, client)
+        param_names, param_types, param_default, return_type = parse_procedure(proc)
         method_name = method_name.underscore
-                
+
+        transform_exceptions = Proc.new do |method_owner, &block|
+          begin
+            block.call
+          rescue ArgumentsNumberErrorSig => err
+            sig = Doc.docstring_for_method(method_owner, method_name, false)
+            if prepend_self_to_args then raise ArgumentsNumberErrorSig.new(err.args_count - 1, (err.valid_params_count_range.min-1)..(err.valid_params_count_range.max-1), sig)
+            else raise err.with_signature(sig) end
+          rescue ArgumentErrorSig => err
+            raise err.with_signature(Doc.docstring_for_method(method_owner, method_name, false))
+          end
+        end
+
+        # Define method
         target_module.instance_eval do
-          define_method method_name do |*args, **kwargs|
-            begin
+          define_method method_name do |*args|
+            transform_exceptions.call(self) do
+              kwargs = args.extract_kwargs!
               args = [self] + args if prepend_self_to_args
-              client.rpc(service_name, proc.name, args, kwargs, param_names, param_types, required_params_count, param_default, return_type: return_type)
-            rescue ArgumentsNumberErrorSig => err
-              sig = Doc.docstring_for_method(self, method_name)
-              if prepend_self_to_args then raise ArgumentsNumberErrorSig.new(err.args_count - 1, (err.valid_params_count_range.min-1)..(err.valid_params_count_range.max-1), sig)
-              else raise err.with_signature(sig) end
-            rescue ArgumentErrorSig => err
-              raise err.with_signature(Doc.docstring_for_method(self, method_name))
+              self.client.rpc(service_name, proc.name, args, kwargs, param_names, param_types, param_default, return_type: return_type)
             end
           end
         end
-        Doc.add_docstring_info(is_static, cls, method_name, service_name, proc, param_names, param_types, param_default, return_type: return_type)
+        # Add stream-constructing Proc
+        unless options.include? :no_stream
+          cls.stream_constructors[method_name] = Proc.new do |this, *args, **kwargs|
+            transform_exceptions.call(this) 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)
+            end
+          end
+        end
+        # Add docstring info
+        Doc.add_docstring_info(is_static, cls, method_name, service_name, proc.name, param_names, param_types, param_default, return_type: return_type, xmldoc: proc.documentation)
       end
       
       private #----------------------------------
       
-      def parse_procedure(proc, client)
+      def parse_procedure(proc)
         param_names = proc.parameters.map{|p| p.name.underscore}
         param_types = proc.parameters.map.with_index do |p,i|
-          client.type_store.get_parameter_type(i, p.type, proc.attributes)
+          TypeStore.get_parameter_type(i, p.type, proc.attributes)
         end
-        param_required = proc.parameters.map{|p| not p.has_field?("default_argument")}
-        required_params_count = param_required.take_while{|x| x}.size      
         param_default = proc.parameters.zip(param_types).map do |param, type|
           if param.has_field?("default_argument")
-            Decoder.decode(param.default_argument, type, client.type_store)
+            Decoder.decode(param.default_argument, type, :clientless)
           else nil
           end
         end
         return_type = if proc.has_field?("return_type")
-          client.type_store.get_return_type(proc.return_type, proc.attributes)
-        else nil
-        end
-        [param_names, param_types, required_params_count, param_default, return_type]
+                        TypeStore.get_return_type(proc.return_type, proc.attributes)
+                      else nil end
+        [param_names, param_types, param_default, return_type]
       end
     end
     
     module RPCMethodGenerator
-      def include_rpc_method(method_name, service_name, procedure_name, return_type: nil)
-        Gen.add_rpc_method(self.class, method_name, service_name, PB::Procedure.new(name: procedure_name, return_type: return_type), client)
+      def include_rpc_method(method_name, service_name, procedure_name, params: [], return_type: nil, xmldoc: "", options: [])
+        Gen.add_rpc_method(self.class, method_name, service_name, PB::Procedure.new(name: procedure_name, parameters: params, return_type: return_type, documentation: xmldoc), options)
       end
     end
     
@@ -94,11 +112,16 @@ module KRPC
     class ClassBase
       extend AvailableToClassAndInstanceMethodsHandler
       include Doc::SuffixMethods
+      include Streaming::StreamConstructors
       
-      attr_reader :remote_oid
+      attr_reader :client, :remote_oid
       
-      def initialize(remote_oid)
-        @remote_oid = 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?, :==
@@ -109,11 +132,14 @@ module KRPC
         remote_oid.hash
       end
       
-      def self.krpc_name
-        name[11..-1]
+      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
-

data/lib/krpc/protobuf_utils.rb

@@ -4,11 +4,11 @@ module KRPC
   module ProtobufUtils
     class << self
       def create_PB_to_PB_message_class_hash(package)
-       protobuf_module = Kernel.const_get(package.gsub(".","::") + "::PB")
-       msg_classes_names = protobuf_module.constants.select{|c| protobuf_module.const_get(c,false).superclass == ::Protobuf::Message}
-       msg_classes_names.map do |name|
-         [package + "." + name.to_s, protobuf_module.const_get(name,false)]
-       end.to_h
+        protobuf_module = Kernel.const_get(package.gsub(".","::") + "::PB")
+        msg_classes_names = protobuf_module.constants.select{|c| protobuf_module.const_get(c,false).superclass == ::Protobuf::Message}
+        msg_classes_names.map do |name|
+          [package + "." + name.to_s, protobuf_module.const_get(name,false)]
+        end.to_h
       end    
     end
 
@@ -29,7 +29,7 @@ module KRPC
           result = 0
           shift = 0
           loop do
-            byte = bytes[pos].ord  # <-- replace ".ord" with ".bytes[0]" if ".ord" start to cause problems again
+            byte = bytes[pos].ord
             pos += 1
             result |= (byte & 0b0111_1111) << shift
             return [result, pos] if (byte & 0b1000_0000) == 0
@@ -129,5 +129,3 @@ module KRPC
     
   end
 end
-
-