ea 0.4.0 → 0.5.0

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

@@ -5,7 +5,12 @@ module Ea
     module Qea
       # Normalizes EA's identifier formats into stable strings used
       # as Ea::Model element ids. EA represents identity as
-      # `{GUID}` strings. We strip the braces to give the bare GUID.
+      # `{GUID}` strings.
+      #
+      # Two output formats:
+      # - `from_guid` — bare GUID without braces (canonical model id)
+      # - `to_eaid` — `EAID_<guid with dashes-to-underscores>` matching
+      #   the reference SVG filename convention
       module IdNormalizer
         module_function
 
@@ -15,6 +20,15 @@ module Ea
           ea_guid.to_s.gsub(/[{}]/, "")
         end
 
+        # Convert a GUID to the EAID_ filename format used by EA's
+        # SVG export: strip braces, replace dashes with underscores,
+        # prefix with EAID_.
+        def to_eaid(ea_guid)
+          return nil if ea_guid.nil? || ea_guid.empty?
+
+          "EAID_" + ea_guid.to_s.gsub(/[{}]/, "").tr("-", "_")
+        end
+
         def synthetic(prefix, *parts)
           "#{prefix}:#{parts.join(":")}"
         end
@@ -22,3 +36,4 @@ module Ea
     end
   end
 end
