sirena 0.1.0

data/lib/sirena/diagram/flowchart.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'base'
+
+module Sirena
+  module Diagram
+    # Represents a flowchart node.
+    #
+    # A node has an identifier, label text, and a shape type that
+    # determines how it should be rendered visually.
+    class FlowchartNode < Lutaml::Model::Serializable
+      # Unique identifier for the node
+      attribute :id, :string
+
+      # Display text/label for the node
+      attribute :label, :string
+
+      # Shape type: :rect, :rounded, :stadium, :subroutine, :cylindrical,
+      # :circle, :asymmetric, :rhombus, :hexagon, :parallelogram,
+      # :parallelogram_alt, :trapezoid, :trapezoid_alt, :double_circle
+      attribute :shape, :string
+
+      # Optional classes/styles
+      attribute :classes, :string
+
+      # Initialize with default shape
+      def initialize(*args)
+        super
+        self.shape ||= 'rect'
+      end
+
+      # Validates the node has required attributes.
+      #
+      # @return [Boolean] true if node is valid
+      def valid?
+        !id.nil? && !id.empty? && !label.nil?
+      end
+    end
+
+    # Represents a flowchart edge (connection between nodes).
+    #
+    # An edge connects a source node to a target node, with optional
+    # label text and arrow styling.
+    class FlowchartEdge < Lutaml::Model::Serializable
+      # Source node identifier
+      attribute :source_id, :string
+
+      # Target node identifier
+      attribute :target_id, :string
+
+      # Optional edge label
+      attribute :label, :string
+
+      # Arrow type: :arrow, :dotted_arrow, :thick_arrow, :line,
+      # :dotted_line, :thick_line
+      attribute :arrow_type, :string
+
+      # Initialize with default arrow type
+      def initialize(*args)
+        super
+        self.arrow_type ||= 'arrow'
+      end
+
+      # Validates the edge has required attributes.
+      #
+      # @return [Boolean] true if edge is valid
+      def valid?
+        !source_id.nil? && !source_id.empty? &&
+          !target_id.nil? && !target_id.empty?
+      end
+    end
+
+    # Flowchart diagram model.
+    #
+    # Represents a complete flowchart with nodes and edges. Flowcharts
+    # support various node shapes and edge types to create flow diagrams,
+    # decision trees, and process flows.
+    #
+    # @example Creating a simple flowchart
+    #   flowchart = Flowchart.new(direction: 'TD')
+    #   flowchart.nodes << FlowchartNode.new(
+    #     id: 'A',
+    #     label: 'Start',
+    #     shape: 'stadium'
+    #   )
+    #   flowchart.nodes << FlowchartNode.new(
+    #     id: 'B',
+    #     label: 'Process',
+    #     shape: 'rect'
+    #   )
+    #   flowchart.edges << FlowchartEdge.new(
+    #     source_id: 'A',
+    #     target_id: 'B',
+    #     arrow_type: 'arrow'
+    #   )
+    class Flowchart < Base
+      # Collection of nodes in the flowchart
+      attribute :nodes, FlowchartNode, collection: true, default: -> { [] }
+
+      # Collection of edges connecting nodes
+      attribute :edges, FlowchartEdge, collection: true, default: -> { [] }
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :flowchart
+      def diagram_type
+        :flowchart
+      end
+
+      # Validates the flowchart structure.
+      #
+      # A flowchart is valid if:
+      # - It has at least one node
+      # - All nodes are valid
+      # - All edges are valid
+      # - All edge references point to existing nodes
+      #
+      # @return [Boolean] true if flowchart is valid
+      def valid?
+        return false if nodes.nil? || nodes.empty?
+        return false unless nodes.all?(&:valid?)
+        return false unless edges.nil? || edges.all?(&:valid?)
+
+        # Validate edge references
+        node_ids = nodes.map(&:id)
+        edges&.each do |edge|
+          return false unless node_ids.include?(edge.source_id)
+          return false unless node_ids.include?(edge.target_id)
+        end
+
+        true
+      end
+
+      # Finds a node by its identifier.
+      #
+      # @param id [String] the node identifier to find
+      # @return [FlowchartNode, nil] the node or nil if not found
+      def find_node(id)
+        nodes.find { |n| n.id == id }
+      end
+
+      # Finds all edges originating from a specific node.
+      #
+      # @param node_id [String] the source node identifier
+      # @return [Array<FlowchartEdge>] edges from the node
+      def edges_from(node_id)
+        edges.select { |e| e.source_id == node_id }
+      end
+
+      # Finds all edges targeting a specific node.
+      #
+      # @param node_id [String] the target node identifier
+      # @return [Array<FlowchartEdge>] edges to the node
+      def edges_to(node_id)
+        edges.select { |e| e.target_id == node_id }
+      end
+    end
+  end
+end

