interfacets 0.1.0 → 0.9.9

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Server
+    module Facets
+      class Serializer
+        def self.call(...)
+          new(...).call
+        end
+
+        attr_reader :facet, :mount_point
+        def initialize(facet, mount_point)
+          @facet = facet
+          @mount_point = mount_point
+        end
+
+        def call
+          {
+            id: facet.entity.id,
+            facet_class: facet.class.name,
+            attributes: facet.entity.serialize,
+          }
+        end
+
+        def attributes(entity)
+          entity
+            .attribute_specs
+            .each_with_object({}) { |(name, _attribute), json|
+              # refactor this, shouldn't be attributes...
+              # next if attribute.is_a?(Facets::Attributes::ClientEvent)
+              # next if attribute.is_a?(Facets::Attributes::ServerEvent)
+              # next if attribute.is_a?(Facets::Attributes::Inherit)
+
+              value = entity.public_send(name)
+
+              json[name] = (
+                if value.is_a?(Array)
+                  value.map { _1.is_a?(Entity) || _1.is_a?(Facet::Handler) ? attributes(_1) : _1 }
+                elsif value.is_a?(Entity) || value.is_a?(Facet::Handler)
+                  attributes(value)
+                else
+                  value
+                end
+              )
+            }
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/server/registry.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+
+module Interfacets
+  module Server
+    class Registry
+      attr_reader :build_dir, :specs
+      def initialize(facets:, build_dir:)
+        @build_dir = build_dir
+        @specs = Array(facets)
+      end
+
+      def register
+        specs
+          .flat_map { _1.respond_to?(:call) ? _1.call : _1 }
+          .each do |klass_or_name|
+
+            klass = (
+              if klass_or_name.is_a?(String)
+                if registry.key?(klass_or_name)
+                  next
+                else
+                  Object.const_get(klass_or_name)
+                end
+              else
+                klass_or_name
+              end
+            )
+
+            next if registry.key?(klass.name)
+
+            shared = Class.new(Shared::Entity) do
+              klass.shareds.each { class_exec(&_1) }
+            end
+
+            entity = Class.new(Shared::Entity) do
+              self.manifest = shared
+              role("server")
+
+              klass.shareds.each { class_exec(&_1) }
+              klass.servers.each { class_exec(&_1) }
+
+              attr_writer :channel
+              def channel
+                @channel || parent.channel
+              end
+            end
+
+            registry[klass.name] = { klass:, entity:}
+          end
+      end
+
+      def build(name, store)
+        register
+        entry = registry.fetch(name.is_a?(Class) ? name.name : name)
+
+
+
+        Api.new(
+          registry: self,
+          name:,
+          entity: (
+            entry
+              .fetch(:entity)
+              .new(
+                store: store.is_a?(Hash) ? OpenStruct.new(store) : store,
+                nesting: ["root"],
+                parent: nil
+              )
+          )
+        )
+      end
+
+      def serialize
+        register
+        FileUtils.mkdir_p(build_dir)
+
+        registry.each do |name, entry|
+          base_name = "#{name}::Client"
+
+          header = ""
+          footer = ""
+          nesting = []
+          name.split("::").each do |mod|
+            nesting << mod
+            footer += "\nend"
+            header +=(
+              if nesting.join("::").constantize.is_a?(Class)
+                "\nclass #{mod}"
+              else
+                "\nmodule #{mod}"
+              end
+            )
+          end
+          header += "\nmodule Client"
+          footer += "\nend"
+
+          File.write(
+            File.join(build_dir, path_for("#{base_name}::Shared")),
+            <<~TXT
+              #{header}
+              class Shared < Interfacets::Shared::Entity
+                #{
+                  entry
+                    .fetch(:klass)
+                    .shareds
+                    .map { write_source(_1) }
+                    .map { "class_exec(&#{_1})" }
+                    .join("\n")
+                }
+              end
+              #{footer}
+            TXT
+          )
+
+          File.write(
+            File.join(build_dir, path_for("#{base_name}::View")),
+            <<~TXT
+              #{header}
+              class View < Interfacets::Client::View
+                #{
+                  entry
+                    .fetch(:klass)
+                    .views
+                    .map { write_source(_1) }
+                    .map { "view(&#{_1})"}
+                    .join("\n")
+                }
+              end
+              #{footer}
+            TXT
+          )
+
+          File.write(
+            File.join(build_dir, path_for("#{base_name}::Entity")),
+            <<~TXT
+              #{header}
+              class Entity < Interfacets::Shared::Entity
+                class << self
+                  def view
+                    #{base_name}::View
+                  end
+
+                  def store
+                    @store ||= (
+                      ::Interfacets::Shared::GeneratedStore.construct(self)
+                        .tap { self.const_set("Store", _1) }
+                    )
+                  end
+                end
+
+                role("client")
+
+                #{
+                  entry
+                    .fetch(:klass)
+                    .shareds
+                    .map { write_source(_1) }
+                    .map { "class_exec(&#{_1})" }
+                    .join("\n")
+                }
+
+                #{
+                  entry
+                    .fetch(:klass)
+                    .clients
+                    .map { write_source(_1) }
+                    .map { "class_exec(&#{_1})" }
+                    .join("\n")
+                }
+
+                self.manifest = Shared
+
+                actions.each do |name, spec|
+                  if name.start_with?("after_")
+                    define_method(name) {}
+                  end
+                end
+
+                def channel(name)
+                  Interfacets::Client::System.current_bus.channel(name).builder
+                end
+              end
+              #{footer}
+            TXT
+          )
+        end
+      end
+
+      def registry
+        @registry ||= {}
+      end
+
+      private
+
+      def path_for(class_name)
+        "#{class_name.gsub("::", "-")}.rb"
+      end
+
+      def write_source(block)
+        return unless block
+
+        RubyVM::AbstractSyntaxTree
+          .of(block, keep_script_lines: true)
+          .source
+          .then { block.is_a?(UnboundMethod) ? _1 : "lambda #{_1}" }
+          .strip
+      end
+    end
+  end
+end

