scarpe 0.2.2 → 0.4.0

data/lib/scarpe/cats_cradle.rb

@@ -1,45 +1,14 @@
 # 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 widget methods on, such as para.replace.
-  # But we'd also like to be able to grab the corresponding display widget 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_widget_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
-  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
 
     def self.instance
@@ -49,20 +18,19 @@ module Scarpe::Test
     def initialize
       log_init("CatsCradle")
 
-      @assertion_data = []
-      @assertions_passed = 0
-      @assertions_failed = []
-
       @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
@@ -74,7 +42,7 @@ module Scarpe::Test
             when ::Scarpe::Promise
               fiber_data[:promise] = result
             else
-              raise "Unexpected object returned from Fiber#transfer for still-living Fiber! #{result.inspect}"
+              raise Scarpe::UnexpectedFiberTransferError, "Unexpected object returned from Fiber#transfer for still-living Fiber! #{result.inspect}"
             end
           end
 
@@ -89,8 +57,19 @@ 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 = [:next_heartbeat, :next_redraw]
+    EVENT_TYPES = [:init, :next_heartbeat, :next_redraw, :every_heartbeat, :every_redraw]
 
     # This needs to be called after the basic display service objects exist
     # and we can find the control interface.
@@ -109,9 +88,19 @@ module Scarpe::Test
           p = @event_promises.delete(:next_heartbeat)
           p&.fulfilled!
 
+          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
@@ -119,52 +108,56 @@ module Scarpe::Test
           p = @event_promises.delete(:next_redraw)
           p&.fulfilled!
 
+          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 "Unknown event type: #{event.inspect}!" unless EVENT_TYPES.include?(event)
+      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
 
-    # What to do about TextWidgets? Link, code, em, strong?
-    # Also, wait, what's up with span? What *is* that?
-    Shoes::Widget.widget_classes.each do |widget_class|
-      finder_name = widget_class.dsl_name
-
-      define_method(finder_name) do |*args|
-        app = Shoes::App.instance
-
-        widgets = app.find_widgets_by(widget_class, *args)
-        raise "Found more than one #{finder_name} matching #{args.inspect}!" if widgets.size > 1
-        raise "Found no #{finder_name} matching #{args.inspect}!" if widgets.empty?
-
-        CCProxy.new(widgets[0])
-      end
-    end
+    def active_fiber(&block)
+      return if @shutdown
 
-    def proxy_for(shoes_widget)
-      CCProxy.new(shoes_widget)
+      p = ::Scarpe::Promise.new
+      p.fulfilled!
+      @waiting_fibers << { promise: p, fiber: cc_fiber(&block), on_event: nil, block: }
     end
 
     def wait(promise)
-      raise("Must supply a promise to wait!") unless promise.is_a?(::Scarpe::Promise)
+      raise(Scarpe::InvalidPromiseError, "Must supply a promise to wait!") unless promise.is_a?(::Scarpe::Promise)
 
       # Wait until this promise is complete before running again
       @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
@@ -181,42 +174,16 @@ module Scarpe::Test
       @manager_fiber.transfer(js_promise)
     end
 
-    def assert(value, msg = nil)
-      msg ||= "Assertion #{value ? "succeeded" : "failed"}"
-      @assertion_data << [value ? true : false, msg]
-      if value
-        @assertions_passed += 1
-      else
-        @assertions_failed << msg
-      end
-    end
-
-    def assert_equal(expected, actual, msg = nil)
-      msg ||= "Expected #{actual.inspect} to equal #{expected.inspect}!"
-      assert actual == expected, msg
+    def query_js_promise(js_code, timeout: 1.0)
+      @wrangler.eval_js_async(js_code, timeout:)
     end
 
-    def assertion_data_as_a_struct
-      {
-        still_pending: 0,
-        succeeded: @assertions_passed,
-        failed: @assertions_failed.size,
-        failures: @assertions_failed,
-      }
-    end
-
-    def test_metadata
-      {}
-    end
-
-    def test_finished
-      if !@assertions_failed.empty?
-        return_results(false, "Assertions failed", assertion_data_as_a_struct)
-      elsif @assertions_passed > 0
-        return_results(true, "All assertions passed", assertion_data_as_a_struct)
-      else
-        return_results(true, "Test finished successfully")
+    def shut_down_shoes_code
+      if @shutdown
+        exit 0
       end
+
+      @shutdown = true
       ::Shoes::DisplayService.dispatch_event("destroy", nil)
     end
   end
