lacci 0.2.1

data/lib/scarpe/wv/webview_local_display.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class Scarpe
+  # This is an in-process Webview-based display service, with all the limitations that
+  # entails. Slow handlers will crash, ending this display service will end the
+  # process, too many or too large evals can crash the process, etc.
+  # Normally the intention is to use a RelayDisplayService to a second
+  # process containing one of these.
+  class WebviewDisplayService < Shoes::DisplayService
+    include Scarpe::Log
+
+    class << self
+      attr_accessor :instance
+    end
+
+    # TODO: re-think the list of top-level singleton objects.
+    attr_reader :control_interface
+    attr_reader :doc_root
+    attr_reader :app
+    attr_reader :wrangler
+
+    # This is called before any of the various WebviewWidgets are created.
+    def initialize
+      if WebviewDisplayService.instance
+        raise "ERROR! This is meant to be a singleton!"
+      end
+
+      WebviewDisplayService.instance = self
+
+      super()
+      log_init("WV::WebviewDisplayService")
+
+      @display_widget_for = {}
+    end
+
+    def create_display_widget_for(widget_class_name, widget_id, properties)
+      if widget_class_name == "App"
+        unless @doc_root
+          raise "WebviewDocumentRoot is supposed to be created before WebviewApp!"
+        end
+
+        display_app = Scarpe::WebviewApp.new(properties)
+        display_app.document_root = @doc_root
+        @control_interface = display_app.control_interface
+        @control_interface.doc_root = @doc_root
+        @app = @control_interface.app
+        @wrangler = @control_interface.wrangler
+
+        set_widget_pairing(widget_id, display_app)
+
+        return display_app
+      end
+
+      # Create a corresponding display widget
+      display_class = Scarpe::WebviewWidget.display_class_for(widget_class_name)
+      display_widget = display_class.new(properties)
+      set_widget_pairing(widget_id, display_widget)
+
+      if widget_class_name == "DocumentRoot"
+        # WebviewDocumentRoot is created before WebviewApp. Mostly doc_root is just like any other widget,
+        # but we'll want a reference to it when we create WebviewApp.
+        @doc_root = display_widget
+      end
+
+      display_widget
+    end
+
+    def destroy
+      @app.destroy
+      WebviewDisplayService.instance = nil
+    end
+  end
+end