data/lib/interfacets/shared/entities/bus.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Interfacets
+module Shared
+module Entities
+class Bus
+  InvalidAction = Class.new(StandardError)
+  InvalidReceiver = Class.new(StandardError)
+
+  # event schema:
+  # {
+  #   from: (role),
+  #   to: (role),
+  #   action:,
+  #   payload: {
+
+  #   }
+  # }
+
+  attr_reader :manifest, :entity
+  def initialize(entity:)
+    @manifest = entity.class.manifest
+    @entity = entity
+  end
+
+  def serialize(to:, action:, nesting:)
+    assert_valid_action(action:, to:, nesting:)
+
+    {
+      id: SecureRandom.uuid,
+      from: entity.role,
+      to: to,
+      nesting:,
+      action:,
+      payload: {
+        attributes: serialize_attributes(manifest:, entity:, to:)
+      }
+    }
+  end
+
+  def handle(event:)
+    assert_valid_receiver(to: event.fetch("to"))
+    assert_valid_action(
+      action: event.fetch("action"),
+      to: entity.role,
+      nesting: event.fetch("nesting"),
+    )
+
+    attributes = event.fetch("payload").fetch("attributes", {})
+
+    merge(entity:, manifest:, attributes:)
+
+    target_entity = entity
+    event.fetch("nesting")[1..-1].each do |assoc_name, id|
+      break if target_entity.nil?
+
+      spec = entity.association(assoc_name)
+
+      target_entity =(
+        if spec.type == :reference
+          target_entity = spec.get
+        else
+          spec.get.find { _1.internal_entity_id == id }
+        end
+      )
+    end
+
+    raise "No EntityError" if target_entity.nil?
+
+    target_entity
+      .class
+      .actions
+      .fetch(event.fetch("action"))
+      .dispatch(target_entity)
+  end
+
+  private
+
+  def serialize_attributes(manifest:, entity:, to:)
+    return if entity.nil?
+
+    data = {}
+
+    manifest
+      .accessors
+      .each do |name, spec|
+        data[name] = entity.send(name)
+      end
+
+    manifest
+      .associations
+      .each do |name, spec|
+        if spec.type == :reference
+          data[name] = serialize_attributes(
+            manifest: spec.klass,
+            entity: entity.send(name),
+            to:
+          )
+        else
+          data[name] = (entity.send(name) || []).map {
+            serialize_attributes(
+              manifest: spec.klass,
+              entity: _1,
+              to:
+            )
+          }
+        end
+      end
+
+    data
+  end
+
+  def merge(manifest:, entity:, attributes:)
+    manifest
+      .accessors
+      .values
+      .select { _1.accepted_by?(entity.role) }
+      .each do |attribute|
+        next unless attributes.key?(attribute.name)
+
+        entity.send("#{attribute.name}=", attributes[attribute.name])
+      end
+
+    manifest
+      .associations
+      .values
+      .select { _1.type == :reference }
+      .select { _1.accepted_by?(entity.role) }
+      .each do |association|
+        next unless attributes.key?(association.name)
+
+        value = attributes.fetch(association.name)
+
+        if value.nil?
+          entity.association(association.name).set(nil)
+          next
+        end
+
+        entity
+          .association(association.name)
+          .get
+          .then { _1 || entity.association(association.name).build }
+          .tap {
+            merge(
+              entity: _1,
+              manifest: association.klass,
+              attributes: value
+            )
+          }
+          .then { entity.association(association.name).set(_1) }
+      end
+
+    manifest
+      .associations
+      .values
+      .select { _1.type == :collection }
+      .select { _1.accepted_by?(entity.role) }
+      .each do |collection|
+        next unless attributes.key?(collection.name)
+
+        identifier = collection.identifier
+
+        incoming_coll = attributes.fetch(collection.name) || []
+        existing_coll = entity.send(collection.name) || []
+
+        items = (
+          incoming_coll.map do |val|
+            found_item = (
+              val.fetch(identifier) &&
+                existing_coll.find { _1.send(identifier) == val.fetch(identifier) }
+            )
+
+            if found_item
+              found_item.tap { |r|
+                merge(
+                  entity: r,
+                  manifest: collection.klass,
+                  attributes: val
+                )
+              }
+            else
+              entity
+                .association(collection.name)
+                .build
+                .tap { |r|
+                    merge(
+                      entity: r,
+                      manifest: collection.klass,
+                      attributes: val
+                    )
+                  }
+            end
+          end
+        )
+        entity.association(collection.name).set(items)
+      end
+  end
+
+  def assert_valid_action(action:, to:, nesting:)
+    nested_manifest = manifest
+    nesting[1..-1].each do |assoc_name, _id|
+      nested_manifest = manifest.associations.fetch(assoc_name).klass
+    end
+
+    unless nested_manifest.actions[action]&.accepted_by?(to.to_s)
+      raise InvalidAction.new("invalid action: #{action}")
+    end
+  end
+
+  def assert_valid_receiver(to:)
+    if to != entity.role
+      raise InvalidReceiver.new("invalid receiver role: to: #{to}, entity: #{entity.role.inspect}")
+    end
+  end
+end
+end
+end
+end