+

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Translates EA t_object rows of Object_Type="Object" into
+      # Ea::Model::InstanceSpecification instances. Slots are parsed
+      # from the RunState field, which uses a packed format:
+      #
+      #   @VAR;Variable=name;Value=val;Op===;@ENDVAR;@VAR;...
+      #
+      # Each @VAR...@ENDVAR block is one Slot.
+      class InstanceBuilder
+        RUN_STATE_PATTERN = /
+          @VAR;
+          (?:Variable=(?<name>[^;]*);)?
+          (?:Value=(?<value>[^;]*);)?
+          (?:Op=(?<op>[^;]*);)?
+          @ENDVAR;
+        /x.freeze
+
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def build_all
+          objects = database.collections[:objects] || []
+          objects.filter_map { |row| build_one(row) if instance?(row) }
+        end
+
+        def build_one(row)
+          Ea::Model::InstanceSpecification.new(
+            id: IdNormalizer.from_guid(row.ea_guid),
+            name: row.name.to_s,
+            classifier_id: classifier_id_for(row),
+            classifier_name: classifier_name_for(row),
+            package_id: package_id_for(row),
+            package_name: package_name_for(row),
+            qualified_name: qualified_name_for(row),
+            slots: slots_for(row),
+            annotations: AnnotationBuilder.from_note(row.note, row.ea_guid,
+                                                      kind: "documentation")
+          )
+        end
+
+        private
+
+        def instance?(row)
+          row.object_type == "Object"
+        end
+
+        def classifier_id_for(row)
+          classifier = database.find_object(row.classifier.to_i) if row.classifier&.to_i&.positive?
+          return nil unless classifier
+
+          IdNormalizer.from_guid(classifier.ea_guid)
+        end
+
+        def classifier_name_for(row)
+          classifier = database.find_object(row.classifier.to_i) if row.classifier&.to_i&.positive?
+          return nil unless classifier
+
+          classifier.name.to_s
+        end
+
+        def package_id_for(row)
+          return nil unless row.package_id&.to_i&.positive?
+
+          pkg = database.find_package(row.package_id.to_i)
+          return nil unless pkg
+
+          IdNormalizer.from_guid(pkg.ea_guid)
+        end
+
+        def package_name_for(row)
+          return nil unless row.package_id&.to_i&.positive?
+
+          pkg = database.find_package(row.package_id.to_i)
+          pkg&.name
+        end
+
+        # EA's t_object.Name may carry a qualified name with a ":"
+        # prefix (e.g. "gml:CodeType"). When the instance is in a
+        # nested package the qualified name uses the package path.
+        def qualified_name_for(row)
+          name = row.name.to_s
+          return name if name.empty?
+
+          pkg_name = package_name_for(row)
+          pkg_name ? "#{pkg_name}::#{name}" : name
+        end
+
+        # Parse the RunState field into Slot instances. Each
+        # @VAR;Variable=X;Value=Y;Op=Z;@ENDVAR; is one slot.
+        # When Op is absent we default to "=".
+        def slots_for(row)
+          run_state = row.runstate.to_s
+          return [] if run_state.empty?
+
+          run_state.scan(RUN_STATE_PATTERN).map do |(name, value, op)|
+            Ea::Model::Slot.new(
+              name: name.to_s,
+              value: value.to_s,
+              op: (op.to_s.empty? ? "=" : op)
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Builds an `Ea::Model::Legend` for a Text element by parsing
+      # the sibling `t_xref` row of name="CustomProperties" on the
+      # same GUID. EA encodes legend configuration in the xref's
+      # Description field using `@PROP=...@ENDPROP;` blocks, one
+      # per item plus one for the title (`LEGEND_STYLE_SETTINGS`).
+      #
+      # Returns nil when no matching xref exists (the Text element
+      # is not a legend — caller should render it as a plain note).
+      class LegendBuilder
+        LEGEND_XREF_NAME = "CustomProperties"
+        LEGEND_TYPE_OBJECT_STYLE = "LEGEND_OBJECTSTYLE"
+        LEGEND_TYPE_STYLE_SETTINGS = "LEGEND_STYLE_SETTINGS"
+
+        PROP_PATTERN = /
+          @PROP=
+          @NAME=(?<name>[^@]*?)@ENDNAME;
+          @TYPE=(?<type>[^@]*?)@ENDTYPE;
+          @VALU=(?<value>[^@]*?)@ENDVALU;
+          (?:@PRMT=(?<prmt>[^@]*?)@ENDPRMT;)?
+          @ENDPROP;
+        /x.freeze
+
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def build_for(ea_guid)
+          description = legend_description_for(ea_guid)
+          return nil unless description
+
+          build_from_description(description)
+        end
+
+        private
+
+        def legend_description_for(ea_guid)
+          xref = database.xrefs_for_client(ea_guid).find { |row| row.name == LEGEND_XREF_NAME }
+          return nil unless xref
+
+          xref.description
+        end
+
+        def build_from_description(description)
+          props = description.scan(PROP_PATTERN)
+          return nil if props.empty?
+
+          items = items_from(props)
+          style = style_settings_from(props)
+
+          build_legend(items: items, style: style)
+        end
+
+        def items_from(props)
+          props.select { |_, type, _, _| type == LEGEND_TYPE_OBJECT_STYLE }
+               .each_with_index
+               .map do |(name, _, value, prmt), display_index|
+                 build_item(name: name, value: value, prmt: prmt,
+                            display_index: display_index)
+               end
+        end
+
+        def style_settings_from(props)
+          entry = props.find { |_, type, _, _| type == LEGEND_TYPE_STYLE_SETTINGS }
+          return {} unless entry
+
+          parse_kv(entry[2])
+        end
+
+        def build_legend(items:, style:)
+          Ea::Model::Legend.new(
+            title: style["TITLE"] || Ea::Model::Legend::DEFAULT_TITLE,
+            heading_size: int_or_nil(style["HEADINGSIZE"]),
+            font_color: int_or(style["FONTCOLOR"],
+                               Ea::Model::Legend::DEFAULT_FONT_COLOR),
+            background_color: int_or(style["BACKGROUNDCOLOR"],
+                                     Ea::Model::Legend::DEFAULT_BACKGROUND_COLOR),
+            border_color: int_or(style["BORDERCOLOR"],
+                                 Ea::Model::Legend::DEFAULT_BORDER_COLOR),
+            background_is_default: background_is_default?(style),
+            items: items
+          )
+        end
+
+        def build_item(name:, value:, prmt:, display_index:)
+          attrs = parse_kv(value)
+          Ea::Model::LegendItem.new(
+            name: name.to_s,
+            background_color: int_or(attrs["Back_Ground_Color"], 0),
+            pen_color: int_or(attrs["Pen_Color"], 0),
+            pen_size: int_or(attrs["Pen_Size"], 1),
+            sort_index: int_or(prmt, display_index)
+          )
+        end
+
+        # EA packs key=value pairs as `#KEY#=VAL;` inside the @VALU
+        # payload. Both KEY and VAL are delimited by `#` or `;`.
+        def parse_kv(payload)
+          return {} if payload.nil? || payload.empty?
+
+          payload.to_s.split(";").each_with_object({}) do |pair, hash|
+            key, val = pair.split("=", 2)
+            next unless key && val
+            next if val.empty?
+
+            hash[key.delete("#")] = val
+          end
+        end
+
+        def background_is_default?(style)
+          value = style["BACKGROUNDISDEFAULT"]
+          return true if value.nil?
+
+          value == "1" || value.to_s.downcase == "true"
+        end
+
+        def int_or(raw, fallback)
+          Integer(raw.to_s)
+        rescue ArgumentError, TypeError
+          fallback
+        end
+
+        def int_or_nil(raw)
+          Integer(raw.to_s)
+        rescue ArgumentError, TypeError
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Extracts Note elements from EA's t_object table. Notes have
+      # object_type="Note" and are filtered out by ClassifierBuilder.
+      # Their body text lives in t_object.Note; the diagram renderer
+      # emits them as dog-eared rects with the body wrapped inside.
+      #
+      # Text elements (object_type="Text") with LegendOpts= in
+      # StyleEx are auto-generated legend blocks rather than notes;
+      # their configuration is parsed from t_xref and attached as
+      # an `Ea::Model::Legend` payload on the Note.
+      class NoteBuilder
+        NOTE_OBJECT_TYPE = "Note".freeze
+        TEXT_OBJECT_TYPE = "Text".freeze
+        LEGEND_STYLEEX_TOKEN = "LegendOpts=".freeze
+
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def build_all
+          objects = database.collections[:objects] || []
+          objects.filter_map { |obj| build_one(obj) }
+        end
+
+        private
+
+        def build_one(obj)
+          return nil unless note_type?(obj.object_type)
+
+          Ea::Model::Note.new(
+            id: IdNormalizer.from_guid(obj.ea_guid),
+            name: obj.name,
+            body: obj.note,
+            note_type: obj.object_type,
+            legend: legend_for(obj)
+          )
+        end
+
+        def note_type?(object_type)
+          object_type == NOTE_OBJECT_TYPE || object_type == TEXT_OBJECT_TYPE
+        end
+
+        def legend_for(obj)
+          return nil unless obj.object_type == TEXT_OBJECT_TYPE
+          return nil unless obj.styleex.to_s.include?(LEGEND_STYLEEX_TOKEN)
+
+          LegendBuilder.new(database).build_for(obj.ea_guid)
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,12 @@ module Ea
           "Enumeration" => "Ea::Model::Enumeration",
           "Interface" => "Ea::Model::Interface",
           "PrimitiveType" => "Ea::Model::PrimitiveType",
-          "Primitive" => "Ea::Model::PrimitiveType"
+          "Primitive" => "Ea::Model::PrimitiveType",
+          "Signal" => "Ea::Model::Signal",
+          # EA "Object" rows are UML InstanceSpecifications. We
+          # don't yet model InstanceSpecification as a distinct
+          # class — they render like a simple named Klass.
+          "Object" => "Ea::Model::Klass"
         }.freeze
 
         def class_for(object_type)

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

