scarpe 0.1.0 → 0.2.0

data/lib/scarpe/wv/app.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+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
+      # 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.
+      @control_interface = ControlInterface.new
+      if ENV["SCARPE_TEST_CONTROL"]
+        @control_interface.instance_eval File.read(ENV["SCARPE_TEST_CONTROL"])
+      end
+
+      # TODO: rename @view
+      @view = Scarpe::WebWrangler.new title: @title,
+        width: @width,
+        height: @height,
+        resizable: @resizable,
+        debug: @debug
+
+      # 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
+      # ControlInterface.new.
+      @control_interface.set_system_components app: self, doc_root: nil, wrangler: @view
+
+      bind_shoes_event(event_name: "init") { init }
+      bind_shoes_event(event_name: "run") { run }
+      bind_shoes_event(event_name: "destroy") { destroy }
+    end
+
+    attr_writer :document_root
+
+    def init
+      scarpe_app = self
+
+      @view.init_code("scarpeInit") do
+        @document_root.request_redraw!
+      end
+
+      @view.bind("scarpeHandler") do |*args|
+        @document_root.handle_callback(*args)
+      end
+
+      @view.bind("scarpeExit") do
+        scarpe_app.destroy
+      end
+    end
+
+    def run
+      @control_interface.dispatch_event(:init)
+
+      # 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?
+      @view.run
+    end
+
+    def destroy
+      if @document_root || @view
+        @control_interface.dispatch_event :shutdown
+      end
+      @document_root = nil
+      if @view
+        @view.destroy
+        @view = nil
+      end
+    end
+  end
+end

data/lib/scarpe/wv/arc.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "shape_helper"
+
+class Scarpe
+  class WebviewArc < Scarpe::WebviewWidget
+    include ShapeHelper
+    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
+
+    private
+
+    def style
+      {
+        left: "#{@left}px",
+        top: "#{@top}px",
+        width: "#{@width}px",
+        height: "#{@height}px",
+      }
+    end
+
+    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)
+    end
+  end
+end

data/lib/scarpe/wv/background.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Scarpe
+  module WebviewBackground
+    def style
+      styles = (super if defined?(super)) || {}
+      return styles unless @background_color
+
+      color = if @background_color.is_a?(Range)
+        "linear-gradient(45deg, #{@background_color.first}, #{@background_color.last})"
+      else
+        @background_color
+      end
+
+      styles.merge(background: color)
+    end
+  end
+end

data/lib/scarpe/wv/border.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Scarpe
+  module WebviewBorder
+    def style
+      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" }
+      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,153 @@
+# 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.
+#
+# 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 Scarpe::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.
+
+    # 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
+    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 |handler|
+        instance_eval(*args, **keywords, &handler)
+      end
+    end
+  end
+end

data/lib/scarpe/wv/control_interface_test.rb

@@ -0,0 +1,253 @@
+# 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
+    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
+
+    # This does a final return of results. If it gets called
+    # multiple times, the test fails because that's not okay.
+    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)]
+
+      # 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
+        @log.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
+      end
+
+      @log.debug("Writing results file #{result_file.inspect} to disk!")
+      File.write(result_file, JSON.pretty_generate(result_structs))
+
+      @results_returned = result_structs
+    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.
+
+    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