scarpe 0.2.1 → 0.3.0

data/lib/scarpe/wv/webview_local_display.rb

@@ -1,72 +1,109 @@
 # frozen_string_literal: true
 
-class Scarpe
+module Scarpe
+  # This is the simplest type of Webview DisplayService. It creates Webview drawables
+  # corresponding to Shoes drawables, manages the Webview and its DOM tree, and
+  # generally keeps the Shoes/Webview connection working.
+  #
   # 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
+  # Frequently it's better to use a RelayDisplayService to a second
   # process containing one of these.
-  class WebviewDisplayService < Scarpe::DisplayService
-    include Scarpe::Log
+  class Webview::DisplayService < Shoes::DisplayService
+    include Shoes::Log
 
     class << self
       attr_accessor :instance
     end
 
-    # TODO: re-think the list of top-level singleton objects.
+    # The ControlInterface is used to handle internal events in Webview Scarpe
     attr_reader :control_interface
+
+    # The DocumentRoot is the top drawable of the Webview-side drawable tree
     attr_reader :doc_root
+
+    # app is the Scarpe::Webview::App
+    attr_reader :app
+
+    # wrangler is the Scarpe::WebWrangler
     attr_reader :wrangler
 
-    # This is called before any of the various WebviewWidgets are created.
+    # This is called before any of the various Webview::Drawables are created, to be
+    # able to create them and look them up.
     def initialize
-      if WebviewDisplayService.instance
-        raise "ERROR! This is meant to be a singleton!"
+      if Webview::DisplayService.instance
+        raise Shoes::Errors::SingletonError, "ERROR! This is meant to be a singleton!"
       end
 
-      WebviewDisplayService.instance = self
+      Webview::DisplayService.instance = self
 
       super()
-      log_init("WV::WebviewDisplayService")
+      log_init("Webview::DisplayService")
 
-      @display_widget_for = {}
+      @display_drawable_for = {}
     end
 
-    def create_display_widget_for(widget_class_name, widget_id, properties)
-      if widget_class_name == "App"
+    # Create a Webview display drawable for a specific Shoes drawable, and pair it with
+    # the linkable ID for this Shoes drawable.
+    #
+    # @param drawable_class_name [String] The class name of the Shoes drawable, e.g. Shoes::Button
+    # @param drawable_id [String] the linkable ID for drawable events
+    # @param properties [Hash] a JSON-serialisable Hash with the drawable's Shoes styles
+    # @param is_widget [Boolean] whether the class is a user-defined Shoes::Widget subclass
+    # @return [Webview::Drawable] the newly-created Webview drawable
+    def create_display_drawable_for(drawable_class_name, drawable_id, properties, is_widget:)
+      existing = query_display_drawable_for(drawable_id, nil_ok: true)
+      if existing
+        @log.warn("There is already a display drawable for #{drawable_id.inspect}! Returning #{existing.class.name}.")
+        return existing
+      end
+
+      if drawable_class_name == "App"
         unless @doc_root
-          raise "WebviewDocumentRoot is supposed to be created before WebviewApp!"
+          raise Scarpe::MissingDocRootError, "Webview::DocumentRoot is supposed to be created before Webview::App!"
         end
 
-        display_app = Scarpe::WebviewApp.new(properties)
+        display_app = Scarpe::Webview::App.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)
+        set_drawable_pairing(drawable_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)
+      # Create a corresponding display drawable
+
+      if is_widget
+        display_class = Scarpe::Webview::Flow
+      else
+        display_class = Scarpe::Webview::Drawable.display_class_for(drawable_class_name)
+        unless display_class < Scarpe::Webview::Drawable
+          raise Scarpe::BadDisplayClassType, "Wrong display class type #{display_class.inspect} for class name #{drawable_class_name.inspect}!"
+        end
+      end
+      display_drawable = display_class.new(properties)
+      set_drawable_pairing(drawable_id, display_drawable)
 
-      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
+      if drawable_class_name == "DocumentRoot"
+        # DocumentRoot is created before App. Mostly doc_root is just like any other drawable,
+        # but we'll want a reference to it when we create App.
+        @doc_root = display_drawable
       end
 
-      display_widget
+      display_drawable
     end
 
+    # Destroy the display service and the app. Quit the process (eventually.)
+    #
+    # @return [void]
     def destroy
       @app.destroy
-      WebviewDisplayService.instance = nil
+      Webview::DisplayService.instance = nil
     end
   end
 end

data/lib/scarpe/wv/webview_relay_display.rb

@@ -3,132 +3,27 @@
 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 < Scarpe::DisplayService
