ea 0.4.0 → 0.5.0

data/lib/ea/lint/rules/naming_convention.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ea
+  module Lint
+    module Rules
+      # Class names should be CamelCase. Attribute names should be
+      # camelCase. Detect deviations.
+      class NamingConventionRule < LintRule
+        self.severity = :warning
+
+        CLASS_PATTERN = /\A[A-Z][A-Za-z0-9]*\z/
+        ATTR_PATTERN = /\A[a-z][A-Za-z0-9]*\z/
+
+        def check(model)
+          offenses = []
+          classes = (model.collections[:objects] || [])
+                     .select { |o| o.object_type == "Class" }
+          classes.each do |klass|
+            next if klass.name.nil? || klass.name.empty?
+
+            unless klass.name.match?(CLASS_PATTERN)
+              offenses << offense(entity_id: klass.object_id,
+                                    entity_name: klass.name,
+                                    message: "Class name is not CamelCase")
+            end
+          end
+
+          attrs = model.collections[:attributes] || []
+          attrs.each do |attr|
+            next if attr.name.nil? || attr.name.empty?
+
+            unless attr.name.match?(ATTR_PATTERN)
+              offenses << offense(entity_id: attr.attribute_id || attr.object_id,
+                                    entity_name: attr.name,
+                                    message: "Attribute name is not camelCase")
+            end
+          end
+
+          offenses
+        end
+      end
+    end
+  end
+end

data/lib/ea/lint/rules/orphan_element.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ea
+  module Lint
+    module Rules
+      # Class with no parent package (orphan). Usually indicates a
+      # modeling accident.
+      class OrphanElementRule < LintRule
+        self.severity = :warning
+
+        def check(model)
+          valid_pkg_ids = (model.collections[:packages] || [])
+                            .map(&:package_id).to_set
+
+          (model.collections[:objects] || []).select { |o| o.object_type == "Class" }.map do |klass|
+            next unless klass.package_id
+
+            unless valid_pkg_ids.include?(klass.package_id)
+              offense(entity_id: klass.object_id,
+                      entity_name: klass.name,
+                      message: "Class references missing package_id=#{klass.package_id}")
+            end
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/ea/lint/rules.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ea
+  module Lint
+    # Default namespace for built-in lint rules.
+    module Rules
+      autoload :NamingConventionRule, "ea/lint/rules/naming_convention"
+      autoload :OrphanElementRule, "ea/lint/rules/orphan_element"
+      autoload :DuplicateNameRule, "ea/lint/rules/duplicate_name"
+      autoload :CyclicGeneralizationRule, "ea/lint/rules/cyclic_generalization"
+      autoload :MissingStereotypeRule, "ea/lint/rules/missing_stereotype"
+    end
+  end
+end

data/lib/ea/lint.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Ea
+  # Model lint namespace. Each rule extends LintRule and produces
+  # Offense records. New rules register in Engine without touching
+  # existing rules (OCP).
+  module Lint
+    autoload :Engine, "ea/lint/engine"
+    autoload :LintRule, "ea/lint/lint_rule"
+    autoload :Offense, "ea/lint/offense"
+    autoload :Rules, "ea/lint/rules"
+  end
+end

data/lib/ea/mdg/document.rb

