etassia 0.1.0

data/lib/etassia/layout/user_journey.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "elk_placement"
+require_relative "user_journey_geometry"
+require_relative "../diagram/user_journey"
+require_relative "../notation/mermaid/ir_adapters/user_journey"
+
+module Etassia
+  module Layout
+    # User Journey diagram transformer for converting journey models to graphs.
+    #
+    # Converts a typed user journey model into a generic graph structure
+    # suitable for layout computation by elkrb. Handles task box sizing
+    # based on task name and actor count, sequential flow between tasks,
+    # and horizontal timeline layout.
+    #
+    # @example Transform a user journey
+    #   transform = UserJourney.new
+    #   graph = transform.to_graph(user_journey)
+    class UserJourney < Base
+      include UserJourneyGeometry
+
+      # Default font size for text measurement
+      DEFAULT_FONT_SIZE = 14
+
+      # Minimum width for a task box
+      MIN_TASK_WIDTH = 120
+
+      # Height per task box
+      TASK_HEIGHT = 80
+
+      # Padding within task box
+      TASK_PADDING = 10
+
+      # Horizontal spacing between tasks
+      TASK_SPACING = 60
+
+      # Vertical spacing between sections
+      SECTION_SPACING = 40
+
+      TITLE_FONT_SIZE = 20
+      SECTION_FONT_SIZE = 16
+      TASK_NAME_FONT_SIZE = 14
+      SCORE_FONT_SIZE = 18
+      ACTOR_FONT_SIZE = 11
+      TITLE_PADDING = 20
+      SECTION_PADDING = 10
+
+      JOURNEY_ELK_OPTIONS = {
+        ElkOptions::NODE_NODE_SPACING => TASK_SPACING,
+        ElkOptions::LAYER_SPACING => TASK_SPACING,
+        ElkOptions::EDGE_NODE_SPACING => 30,
+        ElkOptions::EDGE_EDGE_SPACING => 20,
+        ElkOptions::NODE_PLACEMENT => "SIMPLE",
+        ElkOptions::MODEL_ORDER => "NODES_AND_EDGES",
+        ElkOptions::HIERARCHY_HANDLING => "INCLUDE_CHILDREN",
+      }.freeze
+      private_constant :JOURNEY_ELK_OPTIONS
+
+      class Box < Lutaml::Model::Serializable
+        attribute :x, :float
+        attribute :y, :float
+        attribute :width, :float
+        attribute :height, :float
+        attribute :corner_radius, :float
+        attribute :fill, :string
+      end
+
+      class Label < Lutaml::Model::Serializable
+        attribute :text, :string
+        attribute :x, :float
+        attribute :y, :float
+        attribute :font_size, :float
+        attribute :text_anchor, :string
+        attribute :font_weight, :string
+        attribute :style, :string
+        attribute :fill, :string
+      end
+
+      # A coloured circle: a legend marker or an actor on a task.
+      class Dot < Lutaml::Model::Serializable
+        attribute :x, :float
+        attribute :y, :float
+        attribute :radius, :float
+        attribute :colour, :string
+        attribute :name, :string
+        attribute :index, :integer
+      end
+
+      class Actor < Lutaml::Model::Serializable
+        attribute :dot, Dot
+        attribute :labels, Label, collection: true, default: -> { [] }
+      end
+
+      class Section < Lutaml::Model::Serializable
+        attribute :box, Box
+        attribute :labels, Label, collection: true, default: -> { [] }
+        attribute :number, :integer
+      end
+
+      class Line < Lutaml::Model::Serializable
+        attribute :x1, :float
+        attribute :y1, :float
+        attribute :x2, :float
+        attribute :y2, :float
+      end
+
+      require_relative "user_journey_face"
+
+      class Task < Lutaml::Model::Serializable
+        attribute :id, :string
+        attribute :box, Box
+        attribute :labels, Label, collection: true, default: -> { [] }
+        attribute :dots, Dot, collection: true, default: -> { [] }
+        attribute :number, :integer
+        attribute :score, :float
+        attribute :line_end, :float
+        attribute :section_name, :string
+        attribute :section_index, :integer
+        attribute :face, Face
+      end
+
+      class Arrow < Lutaml::Model::Serializable
+        attribute :id, :string
+        attribute :line, Line
+        attribute :head_path, :string
+      end
+
+      class Scene < Layout::Scene
+        attribute :id, :string
+        attribute :view_box, :string
+        attribute :title, Label
+        attribute :acc_title, :string
+        attribute :acc_description, :string
+        attribute :legend, Actor, collection: true, default: -> { [] }
+        attribute :sections, Section, collection: true, default: -> { [] }
+        attribute :tasks, Task, collection: true, default: -> { [] }
+        attribute :arrows, Arrow, collection: true, default: -> { [] }
+      end
+
+      def self.from_graph(graph, theme: nil)
+        layout = new
+        layout.theme = theme if theme
+        return layout.to_graph(graph) if graph.is_a?(IR::Graph)
+
+        layout.send(:scene_from_graph, graph)
+      end
+
+      # :grid (the default journey geometry) or :elk. The explicit ELK path
+      # is selected by Engine while the default stays byte-compatible.
+      attr_accessor :placement
+
+      # Converts a user journey to a graph structure.
+      #
+      # @param diagram [Diagram::UserJourney, IR::Graph] source journey graph
+      # @return [Hash] elkrb-compatible graph hash
+      def build_graph(diagram)
+        graph = ir_graph(diagram)
+        sections = section_nodes(graph)
+        {
+          id: graph.id,
+          children: transform_tasks(graph, sections),
+          edges: transform_task_flow(graph),
+          layoutOptions: layout_options,
+          metadata: journey_metadata(graph, sections),
+        }
+      end
+
+      private
+
+      def journey_metadata(graph, sections)
+        {
+          title: graph.label,
+          sections: sections.map(&:label),
+          acc_title: graph.accessibility_title,
+          acc_description: graph.accessibility_description,
+        }
+      end
+
+      def scene(diagram)
+        graph = build_graph(diagram)
+        ElkPlacement.apply(graph) if placement == :elk
+        scene_from_graph(graph, positioned: placement == :elk)
+      end
+
+      def ir_graph(diagram)
+        return diagram if diagram.is_a?(IR::Graph)
+
+        Notation::Mermaid::IRAdapters::UserJourney.call(diagram)
+      end
+
+      def section_nodes(graph)
+        graph.nodes.select { |node| node.role == "journey_section" }
+      end
+
+      def transform_tasks(graph, sections)
+        section_indexes = sections.each_with_index.to_h do |section, index|
+          [section.id, index]
+        end
+        graph.nodes.filter_map do |node|
+          next unless task_node?(node)
+
+          transformed_task(graph, node, sections, section_indexes)
+        end
+      end
+
+      def transformed_task(graph, node, sections, section_indexes)
+        metadata = task_metadata(graph, node, sections, section_indexes)
+        dimensions = calculate_task_dimensions(metadata)
+        {
+          id: node.id, width: dimensions[:width], height: dimensions[:height],
+          labels: task_labels(metadata), metadata: metadata
+        }
+      end
+
+      def task_node?(node)
+        node.role&.start_with?("journey_task_")
+      end
+
+      def task_metadata(graph, node, sections, section_indexes)
+        section = sections.find { |candidate| candidate.id == node.parent_id }
+        {
+          name: node.label,
+          score: normalized_score(node.properties.weight),
+          score_color: node.role.delete_prefix("journey_task_"),
+          actors: actor_names(graph, node.id),
+          section_name: section&.label,
+          section_index: section_indexes[node.parent_id],
+        }
+      end
+
+      def normalized_score(score)
+        return score.to_i if score&.finite? && score == score.to_i
+
+        score
+      end
+
+      def actor_names(graph, task_id)
+        graph.nodes.filter_map do |node|
+          actor = node.role == "journey_actor" && node.parent_id == task_id
+          node.label if actor
+        end
+      end
+
+      def transform_task_flow(graph)
+        graph.edges.filter_map do |edge|
+          next unless edge.role == "sequence"
+
+          {
+            id: edge.id, sources: [edge.source_id], targets: [edge.target_id],
+            metadata: { type: "sequence" }
+          }
+        end
+      end
+
+      def calculate_task_dimensions(task)
+        widths = [
+          MIN_TASK_WIDTH,
+          measured_width(task[:name], DEFAULT_FONT_SIZE + 2),
+          measured_width(task[:actors].join(", "), DEFAULT_FONT_SIZE),
+        ]
+        {
+          width: widths.max + (TASK_PADDING * 2),
+          height: TASK_HEIGHT,
+        }
+      end
+
+      def measured_width(text, font_size)
+        measure_text(text, font_size: font_size)[:width]
+      end
+
+      def task_labels(task)
+        [
+          task_label(task[:name], DEFAULT_FONT_SIZE + 2, :top),
+          task_label(task[:score].to_s, DEFAULT_FONT_SIZE + 4, :center),
+          task_label(task[:actors].join(", "), DEFAULT_FONT_SIZE - 2, :bottom),
+        ]
+      end
+
+      def task_label(text, font_size, position)
+        dimensions = measure_text(text, font_size: font_size)
+        {
+          text: text, width: dimensions[:width], height: dimensions[:height],
+          position: position
+        }
+      end
+
+      def layout_options
+        # User journeys use layered algorithm for sequential task flow
+        # DIRECTION_RIGHT provides left-to-right horizontal timeline
+        # SIMPLE node placement maintains task order in journey sequence
+        build_elk_options(
+          algorithm: ALGORITHM_LAYERED, direction: DIRECTION_RIGHT,
+          **JOURNEY_ELK_OPTIONS
+        )
+      end
+    end
+  end
+end

