interfacets 0.1.0 → 0.9.9

data/lib/interfacets/client/channels/url.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      class Url
+        include Channels::Base
+
+        type("interfacets:url")
+
+        class Builder
+          attr_reader :state
+          def initialize
+            @state = {}
+          end
+
+          def path(path, query: {})
+            state[:urlSpec] = {
+              url: (
+                System
+                  .current_bus
+                  .url_for(path)
+              ),
+              queryParams: query,
+            }
+          end
+
+          def redirect(url, query: {})
+            @redirected = true
+            state[:redirectUrlSpec] = { url:, query: }
+          end
+
+          def redirected?
+            @redirected
+          end
+        end
+
+        def prepare(entity)
+          @builder ||= Builder.new
+        end
+
+        def builder(stream = "default")
+          @builder
+        end
+
+        def result
+          { streams: { default: @builder.state } }
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    class Config
+      attr_accessor(
+        :mount_point,
+        :root_url
+      )
+
+      def url_for(path:)
+        [
+          root_url,
+          mount_point,
+          path,
+        ]
+          .map { _1.sub(%r{/$}, "").sub(%r{^/}, "") }
+          .join("/")
+      end
+    end
+  end
+end

data/lib/interfacets/client/delegator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    # alias: CrappyDelegator
+    class Delegator
+      def initialize(obj)
+        @__obj__ = obj
+      end
+
+      def __getobj__
+        @__obj__
+      end
+
+      def respond_to_missing?(...)
+        @__obj__.send(:respond_to_missing?, ...)
+      end
+
+      def method_missing(method, *a, **p, &)
+        @__obj__.send(method, *a, **p, &)
+      end
+
+      # delegation helpers
+      def inspect
+        [self.class.name, __getobj__.inspect].join(" -> ")
+      end
+
+      def to_s
+        inspect
+      end
+
+      def presence
+        self
+      end
+    end
+  end
+end

data/lib/interfacets/client/facet.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    class Facet
+      class << self
+        attr_accessor(
+          :shared,
+          :entity,
+          :view,
+          :store,
+        )
+      end
+
+      attr_reader :entity, :view
+      def initialize(entity)
+        @entity = entity
+        @view = self.class.view.new
+      end
+
+      def render(channels)
+        view.render(entity:, channels:)
+      end
+    end
+  end
+end

data/lib/interfacets/client/facet2.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    class Facet2
+      class << self
+        attr_accessor(
+          :shared_entity,
+          :entity,
+          :view
+        )
+      end
+    end
+  end
+end

