scarpe 0.3.0 → 0.5.0

data/lacci/test/test_niente_test_infra.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestNienteTestInfra < NienteTest
+  def test_app_fail_in_test
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC, expect_process_fail: true)
+      Shoes.app do
+        @b = button "OK"
+        raise "ERROR!"
+      end
+    SHOES_APP
+      assert_equal true, true
+    SHOES_SPEC
+  end
+
+  def test_app_fail_in_spec
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC, expect_minitest_exception: true)
+      Shoes.app do
+        @b = button "OK"
+      end
+    SHOES_APP
+      raise "ERROR!"
+    SHOES_SPEC
+  end
+
+  def test_multi_app_find
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        @b = button "OK"
+      end
+      Shoes.app do
+        @b2 = button "Nope"
+      end
+    SHOES_APP
+      assert_equal "OK", button("@b").text
+      assert_equal "Nope", button("@b2").text
+    SHOES_SPEC
+  end
+end

data/lacci/test/test_oval.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestLacciOval < NienteTest
+  # For an oval, the args go left, top, radius, height
+  def test_simple_oval_values
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        oval 5, 10, 25 # circle with radius 25 with its upper-left point at 5, 10
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal 5, ov.left
+      assert_equal 10, ov.top
+      assert_equal 25, ov.radius
+      assert_equal 50, ov.width
+      assert_equal 50, ov.height
+    SHOES_SPEC
+  end
+
+  def test_oval_with_height
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        oval 5, 10, 25, 35 # oval with radius 25, 50 wide, 35 tall
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal 5, ov.left
+      assert_equal 10, ov.top
+      assert_equal 25, ov.radius
+      assert_equal 50, ov.width
+      assert_equal 35, ov.height
+    SHOES_SPEC
+  end
+
+  def test_simple_oval_keyword_values
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        oval left: 5, top: 10, radius: 25
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal 5, ov.left
+      assert_equal 10, ov.top
+      assert_equal 25, ov.radius
+      assert_equal 50, ov.height
+      assert_equal 50, ov.width
+    SHOES_SPEC
+  end
+
+  def test_oval_keywords_with_height_but_no_radius
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        oval left: 5, top: 10, height: 25
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal 5, ov.left
+      assert_equal 10, ov.top
+      assert_equal 12, ov.radius
+      assert_equal 25, ov.height
+      assert_equal 25, ov.width
+    SHOES_SPEC
+  end
+
+  def test_oval_strokewidth
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        strokewidth 3
+        oval 5, 10, 25
+      end
+    SHOES_APP
+      ov = oval()
+      assert_equal 5, ov.left
+      assert_equal 10, ov.top
+      assert_equal 25, ov.radius
+      assert_equal 3, ov.draw_context["strokewidth"]
+      # assert_equal 3, ov.strokewidth # This should work but doesn't yet, see issue #476
+    SHOES_SPEC
+  end
+end

