scarpe-wasm 0.1.0

data/lib/scarpe/wasm/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Scarpe
+  module Wasm
+    VERSION = "0.1.0"
+  end
+end

data/lib/scarpe/wasm/video.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Scarpe
+  class WASMVideo < Scarpe::WASMWidget
+    SUPPORTED_FORMATS = {
+      "video/mp4" => [".mp4"],
+      "video/webp" => [".webp"],
+      "video/quicktime" => [".mov"],
+      "video/x-matroska" => [".mkv"],
+      # Add more formats and their associated file extensions if needed
+    }.freeze
+
+    def initialize(properties)
+      @url = properties[:url]
+      super
+    end
+
+    def element
+      HTML.render do |h|
+        h.video(id: html_id, style: style, controls: true) do
+          supported_formats.each do |format|
+            h.source(src: @url, type: format)
+          end
+        end
+      end
+    end
+
+    private
+
+    def supported_formats
+      SUPPORTED_FORMATS.select { |_format, extensions| extensions.include?(File.extname(@url)) }.keys
+    end
+
+    def style
+      styles = {}
+
+      # ADD YOUR STYLES HERE
+
+      styles.compact
+    end
+  end
+end

data/lib/scarpe/wasm/wasm_calls.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "js"
+
+class Scarpe
+  class WASMInterops
+    include Scarpe::Log
+
+    def initialize
+      log_init("WASM")
+    end
+
+    def js_integer?(num)
+      if JS.global[:Number].isInteger(num)
+        true
+      else
+        false
+      end
+    end
+
+    def rubify(obj)
+      type = obj.typeof
+      case type
+      when "string"
+        obj.to_s
+      when "number"
+        if js_integer?(obj)
+          obj.to_i
+        else
+          obj.to_f
+        end
+      when "undefined"
+        nil
+      else
+        obj
+      end
+    end
+
+    def bind(name, func = nil, &block)
+      JS.global[:self][name.to_sym] = proc do |*args|
+        args = args.map { |x| rubify(x) }
+        (func ? func : block).call(*args)
+      rescue => e
+        @log.error(e)
+        @log.error(e.backtrace)
+      end
+      defined?(JS.global[:self][name.to_sym])
+    end
+
+    def eval(command)
+      JS.eval(command)
+    end
+
+    def init(command)
+      @commands ||= []
+      @commands << command
+    end
+
+    def set_title(title)
+      JS.global[:document][:title] = title
+    end
+
+    def set_size(width, height, hint)
+      #JS.global[:document][:body][:style][:width] = width
+      #JS.global[:document][:body][:style][:height] = height
+    end
+
+    def navigate(string)
+      # JS.eval('var empty =
+      # `body {
+      #   font-family: arial, Helvetica, sans-serif;
+      #   margin: 0;
+      #   height: 100%;
+      #   overflow: hidden;
+      # }
+      # p {
+      #   margin: 0;
+      # }`;')
+      # JS.eval("var head = document.head || document.getElementsByTagName('head')[0];")
+      # JS.eval("var style = document.createElement('style');")
+      # JS.eval("head.appendChild(style);")
+      # JS.eval("style.type = 'text/css';")
+      # # JS.eval("style.id = 'style-wvroot';")
+      # JS.eval("head.id = 'head-wvroot';")
+      # JS.eval("head.appendChild(style);")
+      # JS.eval("style.appendChild(document.createTextNode(empty));")
+      # JS.eval("var body = document.body;")
+      # JS.eval("body.id = 'body-wvroot';")
+      # JS.eval("var newDiv = document.createElement('div');")
+      # JS.eval("newDiv.id = 'wrapper-wvroot';")
+      # JS.eval("body.appendChild(newDiv);")
+
+      style = JS.global[:document].createElement("style")
+      style[:id] = "style-wvroot"
+      style.appendChild(JS.global[:document].createTextNode("body {
+        font-family: arial, Helvetica, sans-serif;
+        margin: 0;
+        height: 100%;
+      }
+      p {
+        margin: 0;
+      }"))
+      JS.global[:document][:head].appendChild(style)
+      JS.global[:document][:head][:id] = "head-wvroot"
+      div = JS.global[:document].createElement("div")
+      div[:id] = "wrapper-wvroot"
+      JS.global[:document][:body].appendChild(div)
+    end
+
+    def run
+      @commands.each { |command| JS.eval(command) }
+    end
+
+    def terminate
+      # stub
+    end
+  end
+end

data/lib/scarpe/wasm/wasm_local_display.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+class Scarpe
+  # This is the simplest type of WASM DisplayService. It creates WASM widgets
+  # corresponding to Shoes widgets, manages the WASM and its DOM tree, and
+  # generally keeps the Shoes/WASM connection working.
+  #
+  # This is an in-process WASM-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.
+  # Frequently it's better to use a RelayDisplayService to a second
+  # process containing one of these.
+  class WASMDisplayService < Shoes::DisplayService
+    include Shoes::Log
+
+    class << self
+      attr_accessor :instance
+    end
+
+    # The ControlInterface is used to handle internal events in WASM Scarpe
+    attr_reader :control_interface
+
+    # The DocumentRoot is the top widget of the WASM-side widget tree
+    attr_reader :doc_root
+
+    # app is the Scarpe::WASMApp
+    attr_reader :app
+
+    # wrangler is the Scarpe::WebWrangler
+    attr_reader :wrangler
+
+    # This is called before any of the various WASMWidgets are created, to be
+    # able to create them and look them up.
+    def initialize
+      if WASMDisplayService.instance
+        raise "ERROR! This is meant to be a singleton!"
+      end
+
+      WASMDisplayService.instance = self
+
+      super()
+      log_init("WASM::WASMDisplayService")
+
+      @display_widget_for = {}
+    end
+
+    # Create a WASM display widget for a specific Shoes widget, and pair it with
+    # the linkable ID for this Shoes widget.
+    #
+    # @param widget_class_name [String] The class name of the Shoes widget, e.g. Shoes::Button
+    # @param widget_id [String] the linkable ID for widget events
+    # @param properties [Hash] a JSON-serialisable Hash with the widget's display properties
+    # @return [WASMWidget] the newly-created WASM widget
+    def create_display_widget_for(widget_class_name, widget_id, properties)
+      if widget_class_name == "App"
+        unless @doc_root
+          raise "WASMDocumentRoot is supposed to be created before WASMApp!"
+        end
+
+        display_app = Scarpe::WASMApp.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::WASMWidget.display_class_for(widget_class_name)
+      display_widget = display_class.new(properties)
+      set_widget_pairing(widget_id, display_widget)
+
+      if widget_class_name == "DocumentRoot"
+        # WASMDocumentRoot is created before WASMApp. Mostly doc_root is just like any other widget,
+        # but we'll want a reference to it when we create WASMApp.
+        @doc_root = display_widget
+      end
+
+      display_widget
+    end
+
+    # Destroy the display service and the app. Quit the process (eventually.)
+    #
+    # @return [void]
+    def destroy
+      @app.destroy
+      WASMDisplayService.instance = nil
+    end
+  end
+end