data/lib/scarpe/wv/webview_relay_display.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "socket"
+require "rbconfig"
+
+class Scarpe
+  class AppShutdownError < Scarpe::Error; end
+
+  module WVRelayUtil # Make sure the including class also includes Scarpe::Log
+    def ready_to_read?(timeout = 0.0)
+      r, _, e = IO.select [@from], [], [@from, @to].uniq, timeout
+
+      # On timeout, select returns nil instead of arrays.
+      return if r.nil?
+
+      unless e.empty?
+        raise "#{@i_am}: Got error on connection(s) from IO.select! Dying!"
+      end
+
+      !r.empty?
+    end
+
+    def send_datagram(contents)
+      str_data = JSON.dump contents
+      dgram_str = (str_data.length.to_s + "a" + str_data).encode(Encoding::BINARY)
+      to_write = dgram_str.bytesize
+      written = 0
+
+      until written == to_write
+        count = @to.write(dgram_str.byteslice(written..-1))
+        if count.nil? || count == 0
+          raise "Something was wrong in send_datagram! Write returned #{count.inspect}!"
+        end
+
+        written += count
+      end
+
+      nil
+    end
+
+    def receive_datagram
+      @readbuf ||= String.new.encode(Encoding::BINARY)
+      to_read = nil
+
+      loop do
+        # Have we read a packet length already, sitting in @readbuf?
+        a_idx = @readbuf.index("a")
+        if a_idx
+          to_read = @readbuf[0..a_idx].to_i
+          @readbuf = @readbuf[(a_idx + 1)..-1]
+          break
+        end
+
+        # If not, read more bytes
+        new_bytes = @from.read(10)
+        if new_bytes.nil?
+          # This is perfectly normal, if the connection closed
+          raise AppShutdownError, "Got an unexpected EOF reading datagram! " +
+            "Did the #{@i_am == :child ? "parent" : "child"} process die?"
+        end
+        @readbuf << new_bytes
+      end
+
+      loop do
+        if @readbuf.bytesize >= to_read
+          out = @readbuf.byteslice(0, to_read)
+          @readbuf = @readbuf.byteslice(to_read, -1)
+          return out
+        end
+
+        new_bytes = @from.read(to_read - @readbuf.bytesize)
+        @readbuf << new_bytes
+      end
+    rescue
+      raise AppShutdownError, "Got exception #{$!.class} when receiving datagram... #{$!.inspect}"
+    end
+
+    def respond_to_datagram
+      message = receive_datagram
+      m_data = JSON.parse(message)
+
+      if m_data["type"] == "event"
+        kwargs_hash = {}
+        m_data["kwargs"].each { |k, v| kwargs_hash[k.to_sym] = v }
+        send_shoes_event(
+          *m_data["args"],
+          event_name: m_data["kwargs"]["event_name"],
+          target: m_data["kwargs"]["event_target"],
+          **kwargs_hash,
+        )
+      elsif m_data["type"] == "create"
+        raise "Parent process should never receive :create datagram!" if @i_am == :parent
+
+        @wv_display.create_display_widget_for(m_data["class_name"], m_data["id"], m_data["properties"])
+      elsif m_data["type"] == "destroy"
+        if @i_am == :parent
+          @shutdown = true
+        else
+          @log.info("Shutting down...")
+          exit 0
+        end
+      else
+        @log.error("Unrecognized datagram type:event: #{m_data.inspect}!")
+      end
+    end
+
+    def event_loop_for(t = 1.5)
+      t_start = Time.now
+      delay_time = t
+
+      while Time.now - t_start < delay_time
+        if ready_to_read?(0.1)
+          respond_to_datagram
+        else
+          sleep 0.1
+        end
+      end
+    end
+  end
+
+  # This "display service" actually creates a child process and sends events
+  # back and forth, but creates no widgets of its own.
+  class WVRelayDisplayService < Shoes::DisplayService
+    include Scarpe::Log
+    include WVRelayUtil # Needs Scarpe::Log
+
+    attr_accessor :shutdown
+
+    def initialize
+      super()
+      log_init("WV::RelayDisplayService")
+
+      @event_subs = []
+      @shutdown = false
+      @i_am = :parent
+
+      server = TCPServer.new("127.0.0.1", 0)
+      port = server.addr[1]
+
+      @pid = spawn(RbConfig.ruby, File.join(__dir__, "wv_display_worker.rb"), port.to_s)
+      @from = @to = server.accept
+
+      # Subscribe to all event notifications and relay them to the worker
+      @event_subs << bind_shoes_event(event_name: :any, target: :any) do |*args, **kwargs|
+        unless kwargs[:relayed]
+          kwargs[:relayed] = true
+          send_datagram({ type: :event, args:, kwargs: })
+        end
+
+        # Forward the run event to the child process before doing this
+        if event_name == "run"
+          run_event_loop
+        end
+      rescue AppShutdownError
+        @shutdown = true
+        @log.info("Attempting to shut down...")
+        self.destroy
+      end
+    end
+
+    def run_event_loop
+      until @shutdown
+        respond_to_datagram while ready_to_read?
+        sleep 0.1
+      end
+    rescue AppShutdownError
+      @shutdown = true
+      @log.info("Attempting to shut down...")
+      self.destroy
+    end
+
+    def create_display_widget_for(widget_class_name, widget_id, properties)
+      send_datagram({ type: :create, class_name: widget_class_name, id: widget_id, properties: })
+      # Don't need to return anything. It wouldn't be used anyway.
+    end
+
+    def destroy
+      unless @shutdown
+        send_datagram({ type: :destroy })
+      end
+      @shutdown = true
+      (@events_subs || []).each { |unsub_id| DisplayService.unsub_from_events(unsub_id) }
+    end
+  end
+end

