diagram 0.2.1 → 0.3.2

data/sig/diagrams/elements/git_branch.rbs

@@ -0,0 +1,19 @@
+module Diagrams
+  module Elements
+    # Represents a branch in a Gitgraph diagram.
+    class GitBranch < ::Dry::Struct
+      include Elements::Types
+
+      # Attributes
+      attr_reader name: String
+      attr_reader head_commit_id: String?
+      attr_reader start_commit_id: String
+
+      # Methods
+      def initialize: (name: String, ?head_commit_id: String?, start_commit_id: String) -> void
+                     | (Hash[Symbol, untyped]) -> void # Allow hash initialization
+
+      def to_h: () -> Hash[Symbol, String]
+    end
+  end
+end

data/sig/diagrams/elements/git_commit.rbs

@@ -0,0 +1,23 @@
+module Diagrams
+  module Elements
+    # Represents a commit in a Gitgraph diagram.
+    class GitCommit < ::Dry::Struct
+      include Elements::Types
+
+      # Attributes
+      attr_reader id: String
+      attr_reader parent_ids: Array[String]
+      attr_reader branch_name: String
+      attr_reader message: String?
+      attr_reader tag: String?
+      attr_reader type: Symbol # :NORMAL | :REVERSE | :HIGHLIGHT | :MERGE | :CHERRY_PICK
+      attr_reader cherry_pick_source_id: String?
+
+      # Methods
+      def initialize: (id: String, ?parent_ids: Array[String], branch_name: String, ?message: String?, ?tag: String?, ?type: Symbol, ?cherry_pick_source_id: String?) -> void
+                     | (Hash[Symbol, untyped]) -> void # Allow hash initialization
+
+      def to_h: () -> Hash[Symbol, String | Array[String] | Symbol]
+    end
+  end
+end

data/sig/diagrams/elements/node.rbs

@@ -0,0 +1,14 @@
+module Diagrams
+  module Elements
+    class Node < ::Dry::Struct
+      include Diagrams::Elements::Types
+
+      # Attributes
+      def id: () -> ::String
+      def label: () -> ::String
+
+      # Methods
+      def to_h: () -> { id: ::String, label: ::String }
+    end
+  end
+end

data/sig/diagrams/elements/relationship.rbs

@@ -0,0 +1,16 @@
+module Diagrams
+  module Elements
+    class Relationship < ::Dry::Struct
+      include Diagrams::Elements::Types
+
+      # Attributes
+      def source_class_name: () -> ::String
+      def target_class_name: () -> ::String
+      def type: () -> ::String
+      def label: () -> ::String?
+
+      # Methods
+      def to_h: () -> { source_class_name: ::String, target_class_name: ::String, type: ::String, ?label: ::String }
+    end
+  end
+end

data/sig/diagrams/elements/slice.rbs

@@ -0,0 +1,14 @@
+module Diagrams
+  module Elements
+    class Slice < ::Dry::Struct
+      include Diagrams::Elements::Types
+
+      # Attributes
+      def label: () -> ::String
+      def value: () -> ::Float
+
+      # Methods
+      def to_h: () -> { label: ::String, value: ::Float }
+    end
+  end
+end

data/sig/diagrams/elements/state.rbs

@@ -0,0 +1,14 @@
+module Diagrams
+  module Elements
+    class State < ::Dry::Struct
+      include Diagrams::Elements::Types
+
+      # Attributes
+      def id: () -> ::String
+      def label: () -> ::String?
+
+      # Methods
+      def to_h: () -> { id: ::String, ?label: ::String }
+    end
+  end
+end

data/sig/diagrams/elements/task.rbs

@@ -0,0 +1,16 @@
+module Diagrams
+  module Elements
+    class Task < ::Dry::Struct
+      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
+
+      # Methods
+      def to_h: () -> { id: ::String, name: ::String, start_date: ::String, end_date: ::String }
+    end
+  end
+end

data/sig/diagrams/elements/timeline_event.rbs

@@ -0,0 +1,17 @@
+module Diagrams
+  module Elements
+    # Represents a single event description within a timeline period.
+    class TimelineEvent < ::Dry::Struct
+      include Elements::Types
+
+      # Attributes
+      attr_reader description: String
+
+      # Methods
+      def initialize: (description: String) -> void
+                     | (Hash[Symbol, untyped]) -> void # Allow hash initialization
+
+      def to_h: () -> Hash[Symbol, String]
+    end
+  end
+end

data/sig/diagrams/elements/timeline_period.rbs

@@ -0,0 +1,18 @@
+module Diagrams
+  module Elements
+    # Represents a specific time period on the timeline, containing one or more events.
+    class TimelinePeriod < ::Dry::Struct
+      include Elements::Types
+
+      # Attributes
+      attr_reader label: String
+      attr_reader events: Array[TimelineEvent]
+
+      # Methods
+      def initialize: (label: String, events: Array[TimelineEvent]) -> void
+                     | (Hash[Symbol, untyped]) -> void # Allow hash initialization
+
+      def to_h: () -> Hash[Symbol, String | Array[Hash[Symbol, String]]]
+    end
+  end
+end

