interfacets 0.9.9 → 0.9.99

data/lib/interfacets/test/js/inline_bus.rb

@@ -19,7 +19,7 @@ module Interfacets
             type: "interfacets:system:create_bus",
             payload: {
               id: "default",
-              channel_ids: ["interfacets:api", "dom", "url"],
+              channel_ids: ["interfacets:api", "dom", "url", "timer"],
               hydration: {
                 destination: { bus: "default", channel: "interfacets:api" },
                 type: "interfacets:api:hydrate",
@@ -30,6 +30,10 @@ module Interfacets
           }))
         end
 
+        def dispatch(channel_id, event)
+          dispatch_to_bus(bus_id: "default", channel_id: channel_id, event: event)
+        end
+
         private
 
         def handle(event)
@@ -40,21 +44,33 @@ module Interfacets
 
             bus_event.fetch("payload").each do |channel_event|
               channel_id = channel_event.fetch("id")
-              receiver_index
-                .fetch(channel_id)
+              receiver = receiver_index.fetch(channel_id)
+
+              receiver
                 .receive(
                   payload: channel_event.fetch("payload"),
                   dispatch: ->(ev) {
-                    dispatch(bus_id:, channel_id:, event: ev)
+                    dispatch_to_bus(bus_id:, channel_id:, event: ev)
                   },
                 )
             end
           else
             raise("unhandled event type: #{event}")
           end
+
+          # Flush any responses that may have come from the server
+          # should separate this out so that auto-flush or manual-flush
+          # is possible to simulate ordering events as needed.
+          receiver_index.each do |channel_id, receiver|
+            if receiver.respond_to?(:response_queue)
+              receiver.flush_responses.each do |response|
+                dispatch_to_bus(bus_id:, channel_id:, event: response)
+              end
+            end
+          end
         end
 
