diagram 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6a7329e68d37cab7fe076fb763b56fddff42b23e81619bd70f3a89ef82ebff8
-  data.tar.gz: 3eac3513c7ebb76307967f12f3c9d189e35022203ce817e3fbc90be310ac7b10
+  metadata.gz: c99defb74ddced6d50a0dd2bd5cf61b90ce2edab9192c5f119586442eb625d12
+  data.tar.gz: 1bd666eed832e6052f789c3a37fd634d2cb4c198468281bafc17bc1ca500d05a
 SHA512:
-  metadata.gz: 0b59a02a496318c080f8ff72bbfb6bb224ae4dfeb3657eda3e262ac401cca6871f8a18a487fbe012699c7016ae8ef07cfc565f224e7697cc3a6aba9abb60907b
-  data.tar.gz: 6cee2aa87b44ae4aab58a99fcf9cfadfbde2f9496523d7e02e5dcb00f6c4ec14abce8b36ff79c1b276e44eec407fe09db6dcaabd9a14c83a050b7684df854f41
+  metadata.gz: f9d0b5269c5093821a09140273590af586dc35e4a21b9aed5c45a5201db8ebcfdb769e3764038fe0a74e467eea3d18e1f1fc970c295e69fefbdc686230106b48
+  data.tar.gz: 7a53a67aecab0fa28adee1e6f826114ad0f0184e994e31c346d9b3224a4fd72e255ed4eaea714327c467664cef766ae2da1cbded21c58d620d7cb5862c65617d

data/lib/diagrams/base.rb

@@ -66,13 +66,13 @@ module Diagrams
         other_collection = other_elements[type] || []
 
         # Determine identifier method (prefer id, then name, then title, then label, fallback to object itself)
-        identifier_method = if self_collection.first&.respond_to?(:id)
+        identifier_method = if self_collection.first.respond_to?(:id)
                               :id
-                            elsif self_collection.first&.respond_to?(:name)
+                            elsif self_collection.first.respond_to?(:name)
                               :name
-                            elsif self_collection.first&.respond_to?(:title) # For TimelineSection
+                            elsif self_collection.first.respond_to?(:title) # For TimelineSection
                               :title
-                            elsif self_collection.first&.respond_to?(:label) # For Slice, TimelinePeriod
+                            elsif self_collection.first.respond_to?(:label) # For Slice, TimelinePeriod
                               :label
                             else
                               :itself # Fallback to object identity/equality
@@ -196,6 +196,10 @@ module Diagrams
       # Simple helper to convert snake_case to CamelCase
       # (Avoids ActiveSupport dependency)
       def snake_to_camel_case(string)
+        # Handle specific acronyms first
+        return 'ERDiagram' if string == 'er_diagram'
+
+        # Default conversion
         string.split('_').collect(&:capitalize).join
       end
     end

data/lib/diagrams/elements/erd_attribute.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Diagrams
+  module Elements
+    # Represents an attribute within an ERD entity.
+    class ERDAttribute < Dry::Struct
+      include Elements::Types
+
+      attribute :type, Types::Strict::String.constrained(min_size: 1)
+      attribute :name, Types::Strict::String.constrained(min_size: 1)
+      attribute :keys, Types::Strict::Array.of(Types::Strict::Symbol.enum(:PK, :FK, :UK)).default([].freeze)
+      attribute :comment, Types::Strict::String.optional.default(nil)
+
+      # Returns a hash representation suitable for serialization.
+      #
+      # @return [Hash{Symbol => String | Array<Symbol>}]
+      def to_h
+        hash = {
+          type:,
+          name:,
+          keys: keys.map(&:to_s) # Convert symbols to strings for serialization
+        }
+        hash[:comment] = comment if comment
+        hash
+      end
+    end
+  end
+end

data/lib/diagrams/elements/erd_entity.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Diagrams
+  module Elements
+    # Represents an entity (table) in an ER Diagram.
+    class ERDEntity < Dry::Struct
+      include Elements::Types
+
+      attribute :name, Types::Strict::String.constrained(min_size: 1)
+      attribute :entity_attributes, Types::Strict::Array.of(ERDAttribute).default([].freeze)
+
+      # Returns a hash representation suitable for serialization.
+      #
+      # @return [Hash{Symbol => String | Array<Hash>}]
+      def to_h
+        {
+          name: name,
+          attributes: entity_attributes.map(&:to_h) # Renamed variable
+        }
+      end
+    end
+  end
+end

