ea 0.3.0 → 0.4.0

data/lib/ea/model/diagram_connector.rb

@@ -5,15 +5,25 @@ module Ea
     # A connector drawn on a diagram between two DiagramElements.
     # References the underlying Relationship (by id) and the source
     # and target DiagramElements (by id). Carries ordered waypoints
-    # for routing.
+    # for routing plus the EA EDGE codes (1=top, 2=right, 3=bottom,
+    # 4=left, 5..8=diagonal variants) which tell the renderer where
+    # to anchor the line on each end.
     class DiagramConnector < Base
       attribute :diagram_id, :string
       attribute :relationship_ref, :string
       attribute :source_element_ref, :string
       attribute :target_element_ref, :string
+      attribute :source_duid, :string
+      attribute :target_duid, :string
+      attribute :source_edge, :integer
+      attribute :target_edge, :integer
       attribute :waypoints, Waypoint, collection: true, initialize_empty: true
       attribute :label, :string
       attribute :style, :hash, default: -> { {} }
+      attribute :line_color, :integer
+      attribute :line_width, :integer
+      attribute :hidden, :boolean
+      attribute :label_boxes, :hash, default: -> { {} }
 
       json do
         map "id", to: :id
@@ -21,9 +31,17 @@ module Ea
         map "relationshipRef", to: :relationship_ref
         map "sourceElementRef", to: :source_element_ref
         map "targetElementRef", to: :target_element_ref
+        map "sourceDuid", to: :source_duid
+        map "targetDuid", to: :target_duid
+        map "sourceEdge", to: :source_edge
+        map "targetEdge", to: :target_edge
         map "waypoints", to: :waypoints, render_empty: true
         map "label", to: :label
         map "style", to: :style
+        map "lineColor", to: :line_color
+        map "lineWidth", to: :line_width
+        map "hidden", to: :hidden, render_default: true
+        map "labelBoxes", to: :label_boxes
       end
     end
   end

data/lib/ea/model/diagram_element.rb

@@ -5,18 +5,46 @@ module Ea
     # A single placed element on a diagram. References the model
     # element it visualizes (by id), carries pixel bounds and a
     # parsed style map (fill color, line color, font, etc.).
+    #
+    # Carries two distinct bounds:
+    # - `bounds` — logical rect (EA's Left/Top/Right/Bottom)
+    # - `image_bounds` — visual rect including padding (EA's
+    #   imgL/imgT/imgR/imgB); used by EA's SVG renderer for the
+    #   actual `<rect>` width/height
     class DiagramElement < Base
       attribute :diagram_id, :string
       attribute :model_element_ref, :string # id of Classifier/Package/etc.
       attribute :bounds, Bounds
+      attribute :image_bounds, Bounds
       attribute :style, :hash, default: -> { {} } # parsed style fields
+      attribute :background_color, :integer # EA BGR integer
+      attribute :line_color, :integer
+      attribute :line_width, :integer
+      attribute :font_family, :string
+      attribute :font_size, :integer
+      attribute :font_bold, :boolean
+      attribute :font_italic, :boolean
+      attribute :font_underline, :boolean
+      attribute :z_order, :integer # seqno
+      attribute :duid, :string # EA's per-placement DUID for connector resolution
 
       json do
         map "id", to: :id
         map "diagramId", to: :diagram_id
         map "modelElementRef", to: :model_element_ref
         map "bounds", to: :bounds
+        map "imageBounds", to: :image_bounds
         map "style", to: :style
+        map "backgroundColor", to: :background_color
+        map "lineColor", to: :line_color
+        map "lineWidth", to: :line_width
+        map "fontFamily", to: :font_family
+        map "fontSize", to: :font_size
+        map "fontBold", to: :font_bold, render_default: true
+        map "fontItalic", to: :font_italic, render_default: true
+        map "fontUnderline", to: :font_underline, render_default: true
+        map "zOrder", to: :z_order
+        map "duid", to: :duid
       end
     end
   end

data/lib/ea/sources/qea/diagram_builder.rb

@@ -63,11 +63,113 @@ module Ea
                                        link_row.instance_id),
             diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
             relationship_ref: ref_for_connector(link_row),