data/lib/interfacets/client/facets/attributes/accessor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Facets
+      module Attributes
+        class Accessor
+          attr_reader :send_if
+          def initialize(send_if:)
+            @send_if = send_if
+          end
+
+          def coerce(val, **)
+            val
+          end
+
+          def serialize(val)
+            val
+          end
+
+          def should_send?(facet)
+            facet.instance_exec(&send_if)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/facets/attributes/association.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Facets
+      module Attributes
+        class Association
+          attr_reader :nested, :anonymous, :config, :bind_map
+
+          def initialize(nested:, anonymous:, config:, bind_map:)
+            @nested = nested
+            @anonymous = anonymous
+            @config = config
+            @bind_map = bind_map
+          end
+
+          def coerce(val, parent:)
+            return if val.nil?
+
+            facet.build(
+              attrs: val,
+              binds: bind_map.transform_values { |v| Bind.new(name: v, facet: parent) },
+            )
+          end
+
+          def build(attrs:, parent:)
+            facet.build(
+              attrs:,
+              binds: bind_map.transform_values { |v| Bind.new(name: v, facet: parent) },
+            )
+          end
+
+          def serialize(val)
+            val&.serialize
+          end
+
+          def facet
+            @facet ||= (
+              if anonymous
+                @nested
+              else
+                config.schema(@nested.fetch("name"))
+              end
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/facets/attributes/bind.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Facets
+      module Attributes
+        class Bind
+          attr_reader :name, :facet
+          def initialize(name:, facet:)
+            @name = name
+            @facet = facet
+          end
+
+          def get
+            facet.public_send(name)
+          end
+
+          def set(v)
+            facet.public_send("#{name}=", v)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/facets/attributes/collection.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Facets
+      module Attributes
+        class Collection
+          attr_reader :nested, :anonymous, :config, :bind_map
+
+          def initialize(nested:, anonymous:, config:, bind_map:)
+            @nested = nested
+            @anonymous = anonymous
+            @config = config
+            @bind_map = bind_map
+          end
+
+          def coerce(val, parent:)
+            return [] if val.nil?
+
+            val.map { build(attrs: _1, parent:) }
+          end
+
+          def build(attrs:, parent:)
+            facet.build(
+              attrs:,
+              binds: bind_map.transform_values { |v| Bind.new(name: v, facet: parent) },
+            )
+          end
+
+          def serialize(val)
+            val.map(&:serialize)
+          end
+
+          def facet
+            @facet ||= (
+              if anonymous
+                @nested
+              else
+                config.schema(@nested.fetch("name"))
+              end
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/facets/attributes/readonly.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Facets
+      module Attributes
+        class Readonly
+          def coerce(val, **)
+            val
+          end
+
+          def serialize(val)
+            val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/facets/deserializer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Facets
+      class Deserializer
+        def self.call(data:, config: Client.system.config)
+          Logger.main.debug("deserializing facet: #{data.fetch("facet_class")}")
+
+          klass = Object.const_get(data.fetch("facet_class"))
+
+          Logger.main.debug("constructing: #{klass.client.name}")
+
+          facet = klass.new
+
+          entity = (
+            klass
+              .client
+              .build(data.fetch("attributes"), parent: nil, facet:)
+          )
+
+          Logger.main.debug("entity constructed")
+
+          facet.entity = entity
+          facet
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/facets/schema/deserializer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Facets
+      module Schema
+        class Deserializer
+          def self.call(...)
+            new(...).call
+          end
+
+          attr_reader :schema, :results
+          def initialize(schema:)
+            @schema = schema
+            @results = { views: {}, entities: {}, apis: {} }
+          end
+
+          def call
+            schema.fetch("views").each do |view_type, view_json|
+              block = view_json.fetch("body")
+
+              results[:views][view_type] = View.new(
+                block: eval(block),
+                name: view_type,
+              )
+            end
+
+            schema.fetch("apis").each do |api_type, entity_json|
+              block = entity_json.fetch("body")
+
+              results[:apis][api_type] =
+                Module.new do
+                  extend ActiveSupport::Concern
+                  define_singleton_method(:name) { api_type }
+
+                  included do
+                    class_exec(&eval(block))
+                  end
+                end
+            end
+
+            schema.fetch("entities").each do |entity_type, client_json|
+              block = client_json.fetch("body")
+              api_type = client_json.fetch("api_type")
+
+              api_mod = results[:apis].fetch(api_type)
+
+              results[:entities][entity_type] =
+                Class.new(Entity) do
+                  define_singleton_method(:name) { entity_type }
+                  include api_mod
+
+                  class_exec(&eval(block))
+                end
+            end
+
+            results
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/facets/schema.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Facets
+      module Schema
+        extend ActiveSupport::Concern
+        class_methods do
+          def view_spec(&block)
+            @view_spec = block
+          end
+
+          def view
+            # TODO: change this to just inherit from view
+            @view ||= View.new(
+              block: @view_spec,
+              name: "#{self.name}::View",
+            )
+          end
+
+          def client_spec(&block)
+            @client_spec = block
+          end
+
+          def client
+            # scoping
+            client_name = "#{self.name}::Client"
+            client_spec = @client_spec
+            entity = self.entity
+
+            @client ||=
+              Class.new(Entity) do
+                define_singleton_method(:name) { client_name }
+                extend_entity { include entity }
+
+                class_exec(&client_spec)
+              end
+          end
+
+          def entity_spec(&block)
+            @entity_spec = block
+          end
+
+          def entity
+            # scoping
+            entity_name = "#{self.name}::Entity"
+            entity_spec = @entity_spec
+
+            @entity ||=
+              Module.new do
+                extend ActiveSupport::Concern
+                define_singleton_method(:name) { entity_name }
+
+                included do
+                  class_exec(&entity_spec)
+                end
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/facets/serializer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Facets
+      class Serializer
+        class << self
+          def call(facet)
+            {
+              facet_class: facet.class.name,
+              attributes: facet.entity.serialize,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/registry.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    class Registry
+      def build(name)
+        entity = Object.const_get("#{name}::Client::Entity")
+
+        entity.new(
+          store: entity.store.new,
+          parent: nil,
+          nesting: ["root"]
+        )
+      end
+
+      def register(schema, namespace: "Things")
+        schema.each do |name, schema|
+          next if registry.key?(name)
+
+          shared = Class.new(Shared::Entity) do
+            schema.fetch("shared").each { class_exec(&eval(_1)) }
+          end
+
+          view = Class.new(View) do
+            schema.fetch("view").each { view(&eval(_1)) }
+          end
+
+          entity = Class.new(Shared::Entity) do
+            define_singleton_method(:view) { view }
+            self.manifest = shared
+
+            schema.fetch("shared").each { class_exec(&eval(_1)) }
+            schema.fetch("client").each { class_exec(&eval(_1)) }
+
+            actions.each do |name, spec|
+              if name.start_with?("after_")
+                define_method(name) {}
+              end
+            end
+          end
+
+          store = Shared::GeneratedStore.construct(entity)
+
+          mod = set_const(
+            [
+              namespace,
+              name.split("::"),
+            ].flatten,
+            Module.new
+          )
+          entity.define_singleton_method(:facet_name) { name }
+          mod.const_set("Entity", entity)
+          entity.const_set("Shared", shared)
+          entity.const_set("View", view)
+
+          registry[name] = { entity:, store: }
+        end
+      end
+
+      private
+
+      def set_const(mods, klass)
+
+        namespace = Object
+
+        mods[0..-1].each do |mod|
+          namespace = (
+            if namespace.const_defined?(mod, false)
+              namespace.const_get(mod)
+            else
+              namespace.const_set(mod, Module.new)
+            end
+          )
+        end
+
+        namespace.const_set(mods.last, klass)
+      end
+
+      def registry
+        @registry ||= {}
+      end
+    end
+  end
+end

data/lib/interfacets/client/system.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    class System
+      module Transmit
+        def self.call(data)
+          Kernel.js_eval("self.rubyEvent(#{data.to_json})")
+        end
+      end
+
+      class << self
+        attr_accessor(
+          :current_bus,
+          :logger,
+        )
+
+        def logger
+          @logger ||= InterfacetsLogger.main
+        end
+
+        def start(transmit: Transmit)
+          @instance = new(transmit)
+        end
+      end
+
+      attr_accessor :transmit
+      def initialize(transmit)
+        @transmit = transmit
+      end
+
+      def handle(event)
+        if event.fetch("type") == "interfacets:system:create_bus"
+          create_bus(event.fetch("payload"))
+        else
+          bus_id = event.dig("destination", "bus")
+          raise("unknown event: #{event.inspect}") unless bus_id
+
+          System.current_bus = bus_registry.fetch(bus_id)
+          payload = System.current_bus.handle(event)
+
+          transmit.(
+            {
+              type: "interfacets:system:render",
+              payload:,
+            },
+          )
+        end
+      ensure
+        GC.start
+      end
+
+      # private
+
+      def config
+        @config ||= Config.new
+      end
+
+      def create_bus(payload)
+        id = payload.fetch("id")
+        hydration_event = payload.fetch("hydration")
+
+        channel_ids = payload.fetch("channel_ids")
+
+        Bus.new(
+          id:,
+          channels: [
+            Channels::Api.new(id: "interfacets:api"),
+            Channels::React::Channel.new(id: "dom"),
+            Channels::Url.new(id: "url"),
+            (Channels::SpeechToText.new(id: "speechToText") if channel_ids.include?("speechToText")),
+            (Channels::Timer.new(id: "timer") if channel_ids.include?("timer")),
+            (Channels::Audio.new(id: "audio") if channel_ids.include?("audio")),
+          ].compact,
+          root_url: payload.fetch("config").fetch("root_url"),
+        ).tap do
+          bus_registry[id] = _1
+        end
+
+        handle(hydration_event)
+      end
+
+      def bus_registry
+        @bus_registry ||= {}
+      end
+    end
+  end
+end