data/lib/diagrams/elements/erd_relationship.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Diagrams
+  module Elements
+    # Represents a relationship between two entities in an ER Diagram.
+    class ERDRelationship < Dry::Struct
+      include Elements::Types
+
+      # Cardinality symbols (Crow's Foot notation mapping)
+      CARDINALITY = Types::Strict::Symbol.enum(
+        :ZERO_OR_ONE,  # |o
+        :ONE_ONLY,     # ||
+        :ZERO_OR_MORE, # }o
+        :ONE_OR_MORE   # }|
+      )
+
+      attribute :entity1, Types::Strict::String.constrained(min_size: 1)
+      attribute :entity2, Types::Strict::String.constrained(min_size: 1)
+      attribute :cardinality1, CARDINALITY # Cardinality of entity1 relative to entity2
+      attribute :cardinality2, CARDINALITY # Cardinality of entity2 relative to entity1
+      attribute :identifying, Types::Strict::Bool.default(false) # Is it an identifying relationship? (solid vs dashed line)
+      attribute :label, Types::Strict::String.optional.default(nil) # Optional action/verb phrase
+
+      # Returns a hash representation suitable for serialization.
+      #
+      # @return [Hash{Symbol => String | Symbol | Bool}]
+      def to_h
+        hash = {
+          entity1: entity1,
+          entity2: entity2,
+          cardinality1: cardinality1.to_s, # Convert symbol to string
+          cardinality2: cardinality2.to_s, # Convert symbol to string
+          identifying: identifying
+        }
+        hash[:label] = label if label
+        hash
+      end
+    end
+  end
+end

data/lib/diagrams/elements/gantt_section.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Diagrams
+  module Elements
+    # Represents a section within a Gantt chart, grouping multiple tasks.
+    class GanttSection < Dry::Struct
+      include Elements::Types
+
+      attribute :title, Types::Strict::String.constrained(min_size: 1)
+      attribute :tasks, Types::Strict::Array.of(Task).default([].freeze)
+
+      # Returns a hash representation suitable for serialization.
+      #
+      # @return [Hash{Symbol => String | Array<Hash>}]
+      def to_h
+        {
+          title:,
+          tasks: tasks.map(&:to_h)
+        }
+      end
+    end
+  end
+end

data/lib/diagrams/elements/task.rb

@@ -7,17 +7,29 @@ module Diagrams
       # Use the shared Types module
       include Elements::Types
 
-      attribute :id, Types::Strict::String.constrained(min_size: 1)
-      attribute :name, Types::Strict::String.constrained(min_size: 1)
-      # Using String for dates initially for simplicity.
-      # Consider Types::Strict::Date or custom coercible types later.
-      attribute :start_date, Types::Strict::String.constrained(min_size: 1) # Basic check
-      attribute :end_date, Types::Strict::String.constrained(min_size: 1)   # Basic check
-      # TODO: Add dependencies attribute (e.g., Types::Strict::Array.of(Types::Strict::String))
+      # Status symbols allowed by Mermaid Gantt
+      STATUS = Types::Strict::Symbol.enum(:done, :active, :crit)
+
+      # Attributes
+      attribute :id, Types::Strict::String.constrained(min_size: 1) # Unique ID for dependencies
+      attribute :label, Types::Strict::String.constrained(min_size: 1) # Display name
+      attribute :status, STATUS.optional.default(nil) # Task status (nil implies default/future)
+      attribute :start, Types::Strict::String.constrained(min_size: 1) # Start date, task ID, or 'after taskX[, taskY]'
+      attribute :duration, Types::Strict::String.constrained(min_size: 1) # Duration string (e.g., '7d', '2w')
 
       # Returns a hash representation suitable for serialization.
       #
-      # @return [Hash{Symbol => String}]
+      # @return [Hash{Symbol => String | Symbol | nil}]
+      def to_h
+        hash = {
+          id: id,
+          label: label,
+          start: start,
+          duration: duration
+        }
+        hash[:status] = status if status # Include status only if set
+        hash
+      end
     end
   end
 end

data/lib/diagrams/elements/timeline_event.rb

@@ -18,4 +18,4 @@ module Diagrams
       end
     end
   end
-end
+end

data/lib/diagrams/elements/timeline_period.rb

@@ -20,4 +20,4 @@ module Diagrams
       end
     end
   end
-end
+end

data/lib/diagrams/elements/timeline_section.rb

@@ -20,4 +20,4 @@ module Diagrams
       end
     end
   end
-end
+end