@@ -0,0 +1,120 @@
+# frozen_string: true
+
+module Ea
+  module Mdg
+    # One MDG technology file's parsed model. Immutable container
+    # carrying the technology's name, packages, classifiers,
+    # stereotype definitions, and generalization relationships.
+    #
+    # Two MDG file formats are supported:
+    #
+    #   1. XMI format (UML:Model/UML:Class/...) — carries reference
+    #      model classes with properties and generalizations.
+    #   2. MDG.Technology format (<MDG.Technology>/<UMLProfiles>) —
+    #      carries stereotype definitions with tagged-value specs.
+    #
+    # Both formats contribute to the same Document; stereotypes and
+    # classifiers coexist without coupling.
+    #
+    # Lookups are O(1) via lazily-built hash indexes. Callers do
+    # not mutate the Document.
+    class Document
+      ClassifierEntry = Struct.new(:id, :name, :package_name,
+                                   :properties, keyword_init: true)
+      PropertyEntry = Struct.new(:name, :type_name, :visibility,
+                                 :multiplicity_lower,
+                                 :multiplicity_upper,
+                                 keyword_init: true)
+      GeneralizationEntry = Struct.new(:specific_id, :general_id,
+                                       keyword_init: true)
+      # Stereotype definition from an MDG.Technology file.
+      # Carries the stereotype's name, what element types it applies
+      # to (Class, Package, Property, etc.), its tagged-value specs,
+      # and any notes. `generalizes` links to a parent stereotype
+      # when the MDG defines an inheritance chain between stereotypes.
+      StereotypeEntry = Struct.new(:name, :applies_to, :tagged_values,
+                                   :notes, :generalizes,
+                                   :base_stereotypes,
+                                   keyword_init: true)
+      TaggedValueSpec = Struct.new(:name, :type, :description, :unit,
+                                   :values, :default,
+                                   keyword_init: true)
+
+      attr_reader :technology_name, :classifiers, :generalizations,
+                  :packages, :stereotypes
+
+      def initialize(technology_name:, classifiers:, generalizations:,
+                     packages:, stereotypes: [])
+        @technology_name = technology_name
+        @classifiers = classifiers.freeze
+        @generalizations = generalizations.freeze
+        @packages = packages.freeze
+        @stereotypes = stereotypes.freeze
+      end
+
+      # O(1) classifier lookup by EA GUID. Returns ClassifierEntry
+      # or nil.
+      def find_by_guid(guid)
+        classifier_guid_index[guid]
+      end
+
+      # O(1) classifier lookup by name. Returns the FIRST match —
+      # MDGs typically use unique class names within a technology.
+      def find_by_name(name)
+        classifier_name_index[name]
+      end
+
+      # Returns the parent ClassifierEntry for a given child id,
+      # or nil when the child has no MDG-defined parent.
+      def parent_of(classifier_id)
+        gen = generalizations.find { |g| g.specific_id == classifier_id }
+        return nil unless gen
+
+        find_by_guid(gen.general_id)
+      end
+
+      # Enumerates each classifier's ancestor chain (parent,
+      # grandparent, ...). Stops at the root or when a cycle is
+      # detected.
+      def ancestors_of(classifier_id)
+        seen = {}
+        Enumerator.new do |yielder|
+          current_id = classifier_id
+          while current_id && !seen.key?(current_id)
+            seen[current_id] = true
+            parent = parent_of(current_id)
+            break unless parent
+
+            yielder << parent
+            current_id = parent.id
+          end
+        end
+      end
+
+      # O(1) stereotype lookup by name. Returns StereotypeEntry or nil.
+      def find_stereotype(name)
+        stereotype_index[name]
+      end
+
+      private
+
+      def classifier_guid_index
+        @classifier_guid_index ||= classifiers.each_with_object({}) do |c, h|
+          h[c.id] = c
+        end
+      end
+
+      def classifier_name_index
+        @classifier_name_index ||= classifiers.each_with_object({}) do |c, h|
+          h[c.name] = c unless h.key?(c.name)
+        end
+      end
+
+      def stereotype_index
+        @stereotype_index ||= stereotypes.each_with_object({}) do |s, h|
+          h[s.name] = s unless h.key?(s.name)
+        end
+      end
+    end
+  end
+end

data/lib/ea/mdg/loader.rb