@@ -224,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
@@ -235,15 +202,29 @@ module Scarpe::Test
   #
   # Ruby Fiber basic docs: https://ruby-doc.org/core-3.0.0/Fiber.html
   #
-  # This module is mixed into Shoes::App 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
+
     def event_init
-      @cc_instance = CCInstance.instance
+      @cc_instance ||= CCInstance.instance
       @cc_instance.event_init
     end
 
     def on_heartbeat(&block)
       @cc_instance.on_event(:next_heartbeat, &block)
     end
+
+    def on_every_heartbeat(&block)
+      @cc_instance.on_event(:every_heartbeat, &block)
+    end
+
+    def on_init(&block)
+      @cc_instance.on_event(:init, &block)
+    end
+
+    def on_next_redraw(&block)
+      @cc_instance.on_event(:next_redraw, &block)
+    end
   end
 end

data/lib/scarpe/errors.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Scarpe
+  class UnknownShoesEventAPIError < Scarpe::Error; end
+
+  class UnknownShapeCommandError < Scarpe::Error; end
+
+  class UnknownBuiltinCommandError < Scarpe::Error; end
+
+  class UnknownEventTypeError < Scarpe::Error; end
+
+  class UnexpectedFiberTransferError < Scarpe::Error; end
+
+  class InvalidPromiseError < Scarpe::Error; end
+
+  class MissingAppError < Scarpe::Error; end
+
+  class MissingDocRootError < Scarpe::Error; end
+
+  class MissingWranglerError < Scarpe::Error; end
+
+  class IllegalSubscribeEventError < Scarpe::Error; end
+
+  class IllegalDispatchEventError < Scarpe::Error; end
+
+  class MissingBlockError < Scarpe::Error; end
+
+  class DuplicateCallbackError < Scarpe::Error; end
+
+  class JSBindingError < Scarpe::Error; end
+
+  class JSInitError < Scarpe::Error; end
+
+  class PeriodicHandlerSetupError < Scarpe::Error; end
+
+  class WebWranglerNotRunningError < Scarpe::Error; end
+
+  class NonexistentEvalResultError < Scarpe::Error; end
+
+  class JSRedrawError < Scarpe::Error; end
+
+  class ConnectionError < Scarpe::Error; end
+
+  class DatagramSendError < Scarpe::Error; end
+
+  class InvalidOperationError < Scarpe::Error; end
+
+  class MissingAttributeError < Scarpe::Error; end
+
+  # This error indicates a problem when running ConfirmedEval
+  class JSEvalError < Scarpe::Error
+    def initialize(data)
+      @data = data
+      super(data[:msg] || (self.class.name + "!"))
+    end
+  end
+
+  # An error running the supplied JS code string in confirmed_eval
+  class JSRuntimeError < JSEvalError; end
+
+  # The code timed out for some reason
+  class JSTimeoutError < JSEvalError; end
+
+  # We got weird or nonsensical results that seem like an error on WebWrangler's part
+  class JSInternalError < JSEvalError; end
+
+  # An error occurred which would normally be handled by shutting down the app
+  class AppShutdownError < Scarpe::Error; end
+
+  class InvalidClassError < Scarpe::Error; end
+
+  class MissingClassError < Scarpe::Error; end
+
+  class EmptyPageNotSetError < Scarpe::Error; end
+
+  class BadDisplayClassType < Scarpe::Error; end
+end

