interfacets 0.1.0 → 0.9.9

data/lib/interfacets/shared/validations.rb

@@ -0,0 +1,71 @@
+# 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] << v
+        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/test/browser.rb

@@ -0,0 +1,63 @@
+
+module Interfacets
+  module Test
+    class Browser
+      TYPES = {
+        inline: Js::InlineBus,
+        nodo: Js::NodoBus,
+      }
+
+      attr_reader :system_json, :router, :type
+      def initialize(system_json:, router:, type:)
+        unless TYPES.keys.include?(type)
+          raise ArgumentError.new(
+            "type: #{type.inspect} not allowed. Must be one of #{TYPES.keys}"
+          )
+        end
+
+        @type = type
+        # Serialize and deserialize to ensure proper data structure for JS
+        @system_json = JSON.parse(system_json.to_json)
+        @router = router
+      end
+
+      def visit(path)
+        js.init(
+          hydrated_facet: router.call(path).render
+        )
+      end
+
+      def c(channel_id)
+        js.handler(channel_id)
+      end
+
+      def dispatch(channel_id, event)
+        js.dispatch(channel_id, event)
+      end
+
+      def url
+        c("url")
+      end
+
+      def dom
+        c("dom")
+      end
+
+      private
+
+      def js
+        @js ||= (
+          js_api = Test::Js::Receivers::Api.new(name: "interfacets:api", router:)
+          js_react = Test::Js::Receivers::React.new(name: "dom")
+          js_url = Test::Js::Receivers::Url.new(name: "url")
+          receivers = [js_api, js_react, js_url]
+
+          TYPES.fetch(type).new(
+            receiver_index: receivers.map { [_1.name, _1] }.to_h,
+            client_system_json: system_json,
+          )
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+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"],
+              hydration: {
+                destination: { bus: "default", channel: "interfacets:api" },
+                type: "interfacets:api:hydrate",
+                payload: hydrated_facet
+              },
+              config: client_system_json,
+            }
+          }))
+        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_index
+                .fetch(channel_id)
+                .receive(
+                  payload: channel_event.fetch("payload"),
+                  dispatch: ->(ev) {
+                    dispatch(bus_id:, channel_id:, event: ev)
+                  },
+                )
+            end
+          else
+            raise("unhandled event type: #{event}")
+          end
+        end
+
+        def dispatch(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")
+            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(
+              transmit: ->(event) {
+                handle(H.j(event))
+              },
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+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|
+            ch.receive(
+              payload: js_get_state(id).fetch("data"),
+              dispatch: ->(e) { dispatch(id, e) }
+            )
+          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,37 @@
+# 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?
+
+            url = payload.dig("streams", "default", "url")
+            payload
+              .dig("streams", "default", "body", "event", "payload")
+              .then { response_queue << router.call(url).handle(_1) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Interfacets
+  module Test
+    module Js
+      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:)
+              new(
+                xml: XmlParser.new(json).call,
+                dispatch:,
+                parent: nil,
+              )
+            end
+
+            Error = Class.new(StandardError)
+            NoMatchesErrorError = 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
+            def initialize(xml:, dispatch:, parent:)
+              @xml = xml
+              @dispatch = dispatch
+              @parent = parent
+            end
+
+            def stale!
+              @stale = true
+            end
+
+            def stale?
+              @stale || parent&.stale?
+            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) }
+                .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)
+                .then { JSON.parse(_1) }
+            end
+
+            def trigger(name, data = {})
+              raise StaleNodeError if stale?
+
+              value = attribute(name.to_s)
+              value["payload"]["event"] = data
+              dispatch.(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Interfacets
+  module Test
+    module Js
+      module Receivers
+        class Url
+          class Handler
+            def initialize(state)
+              @state = state
+            end
+
+            def url
+              url_spec = @state.fetch("urlSpec")
+              base_url = url_spec["url"]
+              query_params = url_spec["queryParams"]
+
+              return base_url if query_params.nil? || query_params.empty?
+
+              uri = URI(base_url)
+              uri.query = URI.encode_www_form(query_params)
+              uri.to_s
+            end
+
+            def redirected_url
+              @state.fetch("redirectSpec")
+            end
+          end
+
+          attr_reader :server, :name, :response_queue
+          def initialize(name:)
+            @name = name
+          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?
+
+            @handler = Handler.new(payload.dig("streams", "default"))
+          end
+
+          def handler
+            @handler
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# require_relative "./test/session"
+# require_relative "./test/js"
+# require_relative "./test/js/channels"
+
+module Interfacets
+  module Test
+    module H
+      module_function
+
+      def j(hash)
+        JSON.parse(hash.to_json)
+      end
+    end
+  end
+end

data/lib/interfacets/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Interfacets
-  VERSION = "0.1.0"
+  VERSION = "0.9.9"
 end

data/lib/interfacets.rb

@@ -1,8 +1,32 @@
 # frozen_string_literal: true
 
-require_relative "interfacets/version"
+require "zeitwerk"
 
 module Interfacets
+  class << self
+    def reload
+      loader.reload
+    end
+
+    def loader
+      @loader ||= (
+        Zeitwerk::Loader
+          .for_gem
+          .tap { _1.ignore("#{__dir__}/interfacets/mruby") }
+          .tap { _1.ignore("#{__dir__}/interfacets/client/utils") }
+          .tap { _1.enable_reloading if enable_reloading? }
+          .tap(&:setup)
+      )
+    end
+
+    def enable_reloading?
+      $interfacets_dev_mode
+    end
+  end
+
   class Error < StandardError; end
-  # Your code goes here...
+end
+
+unless Interfacets.enable_reloading?
+  Interfacets.loader
 end