etassia 0.1.0

data/lib/etassia/diagram/er_diagram.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "base"
+
+module Etassia
+  module Diagram
+    # Represents an attribute in an ER diagram entity.
+    #
+    # An attribute has a name, optional type, and optional key type
+    # (PK for primary key, FK for foreign key).
+    class ErAttribute < Lutaml::Model::Serializable
+      # Attribute name
+      attribute :name, :string
+
+      # Attribute type (e.g., 'string', 'int', 'date')
+      attribute :attribute_type, :string
+
+      # Key types: 'PK', 'FK', 'UK', or several joined by a comma
+      # ('PK,FK'), or nil
+      attribute :key_type, :string
+
+      # Optional quoted comment trailing the attribute, e.g. `"NN"` in
+      # `int rental_id PK "NN"`. Mermaid renders this as the attribute's
+      # comment column; without carrying it here the grammar consumes the
+      # text and the renderer never emits it -- silent data loss on valid
+      # input. Verified against spec/mermaid/unknown/yari2-dc83acff:
+      # mmdc's own SVG puts the comment text in a
+      # `class="label attribute-comment"` node.
+      attribute :note, :string
+
+      # Validates the attribute has required fields.
+      #
+      # @return [Boolean] true if attribute is valid
+      def valid?
+        !name.nil? && !name.empty?
+      end
+
+      # Checks if this is a primary key.
+      #
+      # @return [Boolean] true if key_type includes 'PK'
+      def primary_key?
+        key_types.include?("PK")
+      end
+
+      # Checks if this is a foreign key.
+      #
+      # @return [Boolean] true if key_type includes 'FK'
+      def foreign_key?
+        key_types.include?("FK")
+      end
+
+      # @return [Array<String>] each key in key_type, e.g. ["PK", "FK"]
+      def key_types
+        key_type.to_s.split(",")
+      end
+    end
+
+    # Represents an entity in an ER diagram.
+    #
+    # An entity has an identifier, name, and collection of attributes.
+    class ErEntity < Lutaml::Model::Serializable
+      # Unique identifier for the entity
+      attribute :id, :string
+
+      # Display name for the entity
+      attribute :name, :string
+
+      # Collection of entity attributes
+      attribute :attributes, ErAttribute, collection: true,
+                                          default: -> { [] }
+
+      # Names of the style classes assigned to this entity via `:::`
+      attribute :classes, :string, collection: true,
+                                   default: -> { [] }
+
+      # Validates the entity has required fields.
+      #
+      # A missing attribute collection, or a nil member inside it, makes the
+      # entity invalid rather than raising.
+      #
+      # @return [Boolean] true if entity is valid
+      def valid?
+        present?(id) && present?(name) && valid_attributes?
+      end
+
+      private
+
+      def present?(value)
+        !value.nil? && !value.empty?
+      end
+
+      def valid_attributes?
+        attributes&.all? { |attribute| attribute&.valid? } || false
+      end
+    end
+
+    # Represents a relationship between entities in an ER diagram.
+    #
+    # A relationship connects two entities with cardinality on both ends
+    # and a relationship type (identifying or non-identifying).
+    class ErRelationship < Lutaml::Model::Serializable
+      # Source entity identifier
+      attribute :from_id, :string
+
+      # Target entity identifier
+      attribute :to_id, :string
+
+      # Relationship type: 'identifying' or 'non-identifying'
+      attribute :relationship_type, :string
+
+      # Cardinality from source end (e.g., 'one', 'zero_or_more',
+      # 'zero_or_one', 'one_or_more')
+      attribute :cardinality_from, :string
+
+      # Cardinality at target end (e.g., 'one', 'zero_or_more',
+      # 'zero_or_one', 'one_or_more')
+      attribute :cardinality_to, :string
+
+      # Optional relationship label
+      attribute :label, :string
+
+      # Initialize with default relationship type
+      def initialize(*args)
+        super
+        self.relationship_type ||= "non-identifying"
+      end
+
+      # Validates the relationship has required fields.
+      #
+      # @return [Boolean] true if relationship is valid
+      def valid?
+        required_values.all? { |value| value && !value.empty? }
+      end
+
+      # Checks if this is an identifying relationship.
+      #
+      # @return [Boolean] true if identifying type
+      def identifying?
+        relationship_type == "identifying"
+      end
+
+      # Checks if this is a non-identifying relationship.
+      #
+      # @return [Boolean] true if non-identifying type
+      def non_identifying?
+        relationship_type == "non-identifying"
+      end
+
+      private
+
+      def required_values
+        [
+          from_id,
+          to_id,
+          relationship_type,
+          cardinality_from,
+          cardinality_to,
+        ]
+      end
+    end
+
+    # ER diagram model.
+    #
+    # Represents a complete Entity-Relationship diagram with entities
+    # and their relationships. ER diagrams show the data model structure
+    # with entities, attributes, and relationships.
+    #
+    # @example Creating a simple ER diagram
+    #   diagram = ErDiagram.new
+    #   diagram.entities << ErEntity.new(
+    #     id: 'CUSTOMER',
+    #     name: 'CUSTOMER'
+    #   ).tap do |entity|
+    #     entity.attributes << ErAttribute.new(
+    #       name: 'id',
+    #       attribute_type: 'int',
+    #       key_type: 'PK'
+    #     )
+    #     entity.attributes << ErAttribute.new(
+    #       name: 'name',
+    #       attribute_type: 'string'
+    #     )
+    #   end
+    #   diagram.entities << ErEntity.new(
+    #     id: 'ORDER',
+    #     name: 'ORDER'
+    #   )
+    #   diagram.relationships << ErRelationship.new(
+    #     from_id: 'CUSTOMER',
+    #     to_id: 'ORDER',
+    #     relationship_type: 'non-identifying',
+    #     cardinality_from: 'one',
+    #     cardinality_to: 'zero_or_more',
+    #     label: 'places'
+    #   )
+    class ErDiagram < Base
+      # Collection of entities in the diagram
+      attribute :entities, ErEntity, collection: true,
+                                     default: -> { [] }
+
+      # Collection of relationships between entities
+      attribute :relationships, ErRelationship, collection: true,
+                                                default: -> { [] }
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :er_diagram
+      def diagram_type
+        :er_diagram
+      end
+
+      # Style classes declared by `classDef`, as name => style text.
+      #
+      # Not a lutaml attribute, matching Treemap — the only other
+      # model here carrying classDef. Consequence, recorded because it is
+      # real: value equality on this model ignores class_defs.
+      #
+      # @return [Hash{String => String}] declared classes
+      def class_defs
+        @class_defs ||= {}
+      end
+
+      # Records a `classDef` declaration.
+      #
+      # A repeated `classDef` for the same name ACCUMULATES rather than
+      # replaces — mermaid's own db stores every declaration for a name as
+      # an array in source order (verified against its parser: two
+      # `classDef a` statements with disjoint properties both survive, and
+      # on a conflicting property the LATER declaration wins). Comma-joining
+      # here reproduces that: `parse_declaration` already resolves a
+      # comma-separated run left to right, so a later duplicate key
+      # overwrites an earlier one the same way two classes merge in the
+      # renderer.
+      #
+      # @param name [String] the class name
+      # @param styles [String] the raw style text
+      # @return [String] the combined style text for this name
+      def add_class_def(name, styles)
+        existing = class_defs[name]
+        class_defs[name] = existing ? "#{existing},#{styles}" : styles
+      end
+
+      # Validates the ER diagram structure.
+      #
+      # An ER diagram is valid if:
+      # - It has an entity collection, which may be empty
+      # - All entities are valid
+      # - All relationships are valid
+      # - All relationship references point to existing entities
+      #
+      # A nil entity or relationship makes the diagram invalid rather than
+      # raising. ErEntity#valid? answers the same way for a nil attribute.
+      #
+      # @return [Boolean] true if ER diagram is valid
+      def valid?
+        valid_entities? && valid_relationships? && valid_references?
+      end
+
+      # Finds an entity by its identifier.
+      #
+      # @param id [String] the entity identifier to find
+      # @return [ErEntity, nil] the entity or nil if not found
+      def find_entity(id)
+        entities.find { |e| e.id == id }
+      end
+
+      # Finds all relationships from a specific entity.
+      #
+      # @param entity_id [String] the source entity identifier
+      # @return [Array<ErRelationship>] relationships from the entity
+      def relationships_from(entity_id)
+        relationships.select { |r| r.from_id == entity_id }
+      end
+
+      # Finds all relationships to a specific entity.
+      #
+      # @param entity_id [String] the target entity identifier
+      # @return [Array<ErRelationship>] relationships to the entity
+      def relationships_to(entity_id)
+        relationships.select { |r| r.to_id == entity_id }
+      end
+
+      # Finds all identifying relationships.
+      #
+      # @return [Array<ErRelationship>] identifying relationships
+      def identifying_relationships
+        relationships.select(&:identifying?)
+      end
+
+      # Finds all non-identifying relationships.
+      #
+      # @return [Array<ErRelationship>] non-identifying relationships
+      def non_identifying_relationships
+        relationships.select(&:non_identifying?)
+      end
+
+      private
+
+      def valid_entities?
+        entities&.all? { |entity| entity&.valid? } || false
+      end
+
+      def valid_relationships?
+        relationships.nil? || relationships.all? { |relation| relation&.valid? }
+      end
+
+      def valid_references?
+        entity_ids = entities.map(&:id)
+        Array(relationships).all? do |relation|
+          entity_ids.include?(relation.from_id) &&
+            entity_ids.include?(relation.to_id)
+        end
+      end
+    end
+  end
+end

data/lib/etassia/diagram/error.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "base"
+
+module Etassia
+  module Diagram
+    # Error diagram model.
+    #
+    # Represents a simple error diagram that displays error messages or
+    # error states. Error diagrams are typically used to show parsing
+    # errors, syntax errors, or system failure states.
+    #
+    # @example Creating an error diagram
+    #   error = Error.new
+    #   error.message = "Syntax Error"
+    class Error < Base
+      # Error message to display
+      attribute :message, :string
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :error
+      def diagram_type
+        :error
+      end
+
+      # Validates the error diagram structure.
+      #
+      # Error diagrams are always valid as they have no required content.
+      #
+      # @return [Boolean] true
+      def valid?
+        true
+      end
+    end
+  end
+end