interfacets 0.9.9 → 0.9.99

data/lib/interfacets/server/assets.rb

@@ -118,8 +118,8 @@ module Interfacets
 
           serialized[const.full_name] = true
 
-          const.nesting.each do |_nesting_const|
-            push_bootstrapper(const, results, serialized)
+          const.nesting.each do |nesting_const|
+            push_bootstrapper(nesting_const, results, serialized)
           end
 
           parent = (
@@ -145,7 +145,7 @@ module Interfacets
         end
 
         def resolve_const_name(nesting, name)
-          full_name = [nesting, name].compact.join("::")
+          full_name = [nesting, name].compact.reject(&:empty?).join("::")
           return consts_by_name[full_name] if consts_by_name.key?(full_name)
 
           # maybe a constant that we don't handle loading for (eg, StandardError)
@@ -159,7 +159,7 @@ module Interfacets
         end
 
         def fs_map
-          paths.map { [_1, file.read(_1)] }.to_h
+          @fs_map ||= paths.map { [_1, file.read(_1)] }.to_h
         end
 
         def consts
@@ -181,11 +181,17 @@ module Interfacets
       ].freeze
 
       class << self
-        def bundle(dirs:, registry:)
+        def bundle(dirs:, registry:, only_facets: false)
 
-          registry.serialize
+          target_dirs = (
+            if only_facets
+              dirs
+            else
+              GEM_DIRS + dirs
+            end
+          )
 
-          (dirs + GEM_DIRS + [registry.build_dir])
+          target_dirs
             .flat_map { paths(_1) }
             .flatten
             .map(&:to_s)

data/lib/interfacets/server/basic_router.rb

@@ -10,10 +10,8 @@ module Interfacets
         end
 
         def call(klass:, id:, query:, resolved_path:)
-          klass.bus = bus
-          klass
-            .find
-            .call(id, query:)
+          klass.server_entity_class
+            .find_for_basic_routing(id, query:, bus: bus)
             .tap { _1.entity.api_path = resolved_path }
         end
       end
@@ -26,13 +24,13 @@ module Interfacets
       end
 
       def call(url, query: {})
-        if url.nil? && default
+        path = normalize(url)
+
+        if path.nil? && default
           klass = klass_for(default)
-          evaluator.call(klass:, id: nil, query:, resolved_path: default)
+          return evaluator.call(klass:, id: nil, query:, resolved_path: default)
         end
 
