asterism 0.5.0 → 0.7.0

data/mrblib/future.rb

@@ -48,16 +48,22 @@ module Asterism
       @finished
     end
 
+    # The answer: {"value" => v} gives v, {"error" => {"kind", "class",
+    # "message"}} raises RemoteError; anything else is a malformed answer.
     def value
       raw = raw_value
-      unless raw.is_a?(Array) && (raw[0] == "ok" || raw[0] == "error")
-        raise ::Asterism::Error, "malformed answer from #{@path}"
+      raise ::Asterism::Error, "malformed answer from #{@path}" unless raw.is_a?(Hash)
+      if raw.key?("error")
+        e = raw["error"]
+        raise ::Asterism::Error, "malformed answer from #{@path}" unless e.is_a?(Hash)
+        kind = e["kind"]
+        raise ::Asterism::RemoteError.new(e["class"], e["message"], kind.is_a?(String) ? kind : nil)
       end
-      raise ::Asterism::RemoteError.new(raw[1], raw[2]) if raw[0] == "error"
-      raw[1]
+      raise ::Asterism::Error, "malformed answer from #{@path}" unless raw.key?("value")
+      raw["value"]
     end
 
-    # The decoded answer (meta replies are not ["ok", value] pairs).
+    # The decoded answer (meta and profile replies are not value maps).
     def raw_value
       ::Asterism.wait_until { done? } unless done?
       if @reply.nil?

data/mrblib/profile.rb

@@ -7,11 +7,14 @@
 #
 # Key: asterism/<node>/@profile (a queryable of every application connected
 # as that node). The reply is a MessagePack Hash:
+#   "protocol"   the wire protocol the node speaks (Asterism::PROTOCOL, 1);
+#                a node without it speaks protocol 0
 #   "kind"       what Ruby runs the node: "family_mruby", "picoruby",
 #                "cruby", "console" (others are allowed)
 #   "host"       where it runs, optional ("atoms3r", "tab5", "sim", ...)
 #   "name"       a display name, optional
-#   "icon"       PNG bytes, optional (8 KB and 256x256 at most)
+#   "icon"       PNG bytes as a MessagePack bin, optional (8 KB and
+#                256x256 at most)
 #   "icon_hash"  the icon's summary (Profile.png_info): a reader that has
 #                that icon already asks again with the parameter icon=0 and
 #                gets the rest without it
@@ -87,6 +90,13 @@ module Asterism
       nil
     end
 
+    # The bytes as a binary String (String#b), so that they are sent as a
+    # MessagePack bin; as they are where String#b is missing.
+    # @api private
+    def self.binary(s)
+      s.respond_to?(:b) ? s.b : s
+    end
+
     # @api private
     def self.type?(b, pos, c0, c1, c2, c3)
       b.getbyte(pos + 4) == c0 && b.getbyte(pos + 5) == c1 && b.getbyte(pos + 6) == c2 && b.getbyte(pos + 7) == c3
@@ -107,6 +117,8 @@ module Asterism
       kind = h["kind"]
       return nil unless kind.is_a?(String) && kind?(kind)
       out = { "kind" => kind }
+      pr = h["protocol"]
+      out["protocol"] = pr if pr.is_a?(Integer) && pr >= 0
       host = h["host"]
       out["host"] = host if host.is_a?(String) && !host.empty? && host.bytesize <= HOST_MAX
       name = h["name"]
@@ -301,7 +313,7 @@ module Asterism
   # @api private
   def self.profile_hash(with_icon)
     set = @profile_set || {}
-    h = { "kind" => set["kind"] || default_profile_kind }
+    h = { "protocol" => PROTOCOL, "kind" => set["kind"] || default_profile_kind }
     h["host"] = set["host"] if set["host"]
     h["name"] = set["name"] if set["name"]
     icon = profile_icon
@@ -324,7 +336,8 @@ module Asterism
         bytes = path ? read_icon_file(path) : nil
       end
       info = bytes ? Profile.png_info(bytes) : nil
-      @profile_icon = info ? [bytes, info[2]] : false
+      # A binary String: it goes as a MessagePack bin.
+      @profile_icon = info ? [Profile.binary(bytes), info[2]] : false
     end
     @profile_icon ? @profile_icon : nil
   end
@@ -342,7 +355,7 @@ module Asterism
   # @api private
   def self.answer_profile
     qa = @profile_queryable
-    return unless qa
+    return unless qa && qa.pending > 0
     queries = qa.each_pending
     i = 0
     while i < queries.size

data/mrblib/proxy.rb

@@ -3,9 +3,9 @@ module Asterism
   # Any method it does not have itself becomes a call that waits for the
   # answer. respond_to? and remote_methods come from the object's meta.
   #
-  # Its own methods (not forwarded): async, asterism_path, asterism_meta,
-  # asterism_refresh, remote_methods, respond_to?, methods, inspect, to_s
-  # and those of Object.
+  # Its own methods (not forwarded): async, asterism_call, asterism_path,
+  # asterism_meta, asterism_refresh, remote_methods, respond_to?, methods,
+  # inspect, to_s and those of Object.
   class Proxy
     # Conversions Ruby asks for implicitly (puts, Array#flatten, ...): never
     # forwarded.
@@ -27,6 +27,15 @@ module Asterism
       ::Asterism.call(@path, name, args, kw, @timeout_ms)
     end
 
+    # Calls the remote method by its name (a String or Symbol): for the
+    # names the proxy cannot forward (those Object and Kernel define:
+    # display, hash, class, fail, ...) and for names that are not Ruby
+    # identifiers (from objects written in other languages).
+    def asterism_call(name, *args, **kw, &blk)
+      raise ::ArgumentError, "a block cannot be sent to #{@path}" if blk
+      ::Asterism.call(@path, name.to_s, args, kw, @timeout_ms)
+    end
+
     # In Ruby rather than through respond_to_missing?: Object#respond_to? is
     # C, and calling back into Ruby from it (which then waits for the meta)
     # costs another interpreter entry on the C stack.
@@ -52,7 +61,8 @@ module Asterism
       remote_methods
     end
 
-    # The meta reply, fetched once: {"methods" => [[name, arity], ...]}.
+    # The meta reply, fetched once:
+    # {"methods" => [{"name" => name, "arity" => n}, ...]}.
     def asterism_meta
       @meta ||= ::Asterism.meta(@path, @timeout_ms)
     end
@@ -67,7 +77,9 @@ module Asterism
     def remote_names
       list = asterism_meta["methods"]
       return [] unless list.is_a?(Array)
-      list.map { |pair| pair.is_a?(Array) ? pair[0].to_s : pair.to_s }
+      names = []
+      list.each { |m| names << m["name"].to_s if m.is_a?(Hash) && m["name"].is_a?(String) }
+      names
     end
 
     # The same object, calls that do not wait: each returns a Future.
@@ -100,6 +112,12 @@ module Asterism
       !::Asterism::Proxy::LOCAL_ONLY.include?(name.to_sym)
     end
 
+    # Proxy#asterism_call that does not wait: returns a Future.
+    def asterism_call(name, *args, **kw, &blk)
+      raise ::ArgumentError, "a block cannot be sent to #{@path}" if blk
+      ::Asterism.call_async(@path, name.to_s, args, kw, @timeout_ms)
+    end
+
     def inspect
       "#<Asterism::AsyncProxy #{@path}>"
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asterism
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Katsuhiko Kageyama