-        def dispatch(bus_id:, channel_id:, event:)
+        def dispatch_to_bus(bus_id:, channel_id:, event:)
           client.handle(
             H.j(
               {
@@ -69,13 +85,6 @@ module Interfacets
         def client
           @client ||= (
             $asset_logger = Logger.new("/dev/null")
-            original_verbose = $VERBOSE
-            $VERBOSE = nil
-            begin
-              Client::Assets.bootstrap(client_system_json.fetch("assets"))
-            ensure
-              $VERBOSE = original_verbose
-            end
             Client::System.logger = $asset_logger
 
             Client.start(

data/lib/interfacets/test/js/nodo_bus.rb

@@ -30,10 +30,27 @@ module Interfacets
 
         def render
           receiver_index.each do |id, ch|
+            state = js_get_state(id)
+            next if state.nil?
+
             ch.receive(
-              payload: js_get_state(id).fetch("data"),
+              payload: state.fetch("data"),
               dispatch: ->(e) { dispatch(id, e) }
             )
+
+            receiver_index.each do |id, ch|
+              if ch.respond_to?(:response_queue)
+                ch.flush_responses.each do |response|
+                  dispatch(id, response)
+                end
+              end
+            end
+          end
+
+          if js_get_logs.any? { _1.fetch("type") == "error" }
+            js_get_logs
+            .map { _1.fetch("value") }
+            .then { raise(_1.join("\n")) }
           end
         end
 

data/lib/interfacets/test/js/receivers/api.rb

@@ -25,10 +25,21 @@ module Interfacets
             return if payload.dig("streams", "default").nil?
             return if payload.dig("streams", "default").empty?
 
+            method = payload.dig("streams", "default", "method")
             url = payload.dig("streams", "default", "url")
-            payload
-              .dig("streams", "default", "body", "event", "payload")
-              .then { response_queue << router.call(url).handle(_1) }
+
+
+            if method == "get"
+              response_queue << router.call(url).render
+            else
+              payload
+                .dig("streams", "default", "body", "event", "payload")
+                .then { response_queue << router.call(url).handle(_1) }
+            end
+          end
+
+          def flush_responses
+            response_queue.tap { @response_queue = [] }
           end
         end
       end

data/lib/interfacets/test/js/receivers/react/node/xml_parser.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Interfacets
+  module Test
+    module Js
+      module Receivers
+        class React
+          class Node
+            class XmlParser
+              attr_reader :json, :validation_engine
+              def initialize(json, validation_engine:)
+                @json = json
+                @validation_engine = validation_engine
+              end
+
+              def call
+                xml = Nokogiri::XML.fragment("<Facet/>")
+                json
+                  .dig("streams", "default", "dom")
+                  .map { parse_element(_1) }
+                  .each { xml.add_child(_1) }
+                xml
+              end
+
+              private
+
+              def parse_attribute(value, top: true)
+                case value
+                when Array
+                when Hash
+                  value
+                    .transform_values { parse_attribute(_1, top: false) }
+                    # we don't want to call to_json on nested hashes
+                    .then { top ? _1.to_json : _1 }
+                when Numeric, String, TrueClass, FalseClass, NilClass
+                  value
+                else
+                  raise "unknown attribute type: #{value}"
+                end
+              end
+
+              def parse_element(el)
+                case el.fetch("type")
+                when "interfacets:string-node"
+                  el.dig("attributes", "value").to_s
+                when "interfacets:react-dom:element"
+                  xml = (
+                    el
+                      .fetch("element")
+                      .tap { validation_engine&.validate_props(_1, el.fetch("attributes")) }
+                      .then { Nokogiri::XML.fragment("<#{_1} />").children.first }
+                  )
+
+                  el.fetch("children").each do |child|
+                    xml.add_child(parse_element(child)) if child
+                  end
+
+                  el.fetch("attributes").each do |name, value|
+                    xml.set_attribute(name, parse_attribute(value))
+                  end
+
+                  xml
+                else
+                  raise "unknown type: #{el.fetch("type")}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/test/js/receivers/react/node.rb

@@ -8,71 +8,17 @@ module Interfacets
       module Receivers
         class React
           class Node
-            class XmlParser
-              attr_reader :json
-              def initialize(json)
-                @json = json
-              end
-
-              def call
-                xml = Nokogiri::XML.fragment("<Facet/>")
-                json
-                  .dig("streams", "default", "dom")
-                  .map { parse_element(_1) }
-                  .each { xml.add_child(_1) }
-                xml
-              end
-
-              private
-
-              def parse_attribute(value)
-                case value
-                when Array
-                when Hash
-                  value.transform_values { parse_attribute(_1) }
-                when Numeric, String, TrueClass, FalseClass, NilClass
-                  value
-                else
-                  raise "unknown attribute type: #{value}"
-                end
-              end
-
-              def parse_element(el)
-                case el.fetch("type")
-                when "interfacets:string-node"
-                  el.dig("attributes", "value")
-                when "interfacets:react-dom:element"
-                  xml = (
-                    el
-                      .fetch("element")
-                      .then { Nokogiri::XML.fragment("<#{_1} />").children.first }
-                  )
-
-                  el.fetch("children").each do |child|
-                    xml.add_child(parse_element(child)) if child
-                  end
-
-                  el.fetch("attributes").each do |name, value|
-                    xml.set_attribute(name, parse_attribute(value).to_json)
-                  end
-
-                  xml
-                else
-                  raise "unknown type: #{el.fetch("type")}"
-                end
-              end
-            end
-
-            def self.parse(json:, dispatch:)
+            def self.parse(json:, dispatch:, validation_engine:)
               new(
-                xml: XmlParser.new(json).call,
+                xml: XmlParser.new(json, validation_engine:).call,
                 dispatch:,
+                validation_engine:,
                 parent: nil,
               )
             end
 
             Error = Class.new(StandardError)
-            NoMatchesErrorError = Class.new(Error)
+            NoMatchesError = Class.new(Error)
             MultipleMatchesError = Class.new(Error)
             StaleNodeError = Class.new(Error) do
               def initialize
@@ -87,11 +33,12 @@ module Interfacets
               end
             end
 
-            attr_reader :xml, :dispatch, :parent
-            def initialize(xml:, dispatch:, parent:)
+            attr_reader :xml, :dispatch, :parent, :validation_engine
+            def initialize(xml:, dispatch:, parent:, validation_engine:)
               @xml = xml
               @dispatch = dispatch
               @parent = parent
+              @validation_engine = validation_engine
             end
 
             def stale!
@@ -102,6 +49,20 @@ module Interfacets
               @stale || parent&.stale?
             end
 
+            def component_name
+              raise StaleNodeError if stale?
+
+              xml.name
+            end
+
+            def props
+              raise StaleNodeError if stale?
+
+              xml.attributes.transform_values do |attr|
+                attr.value.then { JSON.parse(_1) rescue _1 }
+              end
+            end
+
             def content
               raise StaleNodeError if stale?
 
@@ -129,12 +90,12 @@ module Interfacets
 
               xml
                 .css(*a, **p)
-                .map { Node.new(xml: _1, dispatch:, parent: self) }
+                .map { Node.new(xml: _1, dispatch:, parent: self, validation_engine:) }
                 .select {
                   (
                     content == EMPTY_ARG || (
                       if content.is_a?(Regexp)
-                        _1.content.match(content)
+                        _1.content.match?(content)
                       else
                         _1.content == content
                       end
@@ -149,13 +110,18 @@ module Interfacets
 
               xml
                 .attribute(name)
-                .then { JSON.parse(_1) }
+                &.value
+                &.then { JSON.parse(_1) rescue _1 }
             end
 
             def trigger(name, data = {})
               raise StaleNodeError if stale?
 
+              validation_engine&.validate_event(xml.name, name, data)
+
               value = attribute(name.to_s)
+              raise "No event handler registered for: #{name}" unless value
+
               value["payload"]["event"] = data
               dispatch.(value)
             end

data/lib/interfacets/test/js/receivers/react.rb

@@ -8,9 +8,10 @@ module Interfacets
     module Js
       module Receivers
         class React
-          attr_reader :name, :node
-          def initialize(name:)
+          attr_reader :name, :node, :validation_engine
+          def initialize(name:, validation_engine: nil)
             @name = name
+            @validation_engine = validation_engine
             @actions = {}
           end
 
@@ -18,7 +19,7 @@ module Interfacets
             @dispatch = dispatch
             @actions = nil
             @node&.stale!
-            @node = Node.parse(json: payload, dispatch:)
+            @node = Node.parse(json: payload, dispatch:, validation_engine:)
           end
 
           def handler

data/lib/interfacets/test/js/receivers/timer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Test
+    module Js
+      module Receivers
+        class Timer
+          include Enumerable
+
+          class Registration
+            attr_reader :ms, :response_payload, :dispatch
+
+            def initialize(ms:, response_payload:, dispatch:)
+              @ms = ms
+              @response_payload = response_payload
+              @dispatch = dispatch
+              @notified = false
+            end
+
+            def notify
+              return if @notified
+              @dispatch.call({ payload: response_payload })
+              @notified = true
+            end
+          end
+
+          attr_reader :name, :registrations
+          def initialize(name:)
+            @name = name
+            @registrations = []
+          end
+
+          def receive(payload:, dispatch:)
+            @dispatch = dispatch
+
+            return if payload.nil?
+            return if payload.empty?
+            return if payload.dig("streams", "default").nil?
+            return if payload.dig("streams", "default").empty?
+
+            event = payload.dig("streams", "default")
+            ms = event["ms"]
+            response_payload = event["response"]
+
+            return unless ms && response_payload
+
+            @registrations << Registration.new(
+              ms: ms,
+              response_payload: response_payload,
+              dispatch: dispatch
+            )
+          end
+
+          def handler
+            self
+          end
+
+          def first
+            registrations.first
+          end
+
+          def last
+            registrations.last
+          end
+
+          def each(&block)
+            registrations.each(&block)
+          end
+
+          def clear
+            @registrations = []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/test/js/receivers/url.rb

@@ -32,6 +32,7 @@ module Interfacets
           attr_reader :server, :name, :response_queue
           def initialize(name:)
             @name = name
+            @response_queue = []
           end
 
           def receive(payload:, dispatch:)
@@ -48,6 +49,10 @@ module Interfacets
           def handler
             @handler
           end
+
+          def flush_responses
+            response_queue.tap { @response_queue = [] }
+          end
         end
       end
     end

data/lib/interfacets/test/standard_elements.yml

@@ -0,0 +1,173 @@
+---
+- a
+- abbr
+- address
+- area
+- article
+- aside
+- audio
+- b
+- base
+- bdi
+- bdo
+- blockquote
+- body
+- br
+- button
+- canvas
+- caption
+- cite
+- code
+- col
+- colgroup
+- data
+- datalist
+- dd
+- del
+- details
+- dfn
+- dialog
+- div
+- dl
+- dt
+- em
+- embed
+- fieldset
+- figcaption
+- figure
+- footer
+- form
+- h1
+- h2
+- h3
+- h4
+- h5
+- h6
+- head
+- header
+- hgroup
+- hr
+- html
+- i
+- iframe
+- img
+- input
+- ins
+- kbd
+- label
+- legend
+- li
+- link
+- main
+- map
+- mark
+- menu
+- meta
+- meter
+- nav
+- noscript
+- object
+- ol
+- optgroup
+- option
+- output
+- p
+- picture
+- pre
+- progress
+- q
+- rp
+- rt
+- ruby
+- s
+- samp
+- script
+- section
+- select
+- slot
+- small
+- source
+- span
+- strong
+- style
+- sub
+- summary
+- sup
+- table
+- tbody
+- td
+- template
+- textarea
+- tfoot
+- th
+- thead
+- time
+- title
+- tr
+- track
+- u
+- ul
+- var
+- video
+- wbr
+- animate
+- animatemotion
+- animatetransform
+- circle
+- clippath
+- defs
+- desc
+- discard
+- ellipse
+- feblend
+- fecolormatrix
+- fecomponenttransfer
+- fecomposite
+- feconvolvematrix
+- fediffuselighting
+- fedisplacementmap
+- fedistantlight
+- fedropshadow
+- feflood
+- fefunca
+- fefuncb
+- fefuncg
+- fefuncr
+- fegaussianblur
+- feimage
+- femerge
+- femergenode
+- femorphology
+- feoffset
+- fepointlight
+- fespecularlighting
+- fespotlight
+- fetile
+- feturbulence
+- filter
+- foreignobject
+- g
+- image
+- line
+- lineargradient
+- marker
+- mask
+- metadata
+- mpath
+- path
+- pattern
+- polygon
+- polyline
+- radialgradient
+- rect
+- script
+- set
+- stop
+- svg
+- switch
+- symbol
+- text
+- textpath
+- tspan
+- use
+- view

data/lib/interfacets/test/{browser.rb → ui_simulator.rb}

@@ -1,14 +1,15 @@
 
 module Interfacets
   module Test
-    class Browser
+    class UiSimulator
       TYPES = {
         inline: Js::InlineBus,
         nodo: Js::NodoBus,
+        mruby_wasm: Js::NodoBus,
       }
 
-      attr_reader :system_json, :router, :type
-      def initialize(system_json:, router:, type:)
+      attr_reader :system_json, :router, :type, :contract_path, :validation
+      def initialize(type:, bus:, router:, contract_path: nil, validation: :strict)
         unless TYPES.keys.include?(type)
           raise ArgumentError.new(
             "type: #{type.inspect} not allowed. Must be one of #{TYPES.keys}"
@@ -17,8 +18,10 @@ module Interfacets
 
         @type = type
         # Serialize and deserialize to ensure proper data structure for JS
-        @system_json = JSON.parse(system_json.to_json)
+        @system_json = JSON.parse(bus.client_system_json(only_facets: type == :inline).to_json)
         @router = router
+        @contract_path = contract_path
+        @validation = validation
       end
 
       def visit(path)
@@ -43,14 +46,23 @@ module Interfacets
         c("dom")
       end
 
+      def timers
+        c("timer")
+      end
+
       private
 
       def js
         @js ||= (
+          validation_engine = if contract_path
+            ValidationEngine.new(ComponentRegistry.load(contract_path), validation_mode: validation)
+          end
+
           js_api = Test::Js::Receivers::Api.new(name: "interfacets:api", router:)
-          js_react = Test::Js::Receivers::React.new(name: "dom")
+          js_react = Test::Js::Receivers::React.new(name: "dom", validation_engine:)
           js_url = Test::Js::Receivers::Url.new(name: "url")
-          receivers = [js_api, js_react, js_url]
+          js_timer = Test::Js::Receivers::Timer.new(name: "timer")
+          receivers = [js_api, js_react, js_url, js_timer]
 
           TYPES.fetch(type).new(
             receiver_index: receivers.map { [_1.name, _1] }.to_h,