krpc 0.1.0

data/lib/krpc/core_extensions.rb

@@ -0,0 +1,28 @@
+
+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?
+    const_set(module_name, value)
+    value
+  end
+end
+
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end
+
+class String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end
+

data/lib/krpc/decoder.rb

@@ -0,0 +1,54 @@
+require 'krpc/protobuf_utils'
+require 'set'
+
+module KRPC
+  module Decoder
+    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, type_store)
+        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) 
+          v = decode_value(data, type_store.as_type("int32"))
+          type.ruby_type.key(v)
+        elsif type.is_a?(Types::ClassType)
+          remote_oid = decode_value(data, type_store.as_type("uint64"))
+          if remote_oid != 0
+            type.ruby_type.new(remote_oid)
+          else nil end
+        elsif type.is_a?(Types::ListType)
+          msg = decode_message(data, type_store.as_type("KRPC.List"))
+          msg.items.map{|x| decode(x, type.value_type, type_store)}.to_a
+        elsif type.is_a?(Types::DictionaryType)
+          msg = decode_message(data, type_store.as_type("KRPC.Dictionary"))
+          msg.entries.map{|e| [decode(e.key,   type.key_type,   type_store),
+                               decode(e.value, type.value_type, type_store)]}.to_h
+        elsif type.is_a?(Types::SetType)
+          msg = decode_message(data, type_store.as_type("KRPC.Set"))
+          Set.new(msg.items.map{|x| decode(x, type.value_type, type_store)}.to_a)
+        elsif type.is_a?(Types::TupleType)
+          msg = decode_message(data, type_store.as_type("KRPC.Tuple"))
+          msg.items.zip(type.value_types).map{|x,t| decode(x, t, type_store)}.to_a
+        else raise RuntimeError.new("Cannot decode type #{type} from data: #{data}")
+        end
+      end
+
+      def decode_value(data, type)
+        ProtobufUtils::Decoder.decode(data, type.protobuf_type)
+      end
+      
+      def decode_message(data, type)
+        msg = type.ruby_type.new
+        msg.parse_from_string data.to_s
+        msg
+      end
+      
+    end
+  end
+end
+

data/lib/krpc/doc.rb

@@ -0,0 +1,124 @@
+require 'krpc/core_extensions'
+require 'colorize'
+
+#TODO: Pry's show-doc integration ?
+
+module KRPC
+  module Doc
+    class << self
+      @@docstr_infos = {}
+      @@procedure_docstr_infos = {}
+      
+      def docstring_for_method(method_owner, method_name)
+        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)
+        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")
+        end
+      end
+      
+      def docstring_for_procedure(service_name, procedure_name)
+        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)
+        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)
+        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
+        if is_static
+          key2 = [service_module_name, true, cls.class_name, method_name].hash
+          @@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, 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
+        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"
+        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}(=)?)$/
+      
+      def self.included(base)
+        base.extend self
+        class << base
+          def krpc_name
+            class_name
+          end
+        end
+      end
+      
+      def method_missing(method, *args, &block)
+        if DOCSTRING_SUFFIX_REGEX =~ method.to_s
+          documented_method_name = $1 + $2.to_s
+          if respond_to? documented_method_name.to_sym
+            return puts Doc.docstring_for_method(self,documented_method_name)
+          end
+        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
+    end
+    
+  end
+end
+

data/lib/krpc/encoder.rb

@@ -0,0 +1,60 @@
+require 'krpc/protobuf_utils'
+
+module KRPC
+  module Encoder
+    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, type_store)
+        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"))
+        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"))
+        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.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
+          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
+          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.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.serialize_to_string
+        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 = req.serialize_to_string
+        length =  ProtobufUtils::Encoder.encode_nonnegative_varint(data.length)
+        length + data
+      end
+      
+    end
+  end
+end
+

data/lib/krpc/error.rb

@@ -0,0 +1,33 @@
+
+module KRPC
+
+  class ConnectionError < Exception; end
+  class RPCError < Exception; end
+  class ValueError < Exception; end
+
+
+  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
+  end
+
+  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