data/lib/diagrams/er_diagram.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Diagrams
+  # Represents an Entity Relationship Diagram (ERD).
+  class ERDiagram < Base
+    attr_reader :entities, :relationships
+
+    # Initializes a new ERDiagram.
+    #
+    # @param entities [Array<Element::ERDEntity>] Initial entities (optional).
+    # @param relationships [Array<Element::ERDRelationship>] Initial relationships (optional).
+    # @param version [String, Integer, nil] User-defined version identifier.
+    def initialize(entities: [], relationships: [], version: 1)
+      super(version:)
+      @entities = (entities.is_a?(Array) ? entities : []).each_with_object({}) { |e, h| h[e.name] = e }
+      @relationships = relationships.is_a?(Array) ? relationships : []
+      validate_relationships!
+      update_checksum!
+    end
+
+    # Adds an entity to the diagram.
+    #
+    # @param name [String] The unique name of the entity.
+    # @param attributes [Array<Hash>] Array of attribute definitions (hashes like { type:, name:, keys:, comment: }).
+    # @raise [ArgumentError] if an entity with the same name already exists.
+    # @return [Elements::ERDEntity] The added entity.
+    def add_entity(name:, attributes: [])
+      raise ArgumentError, "Entity name '#{name}' cannot be empty" if name.nil? || name.strip.empty?
+      raise ArgumentError, "Entity with name '#{name}' already exists" if @entities.key?(name)
+
+      entity_attributes = attributes.map do |attr_hash|
+        Elements::ERDAttribute.new(attr_hash.transform_keys(&:to_sym))
+      end
+      new_entity = Elements::ERDEntity.new(name:, entity_attributes: entity_attributes) # Use renamed attribute
+
+      @entities[name] = new_entity
+      update_checksum!
+      new_entity
+    end
+
+    # Adds a relationship between two entities.
+    #
+    # @param entity1 [String] Name of the first entity.
+    # @param entity2 [String] Name of the second entity.
+    # @param cardinality1 [Symbol] Cardinality of entity1 relative to entity2 (e.g., :ONE_ONLY).
+    # @param cardinality2 [Symbol] Cardinality of entity2 relative to entity1 (e.g., :ZERO_OR_MORE).
+    # @param identifying [Boolean] Whether the relationship is identifying (default: false).
+    # @param label [String, nil] Optional label describing the relationship action.
+    # @raise [ArgumentError] if either entity does not exist.
+    # @return [Elements::ERDRelationship] The added relationship.
+    def add_relationship(entity1:, entity2:, cardinality1:, cardinality2:, identifying: false, label: nil)
+      unless @entities.key?(entity1) && @entities.key?(entity2)
+        raise ArgumentError, "One or both entities ('#{entity1}', '#{entity2}') not found for relationship."
+      end
+
+      new_relationship = Elements::ERDRelationship.new(
+        entity1:,
+        entity2:,
+        cardinality1:,
+        cardinality2:,
+        identifying:,
+        label:
+      )
+      @relationships << new_relationship
+      update_checksum!
+      new_relationship
+    end
+
+    # Finds an entity by its name.
+    #
+    # @param entity_name [String] The name of the entity to find.
+    # @return [Elements::ERDEntity, nil] The found entity or nil.
+    def find_entity(entity_name)
+      @entities[entity_name]
+    end
+
+    # --- Base Class Implementation ---
+
+    def to_h_content
+      {
+        entities: @entities.values.map(&:to_h),
+        relationships: @relationships.map(&:to_h)
+      }
+    end
+
+    def identifiable_elements
+      {
+        entities: @entities.values,
+        relationships: @relationships # Relationships don't have a simple unique ID, rely on object equality for diff
+      }
+    end
+
+    def self.from_h(data_hash, version:, checksum:)
+      entities_data = data_hash[:entities] || data_hash['entities'] || []
+      relationships_data = data_hash[:relationships] || data_hash['relationships'] || []
+
+      entities = entities_data.map do |entity_h|
+        entity_data = entity_h.transform_keys(&:to_sym)
+        attributes_data = entity_data[:entity_attributes] || entity_data[:attributes] || [] # Accept both old and new key for now
+        attributes = attributes_data.map do |attr_h|
+          attr_data = attr_h.transform_keys(&:to_sym)
+          # Convert keys back to symbols if they are strings
+          # Convert keys back to symbols
+          attr_data[:keys] = attr_data[:keys].map(&:to_sym) if attr_data[:keys].is_a?(Array)
+          Elements::ERDAttribute.new(attr_data)
+        end
+        # Use the correct attribute name when creating the entity
+        Elements::ERDEntity.new(entity_data.merge(entity_attributes: attributes))
+      end
+
+      relationships = relationships_data.map do |rel_h|
+        rel_data = rel_h.transform_keys(&:to_sym)
+        # Convert cardinalities back to symbols if they are strings
+        rel_data[:cardinality1] = rel_data[:cardinality1].to_sym if rel_data[:cardinality1].is_a?(String)
+        rel_data[:cardinality2] = rel_data[:cardinality2].to_sym if rel_data[:cardinality2].is_a?(String)
+        Elements::ERDRelationship.new(rel_data)
+      end
+
+      diagram = new(entities:, relationships:, version:)
+
+      # Optional: Verify checksum
+      if checksum && diagram.checksum != checksum
+        warn "Checksum mismatch for loaded ERDiagram (version: #{version}). Expected #{checksum}, got #{diagram.checksum}."
+      end
+
+      diagram
+    end
+
+    private
+
+    # Validates that all relationships refer to existing entities during initialization.
+    def validate_relationships!
+      @relationships.each do |rel|
+        unless @entities.key?(rel.entity1) && @entities.key?(rel.entity2)
+          raise ArgumentError, "Relationship refers to non-existent entity IDs ('#{rel.entity1}' or '#{rel.entity2}')"
+        end
+      end
+    end
+
+    # Protected method access
+    protected :update_checksum!
+  end
+end

data/lib/diagrams/gantt_diagram.rb

