interfacets 0.9.9 → 0.9.99

data/lib/interfacets/shared/entity.rb

@@ -4,109 +4,15 @@ module Interfacets
   module Shared
     class Entity
       include Shared::Validations
+      include EntityDsl
 
       class << self
-        attr_accessor :manifest
+        def inherited(subclass)
+          subclass.inherit_attributes(self)
 
-        def role(name = nil)
-          @role = name.to_s if name
-          @role
-        end
-
-        def accessor(
-          name,
-          getter: -> { store.send(name) },
-          setter: ->(val) { store.send("#{name}=", val) },
-          accepted_by: Entities::Specs::ANY
-        )
-          name = name.to_s
-          accessors[name] = Entities::Specs::Accessor.new(name:, accepted_by:)
-
-          define_method(name, &getter)
-          define_method("#{name}=", &setter)
-        end
-
-        def association(*args, type: :reference, **params, &block)
-          if type == :reference
-            reference(*args, **params, &block)
-          elsif type == :collection
-            collection(*args, **params, &block)
-          else
-            raise ArgumentError
-          end
-        end
-
-        def reference(
-          name,
-          **spec_params,
-          &block
-        )
-          name = name.to_s
-          spec = (associations[name] ||= Entities::Specs::Reference.new(parent: self, name: name))
-          spec.apply(**spec_params, &block)
-
-          define_method(name) do
-            association(name).get
-          end
-
-          define_method("#{name}=") do |val|
-            association(name).set(val)
-          end
-        end
-
-        def collection(
-          name,
-          **spec_params,
-          &block
-        )
-          name = name.to_s
-
-          spec = (associations[name] ||= Entities::Specs::Collection.new(parent: self, name: name))
-          spec.apply(**spec_params, &block)
-
-          define_method(name) do
-            association(name).get
-          end
-
-          define_method("#{name}=") do |val|
-            association(name).set(val)
-          end
-        end
+          subclass.action(:after_load, accepted_by: :client)
 