data/sig/diagrams/elements/timeline_section.rbs

@@ -0,0 +1,18 @@
+module Diagrams
+  module Elements
+    # Represents a section or age within the timeline, grouping multiple time periods.
+    class TimelineSection < ::Dry::Struct
+      include Elements::Types
+
+      # Attributes
+      attr_reader title: String
+      attr_reader periods: Array[TimelinePeriod]
+
+      # Methods
+      def initialize: (title: String, ?periods: Array[TimelinePeriod]) -> 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/transition.rbs

@@ -0,0 +1,15 @@
+module Diagrams
+  module Elements
+    class Transition < ::Dry::Struct
+      include Diagrams::Elements::Types
+
+      # Attributes
+      def source_state_id: () -> ::String
+      def target_state_id: () -> ::String
+      def label: () -> ::String?
+
+      # Methods
+      def to_h: () -> { source_state_id: ::String, target_state_id: ::String, ?label: ::String }
+    end
+  end
+end

data/sig/diagrams/elements/types.rbs

@@ -0,0 +1,18 @@
+# Signatures for the shared Dry::Types module used by elements.
+# Note: Dry::Types integration with RBS can be complex. This is a basic representation.
+module Diagrams
+  module Elements
+    module Types
+      # Define common types used in elements if needed, or rely on Dry::Types inference.
+      # Example:
+      # type StrictString = ::String
+      # type StrictFloat = ::Float
+      # type StrictArray[T] = ::Array[T]
+      # type String? = StrictString?
+      # ... etc ...
+
+      # Include the Dry::Types module interface (basic representation)
+      include ::Dry::Types
+    end
+  end
+end

data/sig/diagrams/flowchart_diagram.rbs

@@ -0,0 +1,32 @@
+module Diagrams
+  class FlowchartDiagram < Base
+    attr_reader nodes: ::Array[Element::Node]
+    attr_reader edges: ::Array[Element::Edge]
+
+    # Initializes a new FlowchartDiagram.
+    def initialize: (?nodes: ::Array[Element::Node]?, ?edges: ::Array[Element::Edge]?, ?version: Integer | String?) -> void
+
+    # Adds a node to the diagram.
+    def add_node: (Element::Node node) -> Element::Node
+
+    # Adds an edge to the diagram.
+    def add_edge: (Element::Edge edge) -> Element::Edge
+
+    # Finds a node by its ID.
+    def find_node: (::String node_id) -> Element::Node?
+
+    # Returns the specific content of the flowchart diagram as a hash.
+    def to_h_content: () -> { nodes: ::Array[Hash[Symbol, untyped]], edges: ::Array[Hash[Symbol, untyped]] }
+
+    # Returns a hash mapping element types to their collections for diffing.
+    def identifiable_elements: () -> { nodes: ::Array[Elements::Node], edges: ::Array[Elements::Edge] }
+
+    # Class method to create a FlowchartDiagram from a hash.
+    def self.from_h: (Hash[Symbol | String, untyped] data_hash, version: Integer | String?, checksum: String?) -> FlowchartDiagram
+
+    private
+
+    # Validates the consistency of nodes and edges during initialization.
+    def validate_elements!: () -> void
+  end
+end

data/sig/diagrams/gantt_diagram.rbs

@@ -0,0 +1,29 @@
+module Diagrams
+  class GanttDiagram < Base
+    attr_reader title: ::String
+    attr_reader tasks: ::Array[Elements::Task]
+
+    # Initializes a new GanttDiagram.
+    def initialize: (?title: ::String?, ?tasks: ::Array[Elements::Task]?, ?version: Integer | String?) -> void
+
+    # Adds a task to the diagram.
+    def add_task: (Elements::Task task) -> Elements::Task
+
+    # Finds a task by its ID.
+    def find_task: (::String task_id) -> Elements::Task?
+
+    # Returns the specific content of the Gantt diagram as a hash.
+    def to_h_content: () -> { title: ::String, tasks: ::Array[Hash[Symbol, untyped]] }
+
+    # Returns a hash mapping element types to their collections for diffing.
+    def identifiable_elements: () -> { tasks: ::Array[Elements::Task] }
+
+    # 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
+
+    private
+
+    # Validates the consistency of tasks during initialization.
+    def validate_elements!: () -> void
+  end
+end

data/sig/diagrams/gitgraph_diagram.rbs