@@ -1,84 +1,156 @@
 # frozen_string_literal: true
 
 module Diagrams
-  # Represents a Gantt Chart diagram consisting of tasks over time.
+  # Represents a Gantt Chart diagram consisting of tasks over time, grouped into sections.
   class GanttDiagram < Base
-    attr_reader :title, :tasks
+    DEFAULT_SECTION_TITLE = 'Default Section'
+
+    attr_reader :title, :sections
 
     # Initializes a new GanttDiagram.
     #
     # @param title [String] The title of the Gantt chart.
-    # @param tasks [Array<Element::Task>] An array of task objects.
+    # @param sections [Array<Element::GanttSection>] An array of section objects (containing tasks).
     # @param version [String, Integer, nil] User-defined version identifier.
-    def initialize(title: '', tasks: [], version: 1)
+    def initialize(title: '', sections: [], version: 1)
       super(version:)
       @title = title.is_a?(String) ? title : ''
-      @tasks = tasks.is_a?(Array) ? tasks : []
+      @sections = sections.is_a?(Array) ? sections : []
+      ensure_default_section if @sections.empty?
       validate_elements!
       update_checksum!
     end
 
-    # Adds a task to the diagram.
+    # Adds a new section to the diagram.
+    # Subsequent tasks will be added to this section.
     #
-    # @param task [Element::Task] The task object to add.
-    # @raise [ArgumentError] if a task with the same ID already exists.
-    # @return [Element::Task] The added task.
-    def add_task(task)
-      raise ArgumentError, 'Task must be a Diagrams::Elements::Task' unless task.is_a?(Diagrams::Elements::Task)
-      raise ArgumentError, "Task with ID '#{task.id}' already exists" if find_task(task.id)
-
-      @tasks << task
+    # @param section_title [String] The title of the section.
+    # @raise [ArgumentError] if a section with the same title already exists.
+    # @return [Elements::GanttSection] The newly added section.
+    def add_section(section_title)
+      clean_title = section_title.strip
+      raise ArgumentError, "Section title '#{clean_title}' cannot be empty" if clean_title.empty?
+      raise ArgumentError, "Section with title '#{clean_title}' already exists" if find_section(clean_title)
+
+      # Remove default section if it's empty and we're adding a real one
+      if @sections.size == 1 && @sections.first.title == DEFAULT_SECTION_TITLE && @sections.first.tasks.empty? # Check tasks for GanttSection
+        @sections.clear
+      end
+
+      # Use GanttSection
+      new_section = Elements::GanttSection.new(title: clean_title, tasks: [])
+      @sections << new_section
       update_checksum!
-      task
+      new_section
     end
 
-    # Finds a task by its ID.
+    # Adds a task to the current (last) section of the diagram.
+    #
+    # @param id [String] Unique ID for the task (used for dependencies).
+    # @param label [String] Display name/label for the task.
+    # @param status [Symbol, nil] Status (:done, :active, :crit). nil implies default/future.
+    # @param start [String] Start date, task ID (e.g., 'task1'), or dependency string ('after taskX').
+    # @param duration [String] Duration string (e.g., '7d', '2w').
+    # @raise [ArgumentError] if required fields are missing or a task with the same ID exists.
+    # @raise [StandardError] if no sections exist.
+    # @return [Elements::Task] The added task.
+    def add_task(id:, label:, start:, duration:, status: nil)
+      raise ArgumentError, 'Task ID cannot be empty' if id.nil? || id.strip.empty?
+      raise ArgumentError, "Task with ID '#{id}' already exists" if find_task(id)
+
+      new_task = Elements::Task.new(
+        id:,
+        label:,
+        status:,
+        start:,
+        duration:
+      )
+
+      current_section = @sections.last
+      raise StandardError, 'Cannot add task: No section available.' unless current_section
+
+      # Add task to the current section's 'tasks' array
+      updated_tasks = current_section.tasks + [new_task]
+      updated_section = Elements::GanttSection.new(title: current_section.title, tasks: updated_tasks)
+
+      # Update the section in the main array
+      current_section_index = @sections.index { |s| s.title == current_section.title }
+      unless current_section_index
+        raise StandardError,
+              "Could not find index for current section '#{current_section.title}'"
+      end
+
+      @sections[current_section_index] = updated_section
+
+      update_checksum!
+      new_task
+    end
+
+    # Finds a task by its ID across all sections.
     #
     # @param task_id [String] The ID of the task to find.
     # @return [Element::Task, nil] The found task or nil.
     def find_task(task_id)
-      @tasks.find { |t| t.id == task_id }
+      all_tasks.find { |t| t.id == task_id }
+    end
+
+    # Finds a section by its title.
+    # @param section_title [String] The title of the section.
+    # @return [Elements::GanttSection, nil] The found section or nil.
+    def find_section(section_title)
+      @sections.find { |s| s.title == section_title }
     end
 
     # Returns the specific content of the Gantt diagram as a hash.
