etassia 0.1.0

data/lib/etassia/diagram/kanban.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "base"
+
+module Etassia
+  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
+
+      # Classes assigned via the `:::className` directive line - mermaid's
+      # `@{ classes: ... }` key is not a recognized metadata field (verified
+      # against the installed @mermaid-js/mermaid-cli 11.12.0
+      # kanban-definition bundle) and is ignored. Not rendered - the
+      # renderer has no classDef-driven styling for kanban, matching
+      # Diagram::MindmapNode#classes, which is carried the same way to its
+      # own renderer and stops there too.
+      attribute :classes, :string, collection: true, default: -> { [] }
+
+      # 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
+
+      # Icon, set by an `@{ icon: ... }` entry on the column's own item line
+      # or by a standalone `::icon(name)` line right after it. Not rendered
+      # - column headers have no metadata row today; see KanbanCard#classes
+      # for the same "modeled, not drawn" precedent.
+      attribute :icon, :string
+
+      # Classes, set by a standalone `:::className` line right after the
+      # column's own item line. Mermaid ignores an `@{ classes: ... }` entry
+      # on the item line itself; see KanbanCard#classes. Not rendered.
+      attribute :classes, :string, collection: true, default: -> { [] }
+
+      # 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 no columns (a bare `kanban` header is a valid empty
+      #   diagram, matching what mmdc renders — do not reintroduce a
+      #   "must have at least one column" check here)
+      # - or every column it does have is valid
+      #
+      # @return [Boolean] true if kanban board is valid
+      def valid?
+        return true if columns.nil? || columns.empty?
+
+        columns.all?(&:valid?)
+      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/etassia/diagram/mindmap.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "base"
+
+module Etassia
+  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]
+          round: "round",         # (text)
+          default: "default",     # plain text
+        }.freeze
+
+        def add_child(child)
+          child.parent = self
+          child.level = level + 1
+          children << child
+        end
+
+        def root?
+          level.zero?
+        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
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :mindmap
+      def diagram_type
+        :mindmap
+      end
+
+      # Mindmaps have no validation rules yet. See TODO.foundation's
+      # corpus burndown for real validation; this is deliberately trivial.
+      #
+      # @return [Boolean] true
+      def valid?
+        true
+      end
+    end
+  end
+end

data/lib/etassia/diagram/packet.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Etassia
+  module Diagram
+    # Represents a packet diagram showing network packet structures
+    class Packet < Base
+      attr_accessor :title, :fields
+
+      def initialize
+        super
+        @fields = []
+      end
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :packet
+      def diagram_type
+        :packet
+      end
+
+      # Packet diagrams have no validation rules yet. See
+      # TODO.foundation's corpus burndown for real validation; this is
+      # deliberately trivial.
+      #
+      # @return [Boolean] true
+      def valid?
+        true
+      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

data/lib/etassia/diagram/pie.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "base"
+
+module Etassia
+  module Diagram
+    # Represents a slice in a pie chart.
+    #
+    # A slice represents a data point with a label and numeric value.
+    class PieSlice < Lutaml::Model::Serializable
+      # Label/name for this slice
+      attribute :label, :string
+
+      # Numeric value for this slice (can be integer or decimal)
+      attribute :value, :float
+
+      # Validates the slice has required attributes.
+      #
+      # @return [Boolean] true if slice is valid
+      def valid?
+        !label.nil? && !label.empty? && !value.nil?
+      end
+
+      # Calculate percentage of total.
+      #
+      # @param total [Float] the total value of all slices
+      # @return [Float] percentage (0-100)
+      def percentage(total)
+        return 0.0 if total.zero?
+
+        (value.to_f / total) * 100.0
+      end
+    end
+
+    # Pie chart diagram model.
+    #
+    # Represents a complete pie chart with labeled slices showing
+    # proportional data distribution. Pie charts are useful for showing
+    # part-to-whole relationships.
+    #
+    # @example Creating a simple pie chart
+    #   pie = Pie.new
+    #   pie.title = 'Sales Report'
+    #   pie.slices << PieSlice.new(label: 'Apples', value: 42.5)
+    #   pie.slices << PieSlice.new(label: 'Oranges', value: 30.2)
+    #   pie.slices << PieSlice.new(label: 'Bananas', value: 27.3)
+    class Pie < Base
+      # Collection of data slices in the pie chart
+      attribute :slices, PieSlice, collection: true, default: -> { [] }
+
+      # Whether to show data values on the chart
+      attribute :show_data, :boolean, default: -> { false }
+
+      # Accessibility title (for screen readers)
+      attribute :acc_title, :string
+
+      # Accessibility description (for screen readers)
+      attribute :acc_description, :string
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :pie
+      def diagram_type
+        :pie
+      end
+
+      # Validates the pie chart structure.
+      #
+      # A pie chart is valid if:
+      # - All slices (if any) are valid
+      # - All slice values are numeric
+      #
+      # Note: Empty pie charts are allowed for parsing tests
+      #
+      # @return [Boolean] true if pie chart is valid
+      def valid?
+        return true if slices.nil? || slices.empty?
+
+        slices.all?(&:valid?)
+      end
+
+      # Calculate total value of all slices.
+      #
+      # @return [Float] sum of all slice values
+      def total_value
+        slices.sum(&:value)
+      end
+
+      # Get slices with their calculated percentages.
+      #
+      # @return [Array<Hash>] array of hashes with :slice and :percentage
+      def slices_with_percentages
+        total = total_value
+        slices.map do |slice|
+          {
+            slice: slice,
+            percentage: slice.percentage(total),
+          }
+        end
+      end
+
+      # Calculate angle in degrees for a slice.
+      #
+      # @param slice [PieSlice] the slice to calculate angle for
+      # @return [Float] angle in degrees (0-360)
+      def slice_angle(slice)
+        total = total_value
+        return 0.0 if total.zero?
+
+        (slice.value / total) * 360.0
+      end
+    end
+  end
+end