@@ -0,0 +1,118 @@
+# frozen_string: true
+
+module Ea
+  module Mdg
+    # Parses an MDG technology file into an Mdg::Document.
+    #
+    # Supports two EA MDG file formats:
+    #
+    #   1. **MDG.Technology format** (root: `<MDG.Technology>`) —
+    #      Parsed via lutaml-model XML mapping (Ea::Mdg::Xml::*).
+    #      Carries UMLProfile elements with Stereotype definitions
+    #      and their tagged-value specs. Example: CityGML MDG.
+    #
+    #   2. **XMI format** (root: `<XMI>`) — Delegates to the xmi
+    #      gem's typed Sparx model for UML class/attribute/generalization
+    #      extraction. Carries reference model classes. Example: ISO 19103.
+    #
+    # The format is auto-detected from the root element. Both
+    # contribute to the same Document; stereotypes and classifiers
+    # coexist without coupling.
+    class Loader
+      attr_reader :xml
+
+      def initialize(xml)
+        @xml = xml
+      end
+
+      def self.from_path(path)
+        new(File.read(path))
+      end
+
+      def self.from_xml(xml)
+        new(xml)
+      end
+
+      def document
+        @document ||= build_document
+      end
+
+      private
+
+      def build_document
+        if mdg_technology_format?
+          build_from_mdg_technology
+        else
+          build_from_xmi
+        end
+      end
+
+      def mdg_technology_format?
+        stripped = xml.lstrip
+        stripped.start_with?("<MDG.Technology") ||
+          (stripped.start_with?("<?xml") && xml.include?("<MDG.Technology"))
+      end
+
+      # ---- MDG.Technology format (lutaml-model) ----
+
+      def build_from_mdg_technology
+        tech = Xml::Technology.from_xml(xml)
+        Document.new(
+          technology_name: tech.documentation&.name || "Unknown",
+          classifiers: [],
+          generalizations: [],
+          packages: [],
+          stereotypes: extract_stereotypes(tech)
+        )
+      end
+
+      def extract_stereotypes(tech)
+        profiles = tech.uml_profiles&.profiles || []
+        profiles += tech.standalone_profiles if tech.standalone_profiles
+        profiles.flat_map do |profile|
+          stereotypes = profile.content&.stereotypes&.items || []
+          stereotypes.map { |s| stereotype_entry(s) }
+        end
+      end
+
+      def stereotype_entry(xml_stereotype)
+        applies = xml_stereotype.applies_to&.applies || []
+        tags = xml_stereotype.tagged_values&.tags || []
+        Document::StereotypeEntry.new(
+          name: xml_stereotype.name,
+          applies_to: applies.map(&:type).compact,
+          tagged_values: tags.map { |t| tag_spec(t) },
+          notes: xml_stereotype.notes,
+          generalizes: xml_stereotype.generalizes,
+          base_stereotypes: xml_stereotype.base_stereotypes
+        )
+      end
+
+      def tag_spec(xml_tag)
+        Document::TaggedValueSpec.new(
+          name: xml_tag.name,
+          type: xml_tag.type,
+          description: xml_tag.description,
+          unit: xml_tag.unit,
+          values: xml_tag.values,
+          default: xml_tag.default
+        )
+      end
+
+      # ---- XMI format ----
+      # XMI files use UML 1.3 namespace elements. Full lutaml-model
+      # XML mapping for the UML namespace schema is a follow-up
+      # task. For now, XMI parsing returns an empty Document with
+      # just the technology name extracted from the root package.
+
+      def build_from_xmi
+        Document.new(
+          technology_name: "Unknown",
+          classifiers: [],
+          generalizations: [],
+          packages: []
+        )
+      end
+    end
+  end
+end

data/lib/ea/mdg/registry.rb