data/lacci/test/test_parenting.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestParenting < NienteTest
+  def test_simple_button
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        button "OK"
+      end
+    SHOES_APP
+      # Test that Lacci has set parents properly
+      doc_root = button().parent
+      assert_equal Shoes::DocumentRoot, doc_root.class
+      assert_equal [button().obj], doc_root.contents
+
+      # Test that Niente has set parents properly
+      assert_equal "DocumentRoot", button().display.parent.shoes_type
+    SHOES_SPEC
+  end
+
+  def test_button_in_stack
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        stack do
+          button "OK"
+        end
+      end
+    SHOES_APP
+      # Test that Lacci has set parents properly
+      assert_equal Shoes::DocumentRoot, stack().parent.class
+      assert_equal Shoes::Stack, button().parent.class
+      assert_equal [button().obj], stack().contents
+
+      # Test that Niente has set parents properly
+      assert_equal "DocumentRoot", stack().display.parent.shoes_type
+      assert_equal "Stack", button().display.parent.shoes_type
+      assert_equal [button().display], stack().display.children
+    SHOES_SPEC
+  end
+
+  # We had a bug with this. It wasn't setting @children properly.
+  def test_clear_with_no_contents
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        @s = stack do
+        end
+        button "Clear" do
+          @s.clear do
+            para "cleared"
+          end
+        end
+      end
+    SHOES_APP
+      button().trigger_click
+      assert_equal "cleared", para.text
+    SHOES_SPEC
+  end
+
+  def test_stack_clear
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        @s = stack do
+          @p = para "Here"
+        end
+        button "Clear" do
+          @s.clear
+        end
+      end
+    SHOES_APP
+      button.trigger_click
+      assert_equal [], stack.contents
+    SHOES_SPEC
+  end
+
+  def test_drawable_remove
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        @s = stack do
+          @p = para "Here"
+        end
+        button "Clear" do
+          @p.remove
+        end
+      end
+    SHOES_APP
+      p = para # grab it while it's still there
+      button.trigger_click
+      assert_equal [], stack.contents
+      assert_nil p.parent
+    SHOES_SPEC
+  end
+
+  # I don't think Shoes does this. We have to use Lacci-specific methods.
+  # It's still good to have a test for it.
+  def test_drawable_reparent
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        @s1 = stack do
+          @p = para "Move me"
+        end
+
+        @s2 = stack do
+        end
+
+        button "Move It!" do
+          @p.set_parent(@s2)
+        end
+      end
+    SHOES_APP
+      button.trigger_click
+
+      # Check parents in Lacci
+      assert_equal [], stack("@s1").contents
+      assert_equal stack("@s2").obj, para.parent
+      assert_equal [para.obj], stack("@s2").contents
+
+      # Check parents in Niente
+      assert_equal [], stack("@s1").display.children
+      assert_equal stack("@s2").display, para.display.parent
+      assert_equal [para.display], stack("@s2").display.children
+    SHOES_SPEC
+  end
+
+  def test_add_to_non_current_slot
+    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+      Shoes.app do
+        @s = stack do
+        end
+        button "Add a Button" do
+          @ok_button = @s.button "OK"
+        end
+      end
+    SHOES_APP
+      button.trigger_click
+      assert_equal [button("@ok_button").obj], stack.contents
+      assert_equal stack.obj, button("@ok_button").parent
+    SHOES_SPEC
+  end
+end

data/lacci/test/test_shoes_errors.rb

@@ -17,19 +17,21 @@ class TestShoesErrors < NienteTest
     SHOES_SPEC
   end
 
-  def test_too_many_instances_error
-    run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
-    $ruby_main = self
-    Shoes.app do
-    end
-    SHOES_APP
-    assert_raises Shoes::Errors::TooManyInstancesError do
-      $ruby_main.instance_eval do
-        Shoes.app {}
-      end
-    end
-    SHOES_SPEC
-  end
+  # Niente can no longer test the TooManyInstancesError because it now
+  # supports multiple Shoes apps.
+  #def test_too_many_instances_error
+  #  run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)
+  #  $ruby_main = self
+  #  Shoes.app do
+  #  end
+  #  SHOES_APP
+  #  assert_raises Shoes::Errors::TooManyInstancesError do
+  #    $ruby_main.instance_eval do
+  #      Shoes.app {}
+  #    end
+  #  end
+  #  SHOES_SPEC
+  #end
 
   def test_drawables_found_errors
     run_test_niente_code(<<~SHOES_APP, app_test_code: <<~SHOES_SPEC)

data/lacci/test/test_text_drawables.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestTextDrawables < NienteTest
+  def test_simple_button
+    run_test_niente_code(<<~'SHOES_APP', app_test_code: <<~'SHOES_SPEC')
+      Shoes.app do
+        para "These are ", em("emphatically"), " ", strong("strongly"), " text drawables!"
+      end
+    SHOES_APP
+      assert_equal "These are emphatically strongly text drawables!", para.text
+
+      # Test that Lacci has set parents properly
+      assert_equal Shoes::DocumentRoot, para.parent.class
+      assert_equal [Shoes::Para], para.parent.contents.map(&:class)
+
+      # Test that Niente has set parents properly
+      assert_equal "DocumentRoot", para().display.parent.shoes_type
+      assert_equal ["Para"], document_root.display.children.map(&:shoes_type), "Doc root should have only para as a child!"
+    SHOES_SPEC
+  end
+end

data/lib/scarpe/assets.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "scarpe/components/asset_server"
+
+module Scarpe::Webview
+  def self.asset_server
+    return @asset_server if @asset_server
+
+    # A Scarpe Webview application can have only a single Shoes::App instance.
+    @asset_server = Scarpe::Components::AssetServer.new app_dir: Shoes.APPS[0].dir
+
+    # at_exit doesn't work reliably under webview. Give this a try.
+    ::Scarpe::Webview::DisplayService.instance.control_interface.on_event(:shutdown) do
+      @asset_server&.kill_server
+    end
+
+    @asset_server
+  end
+end

