scarpe 0.2.1 → 0.2.2

data/lib/scarpe/cats_cradle.rb

@@ -0,0 +1,249 @@
+# 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
+
+  # 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
+      @instance ||= CCInstance.new
+    end
+
+    def initialize
+      log_init("CatsCradle")
+
+      @assertion_data = []
+      @assertions_passed = 0
+      @assertions_failed = []
+
+      @waiting_fibers = []
+      @event_promises = {}
+
+      @manager_fiber = Fiber.new do
+        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?
+
+            @log.debug("Resuming fiber with value #{fiber_data[:promise].returned_value.inspect}")
+            result = fiber_data[:fiber].transfer fiber_data[:promise].returned_value
+
+            # Dead fibers will be removed later, just leave it
+            next unless fiber_data[:fiber].alive?
+
+            case result
+            when ::Scarpe::Promise
+              fiber_data[:promise] = result
+            else
+              raise "Unexpected object returned from Fiber#transfer for still-living Fiber! #{result.inspect}"
+            end
+          end
+
+          # Throw out dead fibers or those that will never wake
+          @waiting_fibers.select! do |fiber_data|
+            fiber_data[:fiber].alive? && !fiber_data[:promise].rejected?
+          end
+
+          # Done with this iteration
+          Fiber.yield
+        end
+      end
+    end
+
+    # If we add "every" events, that's likely to complicate timing and event_promise handling.
+    EVENT_TYPES = [:next_heartbeat, :next_redraw]
+
+    # This needs to be called after the basic display service objects exist
+    # and we can find the control interface.
+    def event_init
+      return if @cc_init_done
+
+      @cc_init_done = true
+
+      @control_interface = ::Shoes::DisplayService.display_service.control_interface
+      @wrangler = @control_interface.wrangler
+
+      cc_instance = self # ControlInterface#on_event does an instance eval. We'll reset self with another.
+
+      @control_interface.on_event(:every_heartbeat) do
+        cc_instance.instance_eval do
+          p = @event_promises.delete(:next_heartbeat)
+          p&.fulfilled!
+
+          # Give every ready fiber a chance to run once.
+          @manager_fiber.resume
+        end
+      end
+
+      @control_interface.on_event(:every_redraw) do
+        cc_instance.instance_eval do
+          p = @event_promises.delete(:next_redraw)
+          p&.fulfilled!
+
+          # Give every ready fiber a chance to run once.
+          @manager_fiber.resume
+        end
+      end
+    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)
+
+      f = Fiber.new do
+        CCInstance.instance.instance_eval(&block)
+      end
+      @waiting_fibers << { promise: event_promise(event), fiber: f }
+    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 proxy_for(shoes_widget)
+      CCProxy.new(shoes_widget)
+    end
+
+    def wait(promise)
+      raise("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
+
+    # This returns a promise, which can be waited on using wait()
+    def fully_updated
+      @wrangler.promise_dom_fully_updated
+    end
+
+    def dom_html(timeout: 1.0)
+      query_js_value("document.getElementById('wrapper-wvroot').innerHTML", timeout:)
+    end
+
+    def query_js_value(js_code, timeout: 1.0)
+      js_promise = @wrangler.eval_js_async(js_code, timeout:)
+
+      # This promise will return the string, so we can just pass it to #transfer
+      @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
+    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")
+      end
+      ::Shoes::DisplayService.dispatch_event("destroy", nil)
+    end
+  end
+
+  # "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
+  # Shoes, Display and JS all at the same time.
+  #
+  # In general, we'll use Fiber.transfer to bounce control back and forth
+  # between the evented implementations (e.g. waiting for redraw) that
+  # need to return control to Webview, and the procedural test flows
+  # that look far better if we don't do that explicitly.
+  #
+  # 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
+  module CatsCradle
+    def event_init
+      @cc_instance = CCInstance.instance
+      @cc_instance.event_init
+    end
+
+    def on_heartbeat(&block)
+      @cc_instance.on_event(:next_heartbeat, &block)
+    end
+  end
+end

data/lib/scarpe/evented_assertions.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "json"
+require "fileutils"
+
+module Scarpe::Test; end
+
+# We need a separate assertion system for the kind of Scarpe
+# testing where we start a subprocess, perform the assertion
+# logic in the subprocess, and then run Minitest in the parent.
+# It's an unusual setup.
+module Scarpe::Test::EventedAssertions
+  # Assert that `text` includes `subtext`.
+  #
+  # @param text [String] the longer text
+  # @param subtext [String] the text that is asserted to be included
+  # @param msg [String,nil] if supplied, the failure message for the assertion
+  # @return [void]
+  def assert_include(text, subtext, msg = nil)
+    msg ||= "Expected #{text.inspect} to include #{subtext.inspect}"
+    assert text.include?(subtext), msg
+  end
+
+  # Assert that `text` does not include `subtext`.
+  #
+  # @param text [String] the longer text
+  # @param subtext [String] the text that is asserted to not be included
+  # @param msg [String,nil] if supplied, the failure message for the assertion
+  # @return [void]
+  def assert_not_include(text, subtext, msg = nil)
+    msg ||= "Expected #{text.inspect} not to include #{subtext.inspect}"
+    assert !text.include?(subtext), msg
+  end
+
+  # Assert that `actual_html` is the same as `expected_tag` with `opts`.
+  # This uses Scarpe's HTML tag-based renderer to render the tag and options
+  # into text, and valides that the text is the same.
+  #
+  # @see Scarpe::HTML.render
+  #
+  # @param actual_html [String] the html to compare to
+  # @param expected_tag [String,Symbol] the HTML tag, used to send a method call
+  # @param opts keyword options passed to the tag method call
+  # @yield block passed to the tag method call.
+  # @return [void]
+  def assert_html(actual_html, expected_tag, **opts, &block)
+    expected_html = Scarpe::HTML.render do |h|
+      h.public_send(expected_tag, opts, &block)
+    end
+
+    assert_equal expected_html, actual_html
+  end
+
+  # This does a final return of results. If it gets called
+  # multiple times, the test fails because that's not allowed.
+  #
+  # @param result_bool [Boolean] true if the results are success, false if failure
+  # @param msg [String] the message included with the results
+  # @param data [Hash] any additional data to pass with the results
+  # @return void
+  def return_results(result_bool, msg, data = {})
+    result_file = ENV["SCARPE_TEST_RESULTS"] || "./scarpe_results.txt"
+
+    result_structs = [result_bool, msg, data.merge(test_metadata)]
+    if File.exist?(result_file)
+      results_returned = JSON.parse File.read(result_file)
+    end
+
+    # Multiple different sets of results is bad, even if both are passing.
+    if results_returned && results_returned[0..1] != result_structs[0..1]
+      # Just raising here doesn't reliably fail the test.
+      # See: https://github.com/scarpe-team/scarpe/issues/212
+      Shoes::Log.logger("Test Results").error("Writing multi-result failure file to #{result_file.inspect}!")
+
+      new_res_data = { first_result: results_returned, second_result: result_structs }.merge(test_metadata)
+      bad_result = [false, "Returned two sets of results!", new_res_data]
+      File.write(result_file, JSON.pretty_generate(bad_result))
+
+      return
+    elsif results_returned
+      Shoes::Log.logger("Test Results").warn "Returning identical results twice: #{results_returned.inspect}"
+    end
+
+    Shoes::Log.logger("Test Results").debug("Writing results file #{result_file.inspect} to disk!")
+    File.write(result_file, JSON.pretty_generate(result_structs))
+  end
+end

data/lib/scarpe/version.rb

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

data/lib/scarpe/wv/alert.rb

@@ -23,8 +23,9 @@ class Scarpe
       end
     end
 
-    private
+    protected
 
+    # If the whole widget is hidden, the parent style adds display:none
     def overlay_style
       {
         position: "fixed",
@@ -38,7 +39,7 @@ class Scarpe
         display: "flex",
         "align-items": "center",
         "justify-content": "center",
-      }
+      }.merge(style)
     end
 
     def modal_style

