lacci 0.2.1 → 0.3.0

data/lib/scarpe/wv/webview_local_display.rb

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

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

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

@@ -1,65 +0,0 @@
-#!/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

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

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

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

@@ -1,29 +0,0 @@
-# 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}"

data/lib/shoes/text_widget.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-# Scarpe::TextWidget
-
-module Shoes
-  class TextWidget < Shoes::Widget
-    class << self
-      # rubocop:disable Lint/MissingSuper
-      def inherited(subclass)
-        Shoes::Widget.widget_classes ||= []
-        Shoes::Widget.widget_classes << subclass
-      end
-      # rubocop:enable Lint/MissingSuper
-    end
-  end
-
-  class << self
-    def default_text_widget_with(element)
-      class_name = element.capitalize
-
-      widget_class = Class.new(Shoes::TextWidget) do
-        # Can we just change content to text to match the Shoes API?
-        display_property :content
-
-        def initialize(content)
-          @content = content
-
-          super
-
-          create_display_widget
-        end
-
-        def text
-          self.content
-        end
-
-        def text=(new_text)
-          self.content = new_text
-        end
-      end
-      # TODO: move this to Shoes module
-      Scarpe.const_set class_name, widget_class
-      widget_class.class_eval do
-        display_property :content
-      end
-    end
-  end
-end
-
-Shoes.default_text_widget_with(:code)
-Shoes.default_text_widget_with(:em)
-Shoes.default_text_widget_with(:strong)