-    include Scarpe::Log
-    include WVRelayUtil # Needs Scarpe::Log
+require_relative "webview_relay_util"
+
+module Scarpe
+  # This display service creates a child process and sends events
+  # back and forth, but creates no drawables of its own. The child
+  # process will spawn a worker with its own Webview::DisplayService
+  # where the real Webview exists. By splitting the Webview
+  # process from the Shoes drawables, it can be easier to return
+  # control to Webview's event handler promptly. Also, the Ruby
+  # process could run background threads if it wanted, and
+  # otherwise behave like a process ***not*** containing Webview.
+  class Webview::RelayDisplayService < Shoes::DisplayService
+    include Shoes::Log
+    include WVRelayUtil # Needs Shoes::Log
 
     attr_accessor :shutdown
 
+    # Create a Webview Relay Display Service
     def initialize
       super()
-      log_init("WV::RelayDisplayService")
+      log_init("Webview::RelayDisplayService")
 
       @event_subs = []
       @shutdown = false
@@ -151,29 +46,33 @@ class Scarpe
         if event_name == "run"
           run_event_loop
         end
-      rescue AppShutdownError
+      rescue Scarpe::AppShutdownError
         @shutdown = true
         @log.info("Attempting to shut down...")
         self.destroy
       end
     end
 
+    # Run, sending and responding to datagrams continuously.
     def run_event_loop
       until @shutdown
         respond_to_datagram while ready_to_read?
         sleep 0.1
       end
-    rescue AppShutdownError
+    rescue Scarpe::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: })
+    # This method sends a message to the worker process to create a drawable. No actual
+    # drawable is created or registered with the display service.
+    def create_display_drawable_for(drawable_class_name, drawable_id, properties)
+      send_datagram({ type: :create, class_name: drawable_class_name, id: drawable_id, properties: })
       # Don't need to return anything. It wouldn't be used anyway.
     end
 
+    # Tell the worker process to quit, and set a flag telling the event loop to shut down.
     def destroy
       unless @shutdown
         send_datagram({ type: :destroy })

data/lib/scarpe/wv/webview_relay_util.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Scarpe
+  # WVRelayUtil defines the datagram format for the sockets that connect a parent
+  # Shoes application with a child display server.
+  #
+  # The class including this module should also include Shoes::Log so that it can
+  # be used.
+  module WVRelayUtil
+    # Checks whether the internal socket is ready to be read from.
+    # If timeout is greater than 0, this will block for up to that long.
+    #
+    # @param timeout [Float] the longest to wait for more input to read
+    # @return [Boolean] whether the socket has data ready for reading
+    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 Scarpe::ConnectionError, "#{@i_am}: Got error on connection(s) from IO.select! Dying!"
+      end
+
+      !r.empty?
+    end
+
+    # Send bytes on the internal socket to the opposite side.
+    #
+    # @param contents [String] data to send
+    # @return [void]
+    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 Scarpe::DatagramSendError, "Something was wrong in send_datagram! Write returned #{count.inspect}!"
+        end
+
+        written += count
+      end
+
+      nil
+    end
+
+    # Read data from the internal socket. Read until a whole datagram
+    # has been received and then return it.
+    #
+    # @return [String] the received datagram
+    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 Scarpe::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 Scarpe::AppShutdownError, "Got exception #{$!.class} when receiving datagram... #{$!.inspect}"
+    end
+
+    # Read a datagram from the internal buffer and then dispatch it to the
+    # appropriate handler.
+    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 Scarpe::InvalidOperationError, "Parent process should never receive :create datagram!" if @i_am == :parent
+
+        @wv_display.create_display_drawable_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
+
+    # Loop for up to `t` seconds, reading data and waiting.
+    #
+    # @param t [Float] the number of seconds to loop for
+    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
+end

data/lib/scarpe/wv/wv_display_worker.rb

@@ -7,9 +7,12 @@ require "socket"
 SCARPE_DIR = File.join(__dir__, "../..")
 
 $LOAD_PATH.prepend(SCARPE_DIR)
+ENV["SCARPE_DISPLAY_SERVICE"] = "wv_local"
 require "scarpe"
 require "scarpe/wv_local"
 
+require_relative "webview_relay_util"
+
 # This script exists to create a WebviewDisplayService that can be operated remotely over a socket.
 
 if ARGV.length != 1
@@ -17,19 +20,29 @@ if ARGV.length != 1
   exit(-1)
 end
 
-class WebviewContainedService < Scarpe::DisplayService::Linkable
-  include Scarpe::Log
-  include Scarpe::WVRelayUtil # Needs Scarpe::Log
+# This is the implementation of a freestanding Scarpe Webview display server,
+# which connects via sockets and sends events and properties back and forth
+# with a display-less Shoes app. The interface is designed to allow fork-based
+# usage, where a parent process could create a paired sockets and start the
+# child server. It can also be used via TCP sockets or similar, where a single
+# socket is both input and output.
+class Scarpe::Webview::ContainedService < Shoes::Linkable
+  include Shoes::Log
+  include Scarpe::WVRelayUtil # Needs Shoes::Log
 
   attr_reader :log
 