data/lib/scarpe/shoes_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "scarpe/cats_cradle"
+require "scarpe/components/string_helpers"
+
+require "scarpe/components/unit_test_helpers"
+
+# Test framework code to allow Scarpe to execute Shoes-Spec test code.
+# This will run inside the exe/scarpe child process, then send
+# results back to the parent Minitest process.
+
+module Scarpe::Test
+  # Is it at all reasonable to define more than one test to run in the same Shoes run? Probably not.
+  # They'll leave in-memory residue.
+  def self.run_shoes_spec_test_code(code, class_name: nil, test_name: nil)
+    if @shoes_spec_init
+      raise Shoes::Errors::MultipleShoesSpecRunsError, "Scarpe-Webview can only run a single Shoes spec per process!"
+    end
+
+    @shoes_spec_init = true
+
+    require "scarpe/components/minitest_export_reporter"
+    Minitest::Reporters::ShoesExportReporter.activate!
+
+    class_name ||= ENV["SHOES_MINITEST_CLASS_NAME"] || "TestShoesSpecCode"
+    test_name ||= ENV["SHOES_MINITEST_METHOD_NAME"] || "test_shoes_spec"
+
+    Scarpe::CCInstance.include Scarpe::ShoesSpecTest
+
+    Scarpe::CCInstance.instance.instance_eval do
+      event_init
+
+      t_timeout = ENV["SCARPE_SSPEC_TIMEOUT"] || "30"
+      timeout(t_timeout.to_f) unless t_timeout.downcase == "none"
+
+      on_event(:next_heartbeat) do
+        Minitest.run ARGV
+
+        wait_after = ENV["SCARPE_SSPEC_TIMEOUT_WAIT_AFTER_TEST"]
+        if !(wait_after && wait_after.downcase != "n" && wait_after.downcase != "no")
+          shut_down_shoes_code
+        end
+      end
+    end
+
+    test_class = Class.new(Minitest::Test)
+    test_class.include Scarpe::ShoesSpecTest
+    Object.const_set(Scarpe::Components::StringHelpers.camelize(class_name), test_class)
+    test_name = "test_" + test_name unless test_name.start_with?("test_")
+    test_class.define_method(test_name) do
+      eval(code)
+    end
+  end
+end
+
+class Scarpe::ShoesSpecProxy
+  attr_reader :obj
+  attr_reader :linkable_id
+  attr_reader :display
+
+  JS_EVENTS = [:click, :hover, :leave, :change]
+
+  def initialize(obj)
+    @obj = obj
+    @linkable_id = obj.linkable_id
+    @display = ::Shoes::DisplayService.display_service.query_display_drawable_for(obj.linkable_id)
+
+    unless @display
+      raise "Can't find display widget for #{obj.inspect}!"
+    end
+  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 trigger(event_name, *args)
+    name = "#{@linkable_id}-#{event_name}"
+    Scarpe::Webview::DisplayService.instance.app.handle_callback(name, *args)
+  end
+
+  JS_EVENTS.each do |ev|
+    define_method "trigger_#{ev}" do |*args|
+      trigger(ev, *args)
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @obj.respond_to_missing?(method_name, include_private)
+  end
+end
+
+# When running ShoesSpec tests, we create a parent class for all of them
+# with the appropriate convenience methods and accessors.
+module Scarpe::ShoesSpecTest
+  include Scarpe::Test::HTMLAssertions
+
+  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?
+
+      Scarpe::ShoesSpecProxy.new(drawables[0])
+    end
+  end
+  def drawable(*specs)
+    drawables = app.find_drawables_by(*specs)
+    raise Scarpe::MultipleDrawablesFoundError, "Found more than one #{finder_name} matching #{args.inspect}!" if drawables.size > 1
+    raise Scarpe::NoDrawablesFoundError, "Found no #{finder_name} matching #{args.inspect}!" if drawables.empty?
+
+    Scarpe::ShoesSpecProxy.new(drawables[0])
+  end
+
+  def catscradle_dsl(&block)
+    Scarpe::CCInstance.instance.instance_eval(&block)
+  end
+
+  def dom_html
+    catscradle_dsl do
+      wait fully_updated
+      dom_html
+    end
+  end
+
+  # A timeout won't cause an error by itself. If you want an error, make sure
+  # to check for a minimum number of assertions or otherwise look for progress.
+  def timeout(t_timeout = 5.0)
+    catscradle_dsl do
+      t0 = Time.now
+      on_event(:every_heartbeat) do
+        if Time.now - t0 >= t_timeout
+          @log.info "Timed out after #{t_timeout} seconds!"
+          shut_down_shoes_code
+        end
+      end
+    end
+  end
+
+  def exit_on_first_heartbeat
+    catscradle_dsl do
+      on_event(:next_heartbeat) do
+        @log.info "Exiting on first heartbeat (exit code #{exit_code})"
+        exit 0
+      end
+    end
+  end
+end

data/lib/scarpe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class Scarpe
-  VERSION = "0.2.2"
+module Scarpe
+  VERSION = "0.4.0"
 end

data/lib/scarpe/wv/app.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-class Scarpe
-  # Scarpe::WebviewApp must only be used from the main thread, due to GTK+ limitations.
-  class WebviewApp < WebviewWidget
+module Scarpe::Webview
+  # Scarpe::Webview::App must only be used from the main thread, due to GTK+ limitations.
+  class App < Drawable # App inherits from Drawable to set up linkable IDs and event methods
     attr_reader :control_interface
 
     attr_writer :shoes_linkable_id
@@ -10,22 +10,16 @@ class Scarpe
     def initialize(properties)
       super
 
