ea 0.4.0 → 0.5.1

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

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Pure parser for EA's `t_xref.Description` mini-language.
+        # Stateless — every call returns a fresh `Xref::Record`.
+        #
+        # Supported formats:
+        #   @STEREO;Name=X;FQName=Y;@ENDSTEREO;
+        #   @PROP=@NAME=..@ENDNAME;@TYPE=..@ENDTYPE;@VALU=..@ENDVALU;@PRMT=..@ENDPRMT;@ENDPROP;
+        #   <key>=<value>;<key>=<value>;
+        #
+        # Unknown formats fall through to key=value parsing.
+        module Parser
+          module_function
+
+          # Parse one Description string into a typed Record.
+          # @param description [String, nil]
+          # @return [Ea::Sources::Qea::Xref::Record]
+          def parse(description)
+            return Record.new if description.nil? || description.empty?
+
+            Record.new(
+              stereotype: parse_stereotype(description),
+              properties: parse_properties(description),
+              legends: parse_legends(description),
+              key_values: parse_key_values(description),
+              raw: description
+            )
+          end
+
+          # -- per-format extractors ----------------------------------
+
+          # Matches both legacy `@STEREO;Name=X;GUID={..};` and the
+          # plateau form `@STEREO;Name=X;FQName=Y;@ENDSTEREO;`.
+          STEREO_REGEX = /
+            @STEREO;
+            (.*?)
+            (?:@ENDSTEREO;|\z)
+          /mx.freeze
+
+          def parse_stereotype(description)
+            match = description.match(STEREO_REGEX)
+            return nil unless match
+
+            fields = parse_semicolon_fields(match[1])
+            StereotypeApplication.new(
+              name: fields["Name"],
+              fqname: fields["FQName"]
+            )
+          end
+
+          # One Description can carry multiple @PROP=...@ENDPROP; blocks.
+          # Split, then classify each as PropertyDefinition or LegendDefinition.
+          PROP_REGEX = /
+            @PROP=
+            (.*?)
+            @ENDPROP;
+          /mx.freeze
+
+          def parse_properties(description)
+            blocks = description.scan(PROP_REGEX).flatten
+            blocks.each_with_object([]) do |block, acc|
+              record = build_prop_record(block)
+              acc << record if record
+            end
+          end
+
+          def parse_legends(description)
+            parse_properties(description).select do |prop|
+              prop.is_a?(LegendDefinition)
+            end
+          end
+
+          def build_prop_record(block)
+            name = extract_tagged_value(block, "NAME")
+            type = extract_tagged_value(block, "TYPE")
+            value = extract_tagged_value(block, "VALU")
+            parameter = extract_tagged_value(block, "PRMT")
+
+            if type&.start_with?("LEGEND_")
+              LegendDefinition.new(
+                name: name,
+                legend_type: type,
+                colors: parse_color_value(value),
+                parameter: parameter
+              )
+            else
+              PropertyDefinition.new(
+                name: name,
+                type: type,
+                value: value,
+                parameter: parameter
+              )
+            end
+          end
+
+          # Extracts the content between @TAG=...@ENDTAG; markers.
+          # Returns nil when the tag is absent.
+          def extract_tagged_value(block, tag)
+            pattern = /@#{tag}=(.*?)@END#{tag};/m.freeze
+            match = block.match(pattern)
+            match ? match[1] : nil
+          end
+
+          # EA encodes legend VALU as `#key#=value;` pairs.
+          # Returns a hash keyed by underscored symbol.
+          def parse_color_value(value)
+            return {} if value.nil? || value.empty?
+
+            value.scan(/#([^#=]+)#=([^;]*);/).each_with_object({}) do |(k, v), acc|
+              acc[k.downcase.to_sym] = v
+            end
+          end
+
+          # Legacy `Key=Value;Key=Value;` parsing. Skips content that
+          # looks like @STEREO or @PROP blocks to avoid noise.
+          def parse_key_values(description)
+            stripped = description
+                       .gsub(/@STEREO;.*?(?:@ENDSTEREO;|\z)/m, "")
+                       .gsub(/@PROP=.*?@ENDPROP;/m, "")
+            pairs = stripped.split(";").map { |s| s.split("=", 2) }
+            pairs.each_with_object({}) do |(k, v), acc|
+              next if k.nil? || k.empty? || v.nil?
+
+              acc[k.downcase.to_sym] = v
+            end
+          end
+
+          # Parse `Key=Value;Key=value;` into a string-keyed hash.
+          # Used internally for the @STEREO body fields.
+          def parse_semicolon_fields(body)
+            body.split(";").each_with_object({}) do |part, acc|
+              key, value = part.split("=", 2)
+              next if key.nil? || key.empty? || value.nil?
+
+              # Strip @END* terminators that may be attached when the
+              # body wasn't cleanly split (defensive — usually already
+              # consumed by STEREO_REGEX).
+              cleaned = value.sub(/@END\w+\z/, "")
+              acc[key] = cleaned
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Tagged-value / property definition record. Produced when the
+        # Description contains one or more `@PROP=@NAME=..@ENDNAME;`
+        # blocks for non-legend properties.
+        #
+        # Example source:
+        #   @PROP=@NAME=isActive@ENDNAME;@TYPE=Boolean@ENDTYPE;
+        #         @VALU=@ENDVALU;@PRMT=@ENDPRMT;@ENDPROP;
+        PropertyDefinition = Struct.new(:name, :type, :value, :parameter,
+                                        keyword_init: true) do
+          # @return [Boolean] true when the value field is non-empty
+          def default_value?
+            !value.nil? && !value.empty?
+          end
+
+          # @return [Boolean] true when the property is declared as Boolean
+          def boolean?
+            type == "Boolean"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Parsed t_xref.Description. Holds typed records for each block
+        # found in the source string. One Description can carry multiple
+        # records (e.g., several `@PROP=` blocks defining a stereotype's
+        # tagged-value set).
+        #
+        # Consumers branch on record type without re-parsing strings.
+        Record = Struct.new(:stereotype, :properties, :legends,
+                            :key_values, :raw, keyword_init: true) do
+          def initialize(*)
+            super
+            self.properties ||= []
+            self.legends ||= []
+            self.key_values ||= {}
+          end
+
+          # @return [Boolean] true when a stereotype application is present
+          def stereotype?
+            !stereotype.nil?
+          end
+
+          # @return [Boolean] true when at least one legend is present
+          def legend?
+            !legends.empty?
+          end
+
+          # Convenience: first legend's name (the legend's title).
+          # @return [String, nil]
+          def legend_title
+            legends.first&.name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Stereotype application record. Produced when the Description
+        # starts with `@STEREO;`. Captures the short name and the
+        # fully-qualified `tech::Stereo` form when present.
+        #
+        # Example source:
+        #   @STEREO;Name=FeatureType;FQName=GML::FeatureType;@ENDSTEREO;
+        StereotypeApplication = Struct.new(:name, :fqname, keyword_init: true) do
+          # Returns the technology prefix from FQName, or nil.
+          # @return [String, nil]
+          def technology
+            return nil unless fqname
+
+            idx = fqname.index("::")
+            idx ? fqname[0, idx] : nil
+          end
+
+          # Returns the stereotype name without technology prefix.
+          # Falls back to +name+ when FQName is absent.
+          # @return [String, nil]
+          def unqualified_name
+            if fqname && fqname.include?("::")
+              fqname.split("::", 2).last
+            else
+              name
+            end
+          end
+        end
+      end
+    end
+  end
+end