@@ -27,6 +27,7 @@ module Ea
             visibility: visibility_from_scope(row.scope),
             is_static: boolean(row.isstatic),
             is_abstract: boolean(row.abstract),
+            is_reception: row.reception?,
             parameters: build_parameters(row),
             annotations: AnnotationBuilder.from_note(row.notes, row.ea_guid,
                                                      kind: "documentation")

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

@@ -24,6 +24,7 @@ module Ea
             name: pkg.name,
             parent_id: parent_id_for(pkg),
             qualified_name: pkg.xmlpath,
+            stereotype_refs: stereotype_refs_for(pkg),
             annotations: AnnotationBuilder.from_note(pkg.notes, pkg.ea_guid)
           )
         end
@@ -38,6 +39,21 @@ module Ea
 
           IdNormalizer.from_guid(parent.ea_guid)
         end
+
+        # EA stores the package's applied stereotype on the t_object
+        # row that mirrors the t_package entry (matched by ea_guid).
+        # t_package itself has no Stereotype column — only t_object
+        # does. Returns [] when no t_object row exists or no
+        # stereotype is set.
+        def stereotype_refs_for(pkg)
+          obj = database.find_object_by_guid(pkg.ea_guid)
+          return [] unless obj
+
+          stereotype = obj.stereotype
+          return [] if stereotype.nil? || stereotype.to_s.empty?
+
+          [stereotype.to_s]
+        end
       end
     end
   end

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

@@ -22,6 +22,7 @@ module Ea
           klass = ConnectorRelationshipMap.class_for(row.connector_type)
           args = common_args(row)
           args.merge!(association_args(row)) if klass == Ea::Model::Association
+          args.merge!(generalization_args(row)) if klass == Ea::Model::Generalization
           klass.new(**args)
         end
 
@@ -32,11 +33,23 @@ module Ea
             id: IdNormalizer.from_guid(row.ea_guid),
             name: row.name,
             qualified_name: row.name,
+            stereotype: row.stereotype,
             annotations: AnnotationBuilder.from_note(row.notes, row.ea_guid,
                                                      kind: "documentation")
           }
         end
 
