ea 0.3.1 → 0.5.0

data/lib/ea/svg/ea_emitter/markers.rb

@@ -0,0 +1,404 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Emits marker `<polygon>` and `<path>` elements per connector,
+      # matching EA's encoding rules. Returns an Array of `Layer`
+      # structs bucketed by marker style.
+      #
+      # Layer style keys:
+      #   - :diamond_filled  → 4-pt <polygon>, black fill
+      #   - :triangle_open   → 3-pt <polygon>, white fill
+      #   - :arrow           → 3-pt <path>, no fill (shares style with
+      #     connector lines — same stroke, no fill)
+      #
+      # Default mode (`grouped: true`) consolidates all markers of
+      # the same style into ONE `<g>`. Pass `grouped: false` for
+      # per-connector grouping.
+      class Markers
+        DIAMOND_HALF_W = 5
+        DIAMOND_HALF_H = 10
+        TRI_HALF_BASE = 6
+        TRI_HEIGHT = 11
+        ARROW_HALF_BASE = 6
+        ARROW_HEIGHT = 11
+
+        attr_reader :diagram, :model_index, :canvas, :grouped, :stroke_width
+
+        def initialize(diagram, model_index:, canvas: nil, grouped: true, stroke_width: 2)
+          @diagram = diagram
+          @model_index = model_index
+          @canvas = canvas
+          @grouped = grouped
+          @stroke_width = stroke_width
+        end
+
+        def layers
+          entries = visible_connectors.flat_map { |c| entries_for(c) }
+          return [] if entries.empty?
+
+          if grouped
+            entries.group_by(&:style_key).map do |key, grouped_entries|
+              # EA emits ONE marker per connector regardless of
+              # anchor overlap. Verified against plateau Bridge
+              # diagram: 9 generalizations fanning from the same
+              # parent anchor produce 9 distinct triangle polygons
+              # at the same coordinates. The earlier "dedup by
+              # anchor" hypothesis is disproven by reference SVGs.
+              Layer.new(style_key: key,
+                        style: style_for(key),
+                        body: grouped_entries.map(&:body).join("\n  "))
+            end
+          else
+            entries.map { |e| Layer.new(style_key: e.style_key, style: style_for(e.style_key), body: e.body) }
+          end
+        end
+
+        def render
+          layers.map(&:to_svg).join("\n")
+        end
+
+        # Backwards-compatible API: count of marker bodies emitted.
+        def count_for(connector)
+          return 0 if connector.hidden
+          return 0 unless connector.waypoints&.any? { |w| w.position }
+
+          entries_for(connector).size
+        end
+
+        private
+
+        # Entry pairs the rendered SVG body with the structural
+        # anchor (rounded integer [x, y] pair). Anchor is retained
+        # for future use (e.g. overlap diagnostics) but no longer
+        # drives dedup — EA emits one marker per connector.
+        Entry = Struct.new(:style_key, :body, :anchor,
+                           :connector_waypoint_count,
+                           keyword_init: true) do
+          def hash
+            anchor.hash
+          end
+
+          def eql?(other)
+            other.is_a?(Entry) && anchor == other.anchor
+          end
+        end
+
+        def style_for(key)
+          case key
+          when :diamond_filled
+            "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
+          when :triangle_open
+            "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#FFFFFF;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
+          when :connector_line
+            "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
+          end
+        end
+
+        def visible_connectors
+          (diagram.connectors || []).select(&:renderable?)
+        end
+
+        def entries_for(connector)
+          specs = specs_for(connector)
+          waypoint_count = waypoint_pairs(connector).size
+          specs.filter_map do |spec|
+            next nil if suppress_arrow?(spec, connector)
+
+            body = render_shape(spec)
+            next nil unless body
+
+            Entry.new(style_key: style_key_for(spec),
+                      body: body,
+                      anchor: anchor_for(spec),
+                      connector_waypoint_count: waypoint_count)
+          end
+        end
+
+        # Suppress arrow markers when:
+        # 1. The diagram is an Object diagram (instance links).
+        # 2. The connector is an unidirectional Association with
+        #    significant waypoint deviation from a straight line
+        #    (> 3px). EA treats connectors with small deviations as
+        #    straight (WITH arrow); large deviations are orthogonal/
+        #    tree-routed (NO arrow). Bidirectional associations always
+        #    show arrows at both ends regardless of routing.
+        BEND_DEVIATION_THRESHOLD = 3
+
+        def suppress_arrow?(spec, connector)
+          return false unless spec.shape == :arrow
+          return true if object_diagram? && association?(connector)
+          return false if connector.direction == "Bi-Directional"
+          return true if horizontal_tree_routed?(connector)
+
+          false
+        end
+
+        # A "horizontal tree-routed" connector has its source and
+        # target endpoints at the SAME y-coordinate with interior
+        # waypoints deviating above and below — the classic EA tree
+        # routing pattern where multiple connectors fan out from a
+        # shared parent at the same height. These don't render arrow
+        # markers in basic.qea Classes diagrams. This check is
+        # deliberately narrow to avoid suppressing arrows on plateau
+        # connectors where source and target are at different heights.
+        def horizontal_tree_routed?(connector)
+          return false unless association?(connector)
+          return false if object_diagram?
+
+          points = waypoint_pairs(connector)
+          return false if points.size < 4
+
+          source = points.first
+          target = points.last
+          return false unless source[1] == target[1]
+
+          max_bend_deviation(connector) > BEND_DEVIATION_THRESHOLD
+        end
+
+        def tree_routed_association?(connector)
+          return false unless association?(connector)
+          return false if object_diagram?
+          return false if connector.direction == "Bi-Directional"
+
+          # Only apply the tree-routed heuristic to connectors with
+          # 4+ waypoints AND significant bend deviation. 3-waypoint
+          # connectors with a single bend are too common on plateau
+          # to suppress reliably.
+          points = waypoint_pairs(connector)
+          return false if points.size < 4
+
+          max_bend_deviation(connector) > BEND_DEVIATION_THRESHOLD
+        end
+
+        def max_bend_deviation(connector)
+          points = waypoint_pairs(connector)
+          return 0 if points.size < 3
+
+          source = points.first
+          target = points.last
+          interior = points[1..-2]
+          interior.map { |p| perpendicular_distance(p, source, target) }.max || 0
+        end
+
+        def perpendicular_distance(point, line_start, line_end)
+          px, py = point
+          x1, y1 = line_start
+          x2, y2 = line_end
+          dx = x2 - x1
+          dy = y2 - y1
+          length_sq = dx * dx + dy * dy
+          return 0 if length_sq.zero?
+
+          ((dy * px - dx * py + x2 * y1 - y2 * x1).abs / Math.sqrt(length_sq)).round
+        end
+
+        def association?(connector)
+          effective_type(connector) == "Association"
+        end
+
+        def object_diagram?
+          diagram.diagram_type == "Object"
+        end
+
+        # Rounded [x, y] of the marker's tip (anchor) in canvas
+        # coordinates. Used for deduplication.
+        def anchor_for(spec)
+          tx, ty = translate_point(spec.anchor)
+          [tx.round, ty.round]
+        end
+
+        def style_key_for(spec)
+          case spec.shape
+          when :diamond  then :diamond_filled
+          when :triangle then :triangle_open
+          when :plus     then :connector_line # shares style with line <g>
+          when :arrow    then :connector_line # share with line <g>
+          when :package_anchor then :connector_line
+          end
+        end
+
+        # Rounded [x, y] of the marker's tip (anchor) in canvas
+        # coordinates. Used for deduplication.
+        def anchor_for(spec)
+          tx, ty = translate_point(spec.anchor)
+          [tx.round, ty.round]
+        end
+
+        def render_shape(spec)
+          case spec.shape
+          when :diamond  then diamond_polygon(spec.anchor, spec.base)
+          when :triangle then triangle_polygon(spec.anchor, spec.base)
+          when :plus     then plus_path(spec.anchor)
+          when :arrow    then arrow_path(spec.anchor, spec.base)
+          when :package_anchor then package_anchor_path(spec.anchor, spec.base)
+          end
+        end
+
+        # Plus marker: two crossed line segments at the anchor.
+        # EA encodes as one <path> with two sub-paths:
+        #   M cx cy-8 L cx cy+8    (vertical arm)
+        #   M cx+8 cy L cx-8 cy    (horizontal arm)
+        def plus_path(anchor)
+          cx, cy = translate_point(anchor)
+          cx_str = Canvas.coord(cx)
+          cy_str = Canvas.coord(cy)
+          up = Canvas.coord(cy - Marker::Plus::ARM_LENGTH)
+          down = Canvas.coord(cy + Marker::Plus::ARM_LENGTH)
+          left = Canvas.coord(cx - Marker::Plus::ARM_LENGTH)
+          right = Canvas.coord(cx + Marker::Plus::ARM_LENGTH)
+          d = "M #{cx_str} #{up} L #{cx_str} #{down} M #{right} #{cy_str} L #{left} #{cy_str}"
+          %(<path d="#{d}" shape-rendering="auto"/>)
+        end
+
+        def specs_for(connector)
+          points = waypoint_pairs(connector)
+          return [] if points.size < 2
+
+          source = points.first
+          target = points.last
+          before_target = points[-2] || source
+          after_source = points[1] || target
+          Marker::Registry.specs_for(connector,
+                                     effective_type(connector),
+                                     source, target,
+                                     before_target, after_source,
+                                     relationship: relationship_for(connector))
+        end
+
+        def effective_type(connector)
+          return connector.connector_type if connector.connector_type
+
+          rel = relationship_for(connector)
+          return "Association" unless rel
+
+          # Use the polymorphic kind field rather than class-name
+          # inspection - subclasses set `relationship_kind` at the
+          # model level (e.g. Association → "association", which we
+          # then capitalize to match EA's Connector_Type).
+          kind = rel.relationship_kind || "association"
+          kind.capitalize
+        end
+
+        def relationship_for(connector)
+          return nil unless connector.relationship_ref && model_index
+
+          model_index[connector.relationship_ref]
+        end
+
+        def diamond_polygon(tip, base)
+          tx, ty = translate_point(tip)
+          bx, by = translate_point(base)
+          ux, uy = unit_vector(tx, ty, bx, by)
+          return nil unless ux
+
+          right_x = tx - ux * DIAMOND_HALF_H + (-uy) * DIAMOND_HALF_W
+          right_y = ty - uy * DIAMOND_HALF_H + ux * DIAMOND_HALF_W
+          back_x = tx - ux * (DIAMOND_HALF_H * 2)
+          back_y = ty - uy * (DIAMOND_HALF_H * 2)
+          left_x = tx - ux * DIAMOND_HALF_H - (-uy) * DIAMOND_HALF_W
+          left_y = ty - uy * DIAMOND_HALF_H - ux * DIAMOND_HALF_W
+          pts = [
+            Canvas.coord(tx), Canvas.coord(ty),
+            Canvas.coord(right_x), Canvas.coord(right_y),
+            Canvas.coord(back_x), Canvas.coord(back_y),
+            Canvas.coord(left_x), Canvas.coord(left_y)
+          ].join(" ")
+          %(<polygon points="#{pts}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
+        end
+
+        def triangle_polygon(tip, base)
+          tx, ty = translate_point(tip)
+          bx, by = translate_point(base)
+          ux, uy = unit_vector(tx, ty, bx, by)
+          return nil unless ux
+
+          back_x = tx - ux * TRI_HEIGHT
+          back_y = ty - uy * TRI_HEIGHT
+          w1_x = back_x + (-uy) * TRI_HALF_BASE
+          w1_y = back_y + ux * TRI_HALF_BASE
+          w2_x = back_x - (-uy) * TRI_HALF_BASE
+          w2_y = back_y - ux * TRI_HALF_BASE
+          pts = [
+            Canvas.coord(tx), Canvas.coord(ty),
+            Canvas.coord(w1_x), Canvas.coord(w1_y),
+            Canvas.coord(w2_x), Canvas.coord(w2_y)
+          ].join(" ")
+          %(<polygon points="#{pts}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
+        end
+
+        def arrow_path(tip, base)
+          tx, ty = translate_point(tip)
+          bx, by = translate_point(base)
+          ux, uy = unit_vector(tx, ty, bx, by)
+          return nil unless ux
+
+          back_x = tx - ux * ARROW_HEIGHT
+          back_y = ty - uy * ARROW_HEIGHT
+          w1_x = back_x + (-uy) * ARROW_HALF_BASE
+          w1_y = back_y + ux * ARROW_HALF_BASE
+          w2_x = back_x - (-uy) * ARROW_HALF_BASE
+          w2_y = back_y - ux * ARROW_HALF_BASE
+          d = "M #{Canvas.coord(w1_x)} #{Canvas.coord(w1_y)} L #{Canvas.coord(tx)} #{Canvas.coord(ty)} L #{Canvas.coord(w2_x)} #{Canvas.coord(w2_y)}"
+          %(<path d="#{d}" shape-rendering="auto"/>)
+        end
+
+        # «import» source-end marker: a small closed trapezoid that
+        # visually represents the imported package. Shape is a 4-point
+        # polygon: top edge shorter than bottom edge, centered on the
+        # anchor point.
+        PACKAGE_ANCHOR_W = 5
+        PACKAGE_ANCHOR_H_TOP = 3
+        PACKAGE_ANCHOR_H_BOTTOM = 4
+
+        def package_anchor_path(tip, base)
+          tx, ty = translate_point(tip)
+          bx, by = translate_point(base)
+          ux, uy = unit_vector(tx, ty, bx, by)
+          return nil unless ux
+
+          back_x = tx - ux * PACKAGE_ANCHOR_H_BOTTOM
+          back_y = ty - uy * PACKAGE_ANCHOR_H_BOTTOM
+          tl_x = tx - ux * PACKAGE_ANCHOR_H_TOP + (-uy) * PACKAGE_ANCHOR_W
+          tl_y = ty - uy * PACKAGE_ANCHOR_H_TOP + ux * PACKAGE_ANCHOR_W
+          tr_x = tx - ux * PACKAGE_ANCHOR_H_TOP - (-uy) * PACKAGE_ANCHOR_W
+          tr_y = ty - uy * PACKAGE_ANCHOR_H_TOP - ux * PACKAGE_ANCHOR_W
+          bl_x = back_x + (-uy) * (PACKAGE_ANCHOR_W + 1)
+          bl_y = back_y + ux * (PACKAGE_ANCHOR_W + 1)
+          br_x = back_x - (-uy) * (PACKAGE_ANCHOR_W + 1)
+          br_y = back_y - ux * (PACKAGE_ANCHOR_W + 1)
+          d = "M #{Canvas.coord(tl_x)} #{Canvas.coord(tl_y)} " \
+              "L #{Canvas.coord(tr_x)} #{Canvas.coord(tr_y)} " \
+              "L #{Canvas.coord(br_x)} #{Canvas.coord(br_y)} " \
+              "L #{Canvas.coord(bl_x)} #{Canvas.coord(bl_y)} " \
+              "L #{Canvas.coord(tl_x)} #{Canvas.coord(tl_y)} Z"
+          %(<path d="#{d}" shape-rendering="auto"/>)
+        end
+
+        def unit_vector(tx, ty, bx, by)
+          dx = tx - bx
+          dy = ty - by
+          len = Math.sqrt(dx * dx + dy * dy)
+          return nil if len.zero?
+
+          [dx / len, dy / len]
+        end
+
+        def translate_point(p)
+          return p unless @canvas
+
+          [@canvas.translate_x(p[0]), @canvas.translate_y(p[1])]
+        end
+
+        def waypoint_pairs(connector)
+          (connector.waypoints || []).filter_map do |w|
+            next unless w.position
+
+            [w.position.x, w.position.y]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/render_context.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Per-element render context. Holds the immutable inputs each
+      # compartment renderer needs (bounds, classifier, fill/stroke,
+      # font, geometry, line data). Built once per element; passed
+      # to every compartment in the pipeline so they don't reach
+      # back into the parent Elements orchestrator.
+      #
+      # Value object: equality by structural attributes. Each
+      # instance is frozen after construction.
+      class RenderContext < Struct.new(
+        :element, :bounds, :model_element, :classifier,
+        :fill, :stroke, :stroke_width, :text_fill,
+        :family, :size, :size_unit,
+        :header_lines, :attr_lines, :op_lines,
+        :enum_literals, :tagged_values, :constraints,
+        :package_content_lines,
+        :geometry, :theme, :canvas, :diagram, :model_index,
+        :off_canvas_parent_name,
+        keyword_init: true
+      )
+        def note_body
+          return nil unless model_element.is_a?(Ea::Model::Note)
+
+          body = model_element.body
+          body.nil? || body.empty? ? nil : body
+        end
+
+        # Resolve a model element by id via the threaded model index.
+        # Returns nil when no index is wired in or the id is absent.
+        def model_index_for(id)
+          return nil unless model_index && id
+
+          model_index[id]
+        end
+
+        # Compartments below the header that produce a divider when
+        # any of them has content. Returns true when at least one
+        # is non-empty.
+        def content_below_header?
+          !attr_lines.empty? || !op_lines.empty? ||
+            enum_literals.any? || tagged_values.any? ||
+            (constraints&.any?) ||
+            (!package_content_lines.nil? && !package_content_lines.empty?)
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/style.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Centralizes SVG style strings used across emitters.
+      # Connector and marker styles are now computed dynamically
+      # via stroke_width parameter — only TEXT_GROUP remains as
+      # a constant (shared across all text-emitting renderers).
+      module Style
+        TEXT_GROUP = "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00"
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/text_renderer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Single source of truth for emitting `<text>` SVG elements.
+      # Handles:
+      #
+      # - Decimal `x`/`y` formatting (`%.2f`): matches EA's
+      #   `x="11.00" y="19.00"` encoding.
+      # - Always-present rotation transform: even when rotation is 0,
+      #   EA emits `transform="rotate(-0.00 X Y)"`.
+      # - Proper XML escaping of content.
+      # - Optional `textLength` integer (computed by caller).
+      #
+      # Replaces the duplicated `build_text` helpers across
+      # HeaderRenderer, AttributeRenderer, OperationRenderer,
+      # EnumerationLiteralRenderer, Labels, and DiagramFrame.
+      class TextRenderer
+        DEFAULT_FILL = "#000000"
+        DEFAULT_ROTATION = -0.00
+        DEFAULT_STROKE_IN_TEXT = "#000000"
+        DEFAULT_WIDTH_FACTOR = 0.65
+
+        attr_reader :content, :x, :y, :family, :size, :weight, :style,
+                    :fill, :text_length, :rotation, :size_unit,
+                    :stroke_in_text, :width_factor
+
+        def initialize(content:, x:, y:, family:, size:, weight: 400,
+                       style: "normal", fill: DEFAULT_FILL,
+                       text_length: nil, rotation: DEFAULT_ROTATION,
+                       size_unit: "px",
+                       stroke_in_text: DEFAULT_STROKE_IN_TEXT,
+                       width_factor: DEFAULT_WIDTH_FACTOR)
+          @content = content.to_s
+          @x = x
+          @y = y
+          @family = family
+          @size = size
+          @weight = weight
+          @style = style
+          @fill = fill
+          @text_length = text_length
+          @rotation = rotation
+          @size_unit = size_unit
+          @stroke_in_text = stroke_in_text
+          @width_factor = width_factor
+        end
+
+        def to_svg
+          attrs = format_attrs
+          style = format_style
+          %(<text #{attrs} textLength="#{formatted_text_length}" style="#{style}" xml:space="preserve" transform="#{formatted_transform}">#{escaped_content}</text>)
+        end
+
+        private
+
+        def format_attrs
+          %(x="#{format('%.2f', x)}" y="#{format('%.2f', y)}")
+        end
+
+        def format_style
+          "font-family:#{family}; font-weight:#{weight}; font-style:#{style}; font-size:#{size}#{size_unit}; fill:#{fill};fill-opacity:1.00; stroke:#{stroke_in_text}; stroke-opacity:0.00 stroke-width:0; white-space: pre;"
+        end
+
+        def self.estimate_width(text, size, width_factor = 0.65)
+          content = text.to_s
+          space_count = content.count(" ")
+          letter_count = content.length - space_count
+          letter_count * size * width_factor + space_count * size * 0.3
+        end
+
+        def formatted_text_length
+          return text_length.to_i.to_s if text_length
+
+          TextRenderer.estimate_width(content, size, width_factor).round.to_s
+        end
+
+        def formatted_transform
+          "rotate(#{format('%<r>.2f', r: rotation)} #{format('%.2f', x)} #{format('%.2f', y)})"
+        end
+
+        def escaped_content
+          content.gsub("&", "&amp;")
+                 .gsub("<", "&lt;")
+                 .gsub(">", "&gt;")
+                 .gsub("\"", "&quot;")
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    # EaEmitter orchestrates SVG output that mirrors EA's layering
+    # and naming conventions.
+    #
+    # Architecture:
+    #
+    #   Document (entry point)
+    #     └─ LayerSequencer (frame?, theme via diagram.theme)
+    #          ├─ Background
+    #          ├─ DiagramFrame (opt-in)
+    #          ├─ Elements → Element::* compartment renderers
+    #          ├─ Connectors → Layer
+    #          ├─ Markers → Marker::Registry (OCP) → Layer
+    #          └─ Labels → TextRenderer
+    #
+    #   Cross-cutting:
+    #     Canvas, BoundsCalculator, ColorResolver, FontResolver
+    #     Ea::Theme::Definition / Registry / Loader (domain-level)
+    #     TextRenderer, Style
+    #
+    # Theme is a top-level domain concept at Ea::Theme::*.
+    # See lib/ea/theme.rb for the full API.
+    #
+    module EaEmitter
+      autoload :Canvas, "ea/svg/ea_emitter/canvas"
+      autoload :Background, "ea/svg/ea_emitter/background"
+      autoload :BoundsCalculator, "ea/svg/ea_emitter/bounds_calculator"
+      autoload :Style, "ea/svg/ea_emitter/style"
+      autoload :Elements, "ea/svg/ea_emitter/elements"
+      autoload :Connectors, "ea/svg/ea_emitter/connectors"
+      autoload :Markers, "ea/svg/ea_emitter/markers"
+      autoload :Labels, "ea/svg/ea_emitter/labels"
+      autoload :GhostLabels, "ea/svg/ea_emitter/ghost_labels"
+      autoload :Layer, "ea/svg/ea_emitter/layer"
+      autoload :LayerSequencer, "ea/svg/ea_emitter/layer_sequencer"
+      autoload :FontResolver, "ea/svg/ea_emitter/font_resolver"
+      autoload :Marker, "ea/svg/ea_emitter/marker"
+      autoload :Element, "ea/svg/ea_emitter/element"
+      autoload :DiagramFrame, "ea/svg/ea_emitter/diagram_frame"
+      autoload :TextRenderer, "ea/svg/ea_emitter/text_renderer"
+      autoload :ColorResolver, "ea/svg/ea_emitter/color_resolver"
+      autoload :Document, "ea/svg/ea_emitter/document"
+      autoload :Label, "ea/svg/ea_emitter/label"
+      autoload :Compartment, "ea/svg/ea_emitter/compartment"
+      autoload :RenderContext, "ea/svg/ea_emitter/render_context"
+    end
+  end
+end