Align annotations vertically with their section labels and deduplicate duplicates

Author: ydah

examples/basic_usage.rb

@@ -5,13 +5,13 @@
 
 aa_text = <<~'AA'
 ┌─────────────────────────────────────┐
-│            REPL (UI)                │
+│            REPL (UI)                │  ← ユーザーとの対話
 ├─────────────────────────────────────┤
-│         Command Parser              │
+│         Command Parser              │  ← コマンド解析
 ├─────────────────────────────────────┤
-│           Database                  │
+│           Database                  │  ← コア機能
 │  ┌─────────────────────────────┐    │
-│  │       StringHashMap         │    │
+│  │       StringHashMap         │    │  ← データ保存
 │  └─────────────────────────────┘    │
 └─────────────────────────────────────┘
 AA

lib/aa2img/ast/box.rb

@@ -36,7 +36,7 @@ def all_labels
       def all_annotations
         own = annotations || []
         from_sections = (sections || []).flat_map { |s| s.annotation ? [s.annotation] : [] }
-        own + from_sections
+        (own + from_sections).uniq { |ann| [ann.row, ann.arrow_col, ann.text] }
       end
     end
   end

lib/aa2img/layout/calculator.rb

@@ -59,7 +59,7 @@ def annotation_position(annotation, box)
         rect = box_rect(box)
         {
           x: rect[:x] + rect[:width] + 15,
-          y: to_px(annotation.row, 0)[:y] + @metrics.cell_height * 0.7
+          y: to_px(annotation.row, 0)[:y] + @metrics.cell_height * 0.5
         }
       end
 

lib/aa2img/parser.rb

@@ -28,7 +28,7 @@ def parse
             section.labels = text_extractor.extract_labels(@grid, section, box, children: box.children)
           end
 
-          box.annotations = text_extractor.extract_annotations(@grid, box)
+          box.annotations = text_extractor.extract_annotations(@grid, box, children: box.children)
 
           box.annotations.each do |ann|
             matching_section = sections.find { |s| ann.row > s.top && ann.row < s.bottom }

lib/aa2img/parser/text_extractor.rb

@@ -28,9 +28,11 @@ def extract_labels(grid, section, box, children: [])
         labels
       end
 
-      def extract_annotations(grid, box)
+      def extract_annotations(grid, box, children: [])
         annotations = []
         (box.top..box.bottom).each do |row|