-            waypoints: parse_waypoints(link_row.geometry),
+            waypoints: waypoints_for_link(link_row, diagram_row),
             style: DiagramStyleParser.parse(link_row.style)
           )
         end
 
+        # EA's t_diagramlinks.Geometry field stores connector routing
+        # in a packed format. The leading "X1,Y1,X2,Y2" pair (when
+        # present) is in a coordinate frame that does NOT match the
+        # element rect frame (elements use RectTop < RectBottom with
+        # negative y; geometry uses positive y). Rather than trust
+        # the stored absolute coords, we compute the polyline from
+        # the actual placed-element bounds + the SX/SY/EX/EY delta
+        # fields, which describe the bend routing relative to the
+        # element edges.
+        #
+        # If we can't resolve the source or target element placement
+        # for this diagram, we emit no waypoints (the connector will
+        # be invisible) — better than drawing garbage lines.
+        def waypoints_for_link(link_row, diagram_row)
+          connector = database.find_connector(link_row.connectorid)
+          return [] unless connector
+
+          source_placement = diagram_object_placement(diagram_row.diagram_id,
+                                                       connector.start_object_id)
+          target_placement = diagram_object_placement(diagram_row.diagram_id,
+                                                       connector.end_object_id)
+          return [] unless source_placement && target_placement
+
+          geom = parse_geometry_fields(link_row.geometry)
+          edge_out = geom[:edge] || 0
+
+          source_point = element_edge_point(source_placement, :source, edge_out)
+          target_point = element_edge_point(target_placement, :target, edge_out)
+          points = [source_point]
+          # SX/SY: delta from source point to first bend.
+          if geom[:sx] && geom[:sy] && (geom[:sx].nonzero? || geom[:sy].nonzero?)
+            points << [source_point[0] + geom[:sx], source_point[1] + geom[:sy]]
+          end
+          # EX/EY: delta from second bend to target point. Reverse
+          # to get from target back to the bend.
+          if geom[:ex] && geom[:ey] && (geom[:ex].nonzero? || geom[:ey].nonzero?)
+            points << [target_point[0] - geom[:ex], target_point[1] - geom[:ey]]
+          end
+          points << target_point
+
+          points.map do |x, y|
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+          end
+        end
+
+        # Parse the SX, SY, EX, EY, EDGE key=value pairs out of the
+        # geometry string. Each is `KEY=<int>;`. We deliberately do
+        # NOT extract the leading X1,Y1,X2,Y2 numbers because those
+        # are in a different coordinate frame (see note above).
+        def parse_geometry_fields(geometry)
+          return {} if geometry.nil? || geometry.empty?
+
+          s = geometry.to_s
+          {
+            sx: pick_int(s, /SX=(-?\d+)/),
+            sy: pick_int(s, /SY=(-?\d+)/),
+            ex: pick_int(s, /EX=(-?\d+)/),
+            ey: pick_int(s, /EY=(-?\d+)/),
+            edge: pick_int(s, /EDGE=(-?\d+)/)
+          }
+        end
+
+        def pick_int(str, pattern)
+          match = str.match(pattern)
+          return nil unless match
+
+          Integer(match[1])
+        rescue ArgumentError
+          nil
+        end
+
+        # Find where a given EA object is placed on this diagram.
+        def diagram_object_placement(diagram_id, ea_object_id)
+          objects = database.diagram_objects_for(diagram_id) || []
+          objects.find { |o| o.ea_object_id == ea_object_id }
+        end
+
+        # Compute the connection point on an element's edge for the
+        # given side. EA's `EDGE` field on t_diagramlinks tells us
+        # which edge the connector attaches to:
+        #   1 = top (source), 2 = right, 3 = bottom, 4 = left,
+        #   plus 5/6/7/8 for diagonals (treated as the cardinal here).
+        # We use the center of the chosen edge as the connection point.
+        def element_edge_point(placement, end_kind, edge_code)
+          b = bounds_from_rect(placement)
+          case effective_edge(edge_code, end_kind)
+          when :top    then [b.x + b.width / 2, b.y]
+          when :right  then [b.x + b.width, b.y + b.height / 2]
+          when :bottom then [b.x + b.width / 2, b.y + b.height]
+          when :left   then [b.x, b.y + b.height / 2]
+          else              [b.x + b.width / 2, b.y + b.height / 2]
+          end
+        end
+
+        def effective_edge(edge_code, end_kind)
+          mapping = {
+            1 => :top, 2 => :right, 3 => :bottom, 4 => :left,
+            5 => :top, 6 => :right, 7 => :bottom, 8 => :left
+          }
+          mapping[edge_code.to_i] || :center
+        end
+
         def package_id_for(diagram_row)
           pkg = database.find_package(diagram_row.package_id)
           return nil unless pkg
