krpc 0.3.2 → 0.4.0.beta1

data/lib/krpc/streaming.rb

@@ -6,19 +6,20 @@ module KRPC
 
     class StreamsManager
       attr_reader :client
-
+      
       def initialize(client)
         @client = client
         @streams = {}
         @streams_mutex = Mutex.new
         @streaming_thread = Thread.new {}
       end
-
-      # Send a streaming request, create related Stream object and return it. If identical Stream
+    
+      # Send the streaming request, create related Stream object and return it. If identical Stream
       # already exists, doesn't create new Stream and return the existing one.
-      def create_stream(request, return_type, method, *args, **kwargs)
+      def create_stream(call, return_type, method, *args, **kwargs)
         raise RuntimeError("Cannot stream a property setter") if method.name.to_s.end_with? '='
-        id = client.core.add_stream(request)
+        stream_msg = client.core.add_stream(call)
+        id = stream_msg.id
         @streams_mutex.synchronize do
           if @streams.include? id
             @streams[id]
@@ -28,9 +29,9 @@ module KRPC
           end
         end
       end
-
-      # Remove a streaming request and deactivate the Stream object. Returns `true` if
-      # streaming request is removed or `false` if passed Stream object is already inactive.
+      
+      # Remove the streaming request and deactivate the Stream object. Returns `true` if the
+      # streaming request has been removed or `false` if passed Stream object is already inactive.
       def remove_stream(stream)
         return false unless stream.active?
         @streams_mutex.synchronize do
@@ -47,42 +48,41 @@ module KRPC
       def remove_all_streams
         @streams.each {|_,stream| remove_stream(stream)}
       end
-
+      
       # Start streaming thread. It receives stream data, and updates Stream object's `value` attribute.
       def start_streaming_thread
         stop_streaming_thread
         @streaming_thread = Thread.new do
           connection = client.stream_connection
-          stream_message_type = TypeStore["KRPC.StreamMessage"]
           loop do
             size = connection.recv_varint
             data = connection.recv(size)
-            stream_msg = Decoder.decode(data, stream_message_type, client)
+            stream_msg = PB::StreamUpdate.decode(data)
             @streams_mutex.synchronize do
-              stream_msg.responses.each do |stream_resp|
-                next unless @streams.include? stream_resp.id
-                stream = @streams[stream_resp.id]
-                if stream_resp.response.has_error
-                  stream.value = RPCError.new(stream_resp.response.error)
+              stream_msg.results.each do |result|
+                next unless @streams.include? result.id
+                stream = @streams[result.id]
+                if result.result.field_empty? :error
+                  stream.value = Decoder.decode(result.result.value, stream.return_type, client)
                 else
-                  stream.value = Decoder.decode(stream_resp.response.return_value, stream.return_type, client)
+                  stream.value = RPCError.new(result.result.error)
                 end
               end
             end
           end
         end
       end
-
+      
       # Stop streaming thread.
       def stop_streaming_thread
         @streaming_thread.terminate
       end
     end
-
+    
     class Stream
       attr_reader :id, :method, :args, :kwargs, :return_type, :manager
       attr_writer :value
-
+      
       def initialize(manager, id, return_type, value, method, *args, **kwargs)
         @manager = manager
         @id = id
@@ -90,7 +90,7 @@ module KRPC
         @method, @args, @kwargs = method, args, kwargs
         @active = true
       end
-
+      
       # Get the current stream value. Has alias method `value`.
       def get
         raise @value if @value.is_a?(Exception)
@@ -103,18 +103,18 @@ module KRPC
         manager.remove_stream self
       end
       alias_method :close, :remove
-
+      
       # Check if stream is active (i.e. not removed).
       def active?; @active end
 
       # Mark stream as inactive.
       # WARNING: This method does not remove the stream. To remove the stream call Stream#remove instead.
       def mark_as_inactive; @active = false end
-
+      
       def to_s
         inspect.gsub(/\n|\t/," ").squeeze(" ").uncolorize
       end
-
+      
       def inspect
         def coderay(x)
           require 'coderay'
@@ -134,11 +134,11 @@ module KRPC
             ">".green
       end
     end