-      # It's possible to provide a Ruby script by setting
-      # SCARPE_TEST_CONTROL to its file path. This can
-      # allow pre-setting test options or otherwise
-      # performing additional actions not written into
-      # the Shoes app itself.
-      #
-      # The control interface is what lets these files see
-      # events, specify overrides and so on.
+      # Scarpe's ControlInterface sets up event handlers
+      # for the display service that aren't sent to
+      # Lacci (Shoes). In general it's used for setup
+      # and additional control or testing, outside the
+      # Shoes app. This is how CatsCradle and Shoes-Spec
+      # set up testing, for instance.
       @control_interface = ControlInterface.new
-      if ENV["SCARPE_TEST_CONTROL"]
-        require "scarpe/components/unit_test_helpers"
-        @control_interface.instance_eval File.read(ENV["SCARPE_TEST_CONTROL"])
-      end
 
       # TODO: rename @view
-      @view = Scarpe::WebWrangler.new title: @title,
+      @view = Scarpe::Webview::WebWrangler.new title: @title,
         width: @width,
         height: @height,
         resizable: @resizable
@@ -61,8 +55,11 @@ class Scarpe
     end
 
     def run
+      # This is run before the Webview event loop is up and running
       @control_interface.dispatch_event(:init)
 
+      @view.empty_page = empty_page_element
+
       # This takes control of the main thread and never returns. And it *must* be run from
       # the main thread. And it stops any Ruby background threads.
       # That's totally cool and normal, right?
@@ -80,14 +77,18 @@ class Scarpe
       end
     end
 
-    # All JS callbacks to Scarpe widgets are dispatched
+    # All JS callbacks to Scarpe drawables are dispatched
     # via this handler
     def handle_callback(name, *args)
-      @callbacks[name].call(*args)
+      if @callbacks.key?(name)
+        @callbacks[name].call(*args)
+      else
+        raise Scarpe::UnknownEventTypeError, "No such Webview callback: #{name.inspect}!"
+      end
     end
 
     # Bind a Scarpe callback name; see handle_callback above.
-    # See Scarpe::Widget for how the naming is set up
+    # See Scarpe::Drawable for how the naming is set up
     def bind(name, &block)
       @callbacks[name] = block
     end
@@ -97,7 +98,7 @@ class Scarpe
     #
     # @return [void]
     def request_redraw!
-      wrangler = WebviewDisplayService.instance.wrangler
+      wrangler = DisplayService.instance.wrangler
       if wrangler.is_running
         wrangler.replace(@document_root.to_html)
       end

data/lib/scarpe/wv/arc.rb

@@ -1,56 +1,9 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class WebviewArc < Scarpe::WebviewWidget
-    def initialize(properties)
-      super(properties)
-    end
-
-    def element(&block)
-      HTML.render do |h|
-        h.div(id: html_id, style: style) do
-          h.svg(width: @width, height: @height) do
-            h.path(d: arc_path)
-          end
-          block.call(h) if block_given?
-        end
-      end
-    end
-
-    protected
-
-    def style
-      super.merge({
-        left: "#{@left}px",
-        top: "#{@top}px",
-        width: "#{@width}px",
-        height: "#{@height}px",
-      })
-    end
-
-    private
-
-    def arc_path
-      center_x = @width / 2
-      center_y = @height / 2
-      radius_x = @width / 2
-      radius_y = @height / 2
-      start_angle_degrees = radians_to_degrees(@angle1) % 360
-      end_angle_degrees = radians_to_degrees(@angle2) % 360
-      large_arc_flag = (end_angle_degrees - start_angle_degrees) % 360 > 180 ? 1 : 0
-
-      "M#{center_x} #{center_y} L#{@width} #{center_y} " \
-        "A#{radius_x} #{radius_y} 0 #{large_arc_flag} 0 " \
-        "#{center_x + radius_x * Math.cos(degrees_to_radians(end_angle_degrees))} " \
-        "#{center_y + radius_y * Math.sin(degrees_to_radians(end_angle_degrees))} Z"
-    end
-
-    def degrees_to_radians(degrees)
-      degrees * Math::PI / 180
-    end
-
-    def radians_to_degrees(radians)
-      radians * (180.0 / Math::PI)
+module Scarpe::Webview
+  class Arc < Drawable
+    def element
+      render("arc")
     end
   end
 end

data/lib/scarpe/wv/arrow.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Scarpe::Webview
+  class Arrow < Drawable
+    def element
+      render("arrow")
+    end
+  end
+end