@@ -0,0 +1,35 @@
+module Diagrams
+  # Represents a Gitgraph diagram, tracking commits, branches, and their relationships.
+  class GitgraphDiagram < Base
+    # Instance Variables (via attr_reader)
+    attr_reader commits: Hash[String, Elements::GitCommit]
+    attr_reader branches: Hash[String, Elements::GitBranch]
+    attr_reader commit_order: Array[String]
+    attr_reader current_branch_name: String
+
+    # Initialization
+    def initialize: (?version: String | Integer) -> void
+
+    # --- Git Operations ---
+    def commit: (?id: String?, ?message: String?, ?tag: String?, ?type: Symbol) -> Elements::GitCommit
+    def branch: (name: String, ?start_commit_id: String?) -> Elements::GitBranch
+    def checkout: (name: String) -> String
+    def merge: (from_branch_name: String, ?id: String?, ?tag: String?, ?type: Symbol) -> Elements::GitCommit
+    def cherry_pick: (commit_id: String, ?parent_override_id: String?) -> Elements::GitCommit
+
+    # --- Base Class Implementation ---
+    def to_h_content: () -> Hash[Symbol, untyped] # More specific: Hash[Symbol, Array[Hash[Symbol, untyped]] | Array[String] | String]
+    def identifiable_elements: () -> Hash[Symbol, Array[Elements::GitCommit | Elements::GitBranch]]
+
+    # Class method for deserialization
+    def self.from_h: (Hash[Symbol, untyped] data_hash, version: String | Integer | nil, checksum: String?) -> GitgraphDiagram
+
+    # --- Private/Protected Methods ---
+    private
+    def generate_commit_id: (Array[String] parent_ids, String? message) -> String
+    def current_head_commit_id: () -> String?
+
+    # Inherited protected method
+    # def update_checksum!: () -> String # Defined in Base, but accessible via send in from_h
+  end
+end

data/sig/diagrams/pie_diagram.rbs

@@ -0,0 +1,36 @@
+module Diagrams
+  class PieDiagram < Base
+    attr_reader title: ::String
+    attr_reader slices: ::Array[Elements::Slice]
+
+    # Initializes a new PieDiagram.
+    def initialize: (?title: ::String?, ?slices: ::Array[Elements::Slice]?, ?version: Integer | String?) -> void
+
+    # Adds a slice to the diagram.
+    # Note: update_checksum and initial_load are internal flags.
+    def add_slice: (Elements::Slice slice, ?update_checksum: bool, ?initial_load: bool) -> Elements::Slice
+
+    # Finds a slice by its label.
+    def find_slice: (::String label) -> Elements::Slice?
+
+    # Calculates the total raw value of all slices.
+    def total_value: () -> ::Float
+
+    # Returns the specific content of the pie diagram as a hash.
+    def to_h_content: () -> { title: ::String, slices: ::Array[Hash[Symbol, untyped]] }
+
+    # Returns a hash mapping element types to their collections for diffing.
+    def identifiable_elements: () -> { slices: ::Array[Elements::Slice] }
+
+    # Class method to create a PieDiagram from a hash.
+    def self.from_h: (Hash[Symbol | String, untyped] data_hash, version: Integer | String?, checksum: String?) -> PieDiagram
+
+    private
+
+    # Validates the consistency of slices during initialization.
+    def validate_elements!: () -> void
+
+    # Recalculates the percentage for each slice based on the total value.
+    def recalculate_percentages!: () -> void
+  end
+end

data/sig/diagrams/state_diagram.rbs

@@ -0,0 +1,40 @@
+module Diagrams
+  class StateDiagram < Base
+    attr_reader title: ::String
+    attr_reader states: ::Array[Elements::State]
+    attr_reader transitions: ::Array[Elements::Transition]
+    attr_reader events: ::Array[Elements::Event]
+
+    # Initializes a new StateDiagram.
+    def initialize: (?title: ::String?, ?states: ::Array[Elements::State]?, ?transitions: ::Array[Elements::Transition]?, ?events: ::Array[Elements::Event]?, ?version: Integer | String?) -> void
+
+    # Adds a state to the diagram.
+    def add_state: (Elements::State state) -> Elements::State
+
+    # Adds a transition to the diagram.
+    def add_transition: (Elements::Transition transition) -> Elements::Transition
+
+    # Adds an event to the diagram.
+    def add_event: (Elements::Event event) -> Elements::Event
+
+    # Finds a state by its ID.
+    def find_state: (::String state_id) -> Elements::State?
+
+    # Finds an event by its ID.
+    def find_event: (::String event_id) -> Elements::Event?
+
+    # Returns the specific content of the state diagram as a hash.
+    def to_h_content: () -> { title: ::String, states: ::Array[Hash[Symbol, untyped]], transitions: ::Array[Hash[Symbol, untyped]], events: ::Array[Hash[Symbol, untyped]] }
+
+    # Returns a hash mapping element types to their collections for diffing.
+    def identifiable_elements: () -> { states: ::Array[Elements::State], transitions: ::Array[Elements::Transition], events: ::Array[Elements::Event] }
+
+    # Class method to create a StateDiagram from a hash.
+    def self.from_h: (Hash[Symbol | String, untyped] data_hash, version: Integer | String?, checksum: String?) -> StateDiagram
+
+    private
+
+    # Validates the consistency of elements during initialization.
+    def validate_elements!: () -> void
+  end
+end

data/sig/diagrams/timeline_diagram.rbs

@@ -0,0 +1,33 @@
+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
+  end
+end