ecs_on_rails 0.2.1

data/lib/ecs_rails/entity.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module EcsRails
+  # An immutable identity row. Carries no domain state.
+  #
+  # Implements RFC-0001. See docs/architecture.md §1 for the invariants and
+  # docs/adr/0002-single-entities-table.md for why the `model` column exists.
+  #
+  # Host apps subclass this once, as ApplicationEntity, then subclass that per
+  # entity type:
+  #
+  #   class ApplicationEntity < EcsRails::Entity
+  #     self.abstract_class = true
+  #   end
+  #
+  #   class User < ApplicationEntity
+  #   end
+  #
+  #   User.create!.model  # => "users"
+  #   User.all            # => SELECT * FROM entities WHERE model = 'users'
+  #   ApplicationEntity.all # => SELECT * FROM entities  (no filter)
+  #
+  # All entity classes share the one `entities` table. There is no updated_at
+  # column: an entity is written once and never changes, so ActiveRecord's
+  # timestamp code — which only touches timestamp columns that actually exist —
+  # stamps created_at and nothing else. No configuration is needed for that.
+  class Entity < ActiveRecord::Base
+    # Makes assignment to a readonly attribute raise on a persisted record.
+    #
+    # ActiveRecord ships this behaviour, but `attr_readonly` only installs it
+    # when `ActiveRecord.raise_on_assign_to_attr_readonly` is true. That config
+    # defaults to *false* in bare ActiveRecord, and in a Rails app it is applied
+    # by the railtie only after this file has already been required — so by the
+    # time `attr_readonly` runs below, the host's setting is not yet visible and
+    # cannot be relied on either way. RFC-0001 requires the raise
+    # unconditionally, so we install our own guard rather than inherit a race.
+    #
+    # Harmless if ActiveRecord's own guard is also installed: both raise the
+    # same error.
+    module ImmutableIdentity
+      # Rejects writes to readonly attributes once the row exists. New records
+      # are untouched, so create — including ActiveRecord assigning the
+      # database-generated id — still works.
+      #
+      # Both writers are guarded because the public #write_attribute does not
+      # call #_write_attribute; it writes to the attribute set directly.
+      def write_attribute(attr_name, value)
+        guard_readonly_attribute!(attr_name)
+        super
+      end
+
+      # The internal writer, which every generated `attr=` method funnels into.
+      def _write_attribute(attr_name, value)
+        guard_readonly_attribute!(attr_name)
+        super
+      end
+
+      private
+
+      def guard_readonly_attribute!(attr_name)
+        return if new_record?
+        return unless self.class.readonly_attributes.include?(attr_name.to_s)
+
+        raise ActiveRecord::ReadonlyAttributeError, attr_name
+      end
+    end
+
+    self.abstract_class = true
+    self.table_name = "entities"
+
+    include ImmutableIdentity
+
+    # Lazy / virtual components (RFC-0006): the memo behind every component
+    # reader, and the save cascade. The readers themselves are generated per
+    # component by the DSL, into generated_component_methods.
+    include Lazy::Entity
+
+    # Component presence (RFC-0009): add / has? / remove. Included after
+    # Lazy::Entity because it works through Lazy's memo (@ecs_components) and its
+    # reader — `add` persists the memoised instance, `remove` relies on
+    # Lazy::Component's after_destroy to reset it. The `<reader>?` predicate is
+    # generated per component by the DSL.
+    include Presence::Entity
+
+    # Validation error merging (RFC-0007): the `validate` callback that reflects
+    # a dirty component's validity onto the entity, and the human_attribute_name
+    # override that keeps `errors[:"email.address"]` machine-readable while
+    # `full_messages` reads "Email address is invalid". Included after
+    # Lazy::Entity because it walks Lazy's memo (@ecs_components).
+    include Validations::Entity
+
+    # The `component` DSL (RFC-0004). Extended rather than defined here: RFC-0001
+    # is about identity, and composition is a separate concern with its own file.
+    # Singleton methods are inherited, so every entity subclass answers it.
+    extend DSL
+
+    # The `relates_to` DSL (RFC-0012): cross-entity links, decided by ADR-0013.
+    # Extended after DSL because it is built on `component` — it dynamically
+    # defines a backing component class and declares it — and reuses DSL's own
+    # private reader/delegation resolution for its collision check. See
+    # EcsRails::Relationships.
+    extend Relationships
+
+    # The component query DSL (RFC-0010): with_component / without_component.
+    # Extended as class methods so every entity subclass answers them, and so
+    # ActiveRecord delegates them to relations (`Post.where(...).with_component`).
+    # They compile to correlated EXISTS / NOT EXISTS subqueries and rely on
+    # running against the class's own default-scoped relation — see
+    # docs/adr/0011-component-query-dsl.md.
+    extend Querying
+
+    # Component preloading (RFC-0011): includes_components. Extended as class
+    # methods, like Querying, so every entity subclass answers it and ActiveRecord
+    # delegates it to relations (`User.where(...).includes_components`). It is a
+    # thin wrapper over ActiveRecord's own `preload` — which already batches
+    # component has_one loads and, via RFC-0006's `super`-calling reader, still
+    # yields virtual instances — see docs/adr/0012-component-preloading.md.
+    extend Preloading
+
+    # Immutable identity (architecture.md §1). Beyond the guard above, this is
+    # what excludes id and model from any UPDATE statement.
+    attr_readonly :id, :model
+
+    # Filters each concrete subclass to its own discriminator.
+    #
+    # `default_scope` is the right mechanism here despite its usual reputation,
+    # for two reasons:
+    #
+    # 1. `build_default_scope` returns early for abstract classes, so the
+    #    abstract base applies no filter and can query across all entities —
+    #    exactly what RFC-0001 asks for, with no special-casing from us.
+    # 2. The block is instance_exec'd against the relation, so `klass` is
+    #    whichever class is being queried. One declaration here covers every
+    #    subclass, and a subclass of a subclass filters on its own plural.
+    #
+    # Its notorious leak into `new`/`create` is, unusually, wanted: scope_for_create
+    # means `User.new.model` is already "users" before save. That leak is a
+    # convenience, not the mechanism — #stamp_model below is what guarantees the
+    # discriminator is correct.
+    #
+    # Must use the same derivation as #stamp_model, or entities become
+    # unfindable by the very scope that is supposed to select them.
+    default_scope { where(model: klass.model_name.collection) }
+
+    # RFC-0001: model is set on create from the subclass's model_name.collection.
+    #
+    # Deliberately not left to the default scope's scope_for_create. The
+    # discriminator is derived from the class, never supplied by the caller, so
+    # it is stamped unconditionally: `User.create!(model: "posts")` yields a
+    # user, and `User.unscoped.create!` — which has no create scope to inherit —
+    # is still stamped rather than failing the NOT NULL constraint.
+    before_validation :stamp_model, on: :create
+
+    class << self
+      # Both hooks are private in ActiveRecord, and both are only ever called
+      # with an implicit receiver from within AR's own class methods. Matching
+      # that visibility keeps them out of the gem's public surface.
+      private
+
+      # Resolves a row's `model` discriminator back to the entity subclass that
+      # wrote it, so ApplicationEntity.find(id) returns a User. See ADR-0008.
+      #
+      # This is Rails' own STI resolution hook, applied to a column that is not
+      # `inheritance_column` — taking the one piece of machinery we want and
+      # none of the rest.
+      #
+      # Raises NameError for a discriminator that names no live constant (class
+      # deleted or renamed). ADR-0008 chooses this deliberately: it matches the
+      # registry's fail-loudly stance, and a silent nil would hand back a
+      # useless abstract instance.
+      #
+      # Note this is only ever reached via #instantiate_instance_of below — see
+      # the comment there for why the hook alone is not enough.
+      def discriminate_class_for_record(record)
+        model = record["model"]
+        return super if model.blank?
+
+        model.classify.constantize
+      rescue NameError => e
+        raise NameError, "EcsRails: entity row has model #{model.inspect}, " \
+                         "which does not resolve to a class (#{e.message}). " \
+                         "See ADR-0008.", e.backtrace
+      end
+
+      # Routes every read path through #discriminate_class_for_record.
+      #
+      # ADR-0008 says to override #discriminate_class_for_record and stop. That
+      # is not sufficient on its own: ActiveRecord only consults the hook when
+      # the result set contains the *inheritance_column*. From
+      # ActiveRecord::Querying#_load_from_sql (8.1):
+      #
+      #   if result_set.includes_column?(inheritance_column)
+      #     rows.map { |r| instantiate(r, ...) }          # calls the hook
+      #   else
+      #     rows.map { |r| instantiate_instance_of(self, r, ...) }  # does not
+      #   end
+      #
+      # `inheritance_column` is "type", and `entities` has no such column, so
+      # entities always take the second branch and the hook is never called.
+      # Setting `inheritance_column = "model"` opens the gate but drags in the
+      # rest of STI — a type_condition that breaks sub-subclass scoping, and
+      # subclass_from_attributes, which turns User.create!(model: "posts") into
+      # a SubclassNotFound. Both are behaviours RFC-0001 has already specified
+      # otherwise, and both are exactly why ADR-0008 rejected Option B.
+      #
+      # Overriding here instead keeps #discriminate_class_for_record as the one
+      # decision point and leaves inheritance_column alone. Both callers of
+      # this method funnel through it — the fast path above, and #instantiate
+      # (which the eager-loading path uses) — so every read resolves, and the
+      # double call from #instantiate is idempotent.
+      def instantiate_instance_of(klass, attributes, column_types = {}, &block)
+        super(discriminate_class_for_record(attributes), attributes, column_types, &block)
+      end
+    end
+
+    private
+
+    # Stamps the model discriminator from the class name. See ADR-0002, and
+    # ADR-0008 for why this is #collection and not #plural.
+    #
+    # #plural is lossy for namespaced classes: Blog::Post and BlogPost both give
+    # "blog_posts", so the mapping is not injective and no inverse can separate
+    # them — such an entity could be written but never read back as itself.
+    # #collection gives "blog/posts", which classifies cleanly back to
+    # Blog::Post, and is identical to #plural for every non-namespaced class
+    # ("users" either way) — so this needs no data migration.
+    #
+    # #default_scope above must use the same derivation.
+    def stamp_model
+      self.model = self.class.model_name.collection
+    end
+  end
+end

