krpc 0.1.0

data/lib/krpc/repl_tools.rb

@@ -0,0 +1,12 @@
+require 'krpc/doc'
+
+module KRPC
+  module REPLTools
+    def proc_doc(service_name, procedure_name)
+      puts Doc.docstring_for_procedure(service_name, procedure_name)
+    end
+  end
+end
+
+include KRPC::REPLTools
+

data/lib/krpc/service.rb

@@ -0,0 +1,96 @@
+require 'krpc/gen'
+require 'krpc/attributes'
+require 'krpc/doc'
+
+module KRPC
+  module Services
+    class << self
+    
+      def create_service(service_msg, client)
+        service_name = service_msg.name
+        
+        # Create service class
+        service_class = Class.new(ServiceBase)
+        const_set(service_name, service_class)
+        
+        # Create service' classes
+        service_msg.classes.map(&:name).each do |sc_name|
+          client.type_store.as_type("Class(#{service_name}.#{sc_name})")
+        end
+        
+        # Create service' enums
+        service_msg.enumerations.each do |enum|
+          enum_type = client.type_store.as_type("Enum(#{service_name}.#{enum.name})")
+          enum_type.set_values(enum.values)
+        end
+        
+        # Create service' procedures
+        service_msg.procedures.each do |proc|
+          if Attributes.is_a_class_method_or_property_accessor(proc.attributes)
+            class_name  = Attributes.get_class_name(proc.attributes)
+            class_cls = client.type_store.as_type("Class(#{service_name}.#{class_name})").ruby_type
+            method_name = Attributes.get_class_method_or_property_name(proc.attributes)
+            if Attributes.is_a_class_property_accessor(proc.attributes)  # service' class property
+              if Attributes.is_a_class_property_getter(proc.attributes)
+                Gen.add_rpc_method(class_cls, method_name, service_name, proc, client, :prepend_self_to_args)
+              else
+                Gen.add_rpc_method(class_cls, method_name + '=', service_name, proc, client, :prepend_self_to_args)
+              end
+            elsif Attributes.is_a_class_method(proc.attributes)  # service' class method
+              Gen.add_rpc_method(class_cls, method_name, service_name, proc, client, :prepend_self_to_args)
+            else  # service' static class method
+              Gen.add_rpc_method(class_cls, method_name, service_name, proc, client, :static)
+            end
+          elsif Attributes.is_a_property_accessor(proc.attributes)  # service' property
+            property_name = Attributes.get_property_name(proc.attributes)
+            if Attributes.is_a_property_getter(proc.attributes)
+              Gen.add_rpc_method(service_class, property_name, service_name, proc, client)
+            elsif Attributes.is_a_property_setter(proc.attributes)
+              Gen.add_rpc_method(service_class, property_name + '=', service_name, proc, client)
+            end
+          else  # plain procedure = method available to service class and its instance
+            Gen.add_rpc_method(service_class, proc.name, service_name, proc, client, :static)
+          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 instance
+        service_class.new(client)
+      end
+      
+    end
+    
+    class ServiceBase
+      extend Gen::AvailableToClassAndInstanceMethodsHandler
+      include Doc::SuffixMethods
+      
+      attr_reader :client
+  
+      def initialize(client)
+        @client = client
+      end
+    end
+    
+    class KRPC < ServiceBase
+      include Gen::RPCMethodGenerator
+    
+      def initialize(client)
+        super(client)
+        unless respond_to? :get_status
+          include_rpc_method("get_status", "KRPC", "GetStatus", return_type: "KRPC.Status")
+          include_rpc_method("get_services", "KRPC", "GetServices", return_type: "KRPC.Services")
+          # TODO: implement me:
+          # include_rpc_method("add_stream", "KRPC", "AddStream", ...)
+          # include_rpc_method("remove_stream", "KRPC", "RemoveStream", ...)
+        end
+      end
+    end
+    
+  end
+end
+

data/lib/krpc/types.rb

