sirena 0.1.0

data/lib/sirena/diagram/class_diagram.rb

@@ -0,0 +1,385 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'base'
+
+module Sirena
+  module Diagram
+    # Represents a class attribute in a UML class diagram.
+    #
+    # An attribute has a name, type, and visibility modifier that
+    # controls its access level.
+    class ClassAttribute < Lutaml::Model::Serializable
+      # Attribute name
+      attribute :name, :string
+
+      # Attribute type (e.g., 'string', 'int', 'List~String~')
+      attribute :type, :string
+
+      # Visibility: :public (+), :private (-), :protected (#),
+      # :package (~)
+      attribute :visibility, :string
+
+      # Initialize with default visibility
+      def initialize(*args)
+        super
+        self.visibility ||= 'public'
+      end
+
+      # Validates the attribute has required fields.
+      #
+      # @return [Boolean] true if attribute is valid
+      def valid?
+        !name.nil? && !name.empty?
+      end
+
+      # Returns the UML visibility symbol.
+      #
+      # @return [String] the visibility symbol (+, -, #, ~)
+      def visibility_symbol
+        case visibility
+        when 'public' then '+'
+        when 'private' then '-'
+        when 'protected' then '#'
+        when 'package' then '~'
+        else '+'
+        end
+      end
+    end
+
+    # Represents a class method in a UML class diagram.
+    #
+    # A method has a name, optional parameters, optional return type,
+    # and visibility modifier.
+    class ClassMethod < Lutaml::Model::Serializable
+      # Method name
+      attribute :name, :string
+
+      # Method parameters (e.g., 'x: int, y: int')
+      attribute :parameters, :string
+
+      # Return type (e.g., 'string', 'void')
+      attribute :return_type, :string
+
+      # Visibility: :public (+), :private (-), :protected (#),
+      # :package (~)
+      attribute :visibility, :string
+
+      # Initialize with default visibility
+      def initialize(*args)
+        super
+        self.visibility ||= 'public'
+      end
+
+      # Validates the method has required fields.
+      #
+      # @return [Boolean] true if method is valid
+      def valid?
+        !name.nil? && !name.empty?
+      end
+
+      # Returns the UML visibility symbol.
+      #
+      # @return [String] the visibility symbol (+, -, #, ~)
+      def visibility_symbol
+        case visibility
+        when 'public' then '+'
+        when 'private' then '-'
+        when 'protected' then '#'
+        when 'package' then '~'
+        else '+'
+        end
+      end
+
+      # Returns the full method signature.
+      #
+      # @return [String] method signature with parameters and return type
+      def signature
+        sig = name
+        sig += "(#{parameters})" if parameters && !parameters.empty?
+        sig += " #{return_type}" if return_type && !return_type.empty?
+        sig
+      end
+    end
+
+    # Represents a class/entity in a UML class diagram.
+    #
+    # A class entity has an identifier, name, optional stereotype,
+    # collection of attributes, and collection of methods.
+    class ClassEntity < Lutaml::Model::Serializable
+      # Unique identifier for the class
+      attribute :id, :string
+
+      # Display name for the class
+      attribute :name, :string
+
+      # Optional stereotype (e.g., 'interface', 'abstract', 'enum')
+      attribute :stereotype, :string
+
+      # Collection of class attributes
+      attribute :attributes, ClassAttribute, collection: true,
+                                             default: -> { [] }
+
+      # Collection of class methods
+      attribute :class_methods, ClassMethod, collection: true,
+                                             default: -> { [] }
+
+      # Validates the class entity has required fields.
+      #
+      # @return [Boolean] true if class entity is valid
+      def valid?
+        !id.nil? && !id.empty? && !name.nil? && !name.empty? &&
+          attributes.all?(&:valid?) && class_methods.all?(&:valid?)
+      end
+
+      # Checks if this is an interface.
+      #
+      # @return [Boolean] true if stereotype is 'interface'
+      def interface?
+        stereotype == 'interface'
+      end
+
+      # Checks if this is an abstract class.
+      #
+      # @return [Boolean] true if stereotype is 'abstract'
+      def abstract?
+        stereotype == 'abstract'
+      end
+
+      # Checks if this is an enum.
+      #
+      # @return [Boolean] true if stereotype is 'enum'
+      def enum?
+        stereotype == 'enum'
+      end
+    end
+
+    # Represents a relationship between classes in a UML class diagram.
+    #
+    # A relationship connects two classes with a specific type
+    # (inheritance, composition, aggregation, or association) and
+    # optional label and cardinality.
+    class ClassRelationship < Lutaml::Model::Serializable
+      # Source class identifier
+      attribute :from_id, :string
+
+      # Target class identifier
+      attribute :to_id, :string
+
+      # Relationship type: :inheritance, :composition, :aggregation,
+      # :association, :dependency, :realization
+      attribute :relationship_type, :string
+
+      # Optional relationship label
+      attribute :label, :string
+
+      # Optional cardinality for source end (e.g., '1', '0..1', '1..*')
+      attribute :source_cardinality, :string
+
+      # Optional cardinality for target end (e.g., '1', '0..1', '1..*')
+      attribute :target_cardinality, :string
+
+      # Initialize with default relationship type
+      def initialize(*args)
+        super
+        self.relationship_type ||= 'association'
+      end
+
+      # Validates the relationship has required fields.
+      #
+      # @return [Boolean] true if relationship is valid
+      def valid?
+        !from_id.nil? && !from_id.empty? &&
+          !to_id.nil? && !to_id.empty? &&
+          !relationship_type.nil? && !relationship_type.empty?
+      end
+
+      # Checks if this is an inheritance relationship.
+      #
+      # @return [Boolean] true if inheritance type
+      def inheritance?
+        relationship_type == 'inheritance'
+      end
+
+      # Checks if this is a composition relationship.
+      #
+      # @return [Boolean] true if composition type
+      def composition?
+        relationship_type == 'composition'
+      end
+
+      # Checks if this is an aggregation relationship.
+      #
+      # @return [Boolean] true if aggregation type
+      def aggregation?
+        relationship_type == 'aggregation'
+      end
+
+      # Checks if this is an association relationship.
+      #
+      # @return [Boolean] true if association type
+      def association?
+        relationship_type == 'association'
+      end
+
+      # Checks if this is a dependency relationship.
+      #
+      # @return [Boolean] true if dependency type
+      def dependency?
+        relationship_type == 'dependency'
+      end
+
+      # Checks if this is a realization relationship.
+      #
+      # @return [Boolean] true if realization type
+      def realization?
+        relationship_type == 'realization'
+      end
+    end
+
+    # Class diagram model.
+    #
+    # Represents a complete UML class diagram with classes and their
+    # relationships. Class diagrams show the static structure of a
+    # system with classes, attributes, methods, and relationships.
+    #
+    # @example Creating a simple class diagram
+    #   diagram = ClassDiagram.new(direction: 'TB')
+    #   diagram.entities << ClassEntity.new(
+    #     id: 'Animal',
+    #     name: 'Animal'
+    #   ).tap do |entity|
+    #     entity.attributes << ClassAttribute.new(
+    #       name: 'age',
+    #       type: 'int',
+    #       visibility: 'protected'
+    #     )
+    #     entity.class_methods << ClassMethod.new(
+    #       name: 'breathe',
+    #       visibility: 'public'
+    #     )
+    #   end
+    #   diagram.entities << ClassEntity.new(
+    #     id: 'Dog',
+    #     name: 'Dog'
+    #   ).tap do |entity|
+    #     entity.class_methods << ClassMethod.new(
+    #       name: 'bark',
+    #       visibility: 'public'
+    #     )
+    #   end
+    #   diagram.relationships << ClassRelationship.new(
+    #     from_id: 'Dog',
+    #     to_id: 'Animal',
+    #     relationship_type: 'inheritance'
+    #   )
+    class ClassDiagram < Base
+      # Collection of class entities in the diagram
+      attribute :entities, ClassEntity, collection: true,
+                                        default: -> { [] }
+
+      # Collection of relationships between entities
+      attribute :relationships, ClassRelationship, collection: true,
+                                                   default: -> { [] }
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :class_diagram
+      def diagram_type
+        :class_diagram
+      end
+
+      # Validates the class diagram structure.
+      #
+      # A class diagram is valid if:
+      # - It has at least one entity
+      # - All entities are valid
+      # - All relationships are valid
+      # - All relationship references point to existing entities
+      #
+      # @return [Boolean] true if class diagram is valid
+      def valid?
+        return false if entities.nil? || entities.empty?
+        return false unless entities.all?(&:valid?)
+        return false unless relationships.nil? ||
+                            relationships.all?(&:valid?)
+
+        # Validate relationship references
+        entity_ids = entities.map(&:id)
+        relationships&.each do |rel|
+          return false unless entity_ids.include?(rel.from_id)
+          return false unless entity_ids.include?(rel.to_id)
+        end
+
+        true
+      end
+
+      # Finds an entity by its identifier.
+      #
+      # @param id [String] the entity identifier to find
+      # @return [ClassEntity, 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<ClassRelationship>] 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<ClassRelationship>] relationships to the entity
+      def relationships_to(entity_id)
+        relationships.select { |r| r.to_id == entity_id }
+      end
+
+      # Finds all inheritance relationships.
+      #
+      # @return [Array<ClassRelationship>] inheritance relationships
+      def inheritance_relationships
+        relationships.select(&:inheritance?)
+      end
+
+      # Finds all composition relationships.
+      #
+      # @return [Array<ClassRelationship>] composition relationships
+      def composition_relationships
+        relationships.select(&:composition?)
+      end
+
+      # Finds all aggregation relationships.
+      #
+      # @return [Array<ClassRelationship>] aggregation relationships
+      def aggregation_relationships
+        relationships.select(&:aggregation?)
+      end
+
+      # Finds parent classes for a given entity.
+      #
+      # @param entity_id [String] the entity identifier
+      # @return [Array<ClassEntity>] parent entities
+      def parent_entities(entity_id)
+        parent_ids = relationships
+                     .select { |r| r.from_id == entity_id && r.inheritance? }
+                     .map(&:to_id)
+        entities.select { |e| parent_ids.include?(e.id) }
+      end
+
+      # Finds child classes for a given entity.
+      #
+      # @param entity_id [String] the entity identifier
+      # @return [Array<ClassEntity>] child entities
+      def child_entities(entity_id)
+        child_ids = relationships
+                    .select { |r| r.to_id == entity_id && r.inheritance? }
+                    .map(&:from_id)
+        entities.select { |e| child_ids.include?(e.id) }
+      end
+    end
+  end
+end