data/lib/ecs_rails/errors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module EcsRails
+  # Base class for every error the gem raises.
+  class Error < StandardError; end
+
+  # Raised when `component` is given something that is not a EcsRails::Component.
+  # See RFC-0004.
+  class InvalidComponent < Error; end
+
+  # Raised when `relates_to` is given a target that is not a concrete
+  # EcsRails::Entity. See RFC-0012 / ADR-0013.
+  #
+  # A subclass of InvalidComponent on purpose. RFC-0012 left the choice open —
+  # reuse InvalidComponent, or add a dedicated class — and this gets both: the
+  # message is relationship-shaped ("relates_to :author expected ... an entity"),
+  # while any existing `rescue InvalidComponent` and the RFC's own contract test
+  # (`raise_error(EcsRails::InvalidComponent)`) still match, because a
+  # relationship *is* a component under the hood. See EcsRails::Relationships.
+  class InvalidRelationship < InvalidComponent; end
+
+  # Raised when an entity declares the same component twice. See RFC-0002.
+  class DuplicateComponent < Error; end
+
+  # Raised at declaration time when two components on one entity would delegate
+  # the same method name. See ADR-0004 and RFC-0005.
+  class DelegationConflict < Error; end
+end

data/lib/ecs_rails/lazy.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module EcsRails
+  # Lazy / virtual components: a component costs nothing until it holds
+  # something.
+  #
+  # Implements RFC-0006 and closes the gap RFC-0004 knowingly left in
+  # architecture.md §3 — `entity.email` now always returns an Email.
+  #
+  #   user = User.create!          # one INSERT, into entities. Nothing else.
+  #   user.email                   # => #<Email address: nil, verified: false>
+  #   user.email.persisted?        # => false        — no row, and none wanted
+  #   user.save!                   # still no emails row
+  #
+  #   user.email.address = "a@b.com"
+  #   user.save!                   # *now* one INSERT into emails
+  #
+  # The whole feature is two questions: which component instance does the reader
+  # hand back (Entity#ecs_component), and does that instance deserve a row
+  # (Component#ecs_dirty?). Everything else here is bookkeeping in service of
+  # those two.
+  module Lazy
+    # Mixed into EcsRails::Entity. The reader itself is generated per component
+    # by the DSL, into generated_component_methods; this supplies the machinery
+    # it calls, and the save cascade.
+    module Entity
+      extend ActiveSupport::Concern
+
+      included do
+        # The cascade (RFC-0006: "entity.save cascades: it saves itself and
+        # every dirty component, in one transaction").
+        #
+        # after_save, not after_create/after_update, because it must run for
+        # both — and it does run on an unchanged persisted entity, which matters
+        # a great deal here: an entity has no mutable fields of its own
+        # (architecture.md §1), so `user.email.address = "x"; user.save!` is
+        # *always* a save with nothing of the entity's own to write. If this
+        # only fired when the entity itself changed, the money path would never
+        # fire at all.
+        #
+        # ActiveRecord wraps save in a transaction and runs after_save inside
+        # it, so "one transaction" needs no work from us.
+        after_save :save_dirty_components
+      end
+
+      # Drops the memo, so the next read goes back to the database.
+      #
+      # ActiveRecord's #reload clears the association cache; the memo is a
+      # second cache over the same rows and has to be cleared with it or reload
+      # would be a lie — the caller would get their stale virtual back.
+      def reload(*)
+        @ecs_components = nil
+        super
+      end
+
+      # The instance `entity.email` hands back. Called by the readers the DSL
+      # generates; the block reaches the has_one reader underneath.
+      #
+      # Memoised per entity instance, which RFC-0006 requires and the money path
+      # depends on: `user.email.address = "x"; user.save!` only works if the
+      # instance the caller mutated is the instance the cascade later sees.
+      # Reading twice must not throw the first read's assignment away.
+      #
+      # The memo caches the *row* case too, not just the virtual one. It costs
+      # nothing (the association has its own cache, holding the same object) and
+      # it means the cascade can simply walk the memo, rather than interrogating
+      # ActiveRecord about which associations happen to be loaded.
+      #
+      # @api private
+      def ecs_component(name)
+        cache = (@ecs_components ||= {})
+        return cache[name] if cache.key?(name)
+
+        cache[name] = yield || ecs_build_component(name)
+      end
+
+      # Forgets a component, so the next read rebuilds it as virtual.
+      #
+      # Public only because a component calls it on its entity, from across the
+      # object boundary — unlike #ecs_component, which the generated readers
+      # call on themselves.
+      #
+      # Called by a component's after_destroy (see Lazy::Component). Clearing
+      # the memo is not enough on its own: if the row was read through the
+      # reader then ActiveRecord's association is *also* holding it, and #super
+      # in the generated reader would hand the frozen, destroyed object straight
+      # back. Both caches have to go.
+      #
+      # The association is left marked loaded-with-nil rather than reset,
+      # because that is not a guess: the row was just deleted, and a component
+      # appears at most once per entity (ADR-0005), so there is provably nothing
+      # left to find. Resetting would buy an identical answer for one SELECT.
+      #
+      # @api private
+      def ecs_forget_component(name)
+        @ecs_components&.delete(name)
+        return unless self.class.reflect_on_association(name)
+
+        association(name).target = nil
+      end
+
+      private
+
+      # An in-memory component with every attribute at its default and entity_id
+      # set (RFC-0006). The defaults are ActiveRecord's own, read from the
+      # column definitions — so a virtual `user.email.address` and a bare
+      # `Email.new.address` agree by construction rather than by us copying a
+      # list of defaults about.
+      def ecs_build_component(name)
+        component = self.class.reflect_on_association(name).klass.new
+        # Not `component.entity_id = id` — the belongs_to writer also sets the
+        # association target, which is what makes `user.email.entity` return
+        # this very entity without a query (architecture.md §1: a system reaches
+        # the entity via component.entity). A virtual component has no row, so
+        # there is nothing for a query to walk back *from*; if the entity is not
+        # handed over here it can never be recovered.
+        #
+        # On a new entity `id` is still nil at this point — the UUID comes back
+        # from the INSERT. #save_dirty_components restamps the foreign key after
+        # the entity is saved, which is where that resolves.
+        component.entity = self
+        component
+      end
+
+      # Saves every dirty component the caller has touched, inside the
+      # transaction ActiveRecord has already opened around #save.
+      #
+      # Walks the memo, not the declared components: an untouched component was
+      # never read, has no instance, and must not be queried for. That absence
+      # is the feature — "components are free unless you use them" is a claim
+      # about SQL, and this method is where it is kept.
+      def save_dirty_components
+        return unless @ecs_components
+
+        @ecs_components.each_value do |component|
+          # Destroyed through the reader inside this same save. Saving it would
+          # resurrect the row the caller just asked to be rid of.
+          next if component.destroyed?
+          next unless component.ecs_dirty?
+
+          # The entity's UUID is assigned by the database, so on create it did
+          # not exist when the component was built. Restamped rather than
+          # assumed. Deliberately after the dirty check, which ignores entity_id
+          # for exactly this reason.
+          component.entity_id = id
+
+          # Bang, so a failure is loud. This is a deliberate, temporary wart:
+          # non-bang `entity.save` will raise RecordInvalid rather than return
+          # false when a dirty component is invalid.
+          #
+          # The alternative is ActiveRecord's own autosave idiom, `raise
+          # ActiveRecord::Rollback`. It is worse here. Rollback raised from an
+          # after_save is swallowed by the transaction that save itself opened,
+          # so `entity.save!` would return nil and raise *nothing at all* — a
+          # silent failure to write, which is the one outcome a bang method must
+          # never have. (`throw :abort` is not an option either: after_ callbacks
+          # cannot halt a chain, and it escapes as an UncaughtThrowError.)
+          #
+          # RFC-0007 is what fixes this properly: once a dirty component's errors
+          # merge onto the entity, `entity.valid?` is false and non-bang `save`
+          # returns false before ever reaching this callback — leaving the bang
+          # here as belt-and-braces, which is exactly the role the equivalent
+          # line plays in ActiveRecord's autosave.
+          component.save!
+        end
+      end
+    end
+
+    # Mixed into EcsRails::Component.
+    module Component
+      extend ActiveSupport::Concern
+
+      included do
+        # architecture.md §3: "entity.email.destroy deletes the row and resets
+        # the component to its virtual default state. entity.email still returns
+        # an instance afterwards."
+        #
+        # Nothing about destroying a row does that on its own — ActiveRecord
+        # leaves the object frozen, still holding the values it had — so the
+        # entity has to be told. See #reset_entity_component.
+        after_destroy :reset_entity_component
+      end
+
+      # Does this component deserve a row?
+      #
+      # RFC-0006 defines dirty as "at least one attribute differs from its
+      # default", explicitly *not* ActiveModel's "differs from the last saved
+      # value". Both halves of that matter, and neither is quite what it looks
+      # like:
+      #
+      # 1. ActiveModel's dirty cannot be used for a component with no row.
+      #    Building a virtual component sets entity_id, and ActiveModel counts
+      #    that as a change — so `user.email.changed?` is true for a component
+      #    nobody has touched, and a cascade built on it would insert a row for
+      #    every component ever read. That is the whole feature, inverted.
+      #
+      # 2. RFC-0006's own wording fails for the same reason, taken literally:
+      #    entity_id differs from its column default (nil) on every virtual
+      #    component too. The foreign key is identity, not state — it says which
+      #    entity this is, never anything about it — so the comparison has to
+      #    skip it, and the primary key with it. See #state_attribute?.
+      #
+      # 3. "Differs from default" is only the right question while there is no
+      #    row. Once there is one, the question is ActiveModel's, because the
+      #    row now has a value to differ *from*: clearing an attribute back to
+      #    its default is an UPDATE, and answering "not dirty" would silently
+      #    discard it. This is where the two definitions genuinely part company,
+      #    and the RFC's destroy-then-reset case is the same split seen from the
+      #    other side.
+      def ecs_dirty?
+        return changed? if persisted?
+
+        self.class.column_defaults.any? do |attribute, default|
+          next false unless state_attribute?(attribute)
+
+          read_attribute(attribute) != default
+        end
+      end
+
+      private
+
+      # Attributes that say something about the component, as opposed to which
+      # component it is. Only these can make it dirty.
+      def state_attribute?(attribute)
+        attribute != self.class.primary_key && attribute != "entity_id"
+      end
+
+      # Tells the owning entity to forget this component, so its reader reverts
+      # to a virtual one (architecture.md §3).
+      #
+      # Reads the association target rather than calling #entity, so a component
+      # destroyed without its entity loaded — `Email.first.destroy` — costs no
+      # query and simply has nobody to notify. Nothing is reset on *this*
+      # object: ActiveRecord freezes a destroyed record, and the entity is going
+      # to hand out a fresh instance anyway.
+      def reset_entity_component
+        owner = association(:entity).target
+        return unless owner.is_a?(EcsRails::Entity)
+
+        owner.ecs_forget_component(model_name.singular.to_sym)
+      end
+    end
+  end
+end