-    # Called by `Diagrams::Base#to_h`.
     #
     # @return [Hash{Symbol => String | Array<Hash>}]
     def to_h_content
       {
         title: @title,
-        tasks: @tasks.map(&:to_h)
+        # Serialize sections, renaming 'periods' back to 'tasks' for clarity
+        sections: @sections.map(&:to_h) # Use GanttSection's to_h directly
       }
     end
 
     # Returns a hash mapping element types to their collections for diffing.
-    # @see Diagrams::Base#identifiable_elements
+    #
     # @return [Hash{Symbol => Array<Diagrams::Elements::Task>}]
     def identifiable_elements
       {
-        tasks: @tasks
+        # Diffing based on tasks directly might be more useful than sections here
+        tasks: all_tasks
+        # sections: @sections # Could also diff sections if needed
       }
     end
 
     # Class method to create a GanttDiagram from a hash.
-    # Used by the deserialization factory in `Diagrams::Base`.
     #
-    # @param data_hash [Hash] Hash containing `:title` and `:tasks` array.
+    # @param data_hash [Hash] Hash containing `:title` and `:sections` array.
     # @param version [String, Integer, nil] Diagram version.
     # @param checksum [String, nil] Expected checksum (optional, for verification).
     # @return [GanttDiagram] The instantiated diagram.
     def self.from_h(data_hash, version:, checksum:)
       title = data_hash[:title] || data_hash['title'] || ''
-      tasks_data = data_hash[:tasks] || data_hash['tasks'] || []
-
-      tasks = tasks_data.map { |task_h| Diagrams::Elements::Task.new(task_h.transform_keys(&:to_sym)) }
+      sections_data = data_hash[:sections] || data_hash['sections'] || []
+
+      sections = sections_data.map do |section_h|
+        section_data = section_h.transform_keys(&:to_sym)
+        tasks_data = section_data[:tasks] || [] # Expect 'tasks' key in hash
+        # Map task data to Task objects
+        tasks = tasks_data.map do |task_h|
+          task_data = task_h.transform_keys(&:to_sym)
+          # Convert status back to symbol if it's a string and present
+          task_data[:status] = task_data[:status].to_sym if task_data[:status].is_a?(String)
+          Elements::Task.new(task_data)
+        end
+        Elements::GanttSection.new(title: section_data[:title], tasks: tasks)
+      end
 
-      diagram = new(title:, tasks:, version:)
+      diagram = new(title:, sections:, version:)
 
-      # Optional: Verify checksum if provided
+      # Optional: Verify checksum
       if checksum && diagram.checksum != checksum
         warn "Checksum mismatch for loaded GanttDiagram (version: #{version}). Expected #{checksum}, got #{diagram.checksum}."
-        # Or raise an error: raise "Checksum mismatch..."
       end
 
       diagram
@@ -86,14 +158,28 @@ module Diagrams
 
     private
 
+    # Helper to get all tasks from all sections.
+    def all_tasks
+      @sections.flat_map(&:tasks)
+    end
+
+    # Ensures a default section exists if the sections array is empty.
+    def ensure_default_section
+      return if @sections.any? { |s| s.title == DEFAULT_SECTION_TITLE }
+
+      @sections << Elements::GanttSection.new(title: DEFAULT_SECTION_TITLE, tasks: [])
+    end
+
     # Validates the consistency of tasks during initialization.
     def validate_elements!
-      task_ids = @tasks.map(&:id)
-      return if task_ids.uniq.size == @tasks.size
+      task_ids = all_tasks.map(&:id)
+      return if task_ids.uniq.size == all_tasks.size
 
       raise ArgumentError, 'Duplicate task IDs found'
-
       # Add more validation if needed (e.g., date formats, dependencies)
     end
+
+    # Protected method access
+    protected :update_checksum!
   end
 end

data/lib/diagrams/timeline_diagram.rb

@@ -40,9 +40,7 @@ module Diagrams
     def add_section(section_title)
       clean_title = section_title.strip
       raise ArgumentError, "Section title '#{clean_title}' cannot be empty" if clean_title.empty?
-      if find_section(clean_title)
-        raise ArgumentError, "Section with title '#{clean_title}' already exists"
-      end
+      raise ArgumentError, "Section with title '#{clean_title}' already exists" if find_section(clean_title)
 
       # Remove default section if it's empty and we're adding a real one
       if @sections.size == 1 && @sections.first.title == DEFAULT_SECTION_TITLE && @sections.first.periods.empty?
@@ -64,16 +62,16 @@ module Diagrams
     # @return [Elements::TimelinePeriod] The newly added period.
     def add_period(period_label:, events:)
       clean_label = period_label.strip
-      raise ArgumentError, "Period label cannot be empty" if clean_label.empty?
+      raise ArgumentError, 'Period label cannot be empty' if clean_label.empty?
 
       event_list = Array(events).map(&:strip).reject(&:empty?)