data/lib/scarpe/wv/app.rb

@@ -3,15 +3,11 @@
 class Scarpe
   # Scarpe::WebviewApp must only be used from the main thread, due to GTK+ limitations.
   class WebviewApp < WebviewWidget
-    attr_reader :debug
     attr_reader :control_interface
 
     attr_writer :shoes_linkable_id
 
     def initialize(properties)
-      # Is this a thing? Do we care about this?
-      # opts = @control_interface.app_opts_get_override(opts)
-
       super
 
       # It's possible to provide a Ruby script by setting
@@ -24,6 +20,7 @@ class Scarpe
       # events, specify overrides and so on.
       @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
 
@@ -31,8 +28,9 @@ class Scarpe
       @view = Scarpe::WebWrangler.new title: @title,
         width: @width,
         height: @height,
-        resizable: @resizable,
-        debug: @debug
+        resizable: @resizable
+
+      @callbacks = {}
 
       # The control interface has to exist to get callbacks like "override Scarpe app opts".
       # But the Scarpe App needs those options to be created. So we can't pass these to
@@ -50,11 +48,11 @@ class Scarpe
       scarpe_app = self
 
       @view.init_code("scarpeInit") do
-        @document_root.request_redraw!
+        request_redraw!
       end
 
       @view.bind("scarpeHandler") do |*args|