@@ -106,24 +208,6 @@ module Ea
 
           IdNormalizer.from_guid(conn.ea_guid)
         end
-
-        # EA stores connector geometry as a packed string of x,y
-        # pairs separated by semicolons and pipes. Conservative
-        # parse: extract digit pairs, take first/last as endpoints.
-        def parse_waypoints(geometry)
-          return [] if geometry.nil? || geometry.empty?
-
-          numbers = geometry.to_s.scan(/-?\d+/).map(&:to_i)
-          return [] if numbers.size < 4
-
-          numbers.each_slice(2).filter_map do |xy|
-            next nil if xy.size < 2
-
-            Ea::Model::Waypoint.new(
-              position: Ea::Model::Point.new(x: xy[0], y: xy[1])
-            )
-          end
-        end
       end
     end
   end

data/lib/ea/sources/xmi/annotation_builder.rb

@@ -23,7 +23,7 @@ module Ea
         end
 
         def self.from_comments(comments, owner_id, kind: "documentation")
-          Array(comments).map { |c| new(owner_id).build(kind, c.body) }
+          Array(comments).map { |c| new(owner_id).build(kind, c.body_element || c.body_attribute) }
         end
 
         def self.comments_on(element)

data/lib/ea/sources/xmi/diagram_builder.rb

@@ -3,10 +3,11 @@
 module Ea
   module Sources
     module Xmi
-      # Translates XMI uml:Diagram elements into Ea::Model::Diagram
-      # instances. Coordinates come from the UML-DI owned_element
-      # bounds; element references come from the model_element
-      # attribute.
+      # Translates EA diagrams from the XMI source into Ea::Model
+      # instances. Uses the rich placement data inside the
+      # <xmi:Extension> block (Left/Top/Right/Bottom, BCol, font,
+      # SOID/EOID, EDGE, label boxes) when present. Falls back to
+      # the UML-DI owned_element bounds otherwise.
       class DiagramBuilder
         attr_reader :root
 
@@ -15,67 +16,186 @@ module Ea
         end
 
         def build_all
-          diagrams = Array(root.model.diagram)
-          diagrams.map { |d| build_one(d) }
+          ext_diagrams = extension_diagrams
+          return [] if ext_diagrams.empty?
+
+          ext_diagrams.map { |d| build_one(d) }
+        end
+
+        # The XMI stores diagrams in two places:
+        # - root.model.diagram — UML-DI shape (often just one or none)
+        # - root.extension.diagrams.diagram — the rich EA extension
+        #   block with placement/style/connector data (the source of
+        #   truth for rendering).
+        # We use the extension block when present; fall back to UML-DI
+        # otherwise.
+        def extension_diagrams
+          ext = root.extension
+          return [] unless ext&.diagrams
+
+          ext.diagrams.diagram.to_a
         end
 
-        def build_one(diagram)
-          id = IdNormalizer.from_xmi_id(diagram.id)
-          ext_diagram = extension_diagram_for(id)
+        def build_one(ext_diagram)
+          id = IdNormalizer.from_xmi_id(ext_diagram.id)
+          ext_elements = ExtensionElements.new(ext_diagram)
+          placed_elements = ext_elements.placed_elements
+          placed_connectors = ext_elements.placed_connectors
+          props = ext_diagram.properties
+
           Ea::Model::Diagram.new(
             id: id,
-            name: ext_diagram&.properties&.name,
-            package_id: ext_diagram&.model&.package,
-            diagram_type: ext_diagram&.properties&.type&.split(":")&.last&.downcase,
-            bounds: bounds_for(diagram),
-            elements: build_elements(diagram, id),
-            connectors: [],
-            annotations: AnnotationBuilder.from_element(diagram, id)
+            name: props&.name || ext_diagram.id,
+            package_id: ext_diagram.model&.package,
+            diagram_type: props&.type&.split(":")&.last&.downcase,
+            bounds: canvas_bounds(placed_elements),
+            elements: build_elements(placed_elements, id),
+            connectors: build_connectors(placed_connectors,
+                                          placed_elements, id),
+            annotations: []
           )
         end
 
         private
 