-        path = url.sub(/^#{bus.root_url}/, "/").sub(/^/, "/").sub(%r{^/*}, "/")
-
         if normalized_paths.key?(path)
           klass = klass_for(path)
 
@@ -58,7 +56,7 @@ module Interfacets
       end
 
       def klass_for(path)
-        val = normalized_paths.fetch(path)
+        val = normalized_paths.fetch(normalize(path))
 
         (val.is_a?(String) ? Object.const_get(val) : val)
       end
@@ -66,9 +64,16 @@ module Interfacets
       def normalized_paths
         @normalized_paths ||= (
           paths
-            .transform_keys { _1.start_with?("/") ? _1 : "/#{_1}" }
+            .transform_keys { normalize(_1) }
         )
       end
+
+      def normalize(path)
+        path
+          &.sub(/^#{bus.root_url}/, "/")
+          &.sub(/^/, "/")
+          &.sub(%r{^/*}, "/")
+        end
     end
   end
 end

data/lib/interfacets/server/bus.rb

@@ -9,20 +9,15 @@ module Interfacets
         :registry,
       )
 
-      def initialize(
-        root_url:,
-        asset_paths:,
-        facets:,
-        build_dir:
-      )
-        @registry = Registry.new(facets:, build_dir:)
+      def initialize(root_url:, asset_paths:)
+        @registry = Registry.new
         @root_url = root_url
         @asset_paths = asset_paths
       end
 
-      def client_system_json
+      def client_system_json(only_facets: false)
         {
-          assets: Assets.bundle(dirs: asset_paths, registry:),
+          assets: Assets.bundle(dirs: asset_paths, registry:, only_facets:),
           root_url:
         }
       end

data/lib/interfacets/server/config.rb

@@ -36,7 +36,7 @@ module Interfacets
           .values
           .map { Object.const_get(_1) }
           .then {
-            Interfacets::Server::Facets::Schema::Serializer
+            Interfacets::Shared::Facets::Schema::Serializer
               .call(facets: _1)
           }
       end

data/lib/interfacets/server/registry.rb

@@ -1,212 +1,51 @@
 # frozen_string_literal: true
 
 require "active_support/all"
+require "ostruct"
 
 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
+      class Channel
+        def initialize(registry:)
+          @registry = registry
+        end
 
-            entity = Class.new(Shared::Entity) do
-              self.manifest = shared
-              role("server")
+        def build(...)
+          @registry.build(...)
+        end
 
-              klass.shareds.each { class_exec(&_1) }
-              klass.servers.each { class_exec(&_1) }
+        def render_facet
+          @facet.render
+        end
 
-              attr_writer :channel
-              def channel
-                @channel || parent.channel
-              end
-            end
+        def rendered?
+          @facet
+        end
 
-            registry[klass.name] = { klass:, entity:}
-          end
+        def render(klass, store)
+          @facet = @registry.build(klass, store)
+        end
       end
 
       def build(name, store)
-        register
-        entry = registry.fetch(name.is_a?(Class) ? name.name : name)
-
-
+        facet = name.is_a?(Module) ? name : Object.const_get(name)
 
         Api.new(
           registry: self,
           name:,
           entity: (
-            entry
-              .fetch(:entity)
+            facet
+              .server_entity_class
               .new(
                 store: store.is_a?(Hash) ? OpenStruct.new(store) : store,
-                nesting: ["root"],
-                parent: nil
+                nesting: "root",
+                parent: nil,
+                channel: Channel.new(registry: self)
               )
           )
         )
       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/basic_routable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    module BasicRoutable
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          attr_accessor :bus
+
+          def build(klass, store)
+            bus.registry.build(klass, store)
+          end
+        end
+
+        # This is unfortunate, but in order to be able to do:
+
+        # build(self, ...)
+        # we need the self to be the facet.
+        # We could also update the registry to handle being passed a server
+        # entity, but I'm currently tweaking the registry. so this is a TODO.
+        facet = self
+
+        entity_base do
+          accessor(:api_path, accepted_by: :client)
+        end
+
+        server_entity(unshift: true) do
+          attr_accessor :api_path
+
+          define_singleton_method(:find) do |&block|
+            @find = block if block
+            @find
+          end
+
+          define_singleton_method(:find_for_basic_routing) do |id, query:, bus:|
+            facet.bus = bus
+            facet.instance_exec(id, query:, &find)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -39,39 +39,26 @@ class Bus
   end
 
   def handle(event:)
+    action = event.fetch("action")
+
     assert_valid_receiver(to: event.fetch("to"))
     assert_valid_action(
-      action: event.fetch("action"),
+      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
+    merge(entity:, manifest:, attributes:, action:)
 
-    raise "No EntityError" if target_entity.nil?
+    target_entity = entity.entity_at(event.fetch("nesting"))
 
     target_entity
-      .class
-      .actions
-      .fetch(event.fetch("action"))
-      .dispatch(target_entity)
+      &.class
+      &.actions
+      &.fetch(event.fetch("action"))
+      &.dispatch(target_entity)
   end
 
   private
@@ -81,6 +68,8 @@ class Bus
 
     data = {}
 
+    data[:errors] = entity.errors.to_h if entity.respond_to?(:errors)
+
     manifest
       .accessors
       .each do |name, spec|
@@ -110,7 +99,14 @@ class Bus
     data
   end
 
-  def merge(manifest:, entity:, attributes:)
+  def merge(manifest:, entity:, attributes:, action:)
+    if (errs = attributes[:errors] || attributes["errors"])
+      entity.errors.clear if entity.errors.respond_to?(:clear)
+      errs.each do |k, vs|
+        Array(vs).each { |v| entity.errors.add(k.to_sym, v) }
+      end
+    end
+
     manifest
       .accessors
       .values
@@ -118,7 +114,19 @@ class Bus
       .each do |attribute|
         next unless attributes.key?(attribute.name)
 
-        entity.send("#{attribute.name}=", attributes[attribute.name])
+        attr_mergers = (
+          entity.class.mergers[attribute.name]
+        )
+
+        merger = (
+          if attr_mergers.key?(action)
+            attr_mergers.fetch(action)
+          else
+            attr_mergers.fetch(:default)
+          end
+        )
+
+        merger.call(entity, attributes[attribute.name])
       end
 
     manifest
@@ -140,11 +148,12 @@ class Bus
           .association(association.name)
           .get
           .then { _1 || entity.association(association.name).build }
-          .tap {
+          .tap { |nested_entity|
             merge(
-              entity: _1,
+              entity: nested_entity,
               manifest: association.klass,
-              attributes: value
+              attributes: value,
+              action:
             )
           }
           .then { entity.association(association.name).set(_1) }
@@ -175,7 +184,8 @@ class Bus
                 merge(
                   entity: r,
                   manifest: collection.klass,
-                  attributes: val
+                  attributes: val,
+                  action:
                 )
               }
             else
@@ -186,7 +196,8 @@ class Bus
                     merge(
                       entity: r,
                       manifest: collection.klass,
-                      attributes: val
+                      attributes: val,
+                      action:
                     )
                   }
             end
@@ -198,6 +209,7 @@ class Bus
 
   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

data/lib/interfacets/shared/entities/specs/handlers.rb

@@ -43,6 +43,14 @@ module Interfacets
           end
 
           class Reference < Handler
+            def collection?
+              false
+            end
+
+            def reference?
+              true
+            end
+
             def get
               wrap(entity.instance_exec(&spec.getter))
                 .tap {
@@ -70,6 +78,14 @@ module Interfacets
           end
 
           class Collection < Handler
+            def collection?
+              true
+            end
+
+            def reference?
+              false
+            end
+
             def get
               values = entity.instance_exec(&spec.getter) || []
 

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

@@ -72,6 +72,7 @@ module Interfacets
             :builder,
             :parent,
             :identifier,
+            :type,
           )
           def initialize(parent:, name:)
             @parent = parent
@@ -81,6 +82,7 @@ module Interfacets
             @setter = ->(val) { store.send("#{name}=", val) }
             @builder = ->() { store.association(name).build }
             @identifier = "id"
+
             @klass = Class.new(Entity) do
               define_singleton_method(:name) { "#{parent.name}.#{name}" }
             end
@@ -92,6 +94,8 @@ module Interfacets
             setter: NOT_PASSED,
             builder: NOT_PASSED,
             identifier: NOT_PASSED,
+            mod: nil,
+            type: NOT_PASSED,
             &block
           )
             @accepted_by = Array(accepted_by).map(&:to_s) unless accepted_by == NOT_PASSED
@@ -99,23 +103,56 @@ module Interfacets
             @setter = setter unless setter == NOT_PASSED
             @builder = builder unless builder == NOT_PASSED
             @identifier = identifier.to_s unless identifier == NOT_PASSED
-            klass.class_exec(&block) if block_given?
+
+            if type && type != NOT_PASSED
+              type = type.to_sym
+              unless [:reference, :collection].include?(type)
+                raise ArgumentError.new("invalid association type: #{type.inspect}")
+              end
+
+              if @type && type != @type
+                raise ArgumentError.new("invalid association cannot change type")
+              end
+
+              @type = type
+            end
+
+            @klass.include(mod) if mod
+
+            @klass.class_exec(&block) if block_given?
           end
-        end
 
-        class Reference < Association
-          def type = :reference
+          def dup_for(new_parent)
+            dup.tap do |new_spec|
+              new_spec.instance_variable_set(:@parent, new_parent)
+              new_spec.instance_variable_set(:@klass, Class.new(@klass))
+            end
+          end
 
           def handler(entity)
-            Handlers::Reference.new(entity:, spec: self)
+            klass = (
+              if type == :reference
+                Handlers::Reference
+              elsif type == :collection
+                Handlers::Collection
+              else
+                raise "Type was never set for association #{parent.name}.#{name}"
+              end
+            )
+
+            klass.new(entity:, spec: self)
           end
         end
 
-        class Collection < Association
-          def type = :collection
+        class Merger
+          attr_reader(:name, :block)
+          def initialize(name:, block:)
+            @name = name
+            @block = block
+          end
 
-          def handler(entity)
-            Handlers::Collection.new(entity:, spec: self)
+          def call(entity, value)
+            block.call(entity, value)
           end
         end
       end