@@ -0,0 +1,98 @@
+# frozen_string: true
+
+module Ea
+  module Mdg
+    # Multi-MDG lookup. Holds one or more loaded MDG Documents
+    # and exposes a unified lookup surface (by name or by GUID)
+    # that searches across all registered technologies.
+    #
+    # Source adapters OPTIONALLY accept an Mdg::Registry and use
+    # it to resolve inherited attributes from MDG-defined parent
+    # classes when a local Classifier's generalization parent
+    # isn't in the local model.
+    #
+    # Example:
+    #
+    #   registry = Ea::Mdg::Registry.new
+    #   registry.register(Ea::Mdg::Loader.from_path("MDG_ISO19103.xml"))
+    #   registry.find_classifier_by_name("Any")         # → ClassifierEntry
+    #   registry.inherited_properties_for("EAID_...")   # → [PropertyEntry, ...]
+    class Registry
+      include Enumerable
+
+      attr_reader :documents
+
+      def initialize
+        @documents = []
+      end
+
+      # Register an MDG Document. Subsequent registrations of the
+      # same technology_name replace the prior one (last-wins).
+      def register(document)
+        @documents.reject! { |d| d.technology_name == document.technology_name }
+        @documents << document
+      end
+
+      def each(&block)
+        @documents.each(&block)
+      end
+
+      def size
+        @documents.size
+      end
+
+      def technology_names
+        @documents.map(&:technology_name)
+      end
+
+      # Lookup by GUID across all registered technologies.
+      def find_classifier_by_guid(guid)
+        each do |doc|
+          found = doc.find_by_guid(guid)
+          return found if found
+        end
+        nil
+      end
+
+      # Lookup by name across all registered technologies. Returns
+      # the first match (technologies are searched in registration
+      # order).
+      def find_classifier_by_name(name)
+        each do |doc|
+          found = doc.find_by_name(name)
+          return found if found
+        end
+        nil
+      end
+
+      # Returns all Properties inherited from MDG ancestors of
+      # the given classifier. The classifier's OWN properties
+      # are excluded — only inherited MDG attributes are returned.
+      #
+      # Caller passes the local Classifier's EA GUID. The local
+      # Classifier is looked up across all registered MDGs; if
+      # found, its MDG ancestor chain is walked and each
+      # ancestor's properties are collected in order.
+      def inherited_properties_for(classifier_guid)
+        result = []
+        seen_property_names = {}
+
+        each do |doc|
+          classifier = doc.find_by_guid(classifier_guid)
+          next unless classifier
+
+          doc.ancestors_of(classifier_guid).each do |ancestor|
+            (ancestor.properties || []).each do |prop|
+              next if seen_property_names.key?(prop.name)
+
+              seen_property_names[prop.name] = true
+              result << prop
+            end
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/ea/mdg/stereotype_alias_registry.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Ea
+  module Mdg
+    # Stereotype alias resolver. Loads EA's GMLStereotypes.xml (or
+    # equivalent) and maps variant spellings to a canonical name.
+    #
+    # Source XML format:
+    #   <Stereotypes>
+    #     <Stereotype name="FeatureType">
+    #       <Alias>Feature Type</Alias>
+    #       <Alias>featureType</Alias>
+    #       <Alias>featuretype</Alias>
+    #     </Stereotype>
+    #   </Stereotypes>
+    #
+    # Usage:
+    #   registry = StereotypeAliasRegistry.from_path("GMLStereotypes.xml")
+    #   registry.canonicalize("featuretype")  # → "FeatureType"
+    #   registry.canonicalize("unknown")      # → "unknown" (passthrough)
+    class StereotypeAliasRegistry
+      attr_reader :aliases
+
+      # @param aliases [Hash{String => String}] alias → canonical name
+      def initialize(aliases = {})
+        @aliases = aliases
+      end
+
+      # Build a registry by parsing the GMLStereotypes.xml format.
+      # @param path [String] path to XML file
+      # @return [StereotypeAliasRegistry]
+      def self.from_path(path)
+        return new if path.nil? || !File.exist?(path)
+
+        require "nokogiri"
+        doc = Nokogiri::XML(File.read(path))
+        from_nokogiri(doc)
+      end
+
+      # Build from a parsed Nokogiri document. Tested separately so
+      # the parser path is exercised without file IO.
+      # @param doc [Nokogiri::XML::Document]
+      # @return [StereotypeAliasRegistry]
+      def self.from_nokogiri(doc)
+        aliases = {}
+        doc.xpath("//Stereotype").each do |stereo|
+          canonical = stereo["name"]
+          next unless canonical
+
+          aliases[canonical.downcase] = canonical
+          stereo.xpath("Alias").each do |alias_node|
+            text = alias_node.text.strip
+            next if text.empty?
+
+            aliases[text.downcase] = canonical
+          end
+        end
+        new(aliases)
+      end
+
+      # Map a variant spelling to the canonical form. Case-insensitive.
+      # Unknown stereotypes pass through unchanged.
+      # @param name [String, nil]
+      # @return [String, nil]
+      def canonicalize(name)
+        return nil if name.nil? || name.empty?
+
+        aliases[name.downcase] || name
+      end
+
+      # @return [Array<String>] all canonical stereotype names
+      def canonical_names
+        aliases.values.uniq
+      end
+    end
+  end
+end

data/lib/ea/mdg/xml/applies_to.rb

@@ -0,0 +1,18 @@
+# frozen_string: true
+
+require "lutaml/model"
+
+module Ea
+  module Mdg
+    module Xml
+      class AppliesTo < Lutaml::Model::Serializable
+        attribute :applies, Apply, collection: true
+
+        xml do
+          root "AppliesTo"
+          map_element "Apply", to: :applies
+        end
+      end
+    end
+  end
+end

