scarpe-wasm 0.1.0

data/lib/scarpe/wasm/webview_relay_display.rb

@@ -0,0 +1,220 @@
+# # frozen_string_literal: true
+
+# require "socket"
+# require "rbconfig"
+
+# class Scarpe
+#   # An error occurred which would normally be handled by shutting down the app
+#   class AppShutdownError < Scarpe::Error; end
+
+#   # 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 "#{@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 "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 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
+
+#     # 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 "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
+
+#     # 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
+
+#   # This display service creates a child process and sends events
+#   # back and forth, but creates no widgets of its own. The child
+#   # process will spawn a worker with its own WebviewDisplayService
+#   # where the real Webview exists. By splitting the Webview
+#   # process from the Shoes widgets, 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 WVRelayDisplayService < 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")
+
+#       @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
+
+#     # 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
+#       @shutdown = true
+#       @log.info("Attempting to shut down...")
+#       self.destroy
+#     end
+
+#     # This method sends a message to the worker process to create a widget. No actual
+#     # widget is created or registered with the display service.
+#     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
+
+#     # 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 })
+#       end
+#       @shutdown = true
+#       (@events_subs || []).each { |unsub_id| DisplayService.unsub_from_events(unsub_id) }
+#     end
+#   end
+# end

data/lib/scarpe/wasm/widget.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+class Scarpe
+  # The WASMWidget parent class helps connect a WASM widget with
+  # its Shoes equivalent, render itself to the WASM DOM, handle
+  # Javascript events and generally keep things working in WASM.
+  class WASMWidget < Shoes::Linkable
+    include Shoes::Log
+
+    class << self
+      # Return the corresponding WASM class for a particular Shoes class name
+      def display_class_for(scarpe_class_name)
+        scarpe_class = Shoes.const_get(scarpe_class_name)
+        unless scarpe_class.ancestors.include?(Shoes::Linkable)
+          raise "Scarpe WASM can only get display classes for Shoes " +
+            "linkable widgets, not #{scarpe_class_name.inspect}!"
+        end
+
+        klass = Scarpe.const_get("WASM" + scarpe_class_name.split("::")[-1])
+        if klass.nil?
+          raise "Couldn't find corresponding Scarpe WASM class for #{scarpe_class_name.inspect}!"
+        end
+
+        klass
+      end
+    end
+
+    # The Shoes ID corresponding to the Shoes widget for this WASM widget
+    attr_reader :shoes_linkable_id
+
+    # The WASMWidget parent of this widget
+    attr_reader :parent
+
+    # An array of WASMWidget children (possibly empty) of this widget
+    attr_reader :children
+
+    # Set instance variables for the display properties of this widget. Bind Shoes
+    # events for changes of parent widget and changes of property values.
+    def initialize(properties)
+      log_init("WASM::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 = WASMDisplayService.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
+
+    # Properties_changed will be called automatically when properties change.
+    # The widget should delete any changes from the Hash that it knows how
+    # to incrementally handle, and pass the rest to super. If any changes
+    # go entirely un-handled, a full redraw will be scheduled.
+    # This exists to be overridden by children watching for changes.
+    #
+    # @param changes [Hash] a Hash of new values for properties that have changed
+    def properties_changed(changes)
+      needs_update! unless changes.empty?
+    end
+
+    # Give this widget a new parent, including managing the appropriate child lists for parent widgets.
+    def set_parent(new_parent)
+      @parent&.remove_child(self)
+      new_parent&.add_child(self)
+      @parent = new_parent
+    end
+
+    # A shorter inspect text for prettier irb output
+    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-WASM for just this element and its children, if any.
+    # It is normally called by the widget itself to do its DOM management.
+    #
+    # @return [Scarpe::WebWrangler::ElementWrangler] a DOM object manager
+    def html_element
+      @elt_wrangler ||= Scarpe::WebWrangler::ElementWrangler.new(html_id)
+    end
+
+    # Return a promise that guarantees all currently-requested changes have completed
+    #
+    # @return [Scarpe::Promise] a promise that will be fulfilled when all pending changes have finished
+    def promise_update
+      html_element.promise_update
+    end
+
+    # Get the object's HTML ID
+    #
+    # @return [String] the HTML ID
+    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 WASM.
+    #
+    # @return [String] the rendered HTML
+    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 app
+    #
+    # @param event [String] the Scarpe widget event name
+    # @yield the block to call when the event occurs
+    def bind(event, &block)
+      raise("Widget has no linkable_id! #{inspect}") unless linkable_id
+
+      WASMDisplayService.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.
+    #
+    # @return [Scarpe::Promise] a promise that is fulfilled when the HTML change is complete
+    def destroy_self
+      @parent&.remove_child(self)
+      html_element.remove
+    end
+
+    # Request a full redraw of all widgets.
+    #
+    # 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.
+    #
+    # @return [void]
+    def needs_update!
+      WASMDisplayService.instance.app.request_redraw!
+    end
+
+    # Generate JS code to trigger a specific event name on this widget with the supplies arguments.
+    #
+    # @param handler_function_name [String] the event name - @see #bind
+    # @param args [Array] additional arguments that will be passed to the event in the generated JS
+    # @return [String] the generated JS code
+    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/wasm/wv_display_worker.rb

@@ -0,0 +1,75 @@
+# #!/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
+
+# # 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 WebviewContainedService < 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")
+
+#     @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/wasm.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Scarpe WASM Display Services
+
+require_relative "wasm/wasm_version"
+
+require_relative "wasm/wasm_calls"
+require_relative "wasm/web_wrangler"
+require_relative "wasm/control_interface"
+
+require_relative "wasm/widget"
+require_relative "wasm/wasm_local_display"
+
+require_relative "wasm/dimensions"
+require_relative "wasm/html"
+
+require_relative "wasm/spacing"
+require_relative "wasm/star"
+require_relative "wasm/radio"
+require_relative "wasm/background"
+require_relative "wasm/border"
+
+require_relative "wasm/arc"
+require_relative "wasm/font"
+
+require_relative "wasm/app"
+require_relative "wasm/para"
+require_relative "wasm/slot"
+require_relative "wasm/stack"
+require_relative "wasm/flow"
+require_relative "wasm/document_root"
+require_relative "wasm/subscription_item"
+require_relative "wasm/button"
+require_relative "wasm/image"
+require_relative "wasm/edit_box"
+require_relative "wasm/edit_line"
+require_relative "wasm/list_box"
+require_relative "wasm/alert"
+require_relative "wasm/span"
+require_relative "wasm/shape"
+
+require_relative "wasm/text_widget"
+require_relative "wasm/link"
+require_relative "wasm/line"
+require_relative "wasm/video"
+require_relative "wasm/check"

data/scarpe-wasm.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/scarpe/wasm/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "scarpe-wasm"
+  spec.version = Scarpe::Wasm::VERSION
+  spec.authors = ["Giovanni Borgh", "Noah Gibbs", "Scarpe Team"]
+  spec.email = ["the.codefolio.guy@gmail.com"]
+
+  spec.summary = "A WASM display library for Scarpe."
+  #spec.description = "TODO: Write a longer description or delete this line."
+  spec.homepage = "https://github.com/scarpe-team/scarpe-wasm"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  #spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/scarpe/wasm.rbs

@@ -0,0 +1,6 @@
+module Scarpe
+  module Wasm
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end