-        @document_root.handle_callback(*args)
+        handle_callback(*args)
       end
 
       @view.bind("scarpeExit") do
@@ -81,5 +79,29 @@ class Scarpe
         @view = nil
       end
     end
+
+    # All JS callbacks to Scarpe widgets are dispatched
+    # via this handler
+    def handle_callback(name, *args)
+      @callbacks[name].call(*args)
+    end
+
+    # Bind a Scarpe callback name; see handle_callback above.
+    # See Scarpe::Widget for how the naming is set up
+    def bind(name, &block)
+      @callbacks[name] = block
+    end
+
+    # Request a full redraw if Webview is running. Otherwise
+    # this is a no-op.
+    #
+    # @return [void]
+    def request_redraw!
+      wrangler = WebviewDisplayService.instance.wrangler
+      if wrangler.is_running
+        wrangler.replace(@document_root.to_html)
+      end
+      nil
+    end
   end
 end

data/lib/scarpe/wv/arc.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "shape_helper"
-
 class Scarpe
   class WebviewArc < Scarpe::WebviewWidget
-    include ShapeHelper
     def initialize(properties)
       super(properties)
     end
@@ -20,17 +17,19 @@ class Scarpe
       end
     end
 
-    private
+    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

data/lib/scarpe/wv/background.rb

@@ -1,13 +1,22 @@
 # frozen_string_literal: true
 
+require "scarpe/components/base64"
+
 class Scarpe
   module WebviewBackground
+    include Components::Base64
+
     def style
       styles = (super if defined?(super)) || {}
       return styles unless @background_color
 
-      color = if @background_color.is_a?(Range)
+      color = case @background_color
+      when Array
+        "rgba(#{@background_color.join(", ")})"
+      when Range
         "linear-gradient(45deg, #{@background_color.first}, #{@background_color.last})"
+      when ->(value) { File.exist?(value) }
+        "url(data:image/png;base64,#{encode_file_to_base64(@background_color)})"
       else
         @background_color
       end

data/lib/scarpe/wv/border.rb

@@ -6,12 +6,14 @@ class Scarpe
       styles = (super if defined?(super)) || {}
       return styles unless @border_color
 
-      border_color = if @border_color.is_a?(Range)
-        { "border-image": "linear-gradient(45deg, #{@border_color.first}, #{@border_color.last}) 1" }
+      border_color = case @border_color
+      when Range
+        { "border-image": "linear-gradient(45deg, #{@border_color.first}, #{@border_color.last})" }
+      when Array
+        { "border-color": "rgba(#{@border_color.join(", ")})" }
       else
         { "border-color": @border_color }
       end