-
+  
     module StreamConstructors
       STREAM_METHOD_SUFFIX = "_stream"
       STREAM_METHOD_REGEX = /^(.+)(?:#{STREAM_METHOD_SUFFIX})$/
-
+      
       module ClassMethods
         def stream_constructors
           @stream_constructors ||= {}
@@ -149,7 +149,7 @@ module KRPC
         base.extend ClassMethods
         base.extend self
       end
-
+      
       def method_missing(method, *args, **kwargs, &block)
         if STREAM_METHOD_REGEX =~ method.to_s
           if respond_to? $1.to_sym
@@ -159,7 +159,7 @@ module KRPC
         end
         super
       end
-
+      
       def respond_to_missing?(method, *)
         if STREAM_METHOD_REGEX =~ method.to_s
           if respond_to? $1.to_sym
@@ -169,8 +169,8 @@ module KRPC
         end
         super
       end
-
+      
     end
-
+    
   end
 end

data/lib/krpc/types.rb

@@ -1,5 +1,4 @@
 require 'krpc/gen'
-require 'krpc/attributes'
 require 'krpc/protobuf_utils'
 require 'krpc/error'
 require 'krpc/core_extensions'
@@ -7,78 +6,40 @@ 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, Array]
-    PROTOBUF_TO_RUBY_VALUE_TYPE = {
-      "double" => Float,
-      "float"  => Float,
-      "int32"  => Integer,
-      "int64"  => Integer,
-      "uint32" => Integer,
-      "uint64" => Integer,
-      "bool"   => Boolean,
-      "string" => String,
-      "bytes"  => Array
+    PROTOBUF_TO_RUBY_VALUE_TYPES = {
+      DOUBLE: Float,
+      FLOAT: Float,
+      SINT32: Integer,
+      SINT64: Integer,
+      UINT32: Integer,
+      UINT64: Integer,
+      BOOL: Boolean,
+      STRING: String,
+      BYTES: Array
     }
-    PROTOBUF_TO_MESSAGE_TYPE = ProtobufUtils.create_PB_to_PB_message_class_hash("KRPC")
-
+    PROTOBUF_TO_RUBY_MESSAGE_TYPES = {
+      PROCEDURE_CALL: PB::ProcedureCall,
+      STREAM: PB::Stream,
+      STATUS: PB::Status,
+      SERVICES: PB::Services
+    }
+    
+    
     class TypeStore
       @cache = {}
       class << self
-
-        def [](type_string)
-          return @cache[type_string] if @cache.include? type_string
-
-          type =
-            if PROTOBUF_VALUE_TYPES.include? type_string then ValueType.new(type_string)
-            elsif type_string.start_with? "Class(" || type_string == "Class" then ClassType.new(type_string)
-            elsif type_string.start_with? "Enum("  || type_string == "Enum"  then EnumType.new(type_string)
-            elsif type_string.start_with? "List("  || type_string == "List"  then ListType.new(type_string)
-            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)
-            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
-                MessageType.new(type_string)
-              else
-                raise(ValueError, "\"#{type_string}\" is not a valid type string")
-              end
-            end
-
-          @cache[type_string] = type
-          type
-        end
-
-        def get_parameter_type(pos, type, attrs)
-          type_attrs = Attributes.get_parameter_type_attrs(pos, attrs)
-          type_attrs.each do |ta|
-            begin
-              return self[ta]
-            rescue ValueError
-            end
-          end
-          self[type]
-        end
-
-        def get_return_type(type, attrs)
-          type_attrs = Attributes.get_return_type_attrs(attrs)
-          type_attrs.each do |ta|
-            begin
-              return self[ta]
-            rescue ValueError
-            end
-          end
-          self[type]
+      
+        def [](protobuf_type)
+          @cache[protobuf_type.to_proto.hash] ||= PROTOBUF_TYPE_CODE_TO_TYPE_TYPE[protobuf_type.code].new(protobuf_type)
         end
-
+        
         def coerce_to(value, type)
           return value if type.is_a?(EnumType) && value.class == Symbol # Enum handling
           return value if value.is_a?(type.ruby_type)
           # A NilClass can be coerced to a ClassType
           return nil if type.is_a?(ClassType) && value.nil?
           # Handle service' class instance
-          if type.is_a?(ClassType) && value.is_a?(Gen::ClassBase) &&
+          if type.is_a?(ClassType) && value.is_a?(Gen::ClassBase) && 
              type.ruby_type == value.class
             return value
           end
@@ -103,138 +64,96 @@ module KRPC
             return value.to_i
           end
           # Convert value type to string
-          if type.is_a?(ValueType) && type.ruby_type == String
+          if 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
-
+      
       end
     end
-
-
+    
+    
     class TypeBase
       attr_reader :protobuf_type, :ruby_type
       def initialize(protobuf_type, ruby_type)
         @protobuf_type = protobuf_type
         @ruby_type = ruby_type
       end
-
-      protected
-
-      def parse_type_string(type)
-        raise ValueError.new if type.nil?
-        result = ""
-        level  = 0
-        type.each_char do |x|
-          break if level == 0 && x == ','
-          level += 1 if x == '('
-          level -= 1 if x == ')'
-          result += x
-        end
-        raise ValueError.new if level != 0
-        return [result, nil] if result == type
-        raise ValueError.new if type[result.length] != ','
-        [result, type[(result.length+1)..-1]]
-      end
     end
-
+    
     class ValueType < TypeBase
-      def initialize(type_string)
-        raise(ValueError, "\"#{type_string}\" is not a valid type string for a value type") unless PROTOBUF_TO_RUBY_VALUE_TYPE.has_key? type_string
-        super(type_string, PROTOBUF_TO_RUBY_VALUE_TYPE[type_string])
+      def initialize(pb_type)
+        super(pb_type, PROTOBUF_TO_RUBY_VALUE_TYPES[pb_type.code] || raise(ValueError, "#{pb_type.code} is not a valid type code for a value type"))
       end
     end
