krpc 0.2.0 → 0.2.1

data/krpc.gemspec

@@ -2,10 +2,11 @@
 
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'krpc/version'
 
 Gem::Specification.new do |s|
   s.name          = "krpc"
-  s.version       = "0.2.0"
+  s.version       = KRPC::VERSION
   s.authors       = ["Tomasz Więch"]
   s.email         = ["tewu.dev@gmail.com"]
   
@@ -27,7 +28,8 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "ruby_protobuf", "~> 0.4"
   s.add_runtime_dependency "colorize", "~> 0.7"
   s.add_runtime_dependency "nokogiri", "~> 1.6"
-  s.add_development_dependency "bundler", "~> 1.10"
+  s.add_development_dependency 'bundler', '~> 1.7', '>= 1.7.0'
   s.add_development_dependency "pry", "~> 0.10"
+  s.add_development_dependency "rspec", "~> 3.0"
   s.add_development_dependency "hanna-nouveau", "~> 0.4"
 end

data/lib/krpc.rb

@@ -1,3 +1,4 @@
+require 'krpc/version'
 require 'krpc/client'
 
 module KRPC

data/lib/krpc/client.rb

@@ -14,7 +14,7 @@ module KRPC
   # A kRPC client, through which all Remote Procedure Calls are made. To make RPC calls client 
   # must first connect to server. This can be achieved by calling Client#connect or Client#connect!
   # methods. Client object can connect and disconnect from the server many times during it's 
-  # lifetime. RPCs can be made by calling Client#rpc method. After generating services API (with
+  # lifetime. RPCs can be made by calling Client#execute_rpc method. After generating services API (with
   # Client#generate_services_api! call), RPCs can be also made using
   # `client.service_name.procedure_name(parameter, ...)`
   #
@@ -126,72 +126,86 @@ module KRPC
     
     # Returns `true` if services API has been already generated, `false` otherwise.
     def services_api_generated?
-      respond_to? :space_center
+      respond_to? :space_center or respond_to? :test_service
     end
     
     # Execute an RPC.
-    def rpc(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], param_default=[], return_type: nil)
-      # Send request
-      req = build_request(service, procedure, args, kwargs, param_names, param_types, param_default)
-      rpc_connection.send Encoder.encode_request(req)
-      # Receive response
-      resp_length = rpc_connection.recv_varint
-      resp_data = rpc_connection.recv resp_length
-      resp = PB::Response.new
-      resp.parse_from_string resp_data
-      # Check for an error response
+    def execute_rpc(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], param_default=[], return_type: nil)
+      send_request(service, procedure, args, kwargs, param_names, param_types, param_default)
+      resp = receive_response
       raise(RPCError, resp.error) if resp.has_field? "error"
-      # Optionally decode and return the response' return value
-      if return_type == nil
-        nil
-      else
+      unless return_type.nil?
         Decoder.decode(resp.return_value, return_type, self)
+      else
+        nil
       end
     rescue IOError => e
       raise(Exception, "RPC call attempt while not connected to server -- call Client#connect first") if not connected?
       raise e
     end
-    
+
     # Build a PB::Request object.
     def build_request(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], param_default=[])
       begin
         raise(ArgumentError, "param_names and param_types should be equal length\n\tparam_names = #{param_names}\n\tparam_types = #{param_types}") unless param_names.length == param_types.length
         raise(ArgumentError, "param_names and param_default should be equal length\n\tparam_names = #{param_names}\n\tparam_default = #{param_default}") unless param_names.length == param_default.length
-        required_params_count = param_default.take_while(&:nil?).count
+        required_params_count = param_default.take_while{|pd| pd == :no_default_value}.count
         raise ArgumentsNumberErrorSig.new(args.count, required_params_count..param_names.count) unless args.count <= param_names.count