data/lib/ecs_rails/preloading.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module EcsRails
+  # Batch component loads so a list view issues a bounded number of queries
+  # instead of one per component per row.
+  #
+  # Implements RFC-0011, decided by ADR-0012. Surfaced by the demo, where the
+  # 2-post index fired 14 queries (one per component per row).
+  #
+  #   Post.published.includes_components                    # all declared components
+  #   User.includes_components(Name, Email)                 # a named subset
+  #   Post.with_component(PublishState).includes_components(Title, Body)
+  #
+  # Extended into EcsRails::Entity, so these are class methods on every entity
+  # class. Like Querying, ActiveRecord delegates class methods to relations, so
+  # `User.where(...).includes_components(...)` chains: the method runs with `all`
+  # returning the current relation, which already carries the entity-model scope.
+  #
+  # ## The finding this rests on (ADR-0012)
+  #
+  # This method builds no preload machinery. Each component is a `has_one`
+  # (RFC-0004), and RFC-0006's lazy reader overrides that has_one but calls
+  # `super`, reaching it underneath — so ActiveRecord's own `preload` already
+  # batches component loads AND the lazy reader still returns a *virtual* instance
+  # for an entity with no row (the has_one preloads to nil-and-loaded, the reader
+  # builds the virtual). `includes_components` is a thin, discoverable wrapper
+  # over `preload(*association_names)`; the regression tests in
+  # spec/preloading_spec.rb pin the native path so it cannot silently break.
+  module Preloading
+    # Preloads the given components and returns a chainable relation.
+    #
+    # With no arguments, preloads *every* declared component of the entity —
+    # walking inherited declarations (RFC-0004) via #components — which is the one
+    # affordance the raw `preload(:a, :b, :c)` cannot offer.
+    #
+    # Takes component **classes**, not association symbols, consistent with
+    # `with_component` / `add` / `has?`. Each must be a component declared on the
+    # entity; otherwise EcsRails::InvalidComponent naming it, rather than leaking
+    # ActiveRecord's `AssociationNotFoundError` and the has_one abstraction the gem
+    # otherwise hides (ADR-0012).
+    #
+    # Uses `preload` (separate queries), never `includes`/`eager_load`: one extra
+    # query per component, predictable, and no surprise JOIN that changes row
+    # identity or interacts with `with_component`'s EXISTS. A developer who wants a
+    # JOIN calls `eager_load` on the association names directly.
+    #
+    # Built from `all` — like Querying — so it chains onto any prior scope and
+    # keeps the entity-model default scope (ADR-0002/ADR-0011).
+    def includes_components(*component_classes)
+      declared = components
+      targets = component_classes.empty? ? declared : component_classes
+      targets.each { |component_class| ecs_validate_declared_component!(component_class, declared) }
+
+      all.preload(*targets.map { |component_class| ecs_component_association_name(component_class) })
+    end
+
+    private
+
+    # The has_one name for a component — the same derivation the DSL uses when it
+    # defines the association (EcsRails::DSL#define_component_association).
+    def ecs_component_association_name(component_class)
+      component_class.model_name.singular.to_sym
+    end
+
+    # A preloadable component is one this entity *declares* — unlike the query DSL
+    # (RFC-0010), which accepts any concrete component. Preloading an undeclared
+    # component could only ever preload a has_one that does not exist, so it is a
+    # programming error, caught here with a component-shaped message (ADR-0012)
+    # before any database work. `declared` is passed in so #components is walked
+    # once per call, not once per argument.
+    def ecs_validate_declared_component!(component_class, declared)
+      unless component_class.is_a?(Class) && component_class < EcsRails::Component
+        raise InvalidComponent,
+              "#{component_class.inspect} is not an EcsRails::Component subclass"
+      end
+
+      return if declared.include?(component_class)
+
+      raise InvalidComponent,
+            "#{component_class.name} is not a component declared on #{name}. " \
+            "#{name} is composed from: #{declared.map(&:name).join(', ')}."
+    end
+  end
+end