-
       styles.merge(
         "border-style": "solid",
         "border-width": "#{@options[:strokewidth] || 1}px",

data/lib/scarpe/wv/button.rb

@@ -20,24 +20,26 @@ class Scarpe
       end
     end
 
-    private
+    protected
 
     def style
-      styles = {}
-      styles["background-color"] = @color
-      styles["padding-top"] = @padding_top
-      styles["padding-bottom"] = @padding_bottom
+      styles = super
+
+      styles[:"background-color"] = @color
+      styles[:"padding-top"] = @padding_top
+      styles[:"padding-bottom"] = @padding_bottom
       styles[:color] = @text_color
       styles[:width] = Dimensions.length(@width) if @width
       styles[:height] = Dimensions.length(@height) if @height
-      styles["font-size"] = @font_size
+      styles[:"font-size"] = @font_size
 
       styles[:top] = Dimensions.length(@top) if @top
       styles[:left] = Dimensions.length(@left) if @left
       styles[:position] = "absolute" if @top || @left
-      styles["font-size"] = Dimensions.length(font_size) if @size
-      styles["font-family"] = @font if @font
-      styles["color"] = rgb_to_hex(@stroke) if @stroke
+      styles[:"font-size"] = Dimensions.length(font_size) if @size
+      styles[:"font-family"] = @font if @font
+      styles[:color] = rgb_to_hex(@stroke) if @stroke
+
       styles
     end
 

data/lib/scarpe/wv/check.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class WebviewCheck < Scarpe::WebviewWidget
+    attr_reader :text
+
+    def initialize(properties)
+      super
+
+      bind("click") do
+        send_self_event(event_name: "click", target: shoes_linkable_id)
+      end
+    end
+
+    def properties_changed(changes)
+      checked = changes.delete("checked")
+
+      html_element.toggle_input_button(checked)
+
+      super
+    end
+
+    def element
+      HTML.render do |h|
+        h.input(type: :checkbox, id: html_id, onclick: handler_js_code("click"), value: "hmm #{text}", checked: @checked, style:)
+      end
+    end
+  end
+end

data/lib/scarpe/wv/control_interface.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 # The ControlInterface is used for testing. It's a way to register interest
-# in important events like redraw, init and shutdown, and to override
-# test-relevant values like the options to Shoes.app(). Note that no part
-# of the Scarpe framework should ever *depend* on ControlInterface. It's
-# for testing, not normal operation. If no ControlInterface were ever
-# created or called, Scarpe apps should run fine with no modifications.
+# in important events like redraw, init and shutdown, and to configure a
+# Shoes app for testing. Note that no part of the Scarpe framework should
+# ever *depend* on ControlInterface. It's for testing, not normal operation.
+# If no ControlInterface were ever created or called, Scarpe apps should run
+# fine with no modifications.
 #
 # And if you depend on this from the framework, I'll add a check-mode that
 # never dispatches any events to any handlers. Do NOT test me on this.
 
 class Scarpe
   class ControlInterface
-    include Scarpe::Log
+    include Shoes::Log
 
     SUBSCRIBE_EVENTS = [:init, :shutdown, :next_redraw, :every_redraw, :next_heartbeat, :every_heartbeat]
     DISPATCH_EVENTS = [:init, :shutdown, :redraw, :heartbeat]
@@ -33,7 +33,7 @@ class Scarpe
       "<#ControlInterface>"
     end
 
-    # This should get called once, from Scarpe::App
+    # This should get called once, from Shoes::App
     def set_system_components(app:, doc_root:, wrangler:)
       unless app && wrangler
         @log.error("False app passed to set_system_components!") unless app
@@ -79,23 +79,17 @@ class Scarpe
     # The control interface has overrides for certain settings. If the override has been specified,
     # those settings will be overridden.
 
-    # Override the Shoes app opts like "debug:" and "die_after:" with new ones.
-    def override_app_opts(new_opts)
-      @new_app_opts = new_opts
-    end
-
-    # Called by Scarpe::App to get the override options
-    def app_opts_get_override(opts)
-      @new_app_opts || opts
-    end
-
     # On recognised events, this sets a handler for that event
     def on_event(event, &block)
       unless SUBSCRIBE_EVENTS.include?(event)
         raise "Illegal subscribe to event #{event.inspect}! Valid values are: #{SUBSCRIBE_EVENTS.inspect}"
       end
 
-      @event_handlers[event] << block
+      @unsub_id ||= 0
+      @unsub_id += 1
+
+      @event_handlers[event] << { handler: block, unsub: @unsub_id }
+      @unsub_id
     end
 
     # Send out the specified event
@@ -145,8 +139,8 @@ class Scarpe
     private
 
     def dumb_dispatch_event(event, *args, **keywords)
-      @event_handlers[event].each do |handler|
-        instance_eval(*args, **keywords, &handler)
+      @event_handlers[event].each do |data|
+        instance_eval(*args, **keywords, &data[:handler])
       end
     end
   end