spqr 0.0.4 → 0.1.0

data/CHANGES

@@ -1,3 +1,22 @@
+version 0.1.0 (3a3ca52c4f086d1f20fdf5ed89dda262622c171d)
+
+*  Note that this version breaks backwards compatibility, for reasons
+   mentioned below.  Most notably, the Manageable API names have changed,
+   and the old-style exposed-method declarations (with hash args) are no
+   longer supported in favor of a more idiomatic style.
+
+*  Exposed methods now use idiomatic parameter-passing style: input
+   (and in/out) parameters are passed in to methods by name (in the
+   order that they appear in the expose declaration), and output (and
+   in/out) values are returned in a list via a standard return
+   statement.  (Again, the order of output and in/out parameters is
+   specified by the order that they appear in the expose declaration.)
+
+*  Code generation now uses idiomatic parameter-passing style.  Code
+   generation should still be considered "alpha"-quality.
+
+*  Changed mixed-in method names from Manageable.
+
 version 0.0.4  (180897a77b55400b31d364a08cb9f81c423eb59f)
 
 *  Test suite is mainly stable (individual tests will sometimes hang

data/TODO

@@ -1,6 +1,6 @@
 To do, overall:
 
-* packaging
+* packaging (partially done)
 
 
 To do for spqr:
@@ -8,12 +8,11 @@ To do for spqr:
 ! Event support
 * Broader query support (partially done)
 * Documentation
-* Test suite
+* Test suite (partially done)
 - Automatic generation of smoke tests for services (either from schema or manageable class)
 - Automatic schema generation from agent apps
 - Usability improvements:
    - Fewer required annotations
-   - Eliminate requirement for kwargs-style methods
    - Automatic decoration of certain methods
 
 

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.1.0

data/examples/agent-app.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'spqr/spqr'
+require 'spqr/app'
+
+require 'examples/codegen/EchoAgent'
+
+app = SPQR::App.new(:loglevel => :debug)
+app.register Examples::Codegen::EchoAgent
+
+app.main

data/examples/examples/codegen/EchoAgent.rb

@@ -0,0 +1,39 @@
+require 'spqr/spqr'
+
+module Examples
+  module Codegen
+    class EchoAgent
+      include ::SPQR::Manageable
+      
+      qmf_package_name 'examples.codegen'
+      qmf_class_name 'EchoAgent'
+      # Find method (NB:  you must implement this)
+      def EchoAgent.find_by_id(objid)
+        EchoAgent.new
+      end
+      
+      # Find-all method (NB:  you must implement this)
+      def EchoAgent.find_all
+        [EchoAgent.new]
+      end
+      ### Schema method declarations
+      
+      # echo returns its argument
+      # * arg (lstr/IO)
+      # 
+      def echo(arg)
+        # Print values of in/out parameters
+        log.debug "echo: arg => #{arg.inspect}"
+        # Assign values to in/out parameters
+        arg ||= ""
+        # Return value
+        log.debug "echo:  returning #{arg.inspect}"
+        return arg
+      end
+      
+      expose :echo do |args|
+        args.declare :arg, :lstr, :inout, {}
+      end
+    end
+  end
+end

data/examples/hello.rb

@@ -1,30 +1,57 @@
-require 'rubygems'
 require 'spqr/spqr'
 require 'spqr/app'
 require 'logger'
 
 class Hello
    include SPQR::Manageable
-   def hello(args)
-     @people_greeted ||= 0
+
+  # Input (in and inout) parameters are passed to exposed methods in
+  # the order they are declared in the expose block (see below).
+   def hello(name)
+     # We will keep track of the number of people we have greeted over
+     # the lifetime of this agent (see below for the people_greeted
+     # statistic declaration).
      @people_greeted = @people_greeted + 1
-     args["result"] = "Hello, #{args['name']}!"
+
+     # In methods that return only one value --- that is, those which
+     # have only one parameter that is either out or inout --- the
+     # return value is provided normally.  Methods that have multiple
+     # out and inout parameters should return a list that includes the
+     # returned values in the order they are specified in the expose block.
+     "Hello, #{name}!"
     end
 
-   spqr_expose :hello do |args|
+   # This block indicates that we intend to expose the "hello" method
+   # over QMF, that "name" is the first (and only) formal input
+   # parameter, and "result" is the first (and only) formal output
+   # parameter.  Argument declarations include a name, a type, a
+   # direction, and optional keyword arguments.
+   expose :hello do |args|
      args.declare :name, :lstr, :in
      args.declare :result, :lstr, :out
    end
 
-   # This is for the service_name property
+   # This is the method that will be called to get the value of the
+   # service_name property
    def service_name
      @service_name = "HelloAgent"
    end
 
-   spqr_package :hello
-   spqr_class :Hello
-   spqr_statistic :people_greeted, :int
-   spqr_property :service_name, :lstr
+   # The following two declarations provide the QMF package and class
+   # names for the published class.  These can be provided either as
+   # symbols or as strings.  If the class name is omitted, it will be
+   # generated from the class name.
+   qmf_package_name :hello
+   qmf_class_name :Hello
+
+   # The following two declarations create named QMF statistics and
+   # properties with given types.  The value for a statistic or
+   # property is taken from the return values of the instance method
+   # with the same name as that statistic or property.  If a method
+   # with this name does not exist, one is created with attr_reader
+   # and attr_writer.
+   qmf_statistic :people_greeted, :int
+   qmf_property :service_name, :lstr
    
    # These should return the same object for the lifetime of the agent
    # app, since this example has no persistent objects.
@@ -36,6 +63,10 @@ class Hello
      @@hellos ||= [Hello.new]
      @@hellos[0]
    end
+
+   def initialize
+     @people_greeted = 0
+   end
 end
 
 app = SPQR::App.new(:loglevel => :debug)

data/examples/logservice.rb

@@ -22,7 +22,6 @@
 # generated log records in that file, and they will persist between
 # invocations.
 
-require 'rubygems'
 require 'spqr/spqr'
 require 'spqr/app'
 require 'rhubarb/rhubarb'
@@ -31,11 +30,11 @@ class LogService
   include SPQR::Manageable
 
   [:debug, :warn, :info, :error].each do |name|
-    define_method name do |args|
-      args['result'] = LogRecord.create(:l_when=>Time.now.to_i, :severity=>"#{name.to_s.upcase}", :msg=>args['msg'].dup)
+    define_method name do |msg|
+      LogRecord.create(:l_when=>Time.now.to_i, :severity=>"#{name.to_s.upcase}", :msg=>msg.dup)
     end
     
-    spqr_expose name do |args|
+    expose name do |args|
       args.declare :msg, :lstr, :in
       args.declare :result, :objId, :out
     end
@@ -50,8 +49,8 @@ class LogService
     @@singleton ||= LogService.new
   end
 
-  spqr_package :examples
-  spqr_class :LogService
+  qmf_package_name :examples
+  qmf_class_name :LogService
 end
 
 class LogRecord
@@ -65,22 +64,23 @@ class LogRecord
   # XXX: rhubarb should create a find_all by default
   declare_query :find_all, "1"
 
-  spqr_property :l_when, :uint
-  spqr_property :severity, :lstr
-  spqr_property :msg, :lstr
+  qmf_property :l_when, :uint
+  qmf_property :severity, :lstr
+  qmf_property :msg, :lstr
 
-  spqr_package :examples
-  spqr_class :LogRecord
+  qmf_package_name :examples
+  qmf_class_name :LogRecord
 
   def spqr_object_id
     row_id
   end
 end
 
-TABLE = ARGV[0] or ":memory:" 
-DO_CREATE = (TABLE == ":memory:" or not File.exist?(TABLE))
+DBLOC = (ARGV[0] or ":memory:")
+puts "storing results to #{DBLOC}"
+DO_CREATE = (DBLOC == ":memory:" or not File.exist?(DBLOC))
 
-Rhubarb::Persistence::open(TABLE)
+Rhubarb::Persistence::open(DBLOC)
 
 LogRecord.create_table if DO_CREATE
 

data/lib/spqr/app.rb

@@ -56,7 +56,7 @@ module SPQR
         
         schemaclass = schematize(klass)
 
-        klass.spqr_logger = @log
+        klass.log = @log
 
         @classes_by_id[klass.class_id] = klass
         @classes_by_name[klass.name] = ClassMeta.new(klass, schemaclass)
@@ -75,21 +75,41 @@ module SPQR
 
         @log.debug "calling method: context=#{context} method=#{name} object_id=#{obj_id}, args=#{args}, user=#{user_id}"
 
-        # Turn the Qmf::Arguments structure into a proper ruby hash
+        managed_object = find_object(context, class_id, obj_id)
+        @log.debug("managed object is #{managed_object}")
+        managed_method = managed_object.class.spqr_meta.mmethods[name.to_sym]
+
+        raise RuntimeError.new("#{managed_object.class} does not have #{name} exposed as a manageable method; has #{managed_object.class.spqr_meta.mmethods.inspect}") unless managed_method
+
+        # Extract actual parameters from the Qmf::Arguments structure into a proper ruby list
 
         # XXX: consider adding appropriate impl method to Manageable
         # to avoid this little dance
-        hash_args = qmf_arguments_to_hash(args)
+        actuals_in = managed_method.formals_in.inject([]) {|acc,nm| acc << args[nm]}
+        actuals_in = actuals_in[0] if actuals_in.size == 1
 
-        managed_object = find_object(context, class_id, obj_id)
-        @log.debug("managed object is #{managed_object}")
+        @log.debug("managed_object.respond_to? #{managed_method.name.to_sym} ==> #{managed_object.respond_to? managed_method.name.to_sym}")
+        @log.debug("managed_object.class.spqr_meta.mmethods.include? #{name.to_sym} ==> #{managed_object.class.spqr_meta.mmethods.include? name.to_sym}")
+        @log.debug("formals:  #{managed_method.formals_in.inspect}")
+        @log.debug("actuals:  #{actuals_in.inspect}")
 
-        @log.debug("managed_object.respond_to? #{name.to_sym} ==> #{managed_object.respond_to? name.to_sym}")
-        managed_object.send(name.to_sym, hash_args)
+        actuals_out = actuals_in.size > 0 ? managed_object.send(name.to_sym, actuals_in) : managed_object.send(name.to_sym)
+
+        raise RuntimeError.new("#{managed_object.class} did not return the appropriate number of return values; got '#{actuals_out.inspect}', but expected #{managed_method.types_out.inspect}") unless result_valid(actuals_out, managed_method)
+        
+        if managed_method.formals_out.size == 0
+          actuals_out = [] # ignore return value in this case
+        elsif managed_method.formals_out.size == 1
+          actuals_out = [actuals_out] # wrap this up in a list
+        end
         
-        # Copy any out parameters from hash_args from the
+        @log.debug("formals_out == #{managed_method.formals_out.inspect}")
+        @log.debug("actuals_out == #{actuals_out.inspect}")
+
+        # Copy any out parameters from return value to the
         # Qmf::Arguments structure; see XXX above
-        hash_args.each do |k,v|
+        managed_method.formals_out.zip(actuals_out).each do |k,v|
+          @log.debug("fixing up out params:  #{k.inspect} --> #{v.inspect}")
           encoded_val = encode_object(v)
           args[k] = encoded_val
         end
@@ -160,6 +180,10 @@ module SPQR
 
     private
     
+    def result_valid(actuals, mm)
+      (actuals.kind_of?(Array) and mm.formals_out.size == actuals.size) or mm.formals_out.size <= 1
+    end
+    
     def qmf_arguments_to_hash(args)
       result = {}
       args.each do |k,v|
@@ -189,7 +213,7 @@ module SPQR
 
       sc = Qmf::SchemaObjectClass.new(package, classname)
       
-      meta.mmethods.each do |mm|
+      meta.manageable_methods.each do |mm|
         @log.info("+-- creating a QMF schema for method #{mm}")
         m_opts = mm.options
         m_opts[:desc] ||= mm.description if mm.description

data/lib/spqr/codegen.rb

@@ -182,15 +182,17 @@ module SPQR
         pp "include ::SPQR::Manageable"
         pp ""
 
-        pp "spqr_package '#{@package_list.join(".")}'"
-        pp "spqr_class '#{@sc.name.split("::")[-1]}'"
+        pp "qmf_package_name '#{@package_list.join(".")}'"
+        pp "qmf_class_name '#{@sc.name.split("::")[-1]}'"
 
         pp '# Find method (NB:  you must implement this)'
         pp_decl :def, "#{@sc.name}.find_by_id", "(objid)" do
           pp "#{@sc.name}.new"
         end
 
-        pp "\n# Find-all method (NB:  you must implement this)"
+        pp ""
+
+        pp '# Find-all method (NB:  you must implement this)'
         pp_decl :def, "#{@sc.name}.find_all" do
           pp "[#{@sc.name}.new]"
         end
@@ -237,7 +239,7 @@ module SPQR
       property.options[:desc] = property.desc if property.desc
 
       pp ""
-      pp "spqr_property #{property.name.to_sym.inspect}, #{property.kind.to_sym.inspect}, #{property.options.inspect.gsub(/[{}]/, '')}"
+      pp "qmf_property #{property.name.to_sym.inspect}, #{property.kind.to_sym.inspect}, #{property.options.inspect.gsub(/[{}]/, '')}"
     end
 
     def gen_statistic(statistic)
@@ -251,7 +253,7 @@ module SPQR
       statistic.options[:desc] = statistic.desc if statistic.desc
       
       pp ""
-      pp "spqr_property #{statistic.name.to_sym.inspect}, #{statistic.kind.to_sym.inspect}, #{statistic.options.inspect.gsub(/[{}]/, '')}"
+      pp "qmf_property #{statistic.name.to_sym.inspect}, #{statistic.kind.to_sym.inspect}, #{statistic.options.inspect.gsub(/[{}]/, '')}"
     end
 
     def gen_method(method)
@@ -265,8 +267,22 @@ module SPQR
       in_params = method.args.select {|arg| ['in', 'i', 'qmf::dir_in'].include? arg.dir.to_s.downcase }
       out_params = method.args.select {|arg| ['out', 'o', 'qmf::dir_out'].include? arg.dir.to_s.downcase }
       inout_params = method.args.select {|arg| ['inout', 'io', 'qmf::dir_inout'].include? arg.dir.to_s.downcase }
-      
-      pp_decl :def, method.name, "(args)" do
+
+      formals_in = method.args.select {|arg| ['in','i','qmf::dir_in','io','inout','qmf::dir_inout'].include? arg.dir.to_s.downcase}.map{|arg| arg.name}.join(",")
+      formals_out = method.args.select {|arg| ['out','o','qmf::dir_out','io','inout','qmf::dir_inout'].include? arg.dir.to_s.downcase}.map{|arg| arg.name}
+
+      actuals_out = case formals_out.size
+                      when 0 then nil.inspect
+                      when 1 then formals_out[0].to_s
+                    else "[#{formals_out.join(", ")}]"
+                    end
+
+      param_types = method.args.inject({}) do |acc, arg|
+        acc[arg.name.to_s] = arg.kind.to_s
+        acc
+      end
+
+      pp_decl :def, method.name, "(#{formals_in})" do
         
         if in_params.size + inout_params.size > 0  
           what = "in"
@@ -279,8 +295,8 @@ module SPQR
           
           pp "\# Print values of #{what} parameters"
           (in_params + inout_params).each do |arg|
-            argdisplay = arg.name.to_s.inspect
-            pp('log.debug "' + "#{arg.name} => " + '#{args[' + "#{argdisplay}" + ']}"' + " \# #{}")
+            argdisplay = arg.name.to_s
+            pp('log.debug "' + "#{method.name}: #{arg.name} => " + '#{' + "#{argdisplay}" + '}"')
           end
         end
 
@@ -296,15 +312,21 @@ module SPQR
           pp "\# Assign values to #{what} parameters"
 
           (out_params + inout_params).each do |arg|
-            argdisplay = arg.name.to_s.inspect
-            pp "args[#{argdisplay}] = args[#{argdisplay}]"
+            argdisplay = arg.name.to_s
+            argtype = param_types[argdisplay]
+            raise RuntimeError.new("Can't find type for #{argdisplay} in #{param_types.inspect}") unless argtype
+            pp "#{argdisplay} ||= #{default_val(argtype)}"
           end
+
+          pp "\# Return value"
+          pp "return #{actuals_out}"
+
         end
       end
 
 
       pp ""
-      pp_decl :spqr_expose, "#{method.name.to_sym.inspect} do |args|" do
+      pp_decl :expose, "#{method.name.to_sym.inspect} do |args|" do
         {:in => in_params, :inout => inout_params, :out => out_params}.each do |dir,coll|
           coll.each do |arg|
             arg_nm = arg.name
@@ -315,6 +337,19 @@ module SPQR
         end
       end
     end
+
+    def default_val(ty)
+      case ty
+        when 'array', 'list' then [].inspect
+        when 'bool' then false.inspect
+        when 'double', 'float' then 0.0.inspect
+        when 'absTime', 'deltaTime', 'int16', 'int32', 'int64', 'int', 'int8', 'uint16', 'uint32', 'uint64', 'uint', 'uint8' then 0.inspect
+        when 'lstr', 'string', 'sstr', 'uuid' then "".inspect
+        when 'map' then {}.inspect
+        when 'objId' then nil.inspect
+      else raise RuntimeError.new("Unknown type #{ty.inspect}")
+      end
+    end
   end
 
   class AppBoilerplateGenerator

data/lib/spqr/manageable.rb

@@ -19,16 +19,19 @@ module SPQR
       self.options = (({} unless self.options) or self.options.dup)
       self.statistics = [] unless self.statistics
       self.properties = [] unless self.properties
-      self.mmethods ||= []
+      self.mmethods ||= {}
     end
 
     def declare_method(name, desc, options, blk=nil)
       result = MethodMeta.new name, desc, options
       blk.call(result.args) if blk
-      self.mmethods << result
-      self.mmethods[-1]
+      self.mmethods[name] = result
     end
 
+    def manageable_methods
+      self.mmethods.values
+    end
+    
     def declare_statistic(name, kind, options)
       declare_basic(:statistic, name, kind, options)
     end
@@ -57,6 +60,34 @@ module SPQR
       self.args = gen_args
     end
 
+    def formals_in
+      self.args.select {|arg| arg.direction == :in or arg.direction == :inout}.collect{|arg| arg.name.to_s}
+    end
+
+    def formals_out
+      self.args.select {|arg| arg.direction == :inout or arg.direction == :out}.collect{|arg| arg.name.to_s}
+    end
+
+    def types_in
+      self.args.select {|arg| arg.direction == :in or arg.direction == :inout}.collect{|arg| arg.kind.to_s}
+    end
+    
+    def types_out
+      self.args.select {|arg| arg.direction == :inout or arg.direction == :out}.collect{|arg| arg.kind.to_s}
+    end
+
+    def type_of(param)
+      @types_for ||= self.args.inject({}) do |acc,arg| 
+        k = arg.name
+        v = arg.kind.to_s
+        acc[k] = v
+        acc[k.to_s] = v
+        acc
+      end
+      
+      @types_for[param]
+    end
+
     private
     def gen_args
       result = []
@@ -97,36 +128,36 @@ module SPQR
       @spqr_meta ||= ::SPQR::ManageableMeta.new
     end
     
-    def spqr_logger=(logger)
+    def log=(logger)
       @spqr_log = logger
     end
     
-    def spqr_logger
+    def log
       @spqr_log || ::SPQR::Sink.new
     end
     
     # Exposes a method to QMF
-    def spqr_expose(name, description=nil, options=nil, &blk)
+    def expose(name, description=nil, options=nil, &blk)
       spqr_meta.declare_method(name, description, options, blk)
     end      
     
-    def spqr_package(nm)
+    def qmf_package_name(nm)
       spqr_meta.package = nm
     end
     
-    def spqr_class(nm)
+    def qmf_class_name(nm)
       spqr_meta.classname = nm
     end
     
-    def spqr_description(d)
+    def qmf_description(d)
       spqr_meta.description = d
     end
     
-    def spqr_options(opts)
+    def qmf_options(opts)
       spqr_meta.options = opts.dup
     end      
     
-    def spqr_statistic(name, kind, options=nil)
+    def qmf_statistic(name, kind, options=nil)
       spqr_meta.declare_statistic(name, kind, options)
       
       self.class_eval do
@@ -142,7 +173,7 @@ module SPQR
       end
     end
     
-    def spqr_property(name, kind, options=nil)
+    def qmf_property(name, kind, options=nil)
       spqr_meta.declare_property(name, kind, options)
       
       # add a property accessor to instances of other
@@ -188,7 +219,7 @@ module SPQR
     end
 
     def log
-      self.class.spqr_logger
+      self.class.log
     end
 
     def self.included(other)
@@ -216,7 +247,7 @@ module SPQR
         end
       end
 
-      other.spqr_class other.name.to_sym
+      other.qmf_class_name other.name.to_sym
     end
   end
 end

data/test/example-apps.rb

@@ -15,17 +15,17 @@ class QmfClicker
     @clicks = 0
   end
   
-  def click(args)
+  def click
     @clicks = @clicks.succ
   end
   
-  spqr_expose :click do |args| 
+  expose :click do |args| 
   end
   
-  spqr_statistic :clicks, :int
+  qmf_statistic :clicks, :int
   
-  spqr_package :example
-  spqr_class :QmfClicker
+  qmf_package_name :example
+  qmf_class_name :QmfClicker
 end
 
 class QmfHello
@@ -41,17 +41,17 @@ class QmfHello
     @qmf_hellos
   end
 
-  def hello(args)
-    args["result"] = "Hello, #{args['name']}!"
+  def hello(name)
+    "Hello, #{name}!"
   end
 
-  spqr_expose :hello do |args|
+  expose :hello do |args|
     args.declare :name, :lstr, :in
     args.declare :result, :lstr, :out
   end
   
-  spqr_package :example
-  spqr_class :QmfHello
+  qmf_package_name :example
+  qmf_class_name :QmfHello
 end
 
 class QmfDummyProp
@@ -71,10 +71,10 @@ class QmfDummyProp
     "DummyPropService"
   end
   
-  spqr_property :service_name, :lstr
+  qmf_property :service_name, :lstr
 
-  spqr_class :QmfDummyProp
-  spqr_package :example
+  qmf_class_name :QmfDummyProp
+  qmf_package_name :example
 end
 
 
@@ -109,18 +109,18 @@ class QmfIntegerProp
     @qmf_ips
   end
 
-  def next(args)
-    args['result'] = QmfIntegerProp.find_by_id((@int_id + 1) % QmfIntegerProp::SIZE)
+  def next
+    QmfIntegerProp.find_by_id((@int_id + 1) % QmfIntegerProp::SIZE)
   end
   
-  spqr_expose :next do |args|
+  expose :next do |args|
     args.declare :result, :objId, :out
   end
 
-  spqr_property :int_id, :int, :index=>true
+  qmf_property :int_id, :int, :index=>true
 
-  spqr_class :QmfIntegerProp
-  spqr_package :example
+  qmf_class_name :QmfIntegerProp
+  qmf_package_name :example
 end
 
 

data/test/test_spqr_clicker.rb

@@ -15,7 +15,7 @@ class TestSpqrClicker < Test::Unit::TestCase
     assert_nothing_raised do
       obj = $console.objects(:class=>"QmfClicker", :agent=>@ag)[0]
       
-      obj.click({})
+      obj.click
     end
   end
 
@@ -36,7 +36,7 @@ class TestSpqrClicker < Test::Unit::TestCase
       obj = $console.objects(:class=>"QmfClicker", :agent=>@ag)[0]
       assert_equal x, obj[:clicks]
       
-      obj.click({})
+      obj.click
       x = x.succ
     end
   end
@@ -51,7 +51,7 @@ class TestSpqrClicker < Test::Unit::TestCase
       obj.update
       assert_equal x, obj[:clicks]
       
-      obj.click({})
+      obj.click
       x = x.succ
     end
   end

data/test/test_spqr_hello.rb

@@ -18,12 +18,9 @@ class TestSpqrHello < Test::Unit::TestCase
   def test_hello_call
     app_setup QmfHello
     obj = $console.objects(:class=>"QmfHello", :agent=>@ag)[0]
-    
     val = obj.hello("ruby").result
-    args = { 'name' => 'ruby' }
-    QmfHello.find_by_id(0).hello(args)
 
-    expected = args['result']
+    expected = QmfHello.find_by_id(0).hello("ruby")
 
     assert_equal expected, val
   end

data/test/test_spqr_integerprop.rb

@@ -16,7 +16,10 @@ class TestSpqrIntegerProp < Test::Unit::TestCase
     
     objs.size.times do |x|
       expected = objs[(x + 1) % QmfIntegerProp::SIZE]
-      actual = $console.object(:object_id=>objs[x].next.result)
+      o = objs[x]
+      next_o = o.next.result
+      puts ("next_o: #{next_o}")
+      actual = $console.object(:object_id=>next_o)
       assert_equal expected.int_id, actual.int_id
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spqr
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors: 
 - William Benton
@@ -101,5 +101,7 @@ test_files:
 - test/test_spqr_integerprop.rb
 - test/test_rhubarb.rb
 - test/test_spqr_hello.rb
+- examples/agent-app.rb
+- examples/examples/codegen/EchoAgent.rb
 - examples/hello.rb
 - examples/logservice.rb