+  # Create a new DisplayService.
+  #
+  # @param from [Socket] a readable socket to get input from the Shoes process
+  # @param to [Socket] a writable socket on which to send output to the Shoes process
   def initialize(from, to)
     super()
-    log_init("WV::DisplayWorker")
+    log_init("Webview::DisplayWorker")
 
     @i_am = :child
     @event_subs = []
-    @wv_display = Scarpe::WebviewDisplayService.new
+    @wv_display = Scarpe::Webview::DisplayService.new
 
     @from = from
     @to = to
@@ -60,6 +73,6 @@ end
 
 s = TCPSocket.new("localhost", ARGV[0].to_i)
 
-SERVICE = WebviewContainedService.new(s, s)
+SERVICE = Scarpe::Webview::ContainedService.new(s, s)
 
 SERVICE.log.info("Finished event loop. Exiting!")

data/lib/scarpe/wv.rb

@@ -2,38 +2,100 @@
 
 # Scarpe Webview Display Services
 
+# This file is for everything that should be included by *both* wv_local and wv_relay
+
+require "securerandom"
+require "json"
+
+require "bloops"
+require "scarpe/components/html" # HTML renderer
+require "scarpe/components/modular_logger"
+require "scarpe/components/promises"
+require "scarpe/components/string_helpers"
+
+# Module to contain the various Scarpe Webview classes
+module Scarpe::Webview
+  HTML = Scarpe::Components::HTML
+end
+
+# Set up Scarpe-Webview's HTML renderer
+ren = ENV["SCARPE_HTML_RENDERER"] || "calzini"
+# This should *not* be require_relative so that other gems can implement HTML renderers.
+require "scarpe/components/#{ren}"
+class Scarpe::Webview::Drawable < Shoes::Linkable
+  # By default it's Scarpe::Components::Calzini
+  comp = Scarpe::Components::StringHelpers.camelize(ENV["SCARPE_HTML_RENDERER"] || "calzini")
+  mod = Scarpe::Components.const_get(comp)
+  include mod
+end
+
+# Set up hierarchical logging using the SCARPE_LOG_CONFIG var for configuration
+log_config = if ENV["SCARPE_LOG_CONFIG"]
+  JSON.load_file(ENV["SCARPE_LOG_CONFIG"])
+else
+  ENV["SCARPE_DEBUG"] ? Shoes::Log::DEFAULT_DEBUG_LOG_CONFIG : Shoes::Log::DEFAULT_LOG_CONFIG
+end
+
+Shoes::Log.instance = Scarpe::Components::ModularLogImpl.new
+Shoes::Log.configure_logger(log_config)
+
+require "scarpe/components/segmented_file_loader"
+loader = Scarpe::Components::SegmentedFileLoader.new
+Shoes.add_file_loader loader
+
+# Fun trivia: listing the full set of available fonts is a fingerprinting attack, so it's not
+# available from JS. These are all commonly available web fonts, though.
+Shoes::FONTS.push(
+  "Helvetica",
+  "Arial",
+  "Arial Black",
+  "Verdana",
+  "Tahoma",
+  "Trebuchet MS",
+  "Impact",
+  "Gill Sans",
+  "Times New Roman",
+  "Georgia",
+  "Palatino",
+  "Baskerville",
+  "Courier",
+  "Lucida",
+  "Monaco",
+)
+
+require_relative "shoes_spec"
+Shoes::Spec.instance = Scarpe::Test
+
 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/drawable"
 
-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/radio"
 
-require_relative "wv/fill"
 require_relative "wv/arc"
 
 require_relative "wv/app"
-require_relative "wv/document_root"
 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/text_drawable"
+require_relative "wv/span"
 require_relative "wv/link"
 require_relative "wv/line"
+require_relative "wv/rect"
+require_relative "wv/video"
+require_relative "wv/check"
+require_relative "wv/progress"
+require_relative "wv/arrow"

data/lib/scarpe/wv_local.rb

@@ -3,4 +3,4 @@
 require_relative "wv"
 require_relative "wv/webview_local_display"
 
-Scarpe::DisplayService.set_display_service_class(Scarpe::WebviewDisplayService)
+Shoes::DisplayService.set_display_service_class(Scarpe::Webview::DisplayService)

data/lib/scarpe/wv_relay.rb

@@ -3,4 +3,4 @@
 require_relative "wv"
 require_relative "wv/webview_relay_display"
 
-Scarpe::DisplayService.set_display_service_class(Scarpe::WVRelayDisplayService)
+Shoes::DisplayService.set_display_service_class(Scarpe::Webview::RelayDisplayService)