data/lib/scarpe/wv/widget.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class WebviewWidget < Shoes::Linkable
+    include Scarpe::Log
+
+    class << self
+      def display_class_for(scarpe_class_name)
+        scarpe_class = Scarpe.const_get(scarpe_class_name)
+        unless scarpe_class.ancestors.include?(Shoes::Linkable)
+          raise "Scarpe Webview can only get display classes for Scarpe " +
+            "linkable widgets, not #{scarpe_class_name.inspect}!"
+        end
+
+        klass = Scarpe.const_get("Webview" + scarpe_class_name.split("::")[-1])
+        if klass.nil?
+          raise "Couldn't find corresponding Scarpe Webview class for #{scarpe_class_name.inspect}!"
+        end
+
+        klass
+      end
+    end
+
+    attr_reader :shoes_linkable_id
+    attr_reader :parent
+    attr_reader :children
+
+    def initialize(properties)
+      log_init("WV::Widget")
+
+      # Call method, which looks up the parent
+      @shoes_linkable_id = properties["shoes_linkable_id"] || properties[:shoes_linkable_id]
+      unless @shoes_linkable_id
+        raise "Could not find property shoes_linkable_id in #{properties.inspect}!"
+      end
+
+      # Set the display properties
+      properties.each do |k, v|
+        next if k == "shoes_linkable_id"
+
+        instance_variable_set("@" + k.to_s, v)
+      end
+
+      # The parent field is *almost* simple enough that a typed display property would handle it.
+      bind_shoes_event(event_name: "parent", target: shoes_linkable_id) do |new_parent_id|
+        display_parent = WebviewDisplayService.instance.query_display_widget_for(new_parent_id)
+        if @parent != display_parent
+          set_parent(display_parent)
+        end
+      end
+
+      # When Shoes widgets change properties, we get a change notification here
+      bind_shoes_event(event_name: "prop_change", target: shoes_linkable_id) do |prop_changes|
+        prop_changes.each do |k, v|
+          instance_variable_set("@" + k, v)
+        end
+        properties_changed(prop_changes)
+      end
+
+      bind_shoes_event(event_name: "destroy", target: shoes_linkable_id) do
+        destroy_self
+      end
+
+      super(linkable_id: @shoes_linkable_id)
+    end
+
+    # This exists to be overridden by children watching for changes
+    def properties_changed(changes)
+      needs_update! unless changes.empty?
+    end
+
+    def set_parent(new_parent)
+      @parent&.remove_child(self)
+      new_parent&.add_child(self)
+      @parent = new_parent
+    end
+
+    def inspect
+      "#<#{self.class}:#{self.object_id} @shoes_linkable_id=#{@shoes_linkable_id} @parent=#{@parent.inspect} @children=#{@children.inspect}>"
+    end
+
+    protected
+
+    # Do not call directly, use set_parent
+    def remove_child(child)
+      @children ||= []
+      unless @children.include?(child)
+        @log.error("remove_child: no such child(#{child.inspect}) for"\
+          " parent(#{parent.inspect})!")
+      end
+      @children.delete(child)
+    end
+
+    # Do not call directly, use set_parent
+    def add_child(child)
+      @children ||= []
+      @children << child
+
+      # If we add a child, we should redraw ourselves
+      needs_update!
+    end
+
+    # Convert an [r, g, b, a] array to an HTML hex color code
+    # Arrays support alpha. HTML hex does not. So premultiply.
+    def rgb_to_hex(color)
+      return color if color.nil?
+
+      r, g, b, a = *color
+      if r.is_a?(Float)
+        a ||= 1.0
+        r_float = r * a
+        g_float = g * a
+        b_float = b * a
+      else
+        a ||= 255
+        a_float = (a / 255.0)
+        r_float = (r.to_f / 255.0) * a_float
+        g_float = (g.to_f / 255.0) * a_float
+        b_float = (b.to_f / 255.0) * a_float
+      end
+
+      r_int = (r_float * 255.0).to_i.clamp(0, 255)
+      g_int = (g_float * 255.0).to_i.clamp(0, 255)
+      b_int = (b_float * 255.0).to_i.clamp(0, 255)
+
+      "#%0.2X%0.2X%0.2X" % [r_int, g_int, b_int]
+    end
+
+    public
+
+    # This gets a mini-webview for just this element and its children, if any
+    def html_element
+      @elt_wrangler ||= Scarpe::WebWrangler::ElementWrangler.new(html_id)
+    end
+
+    # Return a promise that guarantees all currently-requested changes have completed
+    def promise_update
+      html_element.promise_update
+    end
+
+    def html_id
+      object_id.to_s
+    end
+
+    # to_html is intended to get the HTML DOM rendering of this object and its children.
+    # Calling it should be side-effect-free and NOT update the webview.
+    def to_html
+      @children ||= []
+      child_markup = @children.map(&:to_html).join
+      if respond_to?(:element)
+        element { child_markup }
+      else
+        child_markup
+      end
+    end
+
+    # This binds a Scarpe JS callback, handled via a single dispatch point in the document root
+    def bind(event, &block)
+      raise("Widget has no linkable_id! #{inspect}") unless linkable_id
+
+      WebviewDisplayService.instance.app.bind("#{linkable_id}-#{event}", &block)
+    end
+
+    # Removes the element from both the Ruby Widget tree and the HTML DOM.
+    # Return a promise for when that HTML change will be visible.
+    def destroy_self
+      @parent&.remove_child(self)
+      html_element.remove
+    end
+
+    # It's really hard to do dirty-tracking here because the redraws are fully asynchronous.
+    # And so we can't easily cancel one "in flight," and we can't easily pick up the latest
+    # changes... And we probably don't want to, because we may be halfway through a batch.
+    def needs_update!
+      WebviewDisplayService.instance.app.request_redraw!
+    end
+
+    def handler_js_code(handler_function_name, *args)
+      raise("Widget has no linkable_id! #{inspect}") unless linkable_id
+
+      js_args = ["'#{linkable_id}-#{handler_function_name}'", *args].join(", ")
+      "scarpeHandler(#{js_args})"
+    end
+  end
+end

