interfacets 0.1.0 → 0.9.9

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

@@ -0,0 +1,117 @@
+# 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 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 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,124 @@
+# 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,
+          )
+          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,
+            &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
+            klass.class_exec(&block) if block_given?
+          end
+        end
+
+        class Reference < Association
+          def type = :reference
+
+          def handler(entity)
+            Handlers::Reference.new(entity:, spec: self)
+          end
+        end
+
+        class Collection < Association
+          def type = :collection
+
+          def handler(entity)
+            Handlers::Collection.new(entity:, spec: self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/shared/entity.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    class Entity
+      include Shared::Validations
+
+      class << self
+        attr_accessor :manifest
+
+        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
+
+        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(
+            :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 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_collection.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Shared
+    class EntityCollection
+      include Enumerable
+
+      attr_reader :items
+      def initialize(items, &block)
+        @items = items || []
+        @wrap = block
+      end
+
+      def each(&)
+        @items.each do |item|
+          yield(@wrap.call(item))
+        end
+      end
+
+      def to_a
+        @items.map { @wrap.call(_1) }
+      end
+
+      def size
+        @items.size
+      end
+
+      def length
+        @items.length
+      end
+
+      def empty?
+        @items.empty?
+      end
+
+      def include?(item)
+        @items.include?(to_record(item))
+      end
+
+      def [](index)
+        item = @items[index]
+        item ? @wrap.call(item) : nil
+      end
+
+      def first
+        item = @items.first
+        item ? @wrap.call(item) : nil
+      end
+
+      def last
+        item = @items.last
+        item ? @wrap.call(item) : nil
+      end
+
+      def <<(item_to_add)
+        @items << to_record(item_to_add)
+        self
+      end
+
+      def push(*items_to_add)
+        @items.push(*items_to_add.map { to_record(_1) })
+        self
+      end
+
+      def delete(item)
+        @items.delete(to_record(item))
+      end
+
+      def delete_at(index)
+        @items.delete_at(index)
+      end
+
+      def original
+        @items
+      end
+
+      def inspect
+        "#<#{self.class.name} decorating=#{@items.inspect} with=#{@entity_class}>"
+      end
+
+      private
+
+      def to_record(item)
+        item.is_a?(Entity) ? item.record : item
+      end
+    end
+  end
+end

data/lib/interfacets/shared/generated_store.rb

@@ -0,0 +1,145 @@
+# 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
+              Client::System.current_bus.channel("interfacets:api").builder.submit(name)
+            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(/^\s*$/) 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