lacci 0.2.1

data/lib/scarpe/wv/background.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "scarpe/base64"
+
+class Scarpe
+  module WebviewBackground
+    include Base64
+
+    def style
+      styles = (super if defined?(super)) || {}
+      return styles unless @background_color
+
+      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
+
+      styles.merge(background: color)
+    end
+  end
+end

data/lib/scarpe/wv/border.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Scarpe
+  module WebviewBorder
+    def style
+      styles = (super if defined?(super)) || {}
+      return styles unless @border_color
+
+      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",
+        "border-radius": "#{@options[:curve] || 0}px",
+      ).merge(border_color)
+    end
+  end
+end

data/lib/scarpe/wv/button.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class WebviewButton < WebviewWidget
+    def initialize(properties)
+      super
+
+      # Bind to display-side handler for "click"
+      bind("click") do
+        # This will be sent to the bind_self_event in Button
+        send_self_event(event_name: "click")
+      end
+    end
+
+    def element
+      HTML.render do |h|
+        h.button(id: html_id, onclick: handler_js_code("click"), style: style) do
+          @text
+        end
+      end
+    end
+
+    private
+
+    def style
+      styles = {}
+      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[: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
+    end
+
+    def font_size
+      font_size = @size.is_a?(Symbol) ? SIZES[@size] : @size
+
+      Dimensions.length(font_size)
+    end
+  end
+end

data/lib/scarpe/wv/control_interface.rb

@@ -0,0 +1,147 @@
+# 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 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
+
+    SUBSCRIBE_EVENTS = [:init, :shutdown, :next_redraw, :every_redraw, :next_heartbeat, :every_heartbeat]
+    DISPATCH_EVENTS = [:init, :shutdown, :redraw, :heartbeat]
+
+    attr_writer :doc_root
+    attr_reader :do_shutdown
+
+    # The control interface needs to see major system components to hook into their events
+    def initialize
+      log_init("WV::ControlInterface")
+
+      @do_shutdown = false
+      @event_handlers = {}
+      (SUBSCRIBE_EVENTS | DISPATCH_EVENTS).each { |e| @event_handlers[e] = [] }
+    end
+
+    def inspect
+      "<#ControlInterface>"
+    end
+
+    # 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
+        @log.error("False wrangler passed to set_system_components!") unless wrangler
+        raise "Must pass non-nil app and wrangler to ControlInterface#set_system_components!"
+      end
+      @app = app
+      @doc_root = doc_root # May be nil at this point
+      @wrangler = wrangler
+
+      @wrangler.control_interface = self
+
+      @wrangler.on_every_redraw { self.dispatch_event(:redraw) }
+    end
+
+    def app
+      unless @app
+        raise "ControlInterface code needs to be wrapped in handlers like on_event(:init) " +
+          "to make sure they have access to app, doc_root, wrangler, etc!"
+      end
+
+      @app
+    end
+
+    def doc_root
+      unless @doc_root
+        raise "ControlInterface code needs to be wrapped in handlers like on_event(:init) " +
+          "to make sure they have access to app, doc_root, wrangler, etc!"
+      end
+
+      @doc_root
+    end
+
+    def wrangler
+      unless @wrangler
+        raise "ControlInterface code needs to be wrapped in handlers like on_event(:init) " +
+          "to make sure they have access to app, doc_root, wrangler, etc!"
+      end
+
+      @wrangler
+    end
+
+    # The control interface has overrides for certain settings. If the override has been specified,
+    # those settings will be overridden.
+
+    # 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
+
+      @unsub_id ||= 0
+      @unsub_id += 1
+
+      @event_handlers[event] << { handler: block, unsub: @unsub_id }
+      @unsub_id
+    end
+
+    # Send out the specified event
+    def dispatch_event(event, *args, **keywords)
+      @log.debug("CTL event #{event.inspect} #{args.inspect} #{keywords.inspect}")
+
+      unless DISPATCH_EVENTS.include?(event)
+        raise "Illegal dispatch of event #{event.inspect}! Valid values are: #{DISPATCH_EVENTS.inspect}"
+      end
+
+      if @do_shutdown
+        @log.debug("CTL: Shutting down - not dispatching #{event}!")
+        return
+      end
+
+      if event == :redraw
+        dumb_dispatch_event(:every_redraw, *args, **keywords)
+
+        # Next redraw is interesting. We can add new handlers
+        # when dispatching a next_redraw handler. But we want
+        # each handler to run only once.
+        handlers = @event_handlers[:next_redraw]
+        dumb_dispatch_event(:next_redraw, *args, **keywords)
+        @event_handlers[:next_redraw] -= handlers
+        return
+      end
+
+      if event == :heartbeat
+        dumb_dispatch_event(:every_heartbeat, *args, **keywords)
+
+        # Next heartbeat is interesting. We can add new handlers
+        # when dispatching a next_heartbeat handler. But we want
+        # each handler to run only once.
+        handlers = @event_handlers[:next_heartbeat]
+        dumb_dispatch_event(:next_heartbeat, *args, **keywords)
+        @event_handlers[:next_heartbeat] -= handlers
+        return
+      end
+
+      if event == :shutdown
+        @do_shutdown = true
+      end
+
+      dumb_dispatch_event(event, *args, **keywords)
+    end
+
+    private
+
+    def dumb_dispatch_event(event, *args, **keywords)
+      @event_handlers[event].each do |data|
+        instance_eval(*args, **keywords, &data[:handler])
+      end
+    end
+  end
+end

data/lib/scarpe/wv/control_interface_test.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+# The ControlInterface doesn't, by default, include much of a test framework.
+# But writing a test framework in heredocs in test_helper.rb seems bad.
+# So we write a test framework here, but don't include it by default.
+# A running shoes app won't normally include it, but unit tests will.
+
+require "json"
+
+class Scarpe
+  DEFAULT_ASSERTION_TIMEOUT = 1.0
+
+  class ControlInterface
+    include Scarpe::Test::Helpers
+
+    def timed_out?
+      @did_time_out
+    end
+
+    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!")
+          app.destroy
+        end
+      end
+    end
+
+    # This is returned alongside the actual results automatically
+    def test_metadata
+      data = {}
+      if @die_after
+        t_delta = (Time.now - @die_after[0]).to_f
+        data["die_after"] = {
+          t_start: @die_after[0].to_s,
+          threshold: @die_after[1],
+          passed: t_delta,
+        }
+      end
+      data
+    end
+
+    # Need to be able to query widgets in test code
+
+    def all_wv_widgets
+      known = [doc_root]
+      to_check = [doc_root]
+
+      until to_check.empty?
+        next_layer = to_check.flat_map(&:children)
+        known += next_layer
+        to_check = next_layer
+      end
+
+      # I don't *think* we'll ever have widget trees that merge back together, but just in case we'll de-dup
+      known.uniq
+    end
+
+    # Shoes doesn't name widgets. We aren't guaranteed that the Shoes widgets are even in the same
+    # process, since we have the Relay display service for Webview. So mostly we can look by
+    # display service class.
+    def find_wv_widgets(*specifiers)
+      widgets = all_wv_widgets
+
+      specifiers.each do |spec|
+        if spec.is_a?(Class)
+          widgets.select! { |w| spec === w }
+        else
+          raise "I don't know how to search for widgets by #{spec.inspect}!"
+        end
+      end
+
+      widgets
+    end
+
+    # We want an assertions library, but one that runs inside the spawned
+    # Webview sub-process.
+
+    # Note that we do *not* extract this assertions library to use elsewhere
+    # because it's very focused on evented assertions that start and stop
+    # over a period of time. Instantaneous procedural asserts don't want to
+    # use this API.
+
+    def return_when_assertions_done
+      assertions_may_exist
+
+      wrangler.periodic_code("scarpeReturnWhenAssertionsDone") do |*_args|
+        if @assertions_pending.empty?
+          success = @assertions_failed.empty?
+          return_results success, "Assertions #{success ? "succeeded" : "failed"}", assertion_data_as_a_struct
+          app.destroy
+        end
+      end
+    end
+
+    def assertions_may_exist
+      @assertions_pending ||= {}
+      @assertions_failed ||= {}
+      @assertions_passed ||= 0
+      @assertion_counter ||= 0
+    end
+
+    def start_assertion(code)
+      assertions_may_exist
+
+      this_assertion = @assertion_counter
+      @assertion_counter += 1
+
+      @assertions_pending[this_assertion] = {
+        id: this_assertion,
+        code: code,
+      }
+
+      this_assertion
+    end
+
+    def pass_assertion(id)
+      @assertions_pending.delete(id)
+      @assertions_passed += 1
+    end
+
+    def fail_assertion(id, fail_message)
+      item = @assertions_pending.delete(id)
+      item[:fail_message] = fail_message
+      @assertions_failed[id] = item
+    end
+
+    def assertions_pending?
+      !@assertions_pending.empty?
+    end
+
+    def assertion_data_as_a_struct
+      {
+        still_pending: @assertions_pending.size,
+        succeeded: @assertions_passed,
+        failed: @assertions_failed.size,
+        failures: @assertions_failed.values.map { |item| [item[:code], item[:failure_reason]] },
+      }
+    end
+
+    # Create a promise to do a JS assertion, normally after other ops have finished.
+    def assert_js(js_code, wait_for: [], timeout: DEFAULT_ASSERTION_TIMEOUT)
+      id = start_assertion(js_code)
+
+      # this isn't a TestPromise, so it doesn't have the additional DSL entries
+      promise = wrangler.eval_js_async(js_code, wait_for: wait_for, timeout: timeout)
+      promise.on_rejected do
+        fail_assertion(id, "JS Eval failed: #{promise.reason.inspect}")
+      end
+      promise.on_fulfilled do
+        ret_val = promise.returned_value
+        if ret_val
+          pass_assertion(id)
+        else
+          fail_assertion(id, "Expected true JS value: #{ret_val.inspect}")
+        end
+      end
+
+      # So we wrap it in a no-op TestPromise, to get the DSL entries.
+      TestPromise.new(iface: self, wait_for: [promise]).to_execute {}
+    end
+
+    def assert(value, msg = nil)
+      id = start_assertion("#{caller[0]}: #{msg || "Value should be true!"}")
+
+      if value
+        pass_assertion(id)
+      else
+        fail_assertion(id, "Expected true Ruby value: #{value.inspect}")
+      end
+    end
+
+    def assert_equal(val1, val2, msg = nil)
+      assert val1 == val2, (msg || "Expected #{val2.inspect} to equal #{val1.inspect}!")
+    end
+
+    # How do we signal an error?
+    def with_js_value(js_code, wait_for: [], timeout: DEFAULT_ASSERTION_TIMEOUT, &block)
+      raise "Must give a block to with_js_value!" unless block
+
+      js_promise = wrangler.eval_js_async(js_code, wait_for: wait_for, timeout: timeout)
+      ruby_promise = TestPromise.new(iface: self, wait_for: [js_promise])
+      ruby_promise.to_execute(&block)
+      ruby_promise
+    end
+
+    def with_js_dom_html(wait_for: [], timeout: DEFAULT_ASSERTION_TIMEOUT, &block)
+      with_js_value("document.getElementById('wrapper-wvroot').innerHTML", wait_for: wait_for, timeout: timeout, &block)
+    end
+
+    def fully_updated(wait_for: [])
+      wrangler.promise_dom_fully_updated
+    end
+  end
+
+  # A Promise but with helper functions
+  class TestPromise < Promise
+    def initialize(iface:, state: nil, wait_for: [], &scheduler)
+      @iface = iface
+      super(state: state, parents: wait_for, &scheduler)
+    end
+
+    def inspect
+      "<#TestPromise::#{object_id} state=#{state.inspect} parents=#{parents.inspect} value=#{returned_value.inspect} reason=#{reason.inspect}>"
+    end
+
+    # This method expects to wait for the parent TestPromise and then run a block of Ruby that returns
+    # another promise. This is useful for wrapping Promises like those from replace() that don't have
+    # the test DSL built in. The block will execute when this outer promise is scheduled -- so we don't do
+    # a replace() too early, for instance. And then the outer promise will fulfill when the inner one does.
+    def then_ruby_promise(wait_for: [], &block)
+      ruby_wrapper_promise = TestPromise.new iface: @iface, wait_for: ([self] + wait_for)
+
+      ruby_wrapper_promise.on_scheduled do
+        inner_ruby_promise = block.call
+        inner_ruby_promise.on_fulfilled { ruby_wrapper_promise.fulfilled!(inner_ruby_promise.returned_value) }
+      end
+    end
+
+    def then_with_js_value(js_code, wait_for: [], timeout: DEFAULT_ASSERTION_TIMEOUT, &block)
+      @iface.with_js_value(js_code, wait_for: (wait_for + [self]), timeout:, &block)
+    end
+
+    def then_with_js_dom_html(wait_for: [], timeout: DEFAULT_ASSERTION_TIMEOUT, &block)
+      @iface.with_js_dom_html(wait_for: (wait_for + [self]), timeout:, &block)
+    end
+  end
+end

data/lib/scarpe/wv/dimensions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class Dimensions
+    class << self
+      def length(value)
+        case value
+        when Integer
+          if value < 0
+            "calc(100% - #{value.abs}px)"
+          else
+            "#{value}px"
+          end
+        when Float
+          "#{value * 100}%"
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/scarpe/wv/document_root.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Scarpe
+  # A WebviewDocumentRoot is a WebviewFlow, with all the same properties
+  # and basic behavior.
+  class WebviewDocumentRoot < Scarpe::WebviewFlow
+  end
+end

data/lib/scarpe/wv/edit_box.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class WebviewEditBox < Scarpe::WebviewWidget
+    attr_reader :text, :height, :width
+
+    def initialize(properties)
+      super
+
+      # The JS handler sends a "change" event, which we forward to the Shoes widget tree
+      bind("change") do |new_text|
+        send_self_event(new_text, event_name: "change")
+      end
+    end
+
+    def properties_changed(changes)
+      t = changes.delete("text")
+      if t
+        html_element.value = t
+      end
+
+      super
+    end
+
+    def element
+      oninput = handler_js_code("change", "this.value")
+
+      HTML.render do |h|
+        h.textarea(id: html_id, oninput: oninput, style: style) { text }
+      end
+    end
+
+    private
+
+    def style
+      styles = {}
+
+      styles[:height] = Dimensions.length(height)
+      styles[:width] = Dimensions.length(width)
+
+      styles.compact
+    end
+  end
+end

data/lib/scarpe/wv/edit_line.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class WebviewEditLine < WebviewWidget
+    attr_reader :text, :width
+
+    def initialize(properties)
+      super
+
+      # The JS handler sends a "change" event, which we forward to the Shoes widget tree
+      bind("change") do |new_text|
+        send_self_event(new_text, event_name: "change")
+      end
+    end
+
+    def properties_changed(changes)
+      t = changes.delete("text")
+      if t
+        html_element.value = t
+      end
+
+      super
+    end
+
+    def element
+      oninput = handler_js_code("change", "this.value")
+
+      HTML.render do |h|
+        h.input(id: html_id, oninput: oninput, value: @text, style: style)
+      end
+    end
+
+    private
+
+    def style
+      styles = {}
+
+      styles[:width] = Dimensions.length(@width) if @width
+
+      styles
+    end
+  end
+end

data/lib/scarpe/wv/fill.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class WebviewFill < WebviewWidget
+    def initialize(properties)
+      super(properties)
+    end
+
+    def element
+      width = @parent.get_style[:width]
+      height = @parent.get_style[:height]
+
+      HTML.render do |h|
+        h.div(id: html_id, style: style(width, height)) do
+          @text
+        end
+      end
+    end
+
+    private
+
+    def style(width, height)
+      styles = {}
+      styles[:width] = width
+      styles[:height] = height
+      styles[:background] = @color if @color
+      styles
+    end
+  end
+end

data/lib/scarpe/wv/flow.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class WebviewFlow < Scarpe::WebviewSlot
+    def initialize(properties)
+      super
+    end
+
+    protected
+
+    def style
+      styles = super
+
+      styles[:display] = "flex"
+      styles["flex-direction"] = "row"
+      styles["flex-wrap"] = "wrap"
+      styles["align-content"] = "flex-start"
+      styles["justify-content"] = "flex-start"
+      styles["align-items"] = "flex-start"
+
+      styles
+    end
+  end
+end

data/lib/scarpe/wv/font.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "scarpe/base64"
+
+class Scarpe
+  class WebviewFont < WebviewWidget
+    include Base64
+    attr_accessor :font
+
+    def initialize(properties)
+      @font = properties[:font]
+      super
+    end
+
+    def font_name
+      File.basename(@font, ".*")
+    end
+
+    def element
+      HTML.render do |h|
+        h.link(href: @font, rel: "stylesheet")
+        h.style do
+          <<~CSS
+            @font-face {
+              font-family: #{font_name};
+              src: url("data:font/truetype;base64,#{encode_file_to_base64(@font)}") format('truetype');
+            }
+            * {
+              font-family: #{font_name};
+            }
+          CSS
+        end
+      end
+    end
+  end
+end