data/lib/interfacets/shared/entities/collection_proxy.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    module Entities
+      class CollectionProxy
+        include Enumerable
+
+        attr_reader :wrap, :unwrap
+        def initialize(collection, wrap:, unwrap:)
+          @collection = collection
+          @wrap = wrap
+          @unwrap = unwrap
+        end
+
+        # Read operations - wrap items when accessing
+        def first
+          val = @collection.first
+          val.nil? ? nil : @wrap.call(val)
+        end
+
+        def last
+          val = @collection.last
+          val.nil? ? nil : @wrap.call(val)
+        end
+
+        def [](index)
+          val = @collection[index]
+          val.nil? ? nil : @wrap.call(val)
+        end
+
+        def at(index)
+          val = @collection.at(index)
+          val.nil? ? nil : @wrap.call(val)
+        end
+
+        def each(&block)
+          @collection.each { |item| block.call(@wrap.call(item)) }
+        end
+
+        def size
+          @collection.size
+        end
+        alias_method :length, :size
+        alias_method :count, :size
+
+        def empty?
+          @collection.empty?
+        end
+
+        # Mutation operations - unwrap items and delegate to underlying collection
+        def <<(item)
+          @collection << @unwrap.call(item)
+          self
+        end
+
+        def push(*items)
+          @collection.push(*items.map { |item| @unwrap.call(item) })
+          self
+        end
+
+        def pop
+          val = @collection.pop
+          val.nil? ? nil : @wrap.call(val)
+        end
+
+        def shift
+          val = @collection.shift
+          val.nil? ? nil : @wrap.call(val)
+        end
+
+        def unshift(*items)
+          @collection.unshift(*items.map { |item| @unwrap.call(item) })
+          self
+        end
+
+        def []=(index, item)
+          @collection[index] = @unwrap.call(item)
+        end
+
+        def delete(item)
+          unwrapped = @unwrap.call(item)
+          val = @collection.delete(unwrapped)
+          val.nil? ? nil : @wrap.call(val)
+        end
+
+        def delete_at(index)
+          val = @collection.delete_at(index)
+          val.nil? ? nil : @wrap.call(val)
+        end
+
+        def clear
+          @collection.clear
+          self
+        end
+
+        def insert(index, *items)
+          @collection.insert(index, *items.map { |item| @unwrap.call(item) })
+          self
+        end
+
+        def concat(other_array)
+          @collection.concat(other_array.map { |item| @unwrap.call(item) })
+          self
+        end
+
+        def replace(other_array)
+          @collection.replace(other_array.map { |item| @unwrap.call(item) })
+          self
+        end
+
+        # Enumerable methods that return arrays should return CollectionProxy
+        def select(&block)
+          selected = @collection.select { |item| block.call(@wrap.call(item)) }
+          CollectionProxy.new(selected, wrap: @wrap, unwrap: @unwrap)
+        end
+        alias_method :filter, :select
+
+        def reject(&block)
+          rejected = @collection.reject { |item| block.call(@wrap.call(item)) }
+          CollectionProxy.new(rejected, wrap: @wrap, unwrap: @unwrap)
+        end
+
+        def take(n)
+          taken = @collection.take(n)
+          CollectionProxy.new(taken, wrap: @wrap, unwrap: @unwrap)
+        end
+
+        def take_while(&block)
+          taken = @collection.take_while { |item| block.call(@wrap.call(item)) }
+          CollectionProxy.new(taken, wrap: @wrap, unwrap: @unwrap)
+        end
+
+        def drop(n)
+          dropped = @collection.drop(n)
+          CollectionProxy.new(dropped, wrap: @wrap, unwrap: @unwrap)
+        end
+
+        def drop_while(&block)
+          dropped = @collection.drop_while { |item| block.call(@wrap.call(item)) }
+          CollectionProxy.new(dropped, wrap: @wrap, unwrap: @unwrap)
+        end
+
+        def reverse
+          reversed = @collection.reverse
+          CollectionProxy.new(reversed, wrap: @wrap, unwrap: @unwrap)
+        end
+
+        def sort(&block)
+          if block
+            sorted = @collection.sort { |a, b| block.call(@wrap.call(a), @wrap.call(b)) }
+          else
+            sorted = @collection.sort
+          end
+          CollectionProxy.new(sorted, wrap: @wrap, unwrap: @unwrap)
+        end
+
+        def sort_by(&block)
+          sorted = @collection.sort_by { |item| block.call(@wrap.call(item)) }
+          CollectionProxy.new(sorted, wrap: @wrap, unwrap: @unwrap)
+        end
+
+        def uniq(&block)
+          if block
+            uniqued = @collection.uniq { |item| block.call(@wrap.call(item)) }
+          else
+            uniqued = @collection.uniq
+          end
+          CollectionProxy.new(uniqued, wrap: @wrap, unwrap: @unwrap)
+        end
+
+        def compact
+          compacted = @collection.compact
+          CollectionProxy.new(compacted, wrap: @wrap, unwrap: @unwrap)
+        end
+
+        def slice(*args)
+          sliced = @collection.slice(*args)
+          if sliced.is_a?(Array)
+            CollectionProxy.new(sliced, wrap: @wrap, unwrap: @unwrap)
+          else
+            # Single element access returns wrapped item
+            sliced.nil? ? nil : @wrap.call(sliced)
+          end
+        end
+
+      end
+    end
+  end
+end