+          next if row_inside_child?(row, children)
+
           right_text = extract_row_text(grid, row, box.right + 1, grid.width - 1)
           if (match = right_text.match(ANNOTATION_PATTERN))
             annotations << AST::Annotation.new(

lib/aa2img/renderer/svg_renderer.rb

@@ -113,8 +113,11 @@ def render_box(xml, box, calc, theme, depth)
 
         box.all_annotations.each do |ann|
           pos = calc.annotation_position(ann, box)
+          label_y = aligned_annotation_y(ann, box, calc)
+          pos[:y] = label_y if label_y
           xml.text_(
             x: pos[:x], y: pos[:y],
+            "dominant-baseline": "middle",
             "font-family": theme.font_family,
             "font-size": theme.annotation_font_size,
             fill: theme.annotation_color,
@@ -143,6 +146,34 @@ def render_edge(xml, edge, calc, theme)
 
         xml.line(**attrs)
       end
+
+      def aligned_annotation_y(annotation, box, calc)
+        section = matching_annotation_section(annotation, box)
+        return nil unless section
+        return nil if (section.labels || []).empty?
+
+        label = section.labels.first
+        calc.label_position(
+          label, box,
+          section: section,
+          valign: @valign,
+          label_index: 0,
+          label_count: section.labels.size,
+          children: box.children || []
+        )[:y]
+      end
+
+      def matching_annotation_section(annotation, box)
+        key = annotation_key(annotation)
+        (box.sections || []).find do |section|
+          ann = section.annotation
+          ann && annotation_key(ann) == key
+        end
+      end
+
+      def annotation_key(annotation)
+        [annotation.row, annotation.arrow_col, annotation.text]
+      end
     end
   end
 end

spec/ast/box_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe AA2img::AST::Box do
+  it "deduplicates annotations collected from both box and section" do
+    annotation = AA2img::AST::Annotation.new(text: "note", row: 1, arrow_col: 10)
+    section = AA2img::AST::Section.new(top: 0, bottom: 2, annotation: annotation)
+
+    box = described_class.new(
+      top: 0, left: 0, bottom: 2, right: 10,
+      annotations: [annotation],
+      sections: [section]
+    )
+
+    expect(box.all_annotations).to eq([annotation])
+  end
+end

spec/layout/calculator_spec.rb

@@ -100,4 +100,18 @@ def make_label(text, row:)
       end
     end
   end
+
+  describe "#annotation_position" do
+    let(:scene) { build_scene }
+    let(:calc) { described_class.new(scene, theme) }
+    let(:box) { AA2img::AST::Box.new(top: 0, left: 0, bottom: 4, right: 20) }
+    let(:annotation) { AA2img::AST::Annotation.new(text: "note", row: 2, arrow_col: 21) }
+
+    it "centers annotation vertically within its row" do
+      pos = calc.annotation_position(annotation, box)
+      expected_center_y = padding + annotation.row * cell_height + cell_height * 0.5
+
+      expect(pos[:y]).to eq(expected_center_y)
+    end
+  end
 end

spec/parser/text_extractor_spec.rb

@@ -20,6 +20,26 @@
     expect(annotations.first.text).to eq("comment")
   end
 
+  it "ignores child-row annotations when extracting parent annotations" do
+    text = <<~DIAGRAM
+      ┌─────────────────────────────────────┐
+      │           Database                  │
+      │  ┌─────────────────────────────┐    │
+      │  │       StringHashMap         │    │  ← データ保存
+      │  └─────────────────────────────┘    │
+      └─────────────────────────────────────┘
+    DIAGRAM
+    grid = AA2img::Grid.new(text)
+
+    corner_detector = AA2img::Parser::CornerDetector.new
+    corners = corner_detector.detect(grid)
+    boxes = AA2img::Parser::BoxBuilder.new.detect(grid, corners)
+    parent = AA2img::Parser::NestingAnalyzer.new.analyze(boxes).first
+
+    annotations = extractor.extract_annotations(grid, parent, children: parent.children)
+    expect(annotations).to be_empty
+  end
+
   it "returns empty for no text" do
     grid = AA2img::Grid.new("┌──┐\n│  │\n└──┘")
     box = AA2img::AST::Box.new(top: 0, left: 0, bottom: 2, right: 3)

spec/renderer/svg_renderer_spec.rb

@@ -39,6 +39,52 @@ def parse_fixture(name)
     expect(rects.size).to be >= 3
   end
 
+  it "renders layered architecture annotations once each" do
+    scene = parse_fixture("layered_architecture.txt")
+    svg = renderer.render(scene, theme: theme)
+    doc = Nokogiri::XML(svg)
+
+    annotations = doc.css("text").map(&:text).select { |text| text.start_with?("← ") }
+    counts = annotations.each_with_object(Hash.new(0)) { |text, tally| tally[text] += 1 }
+
+    expect(counts["← ユーザーとの対話"]).to eq(1)
+    expect(counts["← コマンド解析"]).to eq(1)
+    expect(counts["← コア機能"]).to eq(1)
+    expect(counts["← データ保存"]).to eq(1)
+  end
+
+  it "renders annotations with middle baseline alignment" do
+    scene = parse_fixture("layered_architecture.txt")
+    svg = renderer.render(scene, theme: theme)
+    doc = Nokogiri::XML(svg)
+
+    annotation_texts = doc.css("text").select { |node| node.text.start_with?("← ") }
+    expect(annotation_texts).not_to be_empty
+    expect(annotation_texts.map { |node| node["dominant-baseline"] }.uniq).to eq(["middle"])
+  end
+
+  it "aligns annotation y with corresponding labels" do
+    scene = parse_fixture("layered_architecture.txt")
+    svg = renderer.render(scene, theme: theme, valign: :center)
+    doc = Nokogiri::XML(svg)
+
+    pairs = {
+      "REPL (UI)" => "← ユーザーとの対話",
+      "Command Parser" => "← コマンド解析",
+      "Database" => "← コア機能",
+      "StringHashMap" => "← データ保存"
+    }
+
+    pairs.each do |label_text, annotation_text|
+      label_node = doc.css("text").find { |node| node.text == label_text }
+      annotation_node = doc.css("text").find { |node| node.text == annotation_text }
+
+      expect(label_node).not_to be_nil
+      expect(annotation_node).not_to be_nil
+      expect(annotation_node["y"].to_f).to be_within(0.1).of(label_node["y"].to_f)
+    end
+  end
+
   it "includes section divider lines" do
     scene = parse_fixture("sectioned_box.txt")
     svg = renderer.render(scene, theme: theme)