-      raise ArgumentError, "Events cannot be empty" if event_list.empty?
+      raise ArgumentError, 'Events cannot be empty' if event_list.empty?
 
       timeline_events = event_list.map { |desc| Elements::TimelineEvent.new(description: desc) }
       new_period = Elements::TimelinePeriod.new(label: clean_label, events: timeline_events)
 
       current_section = @sections.last
-      raise StandardError, "Cannot add period: No section available." unless current_section
+      raise StandardError, 'Cannot add period: No section available.' unless current_section
 
       # Add period to the current section's periods array
       # Dry::Struct arrays are immutable, so we need to create a new section object
@@ -145,9 +143,9 @@ module Diagrams
 
     # Ensures a default section exists if the sections array is empty.
     def ensure_default_section
-      unless @sections.any? { |s| s.title == DEFAULT_SECTION_TITLE }
-        @sections << Elements::TimelineSection.new(title: DEFAULT_SECTION_TITLE)
-      end
+      return if @sections.any? { |s| s.title == DEFAULT_SECTION_TITLE }
+
+      @sections << Elements::TimelineSection.new(title: DEFAULT_SECTION_TITLE)
     end
 
     # Finds a section by its title.
@@ -158,4 +156,4 @@ module Diagrams
     # Protected method access for from_h
     protected :update_checksum!
   end
-end
+end

data/lib/diagrams/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Diagrams
-  VERSION = '0.3.2'
+  VERSION = '0.3.3'
 end

data/lib/diagrams.rb

@@ -9,6 +9,13 @@ require_relative 'diagrams/version'
 
 loader = Zeitwerk::Loader.for_gem
 loader.ignore("#{__dir__}/diagram.rb")
+# Add inflection for ERDiagram
+loader.inflector.inflect(
+  'er_diagram' => 'ERDiagram',
+  'erd_entity' => 'ERDEntity',
+  'erd_attribute' => 'ERDAttribute',
+  'erd_relationship' => 'ERDRelationship'
+)
 loader.setup
 
 # This module handles diagrams creation and manipulation.

data/sig/diagrams/elements/erd_attribute.rbs

@@ -0,0 +1,20 @@
+module Diagrams
+  module Elements
+    # Represents an attribute within an ERD entity.
+    class ERDAttribute < ::Dry::Struct
+      include Elements::Types
+
+      # Attributes
+      attr_reader type: String
+      attr_reader name: String
+      attr_reader keys: Array[Symbol] # :PK | :FK | :UK
+      attr_reader comment: String?
+
+      # Methods
+      def initialize: (type: String, name: String, ?keys: Array[Symbol], ?comment: String?) -> void
+                     | (Hash[Symbol, untyped]) -> void # Allow hash initialization
+
+      def to_h: () -> Hash[Symbol, String | Array[Symbol]]
+    end
+  end
+end

data/sig/diagrams/elements/erd_entity.rbs

@@ -0,0 +1,20 @@
+require_relative 'erd_attribute'
+
+module Diagrams
+  module Elements
+    # Represents an entity (table) in an ER Diagram.
+    class ERDEntity < ::Dry::Struct
+      include Elements::Types
+
+      # Attributes
+      attr_reader name: String
+      attr_reader entity_attributes: Array[ERDAttribute]
+
+      # Methods
+      def initialize: (name: String, ?entity_attributes: Array[ERDAttribute]) -> void
+                     | (Hash[Symbol, untyped]) -> void # Allow hash initialization
+
+      def to_h: () -> Hash[Symbol, String | Array[Hash[Symbol, untyped]]] # Output key is still :attributes
+    end
+  end
+end

data/sig/diagrams/elements/erd_relationship.rbs

@@ -0,0 +1,25 @@
+module Diagrams
+  module Elements
+    # Represents a relationship between two entities in an ER Diagram.
+    class ERDRelationship < ::Dry::Struct
+      include Elements::Types
+
+      # Type alias for cardinality symbols
+      type CARDINALITY = :ZERO_OR_ONE | :ONE_ONLY | :ZERO_OR_MORE | :ONE_OR_MORE
+
+      # Attributes
+      attr_reader entity1: String
+      attr_reader entity2: String
+      attr_reader cardinality1: CARDINALITY
+      attr_reader cardinality2: CARDINALITY
+      attr_reader identifying: bool
+      attr_reader label: String?
+
+      # Methods
+      def initialize: (entity1: String, entity2: String, cardinality1: CARDINALITY, cardinality2: CARDINALITY, ?identifying: bool, ?label: String?) -> void
+                     | (Hash[Symbol, untyped]) -> void # Allow hash initialization
+
+      def to_h: () -> Hash[Symbol, String | Symbol | bool]
+    end
+  end
+end

data/sig/diagrams/elements/gantt_section.rbs

@@ -0,0 +1,18 @@
+module Diagrams
+  module Elements
+    # Represents a section within a Gantt chart, grouping multiple tasks.
+    class GanttSection < ::Dry::Struct
+      include Elements::Types
+
+      # Attributes
+      attr_reader title: String
+      attr_reader tasks: Array[Task]
+
+      # Methods
+      def initialize: (title: String, ?tasks: Array[Task]) -> void
+                     | (Hash[Symbol, untyped]) -> void # Allow hash initialization
+
+      def to_h: () -> Hash[Symbol, String | Array[Hash[Symbol, untyped]]]
+    end
+  end
+end