data/lib/scarpe/cats_cradle.rb

@@ -1,76 +1,15 @@
 # frozen_string_literal: true
 
 require "scarpe/components/unit_test_helpers"
-require "scarpe/evented_assertions"
 
 require "fiber"
 
-module Scarpe::Test
-  # We'd like something we can call Shoes drawable methods on, such as para.replace.
-  # But we'd also like to be able to grab the corresponding display drawable and
-  # call some of *those* methods.
-  class CCProxy
-    attr_reader :display
-    attr_reader :obj
-
-    def initialize(obj)
-      @obj = obj
-      # TODO: how to do this with Webview relay? Proxy object to send a message, maybe?
-      @display = ::Shoes::DisplayService.display_service.query_display_drawable_for(obj.linkable_id)
-    end
-
-    def method_missing(method, ...)
-      if @obj.respond_to?(method)
-        self.singleton_class.define_method(method) do |*args, **kwargs, &block|
-          @obj.send(method, *args, **kwargs, &block)
-        end
-        send(method, ...)
-      else
-        super # raise an exception
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      @obj.respond_to_missing?(method_name, include_private)
-    end
-
-    def trigger(event_name, *args)
-      name = "#{@obj.linkable_id}-#{event_name}"
-      Scarpe::Webview::DisplayService.instance.app.handle_callback(name, *args)
-    end
-
-    [:click, :hover, :leave, :change].each do |ev|
-      define_method "trigger_#{ev}" do |*args|
-        trigger(ev, *args)
-      end
-    end
-  end
-
-  module DrawableFinders
-    # What to do about TextDrawables? Link, code, em, strong?
-    # Also, wait, what's up with span? What *is* that?
-    Shoes::Drawable.drawable_classes.each do |drawable_class|
-      finder_name = drawable_class.dsl_name
-
-      define_method(finder_name) do |*args|
-        app = Shoes::App.instance
-
-        drawables = app.find_drawables_by(drawable_class, *args)
-        raise Shoes::Errors::MultipleDrawablesFoundError, "Found more than one #{finder_name} matching #{args.inspect}!" if drawables.size > 1
-        raise Shoes::Errors::NoDrawablesFoundError, "Found no #{finder_name} matching #{args.inspect}!" if drawables.empty?
-
-        CCProxy.new(drawables[0])
-      end
-    end
-  end
-
+module Scarpe
   # This class defines the CatsCradle DSL. It also holds a "bag of fibers"
   # with promises for when they should next resume.
   class CCInstance
     include Shoes::Log
-    include Scarpe::Test::EventedAssertions
     include Scarpe::Test::Helpers
-    include Scarpe::Test::DrawableFinders
 
     def self.instance
       @instance ||= CCInstance.new
@@ -79,18 +18,19 @@ module Scarpe::Test
     def initialize
       log_init("CatsCradle")
 
-      evented_assertions_initialize
-
       @waiting_fibers = []
       @event_promises = {}
+      @shutdown = false
 
       @manager_fiber = Fiber.new do
+        Fiber[:catscradle] = true
+
         loop do
           # A fiber can run briefly and then exit. It can run and then block on an API call.
           # These fibers return promises to indicate to CatsCradle when they can run again.
           # A fiber that is no longer #alive? is assumed to be successfully finished.
           @waiting_fibers.each do |fiber_data|
-            next unless fiber_data[:promise].fulfilled?
+            next if !fiber_data[:promise].fulfilled? || !fiber_data[:fiber].alive? || @shutdown
 
             @log.debug("Resuming fiber with value #{fiber_data[:promise].returned_value.inspect}")
             result = fiber_data[:fiber].transfer fiber_data[:promise].returned_value
@@ -117,6 +57,17 @@ module Scarpe::Test
       end
     end
 
+    private
+
+    def cc_fiber(&block)
+      Fiber.new do
+        Fiber[:catscradle] = true
+        CCInstance.instance.instance_eval(&block)
+      end
+    end
+
+    public
+
     # If we add "every" events, that's likely to complicate timing and event_promise handling.
     EVENT_TYPES = [:init, :next_heartbeat, :next_redraw, :every_heartbeat, :every_redraw]
 
@@ -140,9 +91,16 @@ module Scarpe::Test
           p = @event_promises.delete(:every_heartbeat)
           p&.fulfilled!
 