data/lib/scarpe/wv/wv_display_worker.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "socket"
+
+# Wherever this file is installed, locate Scarpe relative to it. This could be an installed gem or a dev repo.
+SCARPE_DIR = File.join(__dir__, "../..")
+
+$LOAD_PATH.prepend(SCARPE_DIR)
+require "scarpe"
+require "scarpe/wv_local"
+
+# This script exists to create a WebviewDisplayService that can be operated remotely over a socket.
+
+if ARGV.length != 1
+  $stderr.puts("Usage: wv_display_worker.rb tcp_port_num")
+  exit(-1)
+end
+
+class WebviewContainedService < Shoes::Linkable
+  include Scarpe::Log
+  include Scarpe::WVRelayUtil # Needs Scarpe::Log
+
+  attr_reader :log
+
+  def initialize(from, to)
+    super()
+    log_init("WV::DisplayWorker")
+
+    @i_am = :child
+    @event_subs = []
+    @wv_display = Scarpe::WebviewDisplayService.new
+
+    @from = from
+    @to = to
+
+    @init_done = false
+
+    # Wait to register our periodic_code until the wrangler exists
+    @event_subs << bind_shoes_event(event_name: "init") do
+      @wv_display.wrangler.periodic_code("datagramProcessor", 0.1) do
+        respond_to_datagram while ready_to_read?(0.0)
+      end
+      @init_done = true
+    end
+
+    # Subscribe to all event notifications and relay them to the opposite side
+    @event_subs << bind_shoes_event(event_name: :any, target: :any) do |*args, **kwargs|
+      unless kwargs[:relayed] || kwargs["relayed"]
+        kwargs[:relayed] = true
+        send_datagram({ type: :event, args:, kwargs: })
+      end
+    end
+
+    # Run for 2.5 seconds to let the app be created and "run" to get called.
+    # Once that happens, Webview will take over the event loop.
+    event_loop_for(2.5)
+  end
+end
+
+s = TCPSocket.new("localhost", ARGV[0].to_i)
+
+SERVICE = WebviewContainedService.new(s, s)
+
+SERVICE.log.info("Finished event loop. Exiting!")

data/lib/scarpe/wv.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Scarpe Webview Display Services
+
+require_relative "wv/web_wrangler"
+require_relative "wv/control_interface"
+
+require_relative "wv/widget"
+require_relative "wv/webview_local_display"
+require_relative "wv/webview_relay_display"
+
+require_relative "wv/dimensions"
+require_relative "wv/html"
+
+require_relative "wv/spacing"
+require_relative "wv/star"
+require_relative "wv/background"
+require_relative "wv/border"
+
+require_relative "wv/fill"
+require_relative "wv/arc"
+require_relative "wv/font"
+
+require_relative "wv/app"
+require_relative "wv/para"
+require_relative "wv/slot"
+require_relative "wv/stack"
+require_relative "wv/flow"
+require_relative "wv/document_root"
+require_relative "wv/subscription_item"
+require_relative "wv/button"
+require_relative "wv/image"
+require_relative "wv/edit_box"
+require_relative "wv/edit_line"
+require_relative "wv/list_box"
+require_relative "wv/alert"
+require_relative "wv/span"
+require_relative "wv/shape"
+
+require_relative "wv/text_widget"
+require_relative "wv/link"
+require_relative "wv/line"
+require_relative "wv/video"

data/lib/scarpe/wv_local.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "wv"
+require_relative "wv/webview_local_display"
+
+Shoes::DisplayService.set_display_service_class(Scarpe::WebviewDisplayService)

data/lib/scarpe/wv_relay.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "wv"
+require_relative "wv/webview_relay_display"
+
+Shoes::DisplayService.set_display_service_class(Scarpe::WVRelayDisplayService)

data/lib/scarpe.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "shoes"
+
+require_relative "scarpe/logger"
+
+# This will never be triggered -- we use the (...) feature below, which means this
+# file won't even parse in old Rubies.
+if RUBY_VERSION[0..2] < "3.2"
+  Scarpe::Logger.logger("Scarpe").error("Scarpe requires Ruby 3.2 or higher!")
+  exit(-1)
+end
+
+require "securerandom"
+require "json"
+
+# Is there a Shoes::Error class? Should this be two different error classes?
+class Scarpe::Error < StandardError; end
+
+require_relative "scarpe/version"
+require_relative "scarpe/promises"
+require_relative "scarpe/display_service"
+require_relative "scarpe/widgets"
+
+require "bloops"
+
+d_s = ENV["SCARPE_DISPLAY_SERVICE"] || "wv_local"
+# This is require, not require_relative, to allow gems to supply a new display service
+require "scarpe/#{d_s}"