data/sig/diagrams/elements/task.rbs

@@ -4,13 +4,21 @@ module Diagrams
       include Diagrams::Elements::Types
 
       # Attributes
-      def id: () -> ::String
-      def name: () -> ::String
-      def start_date: () -> ::String # Or ::Date if type is changed
-      def end_date: () -> ::String   # Or ::Date if type is changed
+      # Type alias for status symbols
+      type STATUS = :done | :active | :crit
+
+      # Attributes
+      attr_reader id: String       # Unique ID for dependencies
+      attr_reader label: String    # Display name
+      attr_reader status: STATUS?  # Task status (nil implies default/future)
+      attr_reader start: String    # Start date, task ID, or 'after taskX[, taskY]'
+      attr_reader duration: String # Duration string (e.g., '7d', '2w')
 
       # Methods
-      def to_h: () -> { id: ::String, name: ::String, start_date: ::String, end_date: ::String }
+      def initialize: (id: String, label: String, start: String, duration: String, ?status: STATUS?) -> void
+                     | (Hash[Symbol, untyped]) -> void # Allow hash initialization
+
+      def to_h: () -> Hash[Symbol, String | Symbol | nil]
     end
   end
 end

data/sig/diagrams/er_diagram.rbs

@@ -0,0 +1,30 @@
+module Diagrams
+  # Represents an Entity Relationship Diagram (ERD).
+  class ERDiagram < Base
+    # Instance Variables (via attr_reader)
+    attr_reader entities: Hash[String, Elements::ERDEntity]
+    attr_reader relationships: Array[Elements::ERDRelationship]
+
+    # Initialization
+    def initialize: (?entities: Array[Elements::ERDEntity], ?relationships: Array[Elements::ERDRelationship], ?version: String | Integer) -> void
+
+    # Public Methods
+    def add_entity: (name: String, ?attributes: Array[Hash[Symbol, untyped]]) -> Elements::ERDEntity
+    def add_relationship: (entity1: String, entity2: String, cardinality1: Symbol, cardinality2: Symbol, ?identifying: bool, ?label: String?) -> Elements::ERDRelationship
+    def find_entity: (String entity_name) -> Elements::ERDEntity?
+
+    # --- Base Class Implementation ---
+    def to_h_content: () -> Hash[Symbol, Array[Hash[Symbol, untyped]]]
+    def identifiable_elements: () -> Hash[Symbol, Array[Elements::ERDEntity | Elements::ERDRelationship]]
+
+    # Class method for deserialization
+    def self.from_h: (Hash[Symbol, untyped] data_hash, version: String | Integer | nil, checksum: String?) -> ERDiagram
+
+    # --- Private Methods ---
+    private
+    def validate_relationships!: () -> void
+
+    # Inherited protected method
+    # def update_checksum!: () -> String
+  end
+end

data/sig/diagrams/gantt_diagram.rbs

@@ -1,29 +1,47 @@
 module Diagrams
+  # Represents a Gantt Chart diagram consisting of tasks over time, grouped into sections.
   class GanttDiagram < Base
-    attr_reader title: ::String
-    attr_reader tasks: ::Array[Elements::Task]
+    DEFAULT_SECTION_TITLE: String
+
+    attr_reader title: String?
+    attr_reader sections: Array[Elements::GanttSection] # Use GanttSection
 
     # Initializes a new GanttDiagram.
-    def initialize: (?title: ::String?, ?tasks: ::Array[Elements::Task]?, ?version: Integer | String?) -> void
+    def initialize: (?title: String?, ?sections: Array[Elements::GanttSection]?, ?version: String | Integer) -> void
+
+    # Adds a new section to the diagram.
+    def add_section: (String section_title) -> Elements::GanttSection
+
+    # Adds a task to the current (last) section of the diagram.
+    def add_task: (id: String, label: String, start: String, duration: String, ?status: Elements::Task::STATUS?) -> Elements::Task
 
-    # Adds a task to the diagram.
-    def add_task: (Elements::Task task) -> Elements::Task
+    # Finds a task by its ID across all sections.
+    def find_task: (String task_id) -> Elements::Task?
 
-    # Finds a task by its ID.
-    def find_task: (::String task_id) -> Elements::Task?
+    # Finds a section by its title.
+    def find_section: (String section_title) -> Elements::GanttSection?
 
     # Returns the specific content of the Gantt diagram as a hash.
-    def to_h_content: () -> { title: ::String, tasks: ::Array[Hash[Symbol, untyped]] }
+    def to_h_content: () -> Hash[Symbol, untyped] # More specific: { title: String?, sections: Array[Hash] }
 
     # Returns a hash mapping element types to their collections for diffing.