-        kwargs_remaining = kwargs.count
-        
-        param_names_symbols = param_names.map(&:to_sym)
-        req_args = param_names_symbols.map.with_index do |name,i|
-          is_kwarg = kwargs.has_key? name
-          raise ArgumentErrorSig.new("there are both positional and keyword arguments for parameter \"#{name}\"") if is_kwarg && i < args.count 
-          kwargs_remaining -= 1 if is_kwarg
-          unless i >= required_params_count && 
-                 (!is_kwarg && i >= args.count ||
-                  !is_kwarg && args[i] == param_default[i] ||
-                  is_kwarg  && kwargs[name] == param_default[i])
-            arg = if is_kwarg then kwargs[name]
-                  elsif i < args.count then args[i]
-                  else raise ArgumentErrorSig.new("missing argument for parameter \"#{name}\"") 
-                  end
-            begin
-              arg = TypeStore.coerce_to(arg, param_types[i])
-            rescue ValueError
-              raise ArgumentErrorSig.new("argument for parameter \"#{name}\" must be a #{param_types[i].ruby_type} -- got #{args[i]} of type #{args[i].class}")
-            end
-            v = Encoder.encode(arg, param_types[i])
-            PB::Argument.new(position: i, value: v)
-          end
-        end.compact
-        raise ArgumentErrorSig.new("keyword arguments for non existing parameters: #{(kwargs.keys - param_names_symbols).join(", ")}") unless kwargs_remaining == 0
+        req_args = construct_arguments(args, kwargs, param_names, param_types, param_default, required_params_count)
       rescue ArgumentErrorSig => err
         raise err.with_signature(Doc.docstring_for_procedure(service, procedure, false))
       end
       PB::Request.new(service: service, procedure: procedure, arguments: req_args)
     end
-    
+
     protected #----------------------------------
     
+    def construct_arguments(args, kwargs, param_names, param_types, param_default, required_params_count)
+      param_names_symbols = param_names.map(&:to_sym)
+      kwargs_remaining = kwargs.count
+      
+      req_args = param_names_symbols.map.with_index do |name, i|
+        is_kwarg = kwargs.has_key? name
+        kwargs_remaining -= 1 if is_kwarg
+        raise ArgumentErrorSig.new("there are both positional and keyword arguments for parameter \"#{name}\"") if is_kwarg && i < args.count
+        is_parameter_optional = i >= required_params_count
+        is_parameter_has_default_value = !is_kwarg && i >= args.count ||
+                                         !is_kwarg && args[i] == param_default[i] ||
+                                         is_kwarg && kwargs[name] == param_default[i]
+        unless is_parameter_optional and is_parameter_has_default_value
+          arg = if is_kwarg then
+                  kwargs[name]
+                elsif i < args.count then
+                  args[i]
+                else
+                  raise ArgumentErrorSig.new("missing argument for parameter \"#{name}\"")
+                end
+          begin
+            arg = TypeStore.coerce_to(arg, param_types[i])
+          rescue ValueError
+            raise ArgumentErrorSig.new("argument for parameter \"#{name}\" must be a #{param_types[i].ruby_type} -- got #{args[i].inspect} of type #{args[i].class}")
+          end
+          v = Encoder.encode(arg, param_types[i])
+          PB::Argument.new(position: i, value: v)
+        end
+      end.compact
+      
+      raise ArgumentErrorSig.new("keyword arguments for non existing parameters: #{(kwargs.keys - param_names_symbols).join(", ")}") unless kwargs_remaining == 0
+      req_args
+    end
+
+    def send_request(service, procedure, args, kwargs, param_names, param_types, param_default)
+      req = build_request(service, procedure, args, kwargs, param_names, param_types, param_default)
+      rpc_connection.send Encoder.encode_request(req)
+    end
+    
+    def receive_response
+      resp_length = rpc_connection.recv_varint
+      resp_data = rpc_connection.recv resp_length
+      resp = PB::Response.new
+      resp.parse_from_string resp_data
+    end
+    
     def call_block_and_close(block)
       begin block.call(self) ensure close end
     end

data/lib/krpc/core_extensions.rb

@@ -24,8 +24,17 @@ class String
     tr("-", "_").
     downcase
   end
+
+  def integer?
+    Integer(self) != nil rescue false 
+  end
+  
+  def numeric?
+    Float(self) != nil rescue false
+  end
 end
 
+
 class Array
   def extract_kwargs!
     last.is_a?(::Hash) ? pop : {}

data/lib/krpc/doc.rb

@@ -13,7 +13,7 @@ module KRPC
         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, is_print_xmldoc_summary)
+          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")
@@ -23,7 +23,7 @@ module KRPC
       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, is_print_xmldoc_summary)
+          construct_docstring(service_name, '.', procedure_name, *@procedure_docstr_infos[key][3..-1], false, false, is_print_xmldoc_summary)
         else
           "No docstring for #{service_name}.#{procedure_name} procedure"
         end
@@ -58,7 +58,7 @@ module KRPC
         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)
+      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)
 