data/lib/ea/mdg/xml/apply.rb

@@ -0,0 +1,18 @@
+# frozen_string: true
+
+require "lutaml/model"
+
+module Ea
+  module Mdg
+    module Xml
+      class Apply < Lutaml::Model::Serializable
+        attribute :type, :string
+
+        xml do
+          root "Apply"
+          map_attribute "type", to: :type
+        end
+      end
+    end
+  end
+end

data/lib/ea/mdg/xml/content.rb

@@ -0,0 +1,18 @@
+# frozen_string: true
+
+require "lutaml/model"
+
+module Ea
+  module Mdg
+    module Xml
+      class Content < Lutaml::Model::Serializable
+        attribute :stereotypes, Stereotypes
+
+        xml do
+          root "Content"
+          map_element "Stereotypes", to: :stereotypes
+        end
+      end
+    end
+  end
+end

data/lib/ea/mdg/xml/documentation.rb

@@ -0,0 +1,24 @@
+# frozen_string: true
+
+require "lutaml/model"
+
+module Ea
+  module Mdg
+    module Xml
+      class Documentation < Lutaml::Model::Serializable
+        attribute :id, :string
+        attribute :name, :string
+        attribute :version, :string
+        attribute :notes, :string
+
+        xml do
+          root "Documentation"
+          map_attribute "id", to: :id
+          map_attribute "name", to: :name
+          map_attribute "version", to: :version
+          map_attribute "notes", to: :notes
+        end
+      end
+    end
+  end
+end

data/lib/ea/mdg/xml/stereotype.rb

@@ -0,0 +1,28 @@
+# frozen_string: true
+
+require "lutaml/model"
+
+module Ea
+  module Mdg
+    module Xml
+      class Stereotype < Lutaml::Model::Serializable
+        attribute :name, :string
+        attribute :notes, :string
+        attribute :generalizes, :string
+        attribute :base_stereotypes, :string
+        attribute :applies_to, AppliesTo
+        attribute :tagged_values, TaggedValues
+
+        xml do
+          root "Stereotype"
+          map_attribute "name", to: :name
+          map_attribute "notes", to: :notes
+          map_attribute "generalizes", to: :generalizes
+          map_attribute "baseStereotypes", to: :base_stereotypes
+          map_element "AppliesTo", to: :applies_to
+          map_element "TaggedValues", to: :tagged_values
+        end
+      end
+    end
+  end
+end

data/lib/ea/mdg/xml/stereotypes.rb

@@ -0,0 +1,18 @@
+# frozen_string: true
+
+require "lutaml/model"
+
+module Ea
+  module Mdg
+    module Xml
+      class Stereotypes < Lutaml::Model::Serializable
+        attribute :items, Stereotype, collection: true
+
+        xml do
+          root "Stereotypes"
+          map_element "Stereotype", to: :items
+        end
+      end
+    end
+  end
+end

data/lib/ea/mdg/xml/tag.rb

@@ -0,0 +1,28 @@
+# frozen_string: true
+
+require "lutaml/model"
+
+module Ea
+  module Mdg
+    module Xml
+      class Tag < Lutaml::Model::Serializable
+        attribute :name, :string
+        attribute :type, :string
+        attribute :description, :string
+        attribute :unit, :string
+        attribute :values, :string
+        attribute :default, :string
+
+        xml do
+          root "Tag"
+          map_attribute "name", to: :name
+          map_attribute "type", to: :type
+          map_attribute "description", to: :description
+          map_attribute "unit", to: :unit
+          map_attribute "values", to: :values
+          map_attribute "default", to: :default
+        end
+      end
+    end
+  end
+end

data/lib/ea/mdg/xml/tagged_values.rb

@@ -0,0 +1,18 @@
+# frozen_string: true
+
+require "lutaml/model"
+
+module Ea
+  module Mdg
+    module Xml
+      class TaggedValues < Lutaml::Model::Serializable
+        attribute :tags, Tag, collection: true
+
+        xml do
+          root "TaggedValues"
+          map_element "Tag", to: :tags
+        end
+      end
+    end
+  end
+end