-    def identifiable_elements: () -> { tasks: ::Array[Elements::Task] }
+    def identifiable_elements: () -> Hash[Symbol, Array[Elements::Task]] # Diffing tasks directly
 
     # Class method to create a GanttDiagram from a hash.
-    def self.from_h: (Hash[Symbol | String, untyped] data_hash, version: Integer | String?, checksum: String?) -> GanttDiagram
+    def self.from_h: (Hash[Symbol, untyped] data_hash, version: String | Integer | nil, checksum: String?) -> GanttDiagram
 
     private
 
+    # Helper to get all tasks from all sections.
+    def all_tasks: () -> Array[Elements::Task]
+
+    # Ensures a default section exists if the sections array is empty.
+    def ensure_default_section: () -> void
+
     # Validates the consistency of tasks during initialization.
     def validate_elements!: () -> void
+
+    # Inherited protected method
+    # def update_checksum!: () -> String
   end
 end

data/sig/diagrams/timeline_diagram.rbs

@@ -1,33 +1,14 @@
+# RBS signatures for patches applied to the 'diagram' gem's TimelineDiagram class
 module Diagrams
-  # Represents a timeline diagram illustrating a chronology of events.
   class TimelineDiagram < Base
-    DEFAULT_SECTION_TITLE: String
-
-    # Instance Variables (via attr_reader)
-    attr_reader title: String?
-    attr_reader sections: Array[Elements::TimelineSection]
-
-    # Initialization
-    def initialize: (?title: String?, ?sections: Array[Elements::TimelineSection], ?version: String | Integer) -> void
-
-    # Public Methods
-    def set_title: (String new_title) -> String
-    def add_section: (String section_title) -> Elements::TimelineSection
-    def add_period: (period_label: String, events: String | Array[String]) -> Elements::TimelinePeriod
-
-    # --- Base Class Implementation ---
-    def to_h_content: () -> Hash[Symbol, untyped] # More specific: Hash[:title?, String | :sections, Array[Hash]]
-    def identifiable_elements: () -> Hash[Symbol, Array[Elements::TimelineSection | Elements::TimelinePeriod]]
-
-    # Class method for deserialization
-    def self.from_h: (Hash[Symbol, untyped] data_hash, version: String | Integer | nil, checksum: String?) -> TimelineDiagram
-
-    # --- Private Methods ---
-    private
-    def ensure_default_section: () -> void
-    def find_section: (String section_title) -> Elements::TimelineSection?
-
-    # Inherited protected method
-    # def update_checksum!: () -> String
+    # Added by mermaid-ruby gem
+    # Generates the Mermaid syntax for the timeline diagram.
+    def to_mermaid: () -> String
+
+    # Original methods from diagram gem (if known/needed for context)
+    # attr_reader title: String?
+    # attr_reader sections: Array[Elements::TimelineSection]
+    # def initialize: (?title: String?, ?sections: Array[Elements::TimelineSection], ?version: untyped) -> void
+    # ... other methods ...
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: diagram
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -219,7 +219,11 @@ files:
 - lib/diagrams/elements.rb
 - lib/diagrams/elements/class_entity.rb
 - lib/diagrams/elements/edge.rb
+- lib/diagrams/elements/erd_attribute.rb
+- lib/diagrams/elements/erd_entity.rb
+- lib/diagrams/elements/erd_relationship.rb
 - lib/diagrams/elements/event.rb
+- lib/diagrams/elements/gantt_section.rb
 - lib/diagrams/elements/git_branch.rb
 - lib/diagrams/elements/git_commit.rb
 - lib/diagrams/elements/node.rb
@@ -231,6 +235,7 @@ files:
 - lib/diagrams/elements/timeline_period.rb
 - lib/diagrams/elements/timeline_section.rb
 - lib/diagrams/elements/transition.rb
+- lib/diagrams/er_diagram.rb
 - lib/diagrams/flowchart_diagram.rb
 - lib/diagrams/gantt_diagram.rb
 - lib/diagrams/gitgraph_diagram.rb
@@ -242,7 +247,11 @@ files:
 - sig/diagrams/class_diagram.rbs
 - sig/diagrams/elements/class_entity.rbs
 - sig/diagrams/elements/edge.rbs
+- sig/diagrams/elements/erd_attribute.rbs
+- sig/diagrams/elements/erd_entity.rbs
+- sig/diagrams/elements/erd_relationship.rbs
 - sig/diagrams/elements/event.rbs
+- sig/diagrams/elements/gantt_section.rbs
 - sig/diagrams/elements/git_branch.rbs
 - sig/diagrams/elements/git_commit.rbs
 - sig/diagrams/elements/node.rbs
@@ -255,6 +264,7 @@ files:
 - sig/diagrams/elements/timeline_section.rbs
 - sig/diagrams/elements/transition.rbs
 - sig/diagrams/elements/types.rbs
+- sig/diagrams/er_diagram.rbs
 - sig/diagrams/flowchart_diagram.rbs
 - sig/diagrams/gantt_diagram.rbs
 - sig/diagrams/gitgraph_diagram.rbs