@@ -79,11 +79,12 @@ module KRPC
         
         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 
         if param_infos.empty?
           params = ""
         else
           params = "\n" + param_infos.map.with_index do |pi, i|
-            "\t#{pi[0].light_green} :#{pi[1]}" + (pi[2].nil? ? "" : " = #{pi[2]}".magenta) \
+            "\t#{pi[0].light_green} :#{pi[1]}" + (pi[2] == :no_default_value ? "" : " = #{pi[2].inspect}".magenta) \
               + (param_infos.size == i+1 ? "" : ",") \
               + xmldoc_params[pi[0]].to_s
           end.join("\n") + "\n"

data/lib/krpc/encoder.rb

@@ -20,25 +20,25 @@ module KRPC
           encode_value(remote_oid, TypeStore["uint64"])
         elsif type.is_a?(Types::ListType)
           msg = TypeStore["KRPC.List"].ruby_type.new
-          msg.items = obj.map{|x| encode(x, type.value_type)}.to_a
+          msg.items = obj.map{|x| encode( TypeStore.coerce_to(x, type.value_type), type.value_type )}.to_a
           msg.serialize_to_string
         elsif type.is_a?(Types::DictionaryType)
           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)
-            entry.value = encode(v, type.value_type)
+            entry.key = encode( TypeStore.coerce_to(k, type.key_type), type.key_type )
+            entry.value = encode( TypeStore.coerce_to(v, type.value_type), type.value_type )
             entry
           end
           msg.serialize_to_string
         elsif type.is_a?(Types::SetType)
           msg = TypeStore["KRPC.Set"].ruby_type.new
-          msg.items = obj.map{|x| encode(x, type.value_type)}.to_a
+          msg.items = obj.map{|x| encode( TypeStore.coerce_to(x, type.value_type), type.value_type )}.to_a
           msg.serialize_to_string
         elsif type.is_a?(Types::TupleType)
           msg = TypeStore["KRPC.Tuple"].ruby_type.new
-          msg.items = obj.zip(type.value_types).map{|x,t| encode(x, t)}.to_a
+          msg.items = obj.zip(type.value_types).map{|x,t| encode( TypeStore.coerce_to(x, t), t )}.to_a
           msg.serialize_to_string
         else raise(RuntimeError, "Cannot encode object #{obj} of type #{type}")
         end

data/lib/krpc/error.rb

@@ -28,6 +28,10 @@ module KRPC
       super("wrong number of arguments (#{args_count} for #{valid_params_str})", sig)
     end
 
+    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

@@ -5,8 +5,6 @@ require 'colorize'
 
 module KRPC
   module Gen
-    AvailableToClassAndInstanceModuleName = "AvailableToClassAndInstance"
-    
     class << self
       def service_gen_module(service_name) 
         const_get_or_create(service_name, Module.new)
@@ -28,52 +26,71 @@ module KRPC
           values.map{|ev| [ev.name.underscore.to_sym, ev.value]}.to_h
         end
       end
-      
+
       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, param_default, return_type = parse_procedure(proc)
         method_name = method_name.underscore
+        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 options.include? :no_stream
+        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
 
-        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))
+      def transform_exceptions(method_owner, method_name, prepend_self_to_args, &block)
+        begin
+          block.call
+        rescue ArgumentsNumberErrorSig => err
+          err = err.with_signature(Doc.docstring_for_method(method_owner, method_name, false))
+          if prepend_self_to_args then raise err.with_arguments_count_incremented_by(-1)
+          elsif method_owner.is_a?(Class) then raise err.with_arguments_count_incremented_by(1)
+          else raise err end
+        rescue ArgumentErrorSig => err
+          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)
+              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)
+            end
           end
         end
+      end
 
-        # Define method
-        target_module.instance_eval do
+      def define_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_method method_name do |*args|
-            transform_exceptions.call(self) do
+            Gen.transform_exceptions(self, method_name, prepend_self_to_args) do
               kwargs = args.extract_kwargs!
               args = [self] + args if prepend_self_to_args
-              self.client.rpc(service_name, proc.name, args, kwargs, param_names, param_types, param_default, return_type: return_type)
+              self.client.execute_rpc(service_name, proc.name, args, kwargs, param_names, param_types, param_default, return_type: return_type)
             end
           end
         end
-        # 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
+
+      def add_stream_constructing_proc(cls, method_name, param_default, param_names, param_types, prepend_self_to_args, proc, return_type, service_name)
+        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)
           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)
         param_names = proc.parameters.map{|p| p.name.underscore}
         param_types = proc.parameters.map.with_index do |p,i|