data/lib/sirena/diagram/er_diagram.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'base'
+
+module Sirena
+  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 type: 'PK' (primary key), 'FK' (foreign key), or nil
+      attribute :key_type, :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 is 'PK'
+      def primary_key?
+        key_type == 'PK'
+      end
+
+      # Checks if this is a foreign key.
+      #
+      # @return [Boolean] true if key_type is 'FK'
+      def foreign_key?
+        key_type == 'FK'
+      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: -> { [] }
+
+      # Validates the entity has required fields.
+      #
+      # @return [Boolean] true if entity is valid
+      def valid?
+        !id.nil? && !id.empty? && !name.nil? && !name.empty? &&
+          attributes.all?(&:valid?)
+      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?
+        !from_id.nil? && !from_id.empty? &&
+          !to_id.nil? && !to_id.empty? &&
+          !relationship_type.nil? && !relationship_type.empty? &&
+          !cardinality_from.nil? && !cardinality_from.empty? &&
+          !cardinality_to.nil? && !cardinality_to.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
+    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
+
+      # Validates the ER diagram structure.
+      #
+      # An ER diagram is valid if:
+      # - It has at least one entity
+      # - All entities are valid
+      # - All relationships are valid
+      # - All relationship references point to existing entities
+      #
+      # @return [Boolean] true if ER diagram is valid
+      def valid?
+        return false if entities.nil? || entities.empty?
+        return false unless entities.all?(&:valid?)
+        return false unless relationships.nil? ||
+                            relationships.all?(&:valid?)
+
+        # Validate relationship references
+        entity_ids = entities.map(&:id)
+        relationships&.each do |rel|
+          return false unless entity_ids.include?(rel.from_id)
+          return false unless entity_ids.include?(rel.to_id)
+        end
+
+        true
+      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
+    end
+  end
+end

data/lib/sirena/diagram/error.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'base'
+
+module Sirena
+  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