@@ -0,0 +1,237 @@
+require 'krpc/gen'
+require 'krpc/attributes'
+require 'krpc/protobuf_utils'
+require 'krpc/error'
+require 'krpc/core_extensions'
+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]
+    PROTOBUF_TO_RUBY_VALUE_TYPE = {
+      "double" => Float,
+      "float"  => Float,
+      "int32"  => Integer,
+      "int64"  => Integer,
+      "uint32" => Integer,
+      "uint64" => Integer,
+      "bool"   => Boolean,
+      "string" => String,
+      "bytes"  => String
+    }
+    PROTOBUF_TO_MESSAGE_TYPE = ProtobufUtils.create_PB_to_PB_message_class_hash("KRPC")
+  
+    class TypeStore
+    
+      def initialize
+        @cache = {}
+      end
+      
+      def as_type(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, self)
+          elsif type_string.start_with? "Dictionary(" || type_string == "Dictionary" then DictionaryType.new(type_string, self)
+          elsif type_string.start_with? "Set("   || type_string == "Set"   then SetType.new(type_string, self)
+          elsif type_string.start_with? "Tuple(" || type_string == "Tuple" then TupleType.new(type_string, self)
+          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 as_type(ta)
+          rescue ValueError
+          end
+        end
+        as_type(type)
+      end
+
+      def get_return_type(type, attrs)
+        type_attrs = Attributes.get_return_type_attrs(attrs)
+        type_attrs.each do |ta|
+          begin
+            return as_type(ta)
+          rescue ValueError
+          end
+        end
+        as_type(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
+        # Coerce identical class types from different client connections
+        if type.is_a?(ClassType) && value.is_a?(Gen::ClassBase) && 
+           type.ruby_type.service_name == value.class.service_name && 
+           type.ruby_type.name == value.class.name
+          return type.ruby_type.new(value.remote_oid)
+        end
+        # -- Collection types --
+        begin
+          # coerce "list" to array
+          if type.is_a?(ListType) && value.respond_to?(:map) && value.respond_to?(:to_a)
+            return type.ruby_type.new(value.map{|x| coerce_to(x, type.value_type) }.to_a)
+          end
+          # coerce "tuple" to array + check elements count
+          if type.is_a?(TupleType) && value.respond_to?(:map) && value.respond_to?(:to_a) && value.respond_to?(:size)
+            raise ValueError if value.size != type.value_types.size
+            return type.ruby_type.new(value.map.with_index{|x,i| coerce_to(x, type.value_types[i]) }.to_a)
+          end
+        rescue ValueError
+          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)
+          return value.to_f
+        elsif type.ruby_type == Integer && value.respond_to?(:to_i)
+          return value.to_i
+        end
+        raise(ValueError, "Failed to coerce value #{value.to_s} of type #{value.class} to type #{type}")
+      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])
+      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))
+      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]
+        # Sets ruby_type to nil, set_values must be called to set the ruby_type
+        super(type_string, 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, type_store)
+        m = /^List\((.+)\)$/.match type_string
+        raise(ValueError, "\"#{type_string}\" is not a valid type string for a list type") unless m
+        @value_type = type_store.as_type(m[1])
+        super(type_string, Array)
+      end
+    end
+    
+    class DictionaryType < TypeBase
+      attr_reader :key_type, :value_type
+      def initialize(type_string, type_store)
+        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") if type != nil
+        @key_type   = type_store.as_type(key_string)
+        @value_type = type_store.as_type(value_string)
+
+        super(type_string, Hash)
+      end
+    end
+    
+    class SetType < TypeBase
+      attr_reader :value_type
+      def initialize(type_string, type_store)
+        m = /^Set\((.+)\)$/.match type_string
+        raise(ValueError, "\"#{type_string}\" is not a valid type string for a set type") unless m
+        @value_type = type_store.as_type(m[1])
+        super(type_string, Set)
+      end
+    end
+    
+    class TupleType < TypeBase
+      attr_reader :value_types
+      def initialize(type_string, type_store)
+        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]
+        while type != nil
+          value_type, type = parse_type_string(type)
+          @value_types << type_store.as_type(value_type)
+        end
+        
+        super(type_string, Array)
+      end
+    end
+        
+  end
+end
+

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: krpc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tomasz Więch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby_protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+description: 
+email:
+- tewu.dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- krpc.gemspec
+- lib/krpc.rb
+- lib/krpc/KRPC.pb.rb
+- lib/krpc/attributes.rb
+- lib/krpc/client.rb
+- lib/krpc/connection.rb
+- lib/krpc/core_extensions.rb
+- lib/krpc/decoder.rb
+- lib/krpc/doc.rb
+- lib/krpc/encoder.rb
+- lib/krpc/error.rb
+- lib/krpc/gen.rb
+- lib/krpc/protobuf_utils.rb
+- lib/krpc/repl_tools.rb
+- lib/krpc/service.rb
+- lib/krpc/types.rb
+homepage: https://github.com/TeWu/krpc-rb
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Client library for kRPC
+test_files: []
+has_rdoc: