interfacets 0.1.0 → 0.9.99

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

@@ -0,0 +1,230 @@
+# 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:)
+    action = event.fetch("action")
+
+    assert_valid_receiver(to: event.fetch("to"))
+    assert_valid_action(
+      action:,
+      to: entity.role,
+      nesting: event.fetch("nesting"),
+    )
+
+    attributes = event.fetch("payload").fetch("attributes", {})
+
+    merge(entity:, manifest:, attributes:, action:)
+
+    target_entity = entity.entity_at(event.fetch("nesting"))
+
+    target_entity
+      &.class
+      &.actions
+      &.fetch(event.fetch("action"))
+      &.dispatch(target_entity)
+  end
+
+  private
+
+  def serialize_attributes(manifest:, entity:, to:)
+    return if entity.nil?
+
+    data = {}
+
+    data[:errors] = entity.errors.to_h if entity.respond_to?(:errors)
+
+    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:, 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
+      .select { _1.accepted_by?(entity.role) }
+      .each do |attribute|
+        next unless attributes.key?(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
+      .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 { |nested_entity|
+            merge(
+              entity: nested_entity,
+              manifest: association.klass,
+              attributes: value,
+              action:
+            )
+          }
+          .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,
+                  action:
+                )
+              }
+            else
+              entity
+                .association(collection.name)
+                .build
+                .tap { |r|
+                    merge(
+                      entity: r,
+                      manifest: collection.klass,
+                      attributes: val,
+                      action:
+                    )
+                  }
+            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

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    module Entities
+      module Specs
+        module Handlers
+          class Handler
+            attr_reader :entity, :spec, :cache
+            def initialize(entity:, spec:)
+              @entity = entity
+              @spec = spec
+              @cache = {}
+            end
+
+            def type
+              spec.type
+            end
+
+            def unwrap(value)
+              if value.is_a?(Entity)
+                value.store
+              elsif value.is_a?(Array)
+                value.map { unwrap(_1) }
+              else
+                value
+              end
+            end
+
+            def wrap(value)
+              if value.is_a?(Entity)
+                value
+              elsif cache[value]
+                cache[value]
+              elsif value
+                @cache[value] = spec.klass.new(
+                  store: value,
+                  nesting: spec.name,
+                  parent: entity,
+                )
+              end
+            end
+          end
+
+          class Reference < Handler
+            def collection?
+              false
+            end
+
+            def reference?
+              true
+            end
+
+            def get
+              wrap(entity.instance_exec(&spec.getter))
+                .tap {
+                  @cache = {}
+                  @cache[_1&.store] = _1
+                }
+            end
+
+            def set(val)
+              entity.instance_exec(unwrap(val), &spec.setter)
+              wrap(val)
+            end
+
+            def build(**attributes)
+              value = entity.instance_exec(&spec.builder)
+              attributes.each do |name, val|
+                value.send("#{name}=", val)
+              end
+
+              # TODO: make sure this is right
+              # set(value)
+
+              wrap(value)
+            end
+          end
+
+          class Collection < Handler
+            def collection?
+              true
+            end
+
+            def reference?
+              false
+            end
+
+            def get
+              values = entity.instance_exec(&spec.getter) || []
+
+              CollectionProxy.new(
+                values,
+                wrap: ->(val) { wrap(val) },
+                unwrap: ->(val) { unwrap(val) },
+              ).tap { |entities|
+                @cache = entities.map { [_1.store, _1] }.to_h
+              }
+            end
+
+            def set(val)
+              @cache ||= {}
+              val.each do |item|
+                if item.is_a?(Entity)
+                  @cache[item.store] = item
+                end
+              end
+
+              entity.instance_exec(unwrap(val), &spec.setter)
+            end
+
+            def build(**attributes)
+              value = unwrap(entity.instance_exec(&spec.builder))
+              attributes.each do |name, val|
+                value.send("#{name}=", val)
+              end
+
+              items = entity.instance_exec(&spec.getter)
+
+              if items.nil?
+                set([value])
+              elsif !items.include?(value)
+                items << value
+              end
+
+              wrap(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    module Entities
+      module Specs
+
+        # I would like to use Object.new for object equality here, however,
+        # in the intergration tests, our shared code gets evaled on the frontend
+        # and again on the backend (for now). For that reason, we cannot use
+        # object equality because the constant will be overridden.
+        NOT_PASSED = :interfacets__not_passed_flag
+        ANY = :interfacets__any_flag
+
+        module Acceptable
+          def accepted_by?(role)
+            standardized_accepted_by == ANY || standardized_accepted_by.include?(role)
+          end
+
+          def standardized_accepted_by
+            @standardized_accepted_by ||= (
+              if accepted_by == ANY
+                ANY
+              else
+                 Array(accepted_by).map(&:to_s)
+              end
+            )
+          end
+        end
+
+        class Action
+          include Acceptable
+
+          attr_reader :name, :accepted_by, :only_if_valid
+          def initialize(name:, accepted_by:, only_if_valid:)
+            @name = name
+            @accepted_by = accepted_by
+            @only_if_valid = only_if_valid
+          end
+
+
+          def type = :action
+
+          def dispatch(entity)
+            if !only_if_valid || entity.valid?
+              entity.send(name)
+            end
+          end
+        end
+
+        class Accessor
+          include Acceptable
+
+          attr_reader :name, :accepted_by
+          def initialize(name:, accepted_by:)
+            @name = name
+            @accepted_by = accepted_by
+          end
+
+          def type = :accessor
+        end
+
+        class Association
+          include Acceptable
+
+          attr_reader(
+            :name,
+            :accepted_by,
+            :klass,
+            :getter,
+            :setter,
+            :builder,
+            :parent,
+            :identifier,
+            :type,
+          )
+          def initialize(parent:, name:)
+            @parent = parent
+            @name = name
+            @accepted_by = Entities::Specs::ANY
+            @getter = -> { store.send(name) }
+            @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
+          end
+
+          def apply(
+            accepted_by: NOT_PASSED,
+            getter: NOT_PASSED,
+            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
+            @getter = getter unless getter == NOT_PASSED
+            @setter = setter unless setter == NOT_PASSED
+            @builder = builder unless builder == NOT_PASSED
+            @identifier = identifier.to_s unless identifier == NOT_PASSED
+
+            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
+
+          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)
+            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 Merger
+          attr_reader(:name, :block)
+          def initialize(name:, block:)
+            @name = name
+            @block = block
+          end
+
+          def call(entity, value)
+            block.call(entity, value)
+          end
+        end
+      end
+    end
+  end
+end