-        def extension_diagram_for(diagram_id)
-          return nil unless root.extension&.diagrams
+        def canvas_bounds(placed_elements)
+          return nil if placed_elements.empty?
+
+          left = placed_elements.map { |e| e.geometry.img_left || e.geometry.left }.compact.min
+          top = placed_elements.map { |e| e.geometry.img_top || e.geometry.top }.compact.min
+          right = placed_elements.map { |e| e.geometry.img_right || e.geometry.right }.compact.max
+          bottom = placed_elements.map { |e| e.geometry.img_bottom || e.geometry.bottom }.compact.max
+          return nil unless left && top && right && bottom
 
-          root.extension.diagrams.diagram.find { |d| d.id == diagram_id }
+          Ea::Model::Bounds.new(x: 0, y: 0,
+                                 width: right - left,
+                                 height: bottom - top)
         end
 
-        def bounds_for(diagram)
-          first_bounds = diagram.owned_element.flat_map(&:bounds).first
-          return nil unless first_bounds
+        def build_elements(placed, owner_id)
+          placed.map { |p| build_element(p, owner_id) }
+        end
 
-          Ea::Model::Bounds.new(
-            x: first_bounds.x || 0,
-            y: first_bounds.y || 0,
-            width: first_bounds.width || 0,
-            height: first_bounds.height || 0
+        def build_element(placed, owner_id)
+          geom = placed.geometry
+          style = placed.style
+          Ea::Model::DiagramElement.new(
+            id: IdNormalizer.synthetic_id(owner_id, "elem", placed.subject),
+            diagram_id: owner_id,
+            model_element_ref: placed.subject,
+            bounds: build_bounds(geom.left, geom.top, geom.right, geom.bottom),
+            image_bounds: build_bounds(geom.img_left, geom.img_top, geom.img_right, geom.img_bottom),
+            background_color: style.background_color,
+            line_color: style.line_color,
+            line_width: style.line_width,
+            font_family: style.font_family,
+            font_size: style.font_size,
+            font_bold: style.bold,
+            font_italic: style.italic,
+            font_underline: style.underline,
+            z_order: placed.seqno,
+            duid: style.duid,
+            style: {}
           )
         end
 
-        def build_elements(diagram, owner_diagram_id)
-          diagram.owned_element.flat_map do |oe|
-            oe.bounds.each_with_index.map do |bnd, idx|
-              build_element(oe, bnd, owner_diagram_id, idx)
-            end
+        def build_bounds(left, top, right, bottom)
+          return nil unless left && top && right && bottom
+
+          Ea::Model::Bounds.new(x: left, y: top,
+                                 width: right - left,
+                                 height: bottom - top)
+        end
+
+        def build_connectors(placed_connectors, placed_elements, owner_id)
+          # Index elements by DUID so we can resolve SOID/EOID.
+          by_duid = placed_elements.each_with_object({}) do |pe, acc|
+            acc[pe.style.duid] = pe if pe.style.duid
           end
+
+          placed_connectors.map { |p| build_connector(p, by_duid, owner_id) }
         end
 
-        def build_element(owned_element, bounds, diagram_id, idx)
-          Ea::Model::DiagramElement.new(
-            id: IdNormalizer.synthetic_id(diagram_id, "elem", idx.to_s),
-            diagram_id: diagram_id,
-            model_element_ref: IdNormalizer.from_xmi_id(owned_element.model_element),
-            bounds: Ea::Model::Bounds.new(
-              x: bounds.x || 0,
-              y: bounds.y || 0,
-              width: bounds.width || 0,
-              height: bounds.height || 0
-            ),
-            style: {}
+        def build_connector(placed, by_duid, owner_id)
+          geom = placed.geometry
+          style = placed.style
+          source = by_duid[style.soid]
+          target = by_duid[style.eoid]
+          waypoints = compute_waypoints(geom, source, target)
+          Ea::Model::DiagramConnector.new(
+            id: IdNormalizer.synthetic_id(owner_id, "conn", placed.subject),
+            diagram_id: owner_id,
+            relationship_ref: placed.subject,
+            source_duid: style.soid,
+            target_duid: style.eoid,
+            source_element_ref: source && synthetic_element_id(owner_id, source),
+            target_element_ref: target && synthetic_element_id(owner_id, target),
+            source_edge: geom.edge,
+            target_edge: geom.edge,
+            waypoints: waypoints,
+            style: {},
+            line_color: style.color,
+            line_width: style.line_width,
+            hidden: style.hidden,
+            label_boxes: serialize_label_boxes(geom.label_boxes)
           )
         end
+
+        def synthetic_element_id(owner_id, placed)
+          IdNormalizer.synthetic_id(owner_id, "elem", placed.subject)
+        end
+
+        def compute_waypoints(geom, source, target)
+          src_pt = edge_point(source, geom.edge, :source)
+          tgt_pt = edge_point(target, geom.edge, :target)
+          return [] unless src_pt && tgt_pt
+
+          pts = [src_pt]
+          if geom.sx && geom.sy && (geom.sx.nonzero? || geom.sy.nonzero?)
+            pts << [src_pt[0] + geom.sx, src_pt[1] + geom.sy]
+          end
+          if geom.ex && geom.ey && (geom.ex.nonzero? || geom.ey.nonzero?)
+            pts << [tgt_pt[0] - geom.ex, tgt_pt[1] - geom.ey]
+          end
+          pts << tgt_pt
+          pts.map do |x, y|
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+          end
+        end
+
+        def edge_point(placed, edge_code, _end_kind)
+          return nil unless placed
+
+          geom = placed.geometry
+          left = geom.left
+          top = geom.top
+          right = geom.right
+          bottom = geom.bottom
+          return nil unless left && top && right && bottom
+
+          case edge_code
+          when 1 then [(left + right) / 2, top]      # top
+          when 2 then [right, (top + bottom) / 2]    # right
+          when 3 then [(left + right) / 2, bottom]   # bottom
+          when 4 then [left, (top + bottom) / 2]     # left
+          else [(left + right) / 2, (top + bottom) / 2]
+          end
+        end
+
+        def serialize_label_boxes(label_boxes)
+          return {} unless label_boxes
+
+          label_boxes.transform_values do |box|
+            {
+              "cx" => box.cx, "cy" => box.cy,
+              "ox" => box.ox, "oy" => box.oy,
+              "bold" => box.bold,
+              "italic" => box.italic,
+              "underline" => box.underline,
+              "align" => box.align
+            }
+          end
+        end
       end
     end
   end

data/lib/ea/sources/xmi/extension_elements.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Walks the <xmi:Extension>/<elements> block for a single
+      # EA diagram. Returns two arrays: placed elements and placed
+      # connectors, each carrying the parsed geometry + style data.
+      #
+      # The xmi gem exposes the raw rows via Sparx::Diagram::Elements.
+      # This class adds EA-aware parsing on top.
+      class ExtensionElements
+        attr_reader :diagram
+
+        def initialize(diagram)
+          @diagram = diagram
+        end
+
+        def placed_elements
+          rows.filter_map { |row| build_placed_element(row) }
+        end
+
+        def placed_connectors
+          rows.filter_map { |row| build_placed_connector(row) }
+        end
+
+        private
+
+        def rows
+          elements_collection = diagram&.elements
+          return [] unless elements_collection
+
+          elements_collection.element.to_a
+        end
+
+        def build_placed_element(row)
+          return nil unless row.subject
+
+          placement = ExtensionGeometryParser.parse(row.geometry)
+          return nil unless placement.left || placement.img_left
+
+          style = ExtensionStyleParser.parse(row.style)
+          PlacedElement.new(
+            subject: row.subject,
+            seqno: row.seqno,
+            geometry: placement,
+            style: style
+          )
+        end
+
+        def build_placed_connector(row)
+          return nil unless row.subject
+
+          placement = ExtensionGeometryParser.parse(row.geometry)
+          style = ExtensionStyleParser.parse(row.style)
+          # Connectors carry SOID/EOID in their style; geometry has
+          # only bend routing.
+          return nil unless style.soid && style.eoid
+
+          PlacedConnector.new(
+            subject: row.subject,
+            geometry: placement,
+            style: style
+          )
+        end
+
+        # Value types — the diagram builder translates these into
+        # Ea::Model::DiagramElement / DiagramConnector.
+        PlacedElement = Struct.new(:subject, :seqno, :geometry, :style, keyword_init: true)
+        PlacedConnector = Struct.new(:subject, :geometry, :style, keyword_init: true)
+      end
+    end
+  end
+end

data/lib/ea/sources/xmi/extension_geometry_parser.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Parses EA's packed geometry string from
+      # <xmi:Extension>/<elements>/<element>/@geometry. Returns a
+      # typed Placement struct with separate fields for placement
+      # and bend routing. Label boxes decoded into a Hash keyed by
+      # EA's role names (:llb, :llt, :lrt, :lrb).
+      module ExtensionGeometryParser
+        LABEL_BOX_KEYS = %i[llb llt lrt lrb lmt lmb irhs ilhs].freeze
+
+        module_function
+
+        def parse(geometry_string)
+          return Placement.new if geometry_string.nil? || geometry_string.empty?
+
+          kv = split_pairs(geometry_string)
+          Placement.new(
+            left: int(kv["Left"]),
+            top: int(kv["Top"]),
+            right: int(kv["Right"]),
+            bottom: int(kv["Bottom"]),
+            img_left: int(kv["imgL"]),
+            img_top: int(kv["imgT"]),
+            img_right: int(kv["imgR"]),
+            img_bottom: int(kv["imgB"]),
+            sx: int(kv["SX"]),
+            sy: int(kv["SY"]),
+            ex: int(kv["EX"]),
+            ey: int(kv["EY"]),
+            edge: int(kv["EDGE"]),
+            label_boxes: extract_label_boxes(geometry_string),
+            path: kv["Path"]
+          )
+        end
+
+        def split_pairs(str)
+          str.split(";").filter_map do |pair|
+            next nil unless pair.include?("=")
+            next nil if pair.start_with?("$") # $LLB= etc handled separately
+
+            key, value = pair.split("=", 2)
+            [key, value] if key && value
+          end.to_h
+        end
+
+        def int(value)
+          return nil if value.nil? || value.empty?
+
+          Integer(value)
+        rescue ArgumentError
+          nil
+        end
+
+        def extract_label_boxes(geometry_string)
+          geometry_string.to_s.scan(/\$?([A-Z]{3})=((?:[A-Za-z]{1,4}=-?\d+:)+)/).each_with_object({}) do |(key, body), acc|
+            sym = key.downcase.to_sym
+            next unless LABEL_BOX_KEYS.include?(sym)
+            next if body.nil? || body.empty?
+
+            acc[sym] = parse_label_body(body)
+          end
+        end
+
+        def parse_label_body(body)
+          pairs = body.to_s.split(":").filter_map do |pair|
+            next nil unless pair.include?("=")
+
+            k, v = pair.split("=", 2)
+            [k, int(v)] if k && v
+          end
+          hash = pairs.to_h
+          LabelBox.new(
+            cx: hash["CX"],
+            cy: hash["CY"],
+            ox: hash["OX"],
+            oy: hash["OY"],
+            bold: hash["BLD"] == 1,
+            italic: hash["ITA"] == 1,
+            underline: hash["UND"] == 1,
+            hidden: hash["HDN"] == 1,
+            align: hash["ALN"],
+            direction: hash["DIR"],
+            rotation: hash["ROT"]
+          )
+        end
+
+        Placement = Struct.new(
+          :left, :top, :right, :bottom,
+          :img_left, :img_top, :img_right, :img_bottom,
+          :sx, :sy, :ex, :ey, :edge,
+          :label_boxes, :path,
+          keyword_init: true
+        )
+
+        LabelBox = Struct.new(
+          :cx, :cy, :ox, :oy,
+          :bold, :italic, :underline, :hidden,
+          :align, :direction, :rotation,
+          keyword_init: true
+        )
+      end
+    end
+  end
+end