-        def server_action(name, only_if_valid: true)
-          action(name, accepted_by: :server, only_if_valid:)
-          action("after_#{name}", accepted_by: :client)
-        end
-
-        def action(name, accepted_by: Entities::Specs::ANY, only_if_valid: false)
-          name = name.to_s
-          actions[name] = Entities::Specs::Action.new(name:, accepted_by:, only_if_valid:)
-
-          define_method(name) do
-            store.send(name)
-          end
-        end
-
-        def accessors
-          @accessors ||= {}
-        end
-
-        def associations
-          @associations ||= {}
-        end
-
-        def actions
-          @actions ||= {}
-        end
-
-        def attributes
-          accessors.merge(associations)
-        end
-
-        def inherited(mod)
-          mod.action(:after_load, accepted_by: :client)
-
-          mod.accessor(
+          subclass.accessor(
             :internal_entity_id,
             getter: -> {
               if store.respond_to?(:internal_entity_id)
@@ -161,6 +67,24 @@ module Interfacets
         @entity_nesting ||= (parent&.entity_nesting || []) + [[@nesting, internal_entity_id]]
       end
 
+      def entity_at(nesting)
+        # ignore first entry, cause it's self
+        real_nesting = nesting[1..-1]
+
+        if real_nesting.count == 0
+          self
+        else
+          assoc, internal_entity_id = real_nesting[0]
+
+          if association(assoc).collection?
+            association(assoc).get.find { _1.internal_entity_id == internal_entity_id }
+          else
+            value = association(assoc).get
+            value.internal_entity_id == internal_entity_id ? value : nil
+          end
+        end
+      end
+
       def association(name)
         # inlined to avoid polluting API
         @association_handlers ||= (

data/lib/interfacets/shared/entity_dsl.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    module EntityDsl
+      extend ActiveSupport::Concern
+
+      included do |base|
+        if base.respond_to?(:inherit_attributes)
+          base.inherit_attributes(self)
+        end
+      end
+
+      class_methods do
+        attr_accessor :manifest
+
+        def role(name = nil)
+          if name
+            @role = name.to_s
+          else
+            @role
+          end
+        end
+
+        def inheritable_attributes
+          {
+            accessors:,
+            actions:,
+            mergers:,
+            role: @role,
+            associations:,
+            validators:
+          }
+        end
+
+        def inherit_attributes(parent)
+          return unless parent.respond_to?(:inheritable_attributes)
+          attrs = parent.inheritable_attributes
+          @accessors = attrs[:accessors].dup.merge(accessors)
+          @actions = attrs[:actions].dup.merge(actions)
+          @mergers = attrs[:mergers].dup.merge(mergers)
+          @role ||= attrs[:role]
+
+          attrs[:associations].each do |name, spec|
+            associations[name] ||= spec.dup_for(self)
+          end
+
+          @validators = (attrs[:validators].dup + validators).uniq
+        end
+
+        def merge(name, *events, &block)
+          spec = Entities::Specs::Merger.new(
+            name:,
+            block:
+          )
+
+          target = (mergers[name.to_s] ||= {})
+
+          if events.empty?
+            target[:default] = spec
+          else
+            events.each do |event|
+              target[event.to_s] = spec
+            end
+          end
+        end
+
+        def accessor(
+          name,
+          getter: -> { store.send(name) },
+          setter: ->(val) { store.send("#{name}=", val) },
+          accepted_by: Entities::Specs::ANY
+        )
+          name = name.to_s
+          accessors[name] = Entities::Specs::Accessor.new(name:, accepted_by:)
+
+          define_method(name, &getter)
+          define_method("#{name}=", &setter)
+        end
+
+        def association(name, mod = nil, **spec_params, &block)
+          name = name.to_s
+          associations[name] ||= Entities::Specs::Association.new(parent: self, name: name)
+          associations[name].apply(mod:, **spec_params, &block)
+
+          define_method(name) do
+            association(name).get
+          end
+
+          define_method("#{name}=") do |val|
+            association(name).set(val)
+          end
+        end
+
+        def reference(*a, **p, &b)
+          association(*a, **p, type: :reference, &b)
+        end
+
+        def collection(*a, **p, &b)
+          association(*a, **p, type: :collection, &b)
+        end
+
+        def server_action(name, only_if_valid: true)
+          action(name, accepted_by: :server, only_if_valid:)
+          action("after_#{name}", accepted_by: :client)
+
+          define_method(name) do
+            store.send(name, entity: self)
+          end
+        end
+
+        def action(name, accepted_by: Entities::Specs::ANY, only_if_valid: false)
+          name = name.to_s
+          actions[name] = Entities::Specs::Action.new(name:, accepted_by:, only_if_valid:)
+
+          define_method(name) {}
+        end
+
+        def accessors
+          @accessors ||= {}
+        end
+
+        def associations
+          @associations ||= {}
+        end
+
+        def actions
+          @actions ||= {}
+        end
+
+        def mergers
+          @mergers ||= Hash.new { |h, k|
+            h[k] = {
+              default: Entities::Specs::Merger.new(
+                name: k,
+                block: ->(entity, value) {
+                  entity.send("#{k}=", value)
+                }
+              )
+            }
+          }
+        end
+
+        def attributes
+          accessors.merge(associations)
+        end
+
+        def validators
+          @validators ||= []
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/shared/facet.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    module Facet
+      extend ActiveSupport::Concern
+
+      class_methods do
+        attr_accessor :shared, :entity, :store
+
+        def mount(facet, as:, type: nil, &block)
+          if block_given?
+            parent_facet = facet
+            facet = Module.new do
+              include Interfacets::Shared::Facet
+
+              server_entity do
+                include parent_facet.server_entity_module
+              end
+
+              entity_base do
+                include parent_facet.entity_base_module
+              end
+
+              client_entity do
+                include parent_facet.client_entity_module
+              end
+
+              view_class.view(&parent_facet.view_class.view) if parent_facet.view_class.view
+
+              class_exec(&block)
+            end
+          end
+
+          server_entity do
+            association(as, facet.server_entity_module, type:)
+          end
+
+          client_entity do
+            association(as, facet.client_entity_module, type:)
+          end
+
+          entity_base do
+            association(as, facet.entity_base_module, type:)
+          end
+        end
+
+        def view(&block)
+          view_class.view(&block)
+        end
+
+        def view_class
+          @view_class ||= Class.new(Interfacets::Shared::View)
+        end
+
+        def client_entity(&block)
+          clients << block
+        end
+
+        def clients
+          @clients ||= []
+        end
+
+        def client_entity_module
+          @client_entity_module ||= (
+            facet = self
+            Module.new do
+              extend ActiveSupport::Concern
+              include facet.entity_base_module
+
+              included do
+                define_singleton_method(:view) do
+                  facet.view_class
+                end
+
+                role("client")
+                facet.clients.each { class_exec(&_1) }
+              end
+            end
+          )
+        end
+
+        def client_entity_class
+          @client_entity_class ||= (
+            facet = self
+            Class
+              .new(entity_base_class)
+              .tap do |k|
+                k.class_exec do
+                  include facet.client_entity_module
+
+                  define_singleton_method(:store) do
+                    @store ||= (
+                      ::Interfacets::Shared::GeneratedStore.construct(self)
+                        .tap { self.const_set("Store", _1) }
+                    )
+                  end
+
+                  self.manifest = facet.entity_base_class
+
+                  def channel(name)
+                    Interfacets::Client::System.current_bus.channel(name).builder
+                  end
+                end
+              end
+          )
+        end
+
+        def entity_base(&block)
+          bases << block
+        end
+
+        def bases
+          @bases ||= []
+        end
+
+        def entity_base_module
+          @entity_base_module ||= (
+            facet = self
+            Module.new do
+              extend ActiveSupport::Concern
+              include Interfacets::Shared::EntityDsl
+              included do
+                facet.bases.each { class_exec(&_1) }
+              end
+            end
+          )
+        end
+
+        def entity_base_class
+          @entity_base_class ||= (
+            facet = self
+
+            Class.new(Shared::Entity)
+              .tap { |k| k.include(facet.entity_base_module) }
+              .tap { facet.const_set("EntityBase", _1) }
+          )
+        end
+
+        def server_entity_module
+          @server_entity_module ||= (
+            facet = self
+            Module.new do
+              extend ActiveSupport::Concern
+              include facet.entity_base_module
+              included do
+                role("server")
+                facet.servers.each { class_exec(&_1) }
+              end
+            end
+          )
+        end
+
+        def server_entity_class
+          @server_entity_class ||= (
+            facet = self
+
+            Class.new(entity_base_class) {
+              include facet.server_entity_module
+
+              attr_reader :channel
+              def initialize(*a, channel:, **p, &b)
+                @channel = channel
+                super(*a, **p, &b)
+              end
+
+              def build_entity(...)
+                channel.build(...)
+              end
+
+              self.manifest = facet.entity_base_class
+            }
+          ).tap { facet.const_set("ServerBase", _1) }
+        end
+
+        def server_entity(unshift: false, &block)
+          if unshift
+            servers.unshift(block)
+          else
+            servers << block
+          end
+        end
+
+        def servers
+          @servers ||= []
+        end
+      end
+
+      attr_reader :entity, :view
+      def initialize(entity)
+        @entity = entity
+        @view = self.class.view.new if self.class.view.is_a?(Class)
+      end
+
+      def render(channels)
+        view.render(entity:, channels:)
+      end
+    end
+  end
+end

data/lib/interfacets/shared/generated_store.rb

@@ -24,8 +24,12 @@ module Interfacets
           end
 
           entity_class.actions.each do |name, spec|
-            klass.define_method(name) do
-              Client::System.current_bus.channel("interfacets:api").builder.submit(name)
+            klass.define_method(name) do |entity:|
+              Client::System
+                .current_bus
+                .channel("interfacets:api")
+                .builder
+                .submit(name, nesting: entity.entity_nesting)
             end
           end
 

data/lib/interfacets/shared/utils.rb

@@ -37,7 +37,7 @@ module Interfacets
       def blank?(str)
         return true if str.nil?
         return str.empty? if str.is_a?(Array)
-        return str.match(/^\s*$/) if str.is_a?(String)
+        return str.match(/\A\s*\z/) if str.is_a?(String)
 
         raise("unsupported blank check")
       end

data/lib/interfacets/shared/validations.rb

@@ -13,7 +13,11 @@ module Interfacets
         end
 
         def add(k, v)
-          @errors[k] << v
+          @errors[k.to_sym] << v
+        end
+
+        def clear
+          @errors.clear
         end
 
         def [](k)

data/lib/interfacets/{client → shared}/view.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Interfacets
-  module Client
+  module Shared
     class View
       class Evaluator
-        def self.call(...)
-          new(...).call
+        def self.call(**p)
+          new(**p).call
         end
 
         attr_reader :entity, :channels, :block
@@ -20,10 +20,23 @@ module Interfacets
           instance_exec(entity, &@block)
         end
 
-        def render(channel_id, stream: "default", &block)
+        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.to_s)
+            .fetch(channel_id)
             .builder(stream.to_s)
+            .then { @current_builder = _1 }
             .then { instance_exec(_1, &block) }
         end
 
@@ -37,10 +50,24 @@ module Interfacets
           @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:)
-        Evaluator.call(entity: entity, channels:, block: self.class.view)
+        return unless self.class.view
+
+        Evaluator.call(
+          entity: entity,
+          channels: channels,
+          block: self.class.view
+        )
       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