data/lib/etassia/diagram/quadrant.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "base"
+
+module Etassia
+  module Diagram
+    # Represents a data point in a quadrant chart.
+    #
+    # A point has a label, normalized x/y coordinates (0-1 range),
+    # and optional styling parameters.
+    class QuadrantPoint < Lutaml::Model::Serializable
+      # Label/name for this point
+      attribute :label, :string
+
+      # X coordinate (normalized 0-1)
+      attribute :x, :float
+
+      # Y coordinate (normalized 0-1)
+      attribute :y, :float
+
+      # Optional radius for the point
+      attribute :radius, :float
+
+      # Optional fill color
+      attribute :color, :string
+
+      # Optional stroke color
+      attribute :stroke_color, :string
+
+      # Optional stroke width
+      attribute :stroke_width, :float
+
+      # Validates the point has required attributes.
+      #
+      # @return [Boolean] true if point is valid
+      def valid?
+        !label.nil? && !label.empty? && coordinate?(x) && coordinate?(y)
+      end
+
+      # Determine which quadrant this point is in (1-4).
+      #
+      # Quadrants are numbered:
+      # - Quadrant 1: top-right (x >= 0.5, y >= 0.5)
+      # - Quadrant 2: top-left (x < 0.5, y >= 0.5)
+      # - Quadrant 3: bottom-left (x < 0.5, y < 0.5)
+      # - Quadrant 4: bottom-right (x >= 0.5, y < 0.5)
+      #
+      # @return [Integer] quadrant number (1-4)
+      def quadrant
+        return x < 0.5 ? 2 : 1 if y >= 0.5
+
+        x < 0.5 ? 3 : 4
+      end
+
+      private
+
+      def coordinate?(value)
+        !value.nil? && value.between?(0.0, 1.0)
+      end
+    end
+
+    # Quadrant chart diagram model.
+    #
+    # Represents a 2x2 quadrant chart for visualizing data points
+    # in a two-dimensional space. Useful for categorizing items
+    # based on two independent variables.
+    #
+    # @example Creating a simple quadrant chart
+    #   chart = Quadrant.new
+    #   chart.title = 'Product Analysis'
+    #   chart.x_axis_left = 'Low Cost'
+    #   chart.x_axis_right = 'High Cost'
+    #   chart.y_axis_bottom = 'Low Value'
+    #   chart.y_axis_top = 'High Value'
+    #   chart.quadrant_1_label = 'Invest'
+    #   chart.points << QuadrantPoint.new(label: 'Product A', x: 0.3, y: 0.7)
+    class Quadrant < Base
+      # X-axis label for the left side
+      attribute :x_axis_left, :string
+
+      # X-axis label for the right side
+      attribute :x_axis_right, :string
+
+      # Y-axis label for the bottom
+      attribute :y_axis_bottom, :string
+
+      # Y-axis label for the top
+      attribute :y_axis_top, :string
+
+      # Label for quadrant 1 (top-right)
+      attribute :quadrant_1_label, :string
+
+      # Label for quadrant 2 (top-left)
+      attribute :quadrant_2_label, :string
+
+      # Label for quadrant 3 (bottom-left)
+      attribute :quadrant_3_label, :string
+
+      # Label for quadrant 4 (bottom-right)
+      attribute :quadrant_4_label, :string
+
+      # Collection of data points in the chart
+      attribute :points, QuadrantPoint, collection: true, default: -> { [] }
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :quadrant
+      def diagram_type
+        :quadrant
+      end
+
+      # Validates the quadrant chart structure.
+      #
+      # A quadrant chart is valid if:
+      # - All points (if any) are valid
+      #
+      # Note: Axis labels are optional for minimal diagrams
+      #
+      # @return [Boolean] true if chart is valid
+      def valid?
+        return false unless points.all?(&:valid?)
+
+        true
+      end
+
+      # Get points grouped by quadrant.
+      #
+      # @return [Hash<Integer, Array<QuadrantPoint>>] points by quadrant
+      def points_by_quadrant
+        points.group_by(&:quadrant)
+      end
+    end
+  end
+end

data/lib/etassia/diagram/radar.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Etassia
+  module Diagram
+    # Represents a radar/spider chart diagram
+    class Radar < Base
+      attr_accessor :title, :acc_title, :acc_descr, :axes, :curves, :options
+
+      def initialize
+        super
+        @axes = []
+        @curves = []
+        @options = {}
+      end
+
+      # Returns the diagram type identifier.
+      #
+      # @return [Symbol] :radar
+      def diagram_type
+        :radar
+      end
+
+      # Radar charts have no validation rules yet. See TODO.foundation's
+      # corpus burndown for real validation; this is deliberately trivial.
+      #
+      # @return [Boolean] true
+      def valid?
+        true
+      end
+    end
+
+    # Represents an axis in a radar chart
+    class RadarAxis
+      attr_accessor :id, :label
+
+      def initialize(id, label = nil)
+        @id = id
+        @label = label || id
+      end
+    end
+
+    # Represents a data curve/dataset in a radar chart
+    class RadarCurve
+      attr_accessor :id, :label, :values
+
+      def initialize(id, label = nil)
+        @id = id
+        @label = label || id
+        @values = {}
+      end
+
+      # Add a value for an axis
+      def add_value(axis_id, value)
+        @values[axis_id] = value.to_f
+      end
+
+      # Get value for an axis
+      def value_for(axis_id)
+        @values[axis_id] || 0.0
+      end
+    end
+  end
+end