data/lib/etassia/layout/user_journey_face.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Etassia
+  module Layout
+    class UserJourney < Base
+      # A point on the canvas.
+      class FacePoint < Lutaml::Model::Serializable
+        attribute :x, :float
+        attribute :y, :float
+        attribute :radius, :float
+      end
+
+      # The mouth, in canvas coordinates: closed arc path data for a smile or
+      # frown, or the two ends of a flat line for a neutral face.
+      class FaceMouth < Lutaml::Model::Serializable
+        attribute :path, :string
+        attribute :line, Line
+      end
+
+      # A task's face and the column centre it hangs from, in canvas
+      # coordinates.
+      class Face < Lutaml::Model::Serializable
+        attribute :center_x, :float
+        attribute :center_y, :float
+        attribute :radius, :float
+        attribute :eyes, FacePoint, collection: true, default: -> { [] }
+        attribute :mouth, FaceMouth
+      end
+    end
+  end
+end

data/lib/etassia/layout/user_journey_face_geometry.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Layout
+    # Where a task's face, eyes and mouth sit on the canvas. The face's height
+    # follows the score; mmdc draws the eyes a third of the radius off centre
+    # and the mouth a few pixels below it.
+    module UserJourneyFaceGeometry
+      FACE_RADIUS = 15
+      EYE_RADIUS = 1.5
+      FACE_TOP = 300
+      FACE_STEP = 30
+      SMILE_OFFSET = 2
+      FROWN_OFFSET = 7
+      FLAT_HALF_WIDTH = 5
+      MOUTH_OUTER = 7.5
+      MOUTH_INNER = 6.818
+
+      private
+
+      def task_face(box, score)
+        center_x = box.x + (box.width / 2.0)
+        center_y = FACE_TOP + ((5 - score) * FACE_STEP)
+        UserJourney::Face.new(
+          center_x: center_x, center_y: center_y, radius: FACE_RADIUS,
+          eyes: face_eyes(center_x, center_y),
+          mouth: face_mouth(center_x, center_y, score)
+        )
+      end
+
+      def face_eyes(center_x, center_y)
+        [-1, 1].map do |side|
+          UserJourney::FacePoint.new(
+            x: center_x + (side * FACE_RADIUS / 3.0),
+            y: center_y - (FACE_RADIUS / 3.0),
+            radius: EYE_RADIUS,
+          )
+        end
+      end
+
+      def face_mouth(center_x, center_y, score)
+        return flat_mouth(center_x, center_y) if score == 3
+
+        smile = score > 3
+        offset = smile ? SMILE_OFFSET : FROWN_OFFSET
+        UserJourney::FaceMouth.new(
+          path: arc_path(center_x, center_y + offset, smile ? 1 : -1),
+        )
+      end
+
+      def flat_mouth(center_x, center_y)
+        row = center_y + FROWN_OFFSET
+        UserJourney::FaceMouth.new(
+          line: UserJourney::Line.new(
+            x1: center_x - FLAT_HALF_WIDTH, y1: row,
+            x2: center_x + FLAT_HALF_WIDTH, y2: row
+          ),
+        )
+      end
+
+      # A smile starts at the right end and sweeps over the top; a frown
+      # starts at the left end.
+      def arc_path(center_x, center_y, direction)
+        row = coord(center_y)
+        at = ->(offset) { "#{coord(center_x + (direction * offset))},#{row}" }
+        "M#{at.(MOUTH_OUTER)}#{arc(MOUTH_OUTER, 1)},#{at.(-MOUTH_OUTER)}" \
+          "L#{at.(-MOUTH_INNER)}#{arc(MOUTH_INNER, 0)},#{at.(MOUTH_INNER)}Z"
+      end
+
+      def arc(radius, sweep)
+        "A#{radius},#{radius},0,1,#{sweep}"
+      end
+
+      def coord(value)
+        rounded = value.round(3)
+        rounded == rounded.to_i ? rounded.to_i.to_s : rounded.to_s
+      end
+    end
+  end
+end