data/lib/sirena/diagram/gantt.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Sirena
+  module Diagram
+    # Gantt chart task
+    class GanttTask < Lutaml::Model::Serializable
+      attribute :description, :string
+      attribute :id, :string
+      attribute :start_date, :string
+      attribute :end_date, :string
+      attribute :duration, :string
+      attribute :after_task, :string
+      attribute :until_task, :string
+      attribute :tags, :string, collection: true
+      attribute :click_href, :string
+      attribute :click_callback, :string
+
+      def initialize
+        super
+        @tags ||= []
+      end
+
+      def done?
+        tags.include?("done")
+      end
+
+      def active?
+        tags.include?("active")
+      end
+
+      def critical?
+        tags.include?("crit")
+      end
+
+      def milestone?
+        tags.include?("milestone")
+      end
+    end
+
+    # Gantt chart section grouping
+    class GanttSection < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :tasks, GanttTask, collection: true
+
+      def initialize(name = nil)
+        super()
+        @name = name
+        @tasks ||= []
+      end
+    end
+
+    # Gantt chart diagram model
+    class GanttChart < Lutaml::Model::Serializable
+      attribute :title, :string
+      attribute :date_format, :string, default: -> { "YYYY-MM-DD" }
+      attribute :axis_format, :string
+      attribute :tick_interval, :string
+      attribute :excludes, :string, collection: true
+      attribute :today_marker, :string
+      attribute :sections, GanttSection, collection: true
+
+      def initialize
+        super
+        @sections ||= []
+        @excludes ||= []
+      end
+    end
+  end
+end

data/lib/sirena/diagram/git_graph.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Sirena
+  module Diagram
+    # Represents a Git Graph diagram
+    class GitGraph < Base
+      # Represents a commit in the git graph
+      class Commit < Lutaml::Model::Serializable
+        attribute :id, :string
+        attribute :message, :string
+        attribute :type, :string, default: -> { "NORMAL" }
+        attribute :tag, :string
+        attribute :branch_name, :string
+        attribute :parent_ids, :string, collection: true, default: -> { [] }
+        attribute :is_merge, :boolean, default: -> { false }
+        attribute :merge_branch, :string
+        attribute :is_cherry_pick, :boolean, default: -> { false }
+        attribute :cherry_pick_parent, :string
+      end
+
+      # Represents a branch in the git graph
+      class Branch < Lutaml::Model::Serializable
+        attribute :name, :string
+        attribute :order, :integer
+        attribute :parent_branch, :string
+        attribute :created_at_commit, :string
+      end
+
+      attribute :orientation, :string, default: -> { "LR" }
+      attribute :commits, Commit, collection: true, default: -> { [] }
+      attribute :branches, Branch, collection: true, default: -> { [] }
+    end
+  end
+end

data/lib/sirena/diagram/info.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require_relative 'base'
+
+module Sirena
+  module Diagram
+    # Info diagram model.
+    #
+    # Represents a simple informational diagram that displays a message
+    # or status information. Info diagrams are typically used to show
+    # system information, help text, or status messages.
+    #
+    # @example Creating an info diagram
+    #   info = Info.new
+    #   info.show_info = true
+    class Info < Base
+      # Whether to show additional info
+      attribute :show_info, :boolean, default: -> { false }
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :info
+      def diagram_type
+        :info
+      end
+
+      # Validates the info diagram structure.
+      #
+      # Info diagrams are always valid as they have no required content.
+      #
+      # @return [Boolean] true
+      def valid?
+        true
+      end
+    end
+  end
+end