-
-    class MessageType < TypeBase
-      def initialize(type_string)
-        if PROTOBUF_TO_MESSAGE_TYPE.has_key? type_string
-          super(type_string, PROTOBUF_TO_MESSAGE_TYPE[type_string])
-        else
-          raise(ValueError, "\"#{type_string}\" is not a valid type string for a message type")
-        end
-      end
-    end
-
+    
     class ClassType < TypeBase
       attr_reader :service_name, :class_name
-      def initialize(type_string)
-        m = /Class\(([^\.]+)\.([^\.]+)\)/.match type_string
-        raise(ValueError, "\"#{type_string}\" is not a valid type string for a class type") unless m
-        @service_name, @class_name = m[1..2]
-        super(type_string, Gen.generate_class(service_name, class_name))
+      def initialize(pb_type)
+        @service_name, @class_name = pb_type.service, pb_type.name
+        super(pb_type, Gen.generate_class(service_name, class_name))
       end
     end
-
+    
     class EnumType < TypeBase
       attr_reader :service_name, :enum_name
-      def initialize(type_string)
-        m = /Enum\(([^\.]+)\.([^\.]+)\)/.match type_string
-        raise(ValueError, "\"#{type_string}\" is not a valid type string for a enumeration type") unless m
-        @service_name, @enum_name = m[1..2]
+      def initialize(pb_type)
+        @service_name, @enum_name = pb_type.service, pb_type.name
         # Sets ruby_type to nil, set_values must be called to set the ruby_type
-        super(type_string, nil)
+        super(pb_type, nil)
       end
-
+      
       def set_values(values)
         @ruby_type = Gen.generate_enum(service_name, enum_name, values)
       end
     end
-
+    
     class ListType < TypeBase
       attr_reader :value_type
-      def initialize(type_string)
-        m = /^List\((.+)\)$/.match type_string
-        raise(ValueError, "\"#{type_string}\" is not a valid type string for a list type") unless m
-        @value_type = TypeStore[m[1]]
-        super(type_string, Array)
+      def initialize(pb_type)
+        @value_type = TypeStore[pb_type.types.first]
+        super(pb_type, Array)
       end
     end
-
-    class DictionaryType < TypeBase
-      attr_reader :key_type, :value_type
-      def initialize(type_string)
-        m = /^Dictionary\((.+)\)$/.match type_string
-        raise(ValueError, "\"#{type_string}\" is not a valid type string for a dictionary type") unless m
-
-        key_string, type   = parse_type_string(m[1])
-        value_string, type = parse_type_string(type)
-        raise(ValueError, "\"#{type_string}\" is not a valid type string for a dictionary type") unless type.nil?
-        @key_type   = TypeStore[key_string]
-        @value_type = TypeStore[value_string]
-
-        super(type_string, Hash)
-      end
-    end
-
+    
     class SetType < TypeBase
       attr_reader :value_type
-      def initialize(type_string)
-        m = /^Set\((.+)\)$/.match type_string
-        raise(ValueError, "\"#{type_string}\" is not a valid type string for a set type") unless m
-        @value_type = TypeStore[m[1]]
-        super(type_string, Set)
+      def initialize(pb_type)
+        @value_type = TypeStore[pb_type.types.first]
+        super(pb_type, Set)
       end
     end
-
+    
     class TupleType < TypeBase
       attr_reader :value_types
-      def initialize(type_string)
-        m = /^Tuple\((.+)\)$/.match type_string
-        raise(ValueError, "\"#{type_string}\" is not a valid type string for a tuple type") unless m
-
-        @value_types = []
-        type = m[1]
-        until type.nil?
-          value_type, type = parse_type_string(type)
-          @value_types << TypeStore[value_type]
-        end
-
-        super(type_string, Array)
+      def initialize(pb_type)
+        @value_types = pb_type.types.map {|t| TypeStore[t] }
+        super(pb_type, Array)
       end
     end
-
+    
+    class DictionaryType < TypeBase
+      attr_reader :key_type, :value_type
+      def initialize(pb_type)
+        @key_type, @value_type = pb_type.types.map {|t| TypeStore[t] }
+        super(pb_type, Hash)
+      end
+    end
+    
+    class MessageType < TypeBase
+      def initialize(pb_type)
+        super(pb_type, PROTOBUF_TO_RUBY_MESSAGE_TYPES[pb_type.code] || raise(ValueError, "\"#{pb_type.code}\" is not a valid type code for a message type"))
+      end
+    end
+    
+    PROTOBUF_TYPE_CODE_TO_TYPE_TYPE =
+      PROTOBUF_TO_RUBY_VALUE_TYPES.keys.inject({}) {|a,e| a[e] = ValueType; a }.merge(
+      PROTOBUF_TO_RUBY_MESSAGE_TYPES.keys.inject({}) {|a,e| a[e] = MessageType; a }).merge(
+        CLASS: ClassType, ENUMERATION: EnumType,
+        LIST: ListType, SET: SetType, TUPLE: TupleType, DICTIONARY: DictionaryType
+      )
   end
-
+  
   TypeStore = Types::TypeStore
 end