interfacets 0.1.0 → 0.9.99

data/lib/interfacets/shared/entity.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    class Entity
+      include Shared::Validations
+      include EntityDsl
+
+      class << self
+        def inherited(subclass)
+          subclass.inherit_attributes(self)
+
+          subclass.action(:after_load, accepted_by: :client)
+
+          subclass.accessor(
+            :internal_entity_id,
+            getter: -> {
+              if store.respond_to?(:internal_entity_id)
+                store.internal_entity_id
+              else
+                (@interfacets_id ||= SecureRandom.uuid)
+              end
+            },
+            setter: ->(val) {
+              if store.respond_to?(:internal_entity_id=)
+                store.internal_entity_id = val
+              else
+                @interfacets_id = val
+              end
+            }
+          )
+        end
+      end
+
+      attr_reader :store, :parent
+      def initialize(store:, nesting:, parent:)
+        @store = store
+        @parent = parent
+        @nesting = nesting
+      end
+
+      def record
+        store
+      end
+
+      def ==(other)
+        if other.is_a?(Entity)
+          store == other.store
+        else
+          store == other
+        end
+      end
+
+      def role
+        if parent.nil?
+          self.class.role
+        else
+          parent.role
+        end
+      end
+
+      def uid
+        [self.class.name, internal_entity_id].join("__")
+      end
+
+      def entity_nesting
+        @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 ||= (
+          self
+            .class
+            .associations
+            .map { |name, spec| [name, spec.handler(self) ] }
+            .to_h
+        )
+
+        @association_handlers.fetch(name.to_s)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    class GeneratedStore
+      class Constructor
+        def self.call(entity_class)
+          klass = Class.new(GeneratedStore) do
+            define_singleton_method(:name) { "#{entity_class.name}.GeneratedStore" }
+          end
+
+          entity_class.accessors.each do |name, spec|
+            klass.accessor(name)
+          end
+
+          entity_class.associations.each do |name, spec|
+            sub_class = call(spec.klass)
+
+            if spec.type == :reference
+              klass.association(name, klass: sub_class)
+            else
+              klass.collection(name, klass: sub_class)
+            end
+          end
+
+          entity_class.actions.each do |name, spec|
+            klass.define_method(name) do |entity:|
+              Client::System
+                .current_bus
+                .channel("interfacets:api")
+                .builder
+                .submit(name, nesting: entity.entity_nesting)
+            end
+          end
+
+          klass
+        end
+      end
+
+      class Handler
+        attr_reader :store, :spec
+        def initialize(store:, spec:)
+          @store = store
+          @spec = spec
+        end
+
+        def build
+          if spec.type == :reference
+            value = spec.klass.new
+            store.send("#{spec.name}=", value)
+            value
+          else
+            value = spec.klass.new
+            items = store.send(spec.name)
+            if items.nil?
+              store.send("#{spec.name}=", [value])
+            else
+              items << value
+            end
+
+            value
+          end
+        end
+      end
+
+
+      class << self
+        def construct(...)
+          Constructor.call(...)
+        end
+
+        class Spec
+          attr_reader(:name, :klass, :type)
+          def initialize(name:, klass:, type:)
+            @name = name
+            @klass = klass
+            @type = type
+          end
+
+          def build
+            spec.klass.new
+          end
+        end
+
+        def accessor(name)
+          name = name.to_s
+
+          define_method(name) do
+            @attributes[name]
+          end
+
+          define_method("#{name}=") do |val|
+            @attributes[name] = val
+          end
+        end
+
+        def association(name, klass:, type: :reference)
+          name = name.to_s
+
+          associations[name] = Spec.new(
+            name:,
+            klass:,
+            type:,
+          )
+
+          define_method(name) do
+            @attributes[name]
+          end
+
+          define_method("#{name}=") do |val|
+            @attributes[name] = val
+          end
+        end
+
+        def collection(*args, **params)
+          association(*args, **params, type: :collection)
+        end
+
+        def associations
+          @associations ||= {}
+        end
+      end
+
+      attr_accessor :attributes
+      def initialize
+        @attributes = {
+          "internal_entity_id" => SecureRandom.uuid
+        }
+      end
+
+      def ==(other)
+        attributes == other.attributes
+      end
+
+      def association(name)
+        @association_handlers ||= (
+          self
+            .class
+            .associations
+            .map { |name, spec| [name, Handler.new(store: self, spec:)] }
+            .to_h
+        )
+
+        @association_handlers.fetch(name)
+      end
+
+    end
+  end
+end

data/lib/interfacets/shared/utils.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    module Utils
+      extend self
+
+      def permissive_exec(receiver, *, &lambda)
+        if lambda.arity.zero?
+          receiver.instance_exec(&lambda)
+        else
+          receiver.instance_exec(*, &lambda)
+        end
+      end
+
+      def permissive_call(lambda, ...)
+        if lambda.arity.zero?
+          lambda.call
+        else
+          lambda.call(...)
+        end
+      end
+
+      def facet_id_to_path(config:, facet:, id:)
+        [config.mount_point, facet, id].join("/")
+      end
+
+      def path_to_facet_id(config:, path:)
+        parts = path.sub(/.*#{config.mount_point}/, "").split("/")
+        id = parts.pop
+        facet = parts.join("/")
+
+        [facet, id]
+      end
+
+      # ActiveSupport?
+      def blank?(str)
+        return true if str.nil?
+        return str.empty? if str.is_a?(Array)
+        return str.match(/\A\s*\z/) if str.is_a?(String)
+
+        raise("unsupported blank check")
+      end
+
+      def present?(str)
+        !blank?(str)
+      end
+
+      def presence(obj)
+        present?(obj) ? obj : nil
+      end
+    end
+  end
+end