data/lib/sirena/diagram/kanban.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "base"
+
+module Sirena
+  module Diagram
+    # Represents a card in a Kanban column.
+    #
+    # A card has an id, text content, and optional metadata like
+    # assigned user, ticket number, icon, priority, etc.
+    class KanbanCard < Lutaml::Model::Serializable
+      # Card identifier
+      attribute :id, :string
+
+      # Card text content
+      attribute :text, :string
+
+      # Optional metadata
+      attribute :assigned, :string
+      attribute :ticket, :string
+      attribute :icon, :string
+      attribute :label, :string
+      attribute :priority, :string
+
+      # Validates the card has required fields.
+      #
+      # @return [Boolean] true if card is valid
+      def valid?
+        !id.nil? && !id.empty? && !text.nil? && !text.empty?
+      end
+
+      # Returns all metadata as a hash.
+      #
+      # @return [Hash] metadata hash
+      def metadata
+        {
+          assigned: assigned,
+          ticket: ticket,
+          icon: icon,
+          label: label,
+          priority: priority
+        }.compact
+      end
+
+      # Checks if card has any metadata.
+      #
+      # @return [Boolean] true if card has metadata
+      def has_metadata?
+        !metadata.empty?
+      end
+    end
+
+    # Represents a column in a Kanban board.
+    #
+    # A column has an id, title, and contains multiple cards.
+    class KanbanColumn < Lutaml::Model::Serializable
+      # Column identifier
+      attribute :id, :string
+
+      # Column title/name
+      attribute :title, :string
+
+      # Collection of cards in this column
+      attribute :cards, KanbanCard, collection: true, default: -> { [] }
+
+      # Validates the column has required fields.
+      #
+      # @return [Boolean] true if column is valid
+      def valid?
+        !id.nil? && !id.empty? &&
+          !title.nil? && !title.empty? &&
+          cards.all?(&:valid?)
+      end
+
+      # Adds a card to this column.
+      #
+      # @param card [KanbanCard] the card to add
+      # @return [void]
+      def add_card(card)
+        cards << card
+      end
+    end
+
+    # Kanban board diagram model.
+    #
+    # Represents a complete Kanban board with columns and cards
+    # for workflow visualization.
+    #
+    # @example Creating a simple kanban board
+    #   diagram = Kanban.new
+    #   column = KanbanColumn.new.tap do |c|
+    #     c.id = "todo"
+    #     c.title = "Todo"
+    #   end
+    #   card = KanbanCard.new.tap do |c|
+    #     c.id = "docs"
+    #     c.text = "Create Documentation"
+    #     c.priority = "High"
+    #   end
+    #   column.add_card(card)
+    #   diagram.add_column(column)
+    class Kanban < Base
+      # Collection of columns in the board
+      attribute :columns, KanbanColumn, collection: true,
+                                        default: -> { [] }
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :kanban
+      def diagram_type
+        :kanban
+      end
+
+      # Validates the kanban board structure.
+      #
+      # A kanban is valid if:
+      # - It has at least one column
+      # - All columns are valid
+      # - All cards within columns are valid
+      #
+      # @return [Boolean] true if kanban board is valid
+      def valid?
+        return false if columns.nil? || columns.empty?
+        return false unless columns.all?(&:valid?)
+
+        true
+      end
+
+      # Adds a column to the board.
+      #
+      # @param column [KanbanColumn] the column to add
+      # @return [void]
+      def add_column(column)
+        columns << column
+      end
+
+      # Returns all cards across all columns.
+      #
+      # @return [Array<KanbanCard>] all cards in the board
+      def all_cards
+        columns.flat_map(&:cards)
+      end
+
+      # Finds a column by id.
+      #
+      # @param id [String] the column id
+      # @return [KanbanColumn, nil] the column or nil if not found
+      def find_column(id)
+        columns.find { |c| c.id == id }
+      end
+
+      # Finds cards by assigned user.
+      #
+      # @param user [String] the assigned user
+      # @return [Array<KanbanCard>] cards assigned to the user
+      def cards_by_assigned(user)
+        all_cards.select { |c| c.assigned == user }
+      end
+
+      # Finds cards by priority.
+      #
+      # @param priority [String] the priority level
+      # @return [Array<KanbanCard>] cards with the given priority
+      def cards_by_priority(priority)
+        all_cards.select { |c| c.priority == priority }
+      end
+
+      # Finds cards by ticket.
+      #
+      # @param ticket [String] the ticket number
+      # @return [Array<KanbanCard>] cards with the given ticket
+      def cards_by_ticket(ticket)
+        all_cards.select { |c| c.ticket == ticket }
+      end
+    end
+  end
+end