+        # EA's Generalization connector points from the specific
+        # (child) to the general (parent): Start_Object_ID is the
+        # child, End_Object_ID is the parent. Direction is
+        # conventionally "Source -> Destination".
+        def generalization_args(row)
+          {
+            specific_id: id_for_object_id(row.start_object_id),
+            general_id: id_for_object_id(row.end_object_id)
+          }
+        end
+
         def association_args(row)
           {
             source_id: id_for_object_id(row.start_object_id),
@@ -63,19 +76,22 @@ module Ea
           IdNormalizer.from_guid(obj.ea_guid)
         end
 
+        # Returns nil when cardinality is absent so the renderer can
+        # distinguish "no multiplicity specified" from an explicit
+        # "1". EA only renders the "1" label when the modeller set it
+        # explicitly (SourceCard/DestCard = "1").
         def parse_lower(cardinality)
-          return 1 if cardinality.nil? || cardinality.empty?
+          return nil if cardinality.nil? || cardinality.empty?
 
-          # EA format: "1", "0..*", "1..1", etc. Take the first number.
           begin
             Integer(cardinality.split("..").first)
           rescue StandardError
-            1
+            nil
           end
         end
 
         def parse_upper(cardinality)
-          return 1 if cardinality.nil? || cardinality.empty?
+          return nil if cardinality.nil? || cardinality.empty?
 
           upper = cardinality.split("..").last
           return -1 if upper == "*"
@@ -83,7 +99,7 @@ module Ea
           begin
             Integer(upper)
           rescue StandardError
-            1
+            nil
           end
         end
 

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

@@ -4,9 +4,11 @@ module Ea
   module Sources
     module Qea
       # Builds Ea::Model::TaggedValue instances from EA's
-      # t_objectproperties (and t_attributetags for attribute-level
-      # tagged values). Each row is one key/value pair; we keep the
-      # optional stereotype scope if EA recorded one.
+      # t_taggedvalue AND t_objectproperties tables. EA stores UML
+      # profile tagged values in t_taggedvalue (keyed by ElementID
+      # GUID), and per-object custom properties in t_objectproperties
+      # (keyed by Object_ID integer). Both surface as tagged values
+      # in the SVG output and merge into one list per classifier.
       class TaggedValueBuilder
         attr_reader :database
 
@@ -14,21 +16,38 @@ module Ea
           @database = database
         end
 
-        def for_object(ea_guid)
+        # Build tagged values for an EA object. Pass both the
+        # GUID (for t_taggedvalue lookups) and the integer EA
+        # Object_ID (for t_objectproperties lookups).
+        def for_object(ea_guid, ea_object_id: nil)
           rows = database.tagged_values_for_element(ea_guid) || []
-          rows.map { |row| build_from_row(row, ea_guid) }
+          tv = rows.map { |row| build_from_tagged_value(row, ea_guid) }
+          return tv unless ea_object_id
+
+          prop_rows = database.properties_for_object(ea_object_id) || []
+          tv + prop_rows.map { |row| build_from_object_property(row) }
         end
 
         def for_attribute(attribute_row)
-          return [] unless attribute_row.respond_to?(:ea_guid)
+          return [] unless attribute_row.is_a?(Ea::Qea::Models::EaAttribute)
 
           rows = database.tagged_values_for_element(attribute_row.ea_guid) || []
-          rows.map { |row| build_from_row(row, attribute_row.ea_guid) }
+          rows.map { |row| build_from_tagged_value(row, attribute_row.ea_guid) }
+        end
+
+        def build_from_tagged_value(row, owner_guid)
+          Ea::Model::TaggedValue.new(
+            id: IdNormalizer.synthetic("tv", owner_guid,
+                                       row.tag&.gsub(/\W+/, "_")),
+            key: row.tag,
+            value: row.value
+          )
         end
 
-        def build_from_row(row, owner_guid)
+        def build_from_object_property(row)
           Ea::Model::TaggedValue.new(
-            id: IdNormalizer.synthetic("tv", owner_guid, row.property&.gsub(/\W+/, "_")),
+            id: IdNormalizer.synthetic("op", row.ea_object_id.to_s,
+                                       row.property&.gsub(/\W+/, "_")),
             key: row.property,
             value: row.value
           )

data/lib/ea/sources/qea/xref/legend_definition.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Legend definition record. Produced when the Description contains
+        # `@PROP=` blocks with `@TYPE=LEGEND_*`. EA encodes legend
+        # entries as color/style rules keyed by name.
+        #
+        # Example source:
+        #   @PROP=@NAME=GMLに定義されたクラス@ENDNAME;
+        #         @TYPE=LEGEND_OBJECTSTYLE@ENDTYPE;
+        #         @VALU=#Back_Ground_Color#=13434828;#Pen_Color#=0;
+        #               #Pen_Size#=1;#Legend_Type#=LEGEND_OBJECTSTYLE;
+        #               @ENDVALU;@PRMT=0@ENDPRMT;@ENDPROP;
+        LegendDefinition = Struct.new(:name, :legend_type, :colors,
+                                      :parameter, keyword_init: true) do
+          # EA encodes colors as signed 32-bit integers (VB-style).
+          # Convert to `#RRGGBB` hex string for SVG consumption.
+          # @param key [Symbol] color key, e.g. :back_ground_color
+          # @return [String, nil] hex color (`#RRGGBB`) or nil
+          def hex_color(key)
+            value = colors&.dig(key)
+            return nil if value.nil?
+
+            int = value.to_i
+            int = (int + 2**32) % 2**32 if int.negative?
+            format("#%06X", int & 0xFFFFFF)
+          end
+        end
+      end
+    end
+  end
+end