@@ -0,0 +1,117 @@
+require 'krpc/doc'
+require 'krpc/core_extensions'
+
+module KRPC
+  module Gen
+    AvailableToClassAndInstanceModuleName = "AvailableToClassAndInstance"
+  
+    class << self
+      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
+          Class.new(ClassBase) do
+            attr_reader :service_name
+            @service_name = service_name
+          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
+          values.map{|ev| [ev.name.underscore.to_sym, ev.value]}.to_h
+        end
+      end
+      
+      def add_rpc_method(cls, method_name, service_name, proc, client, *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)
+        method_name = method_name.underscore
+                
+        target_module.instance_eval do
+          define_method method_name do |*args, **kwargs|
+            begin
+              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))
+            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)
+      end
+      
+      private #----------------------------------
+      
+      def parse_procedure(proc, client)
+        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)
+        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)
+          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]
+      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)
+      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
+    
+    class ClassBase
+      extend AvailableToClassAndInstanceMethodsHandler
+      include Doc::SuffixMethods
+      
+      attr_reader :remote_oid
+      
+      def initialize(remote_oid)
+        @remote_oid = remote_oid
+      end
+      
+      alias_method :eql?, :==
+      def ==(other)
+        other.class == self.class and other.remote_oid == remote_oid
+      end
+      def hash
+        remote_oid.hash
+      end
+      
+      def self.krpc_name
+        name[11..-1]
+      end
+    end
+    
+  end    
+end
+

data/lib/krpc/protobuf_utils.rb

@@ -0,0 +1,134 @@
+require 'krpc/KRPC.pb'
+
+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
+      end    
+    end
+
+    module Decoder
+      class << self
+        def decode(bytes, type)
+          meth_name = "decode_" + type
+          raise RuntimeError.new("Unsupported type #{type}") unless respond_to?(meth_name)
+          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  
+        def decode_varint(bytes)
+          decode_varint_pos(bytes)[0]
+        end
+        def decode_varint_pos(bytes)
+          pos = 0
+          result = 0
+          shift = 0
+          loop do
+            byte = bytes[pos].ord  # <-- replace ".ord" with ".bytes[0]" if ".ord" start to cause problems again
+            binding.pry if byte > 130
+            pos += 1
+            result |= (byte & 0b0111_1111) << shift
+            return [result, pos] if (byte & 0b1000_0000) == 0
+            shift += 7
+            raise(RuntimeError, "too many bytes when decoding varint") if shift >= 64
+          end
+        end
+        def decode_signed_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
+        end
+        def decode_double(bytes)
+          bytes.unpack('E').first
+        end
+        def decode_bool(bytes)
+          decode_varint(bytes) != 0
+        end
+        def decode_string(bytes)  #TODO: String encoding should be utf-8
+          size, pos = decode_varint_pos(bytes)
+          bytes[pos..(pos+size)]
+        end
+        def decode_bytes(bytes)
+          size, pos = decode_varint_pos(bytes)
+          bytes[pos..(pos+size)]
+        end
+        
+      end
+    end
+    
+    module Encoder
+      class << self
+        def encode(value, type)
+          meth_name = "encode_" + type
+          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
+          result = ""
+          loop do
+            byte = value & 0b0111_1111
+            value >>= 7
+            if value == 0
+              return result << byte.chr
+            else
+              result << (byte | 0b1000_0000).chr
+            end
+          end
+        end
+        def encode_signed_varint(value)
+          value += (1 << 64) if value < 0
+          encode_varint(value)
+        end
+        def encode_nonnegative_varint(value)
+          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
+        def encode_double(value)
+          [value].pack('E')
+        end
+        def encode_bool(value)
+          encode_varint(value ? 1 : 0)
+        end
+        def encode_string(value)
+          size = encode_varint(value.bytesize)
+          size + value.bytes.map(&:chr).join.b
+        end
+        def encode_bytes(value)
+          size = encode_varint(value.size)
+          size + value.map(&:chr).join.b
+        end
+        
+      end
+    end
+    
+  end
+end
+
+