data/lib/sirena/diagram/mindmap.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Sirena
+  module Diagram
+    # Represents a Mindmap diagram
+    class Mindmap < Base
+      # Represents a node in the mindmap
+      class MindmapNode < Lutaml::Model::Serializable
+        attribute :id, :string
+        attribute :content, :string
+        attribute :level, :integer, default: -> { 0 }
+        attribute :shape, :string, default: -> { "default" }
+        attribute :icon, :string
+        attribute :classes, :string, collection: true, default: -> { [] }
+        attribute :children, MindmapNode, collection: true, default: -> { [] }
+        attribute :parent, MindmapNode
+
+        # Shape constants
+        SHAPES = {
+          circle: "circle",       # ((text))
+          cloud: "cloud",         # )text(
+          bang: "bang",           # ))text((
+          hexagon: "hexagon",     # {{text}}
+          square: "square",       # [text]
+          default: "default"      # plain text (rounded rectangle)
+        }.freeze
+
+        def add_child(child)
+          child.parent = self
+          child.level = level + 1
+          children << child
+        end
+
+        def root?
+          level == 0
+        end
+
+        def leaf?
+          children.empty?
+        end
+      end
+
+      attribute :root, MindmapNode
+      attribute :nodes, MindmapNode, collection: true, default: -> { [] }
+
+      def add_node(node)
+        nodes << node
+        @root = node if node.root?
+      end
+    end
+  end
+end

data/lib/sirena/diagram/packet.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Sirena
+  module Diagram
+    # Represents a packet diagram showing network packet structures
+    class PacketDiagram < Base
+      attr_accessor :title, :fields
+
+      def initialize
+        super
+        @fields = []
+      end
+
+      def type
+        :packet
+      end
+
+      # Add a field to the packet
+      def add_field(field)
+        @fields << field
+      end
+
+      # Get the maximum bit position used in the packet
+      def max_bit_position
+        return 0 if @fields.empty?
+
+        @fields.map(&:bit_end).max
+      end
+
+      # Calculate the number of rows needed (assuming 32-bit width)
+      def row_count(bits_per_row = 32)
+        return 1 if @fields.empty?
+
+        ((max_bit_position + 1).to_f / bits_per_row).ceil
+      end
+    end
+
+    # Represents a field in a packet diagram
+    class PacketField
+      attr_accessor :bit_start, :bit_end, :label
+
+      def initialize(bit_start, bit_end, label)
+        @bit_start = bit_start.to_i
+        @bit_end = bit_end.to_i
+        @label = label
+      end
+
+      # Get the size of the field in bits
+      def size
+        @bit_end - @bit_start + 1
+      end
+
+      # Get the row this field starts in (for 32-bit rows)
+      def start_row(bits_per_row = 32)
+        @bit_start / bits_per_row
+      end
+
+      # Get the row this field ends in (for 32-bit rows)
+      def end_row(bits_per_row = 32)
+        @bit_end / bits_per_row
+      end
+
+      # Check if this field spans multiple rows
+      def spans_rows?(bits_per_row = 32)
+        start_row(bits_per_row) != end_row(bits_per_row)
+      end
+
+      # Get the bit position within a row (0-31 for 32-bit rows)
+      def start_bit_in_row(bits_per_row = 32)
+        @bit_start % bits_per_row
+      end
+
+      # Get the ending bit position within a row
+      def end_bit_in_row(bits_per_row = 32)
+        @bit_end % bits_per_row
+      end
+    end
+  end
+end