krpc 0.3.1 → 0.3.2

data/lib/krpc/core_extensions.rb

@@ -3,7 +3,7 @@ class Module
   def class_name
     name.rpartition("::").last
   end
-  
+
   def const_get_or_create(module_name, value = nil, &block)
     return const_get(module_name) if const_defined?(module_name, false)
     value = block.call if block_given?
@@ -26,9 +26,9 @@ class String
   end
 
   def integer?
-    Integer(self) != nil rescue false 
+    Integer(self) != nil rescue false
   end
-  
+
   def numeric?
     Float(self) != nil rescue false
   end

data/lib/krpc/decoder.rb

@@ -6,14 +6,14 @@ module KRPC
     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)
         elsif type.is_a?(Types::ValueType) then decode_value(data, type)
-        elsif type.is_a?(Types::EnumType) 
+        elsif type.is_a?(Types::EnumType)
           v = decode_value(data, TypeStore["int32"])
           type.ruby_type.key(v)
         elsif type.is_a?(Types::ClassType)
@@ -41,11 +41,11 @@ module KRPC
       def decode_value(data, type)
         ProtobufUtils::Decoder.decode(data, type.protobuf_type)
       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 => exc
+            rescue RuntimeException
               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,23 +154,18 @@ module KRPC
           false
         end
       end
-      
+
     end
-    
-    
+
+
     module SuffixMethods
       DOCSTRING_SUFFIX = "_doc"
       DOCSTRING_SUFFIX_REGEX = /^(.+)(?:#{DOCSTRING_SUFFIX}(=)?)$/
-      
+
       def self.included(base)
-        base.extend self
-        class << base
-          def krpc_name
-            class_name
-          end
-        end
+        base.extend self, ClassMethods
       end
-      
+
       def method_missing(method, *args, &block)
         if DOCSTRING_SUFFIX_REGEX =~ method.to_s
           documented_method_name = $1 + $2.to_s
@@ -180,14 +175,20 @@ 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

@@ -6,9 +6,9 @@ module KRPC
     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)
@@ -51,17 +51,21 @@ module KRPC
         else raise(RuntimeError, "Cannot encode object #{obj} of type #{type}")
         end
       end
-            
+
       def encode_value(value, type)
         ProtobufUtils::Encoder.encode(value, type.protobuf_type)
       end
-      
+
       def encode_request(req)
         data = PB::Request.encode(req)
         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) }
+      end
+
     end
   end
 end

data/lib/krpc/error.rb

@@ -31,7 +31,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,17 +27,17 @@ module KRPC
         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
+      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
         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)
+        add_stream_constructing_proc(*args) unless switches.include? :no_stream
+        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
 
       def transform_exceptions(method_owner, method_name, prepend_self_to_args, &block)
@@ -52,15 +52,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)
@@ -90,7 +90,7 @@ module KRPC
           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|
@@ -108,29 +108,29 @@ module KRPC
         [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, xmldoc: "", 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 : "", documentation: xmldoc), options)
+      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)
       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 +138,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

data/lib/krpc/protobuf_utils.rb

@@ -8,7 +8,7 @@ module KRPC
         protobuf_module.constants.map do |name|
           [package + "." + name.to_s, protobuf_module.const_get(name,false)]
         end.to_h
-      end    
+      end
     end
 
     module Decoder
@@ -19,7 +19,7 @@ module KRPC
           send(meth_name, bytes)
         end
 
-        # based on: https://developers.google.com/protocol-buffers/docs/encoding#varints  &  http://www.rubydoc.info/gems/ruby-protocol-buffers/1.0.1/ProtocolBuffers/Varint#decode-class_method  &  https://github.com/google/protobuf/blob/master/python/google/protobuf/internal/decoder.py#L136  
+        # based on: https://developers.google.com/protocol-buffers/docs/encoding#varints  &  http://www.rubydoc.info/gems/ruby-protocol-buffers/1.0.1/ProtocolBuffers/Varint#decode-class_method  &  https://github.com/google/protobuf/blob/master/python/google/protobuf/internal/decoder.py#L136
         def decode_varint(bytes)
           decode_varint_pos(bytes)[0]
         end
@@ -37,16 +37,16 @@ module KRPC
           end
         end
         def decode_signed_varint(bytes)
-          result = decode_varint(bytes) 
+          result = decode_varint(bytes)
           result -= (1 << 64) if result > 0x7fffffffffffffff
           result
         end
-        
+
         alias_method :decode_int32, :decode_signed_varint
         alias_method :decode_int64, :decode_signed_varint
         alias_method :decode_uint32, :decode_varint
         alias_method :decode_uint64, :decode_varint
-        
+
         # based on: https://github.com/ruby-protobuf/protobuf/search?q=pack
         def decode_float(bytes)
           bytes.unpack('e').first
@@ -65,10 +65,10 @@ module KRPC
           size, pos = decode_varint_pos(bytes)
           bytes[pos..(pos+size)].bytes
         end
-        
+
       end
     end
-    
+
     module Encoder
       class << self
         def encode(value, type)
@@ -76,7 +76,7 @@ module KRPC
           raise(RuntimeError, "Unsupported type #{type}") unless respond_to?(meth_name)
           send(meth_name, value)
         end
-        
+
         # based on: http://www.rubydoc.info/gems/ruby-protocol-buffers/1.0.1/ProtocolBuffers/Varint#decode-class_method  &  https://github.com/google/protobuf/blob/master/python/google/protobuf/internal/encoder.py#L390
         def encode_varint(value)
           return [value].pack('C') if value < 0b1000_0000
@@ -99,12 +99,12 @@ module KRPC
           raise(RangeError, "Value must be non-negative, got #{value}") if value < 0
           encode_varint(value)
         end
-      
+
         alias_method :encode_int32, :encode_signed_varint
         alias_method :encode_int64, :encode_signed_varint
         alias_method :encode_uint32, :encode_nonnegative_varint
         alias_method :encode_uint64, :encode_nonnegative_varint
-      
+
         def encode_float(value)
           [value].pack('e')
         end
@@ -122,9 +122,9 @@ module KRPC
           size = encode_varint(value.size)
           size + value.map(&:chr).join.b
         end
-        
+
       end
     end
-    
+
   end
 end