interfacets 0.1.0 → 0.9.99

data/lib/interfacets/shared/validations.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    module Validations
+      extend ActiveSupport::Concern
+
+      class Errors
+        include Enumerable
+
+        def initialize
+          @errors = Hash.new { |h, k| h[k] = [] }
+        end
+
+        def add(k, v)
+          @errors[k.to_sym] << v
+        end
+
+        def clear
+          @errors.clear
+        end
+
+        def [](k)
+          @errors[k]
+        end
+
+        def each(...)
+          @errors.each(...)
+        end
+
+        def empty?
+          @errors.all? { _2.empty? }
+        end
+      end
+
+      included do
+        def self.validators
+          @validators ||= []
+        end
+
+        def self.validate(&block)
+          raise(ArgumentError.new("block required")) unless block_given?
+
+          validators << block
+        end
+
+        def errors
+          @errors ||= Errors.new
+        end
+
+        def errors_if_changed(attr)
+          errors[attr].any? ? errors[attr] : nil
+        end
+
+        def valid?
+          errors.empty?
+        end
+
+        def validate
+          @errors = Errors.new
+          self.class.validators.each do |block|
+            instance_exec(&block)
+          end
+        end
+
+        # on_change do |attr, _old_val, _new_val|
+        #   reset_validations
+        # end
+      end
+
+      class_methods do
+      end
+    end
+  end
+end

data/lib/interfacets/shared/view.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    class View
+      class Evaluator
+        def self.call(**p)
+          new(**p).call
+        end
+
+        attr_reader :entity, :channels, :block
+        def initialize(entity:, channels:, block:)
+          @entity = entity
+          @channels = channels
+          @block = block
+          @data = Hash.new { |h, k| h[k] = { streams: {} } }
+        end
+
+        def call
+          instance_exec(entity, &@block)
+        end
+
+        def render(entity)
+          entity
+            .class
+            .view
+            .render(
+              entity:,
+              channels:
+            )
+        end
+
+        def render_to(channel_id, stream: "default", &block)
+          channel_id = channel_id.to_s
+
+          channels
+            .fetch(channel_id)
+            .builder(stream.to_s)
+            .then { @current_builder = _1 }
+            .then { instance_exec(_1, &block) }
+        end
+
+        def channel(name)
+          @channels.fetch(name)
+        end
+      end
+
+      class << self
+        def view(&block)
+          @view = block if block_given?
+          @view
+        end
+
+        def view=(val)
+          @view = val
+        end
+
+        def render(**p)
+          new.render(**p)
+        end
+      end
+
+      def render(entity:, channels:)
+        return unless self.class.view
+
+        Evaluator.call(
+          entity: entity,
+          channels: channels,
+          block: self.class.view
+        )
+      end
+    end
+  end
+end