+          # Reschedule on_every_heartbeat fibers for next heartbeat, too.
+          # This fiber won't be called again by a heartbeat, though it may
+          # continue if it waits on another promise.
+          @waiting_fibers.select { |f| f[:on_event] == :every_heartbeat }.each do |f|
+            on_event(:every_heartbeat, &f[:block])
+          end
+
           # Give every ready fiber a chance to run once.
-          @manager_fiber.resume
-        end
+          @manager_fiber.resume unless @shutdown
+        end unless @shutdown
       end
 
       @control_interface.on_event(:every_redraw) do
@@ -153,42 +111,38 @@ module Scarpe::Test
           p = @event_promises.delete(:every_redraw)
           p&.fulfilled!
 
+          # Reschedule on_every_redraw fibers for next redraw, too.
+          @waiting_fibers.select { |f| f[:on_event] == :every_redraw }.each do |f|
+            on_event(:every_redraw, &f[:block])
+          end
+
           # Give every ready fiber a chance to run once.
-          @manager_fiber.resume
-        end
+          @manager_fiber.resume unless @shutdown
+        end unless @shutdown
       end
     end
 
+    def fiber_start
+      @manager_fiber.resume unless @shutdown
+    end
+
     def event_promise(event)
       @event_promises[event] ||= ::Scarpe::Promise.new
     end
 
     def on_event(event, &block)
       raise Scarpe::UnknownEventTypeError, "Unknown event type: #{event.inspect}!" unless EVENT_TYPES.include?(event)
+      return if @shutdown
 
-      f = Fiber.new do
-        CCInstance.instance.instance_eval(&block)
-      end
-      @waiting_fibers << { promise: event_promise(event), fiber: f }
+      @waiting_fibers << { promise: event_promise(event), fiber: cc_fiber(&block), on_event: event, block: }
     end
 
-    def proxy_for(shoes_drawable)
-      CCProxy.new(shoes_drawable)
-    end
+    def active_fiber(&block)
+      return if @shutdown
 
-    def die_after(time)
-      t_start = Time.now
-      @die_after = [t_start, time]
-
-      @wrangler.periodic_code("scarpeTestTimeout") do |*_args|
-        t_delta = (Time.now - t_start).to_f
-        if t_delta > time
-          @did_time_out = true
-          @log.warn("die_after - timed out after #{t_delta.inspect} (threshold: #{time.inspect})")
-          return_results(false, "Timed out!")
-          ::Shoes::DisplayService.dispatch_event("destroy", nil)
-        end
-      end
+      p = ::Scarpe::Promise.new
+      p.fulfilled!
+      @waiting_fibers << { promise: p, fiber: cc_fiber(&block), on_event: nil, block: }
     end
 
     def wait(promise)
@@ -198,6 +152,12 @@ module Scarpe::Test
       @manager_fiber.transfer(promise)
     end
 
+    def yield
+      p = ::Scarpe::Promise.new
+      p.fulfilled!
+      @manager_fiber.transfer(p)
+    end
+
     # This returns a promise, which can be waited on using wait()
     def fully_updated
       @wrangler.promise_dom_fully_updated
@@ -218,13 +178,12 @@ module Scarpe::Test
       @wrangler.eval_js_async(js_code, timeout:)
     end
 
-    def test_finished(return_results: true)
-      return_assertion_data if return_results
-
-      ::Shoes::DisplayService.dispatch_event("destroy", nil)
-    end
+    def shut_down_shoes_code
+      if @shutdown
+        exit 0
+      end
 
-    def test_finished_no_results
+      @shutdown = true
       ::Shoes::DisplayService.dispatch_event("destroy", nil)
     end
   end
@@ -232,8 +191,8 @@ module Scarpe::Test
   # "Cat's Cradle" is a children's game where they interlace string between
   # their fingers to make beautiful complicated shapes. The interlacing
   # of fibers made it a good name for a prototype.
-
-  # An attempt at an experimental Fiber-based testing system to deal with
+  #
+  # An attempt at an experimental Fiber-based control-flow system to deal with
   # Shoes, Display and JS all at the same time.
   #
   # In general, we'll use Fiber.transfer to bounce control back and forth
@@ -243,7 +202,7 @@ module Scarpe::Test
   #
   # Ruby Fiber basic docs: https://ruby-doc.org/core-3.0.0/Fiber.html
   #
-  # This module is mixed into a test object if we're running CatsCradle-based tests
+  # This module is mixed into an object to coordinate fibers app-wide.
   module CatsCradle
     attr_reader :cc_instance