lacci 0.2.1 → 0.3.0

data/lib/scarpe/wv/control_interface.rb

@@ -1,147 +0,0 @@
-# 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

@@ -1,234 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-# 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

@@ -1,43 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-# 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

data/lib/scarpe/wv/html.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-class Scarpe
-  class HTML
-    CONTENT_TAGS = [:div, :p, :button, :ul, :li, :textarea, :a, :video, :strong, :style, :em, :code, :u, :line, :span, :svg].freeze
-    VOID_TAGS = [:input, :img, :polygon, :source, :link, :path].freeze
-
-    TAGS = (CONTENT_TAGS + VOID_TAGS).freeze
-
-    class << self
-      def render(&block)
-        new(&block).value
-      end
-    end
-
-    def initialize(&block)
-      @buffer = ""
-      block.call(self)
-    end
-
-    def value
-      @buffer
-    end
-
-    def respond_to_missing?(name, include_all = false)
-      TAGS.include?(name) || super(name, include_all)
-    end
-
-    def p(*args, &block)
-      method_missing(:p, *args, &block)
-    end
-
-    def option(**attrs, &block)
-      tag(:option, **attrs, &block)
-    end
-
-    def tag(name, **attrs, &block)
-      if VOID_TAGS.include?(name)
-        raise ArgumentError, "void tag #{name} cannot have content" if block_given?
-
-        @buffer += "<#{name}#{render_attributes(attrs)} />"
-      else
-        @buffer += "<#{name}#{render_attributes(attrs)}>"
-
-        if block_given?
-          result = block.call(self)
-        else
-          result = attrs[:content]
-          @buffer += result if result.is_a?(String)
-        end
-        @buffer += result if result.is_a?(String)
-
-        @buffer += "</#{name}>"
-      end
-
-      nil
-    end
-
-    def select(**attrs, &block)
-      tag(:select, **attrs, &block)
-    end
-
-    def method_missing(name, *args, &block)
-      raise NoMethodError, "no method #{name} for #{self.class.name}" unless TAGS.include?(name)
-
-      if VOID_TAGS.include?(name)
-        raise ArgumentError, "void tag #{name} cannot have content" if block_given?
-
-        @buffer += "<#{name}#{render_attributes(*args)} />"
-      else
-        @buffer += "<#{name}#{render_attributes(*args)}>"
-
-        if block_given?
-          result = block.call(self)
-        else
-          result = args.first
-          @buffer += result if result.is_a?(String)
-        end
-        @buffer += result if result.is_a?(String)
-
-        @buffer += "</#{name}>"
-      end
-
-      nil
-    end
-
-    private
-
-    def render_attributes(attributes = {})
-      return "" if attributes.empty?
-
-      attributes[:style] = render_style(attributes[:style]) if attributes[:style]
-      attributes.compact!
-
-      return if attributes.empty?
-
-      result = attributes.map { |k, v| "#{k}=\"#{v}\"" }.join(" ")
-      " #{result}"
-    end
-
-    def render_style(style)
-      return style unless style.is_a?(Hash)
-      return if style.empty?
-
-      style.map { |k, v| "#{k}:#{v}" }.join(";")
-    end
-  end
-end