data/lib/interfacets/test/component_registry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Interfacets
+  module Test
+    class ComponentRegistry
+      DEFAULT_CONFIG_PATH = "config/interfacets/components.yml"
+
+      def self.load(path = DEFAULT_CONFIG_PATH)
+        new(path)
+      end
+
+      attr_reader :contracts
+
+      def initialize(path)
+        @path = path
+        @schema_cache = {}
+        @contracts = load_contracts
+      end
+
+      def find_component(name)
+        @contracts[name.to_s]
+      end
+
+      def definitions
+        @contracts["definitions"] || {}
+      end
+
+      private
+
+      def load_contracts
+        return {} unless File.exist?(@path)
+
+        contracts = YAML.load_file(@path, aliases: true) || {}
+        contracts.each do |name, config|
+          next unless config.is_a?(Hash)
+
+          schema = config["schema"]
+          if schema.is_a?(String)
+            config["schema"] = load_schema_file(name, schema)
+          end
+        end
+        contracts
+      rescue Psych::SyntaxError => e
+        raise Error, "Failed to parse component registry at #{@path}: #{e.message}"
+      end
+
+      def load_schema_file(component_name, schema_path)
+        full_path = File.expand_path(schema_path, File.dirname(@path))
+        return @schema_cache[full_path] if @schema_cache.key?(full_path)
+
+        raise Errno::ENOENT, "Schema file not found for component '#{component_name}' at #{full_path}" unless File.exist?(full_path)
+
+        begin
+          @schema_cache[full_path] = YAML.load_file(full_path, aliases: true) || {}
+        rescue Psych::SyntaxError => e
+          raise Error, "Failed to parse schema file for component '#{component_name}' at #{full_path}: #{e.message}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+require "nodo"
+
+module Interfacets
+  module Test
+    module Js
+      class InlineBus
+        attr_reader :receiver_index, :client_system_json
+        def initialize(receiver_index:, client_system_json:)
+          @receiver_index = receiver_index
+          @client_system_json = client_system_json
+        end
+
+        def handler(channel_id)
+          receiver_index.fetch(channel_id).handler
+        end
+
+        def init(hydrated_facet:)
+          client.handle(H.j({
+            type: "interfacets:system:create_bus",
+            payload: {
+              id: "default",
+              channel_ids: ["interfacets:api", "dom", "url", "timer"],
+              hydration: {
+                destination: { bus: "default", channel: "interfacets:api" },
+                type: "interfacets:api:hydrate",
+                payload: hydrated_facet
+              },
+              config: client_system_json,
+            }
+          }))
+        end
+
+        def dispatch(channel_id, event)
+          dispatch_to_bus(bus_id: "default", channel_id: channel_id, event: event)
+        end
+
+        private
+
+        def handle(event)
+          case event.fetch("type")
+          when "interfacets:system:render"
+            bus_event = event.fetch("payload")
+            bus_id = bus_event.fetch("id")
+
+            bus_event.fetch("payload").each do |channel_event|
+              channel_id = channel_event.fetch("id")
+              receiver = receiver_index.fetch(channel_id)
+
+              receiver
+                .receive(
+                  payload: channel_event.fetch("payload"),
+                  dispatch: ->(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_to_bus(bus_id:, channel_id:, event:)
+          client.handle(
+            H.j(
+              {
+                destination: { bus: bus_id, channel: channel_id },
+                type: "interfacets:channel:event",
+                payload: event,
+              },
+            ),
+          )
+        end
+
+        def client
+          @client ||= (
+            $asset_logger = Logger.new("/dev/null")
+            Client::System.logger = $asset_logger
+
+            Client.start(
+              transmit: ->(event) {
+                handle(H.j(event))
+              },
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+require "nodo"
+
+module Interfacets
+  module Test
+    module Js
+      class NodoBus < Nodo::Core
+        attr_reader :receiver_index, :client_system_json
+        def initialize(receiver_index:, client_system_json:)
+          super()
+          @receiver_index = receiver_index
+          @client_system_json = client_system_json
+        end
+
+        def dispatch(channel_id, event)
+          js_dispatch(channel_id, event)
+          render
+        end
+
+        def handler(channel_id)
+          receiver_index.fetch(channel_id).handler
+        end
+
+        def init(hydrated_facet:)
+          js_init(
+            clientSystemJson: client_system_json,
+            hydratedFacet: hydrated_facet
+          )
+          render
+        end
+
+        def render
+          receiver_index.each do |id, ch|
+            state = js_get_state(id)
+            next if state.nil?
+
+            ch.receive(
+              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
+
+        import app: File.join(__dir__, "../../../../test/wasm/app.mjs")
+        import :fs
+
+        function :js_init, <<~JS
+          async (config) => {
+            global.logs = []
+            global.console = {
+              log: (...msgs) => {
+                global.logs.push({
+                  type: "log",
+                  value: msgs.map(m => m.toString())
+                })
+              },
+              error: (...msgs) => {
+                global.logs.push({
+                  type: "error",
+                  value: msgs.map(m => m.toString())
+                })
+              },
+            }
+
+            await app.init(config)
+          }
+        JS
+
+        function :js_dispatch, <<~JS
+          (channelName, event) => {
+            app.dispatch(channelName, event)
+          }
+        JS
+
+        function :js_get_logs, <<~JS
+          () => global.logs
+        JS
+
+        function :js_get_state, <<~JS
+          (channelName) => app.getState(channelName)
+        JS
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# require_relative "./channels/react"
+
+module Interfacets
+  module Test
+    module Js
+      module Receivers
+        class Api
+          attr_reader :router, :name, :response_queue
+          def initialize(name:, router:)
+            @name = name
+            @router = router
+            @response_queue = []
+          end
+
+          def handler
+          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?
+
+            method = payload.dig("streams", "default", "method")
+            url = payload.dig("streams", "default", "url")
+
+
+            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
+    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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Interfacets
+  module Test
+    module Js
+      module Receivers
+        class React
+          class Node
+            def self.parse(json:, dispatch:, validation_engine:)
+              new(
+                xml: XmlParser.new(json, validation_engine:).call,
+                dispatch:,
+                validation_engine:,
+                parent: nil,
+              )
+            end
+
+            Error = Class.new(StandardError)
+            NoMatchesError = Class.new(Error)
+            MultipleMatchesError = Class.new(Error)
+            StaleNodeError = Class.new(Error) do
+              def initialize
+                super(
+                  <<~TXT
+                    This node is stale and cannot be used. This occurs when the facet \
+                    has been updated and you are using a reference to an out-of-date \
+                    node. Re-fetch the node using `page.dom` rather than storing a \
+                    reference to the node.
+                  TXT
+                )
+              end
+            end
+
+            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!
+              @stale = true
+            end
+
+            def stale?
+              @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?
+
+              xml.content
+            end
+
+            def one(...)
+              raise StaleNodeError if stale?
+
+              all(...)
+                .tap {
+                  if _1.count == 0
+                    raise NoMatchesError
+                  elsif _1.count > 1
+                    raise MultipleMatchesError.new(_1.map(&:content).join(", "))
+                  end
+                }
+                .first
+            end
+
+            EMPTY_ARG = Object.new
+
+            def all(*a, content: EMPTY_ARG, **p)
+              raise StaleNodeError if stale?
+
+              xml
+                .css(*a, **p)
+                .map { Node.new(xml: _1, dispatch:, parent: self, validation_engine:) }
+                .select {
+                  (
+                    content == EMPTY_ARG || (
+                      if content.is_a?(Regexp)
+                        _1.content.match?(content)
+                      else
+                        _1.content == content
+                      end
+                    )
+                  )
+                }
+
+            end
+
+            def attribute(name)
+              raise StaleNodeError if stale?
+
+              xml
+                .attribute(name)
+                &.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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require_relative "./react/node"
+
+module Interfacets
+  module Test
+    module Js
+      module Receivers
+        class React
+          attr_reader :name, :node, :validation_engine
+          def initialize(name:, validation_engine: nil)
+            @name = name
+            @validation_engine = validation_engine
+            @actions = {}
+          end
+
+          def receive(payload:, dispatch:)
+            @dispatch = dispatch
+            @actions = nil
+            @node&.stale!
+            @node = Node.parse(json: payload, dispatch:, validation_engine:)
+          end
+
+          def handler
+            @node
+          end
+        end
+      end
+    end
+  end
+end