@@ -82,7 +99,7 @@ module KRPC
         param_default = proc.parameters.zip(param_types).map do |param, type|
           if param.has_field?("default_argument")
             Decoder.decode(param.default_argument, type, :clientless)
-          else nil
+          else :no_default_value
           end
         end
         return_type = if proc.has_field?("return_type")
@@ -98,19 +115,9 @@ module KRPC
       end
     end
     
-    module AvailableToClassAndInstanceMethodsHandler
-      def add_methods_available_to_class_and_instance
-        if const_defined? AvailableToClassAndInstanceModuleName
-          extend  const_get(AvailableToClassAndInstanceModuleName)
-          include const_get(AvailableToClassAndInstanceModuleName)
-        end
-      end
-    end
-    
     ##
     # Base class for service-defined class types.
     class ClassBase
-      extend AvailableToClassAndInstanceMethodsHandler
       include Doc::SuffixMethods
       include Streaming::StreamConstructors
       

data/lib/krpc/service.rb

@@ -55,12 +55,6 @@ module KRPC
           end
         end
         
-        # Add methods available to class and instance in service class & service' classes
-        service_class.add_methods_available_to_class_and_instance
-        mod = Gen.service_gen_module(service_name)
-        service_classes = mod.constants.map{|c| mod.const_get(c)}.select {|c| c.is_a? Class}
-        service_classes.each(&:add_methods_available_to_class_and_instance)
-        
         # Return service class
         service_class
       end
@@ -70,7 +64,6 @@ module KRPC
     ##
     # Base class for service objects, created at runtime using information received from the server.
     class ServiceBase
-      extend Gen::AvailableToClassAndInstanceMethodsHandler
       include Doc::SuffixMethods
       include Streaming::StreamConstructors
       

data/lib/krpc/types.rb

@@ -8,7 +8,7 @@ require 'set'
 module KRPC
   module Types
     PROTOBUF_VALUE_TYPES = ["double", "float", "int32", "int64", "uint32", "uint64", "bool", "string", "bytes"]
-    RUBY_VALUE_TYPES = [Float, Integer, Boolean, String]
+    RUBY_VALUE_TYPES = [Float, Integer, Boolean, String, Array]
     PROTOBUF_TO_RUBY_VALUE_TYPE = {
       "double" => Float,
       "float"  => Float,
@@ -18,7 +18,7 @@ module KRPC
       "uint64" => Integer,
       "bool"   => Boolean,
       "string" => String,
-      "bytes"  => String
+      "bytes"  => Array
     }
     PROTOBUF_TO_MESSAGE_TYPE = ProtobufUtils.create_PB_to_PB_message_class_hash("KRPC")
     
@@ -37,6 +37,7 @@ module KRPC
             elsif type_string.start_with? "Dictionary(" || type_string == "Dictionary" then DictionaryType.new(type_string)
             elsif type_string.start_with? "Set("   || type_string == "Set"   then SetType.new(type_string)
             elsif type_string.start_with? "Tuple(" || type_string == "Tuple" then TupleType.new(type_string)
+            elsif type_string == "Test.TestEnum" then ValueType.new("int32")
             else # A message type (eg. type_string = "KRPC.List" or "KRPC.Services")
               raise(ValueError, "\"#{type_string}\" is not a valid type string") unless /^[A-Za-z0-9_\.]+$/ =~ type_string
               if PROTOBUF_TO_MESSAGE_TYPE.has_key? type_string
@@ -97,11 +98,15 @@ module KRPC
             raise(ValueError, "Failed to coerce value #{value.to_s} of type #{value.class} to type #{type}")
           end
           # Numeric types
-          if type.ruby_type == Float && value.respond_to?(:to_f)
+          if type.ruby_type == Float && ( value.kind_of?(Float) || value.to_s.numeric? )
             return value.to_f
-          elsif type.ruby_type == Integer && value.respond_to?(:to_i)
+          elsif type.ruby_type == Integer && ( value.kind_of?(Integer) || value.to_s.integer? )
             return value.to_i
           end
+          # Convert value type to string
+          if type.is_a?(ValueType) && type.ruby_type == String
+            return value.to_s
+          end
           raise(ValueError, "Failed to coerce value #{value.to_s} of type #{value.class} to type #{type}")
         end