ea 0.4.0 → 0.5.0

data/lib/ea/model/relationship.rb

@@ -8,12 +8,14 @@ module Ea
     # consumers dispatch without `is_a?` ladders.
     class Relationship < Base
       attribute :qualified_name, :string
+      attribute :stereotype, :string
       attribute :relationship_kind, :string, default: -> { "relationship" }
 
       json do
         map "id", to: :id
         map "name", to: :name
         map "qualifiedName", to: :qualified_name
+        map "stereotype", to: :stereotype
         map "relationshipKind", to: :relationship_kind, render_default: true
       end
     end

data/lib/ea/model/signal.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # UML Signal: a classifier whose instances represent
+    # asynchronous communications between objects. Distinct from
+    # Klass because EA renders its header with the «signal»
+    # stereotype fallback and supports a separate "receptions"
+    # compartment.
+    class Signal < Classifier
+      attribute :model_kind, :string, default: -> { "signal" }
+    end
+  end
+end

data/lib/ea/model/slot.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A single slot (variable = value) on an InstanceSpecification.
+    class Slot < Base
+      attribute :name, :string
+      attribute :value, :string
+      attribute :op, :string, default: -> { "=" }
+
+      json do
+        map "id", to: :id
+        map "name", to: :name
+        map "value", to: :value
+        map "op", to: :op
+      end
+    end
+  end
+end

data/lib/ea/model.rb

@@ -23,17 +23,25 @@ module Ea
     autoload :Waypoint, "ea/model/waypoint"
     autoload :Annotation, "ea/model/annotation"
     autoload :TaggedValue, "ea/model/tagged_value"
+    autoload :Constraint, "ea/model/constraint"
+    autoload :Slot, "ea/model/slot"
+    autoload :InstanceSpecification, "ea/model/instance_specification"
     autoload :Stereotype, "ea/model/stereotype"
     autoload :EnumerationLiteral, "ea/model/enumeration_literal"
     autoload :Parameter, "ea/model/parameter"
     autoload :Property, "ea/model/property"
     autoload :Operation, "ea/model/operation"
+    autoload :Note, "ea/model/note"
+    autoload :Legend, "ea/model/legend"
+    autoload :LegendItem, "ea/model/legend_item"
+    autoload :GhostLabel, "ea/model/ghost_label"
     autoload :Classifier, "ea/model/classifier"
     autoload :Klass, "ea/model/klass"
     autoload :DataType, "ea/model/data_type"
     autoload :PrimitiveType, "ea/model/primitive_type"
     autoload :Interface, "ea/model/interface"
     autoload :Enumeration, "ea/model/enumeration"
+    autoload :Signal, "ea/model/signal"
     autoload :Package, "ea/model/package"
     autoload :Relationship, "ea/model/relationship"
     autoload :Association, "ea/model/association"

data/lib/ea/ocl/evaluator.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Ea
+  module Ocl
+    # Evaluates an AST produced by Parser against a context object
+    # (the model element under test). Dispatches on node class.
+    module Evaluator
+      module_function
+
+      # @param ast [Nodes::*]
+      # @param context [Object] the model element (self)
+      # @return [Boolean, Object] result of evaluation
+      def evaluate(ast, context)
+        case ast
+        when Nodes::Literal then ast.value
+        when Nodes::AttributeAccess then attribute_value(context, ast.name)
+        when Nodes::StringMatches then eval_string_matches(ast, context)
+        when Nodes::CollectionExists then eval_exists(ast, context)
+        when Nodes::CollectionForAll then eval_for_all(ast, context)
+        when Nodes::BinaryOp then eval_binary(ast, context)
+        when Nodes::UnaryOp then eval_unary(ast, context)
+        else
+          raise UnsupportedError,
+                "Cannot evaluate AST node: #{ast.class}"
+        end
+      end
+
+      def attribute_value(context, name)
+        return nil unless context
+
+        context.public_send(name)
+      end
+
+      def eval_string_matches(ast, context)
+        target = evaluate(ast.string, context).to_s
+        Regexp.new(ast.pattern).match?(target)
+      end
+
+      def eval_exists(ast, context)
+        collection = evaluate(ast.collection, context)
+        return false unless collection.respond_to?(:each)
+
+        var_name = ast.var
+        predicate = ast.predicate
+        collection.any? do |element|
+          evaluate(predicate, var_binding(context, var_name, element))
+        end
+      end
+
+      def eval_for_all(ast, context)
+        collection = evaluate(ast.collection, context)
+        return true unless collection.respond_to?(:each)
+
+        var_name = ast.var
+        predicate = ast.predicate
+        collection.all? do |element|
+          evaluate(predicate, var_binding(context, var_name, element))
+        end
+      end
+
+      def eval_binary(ast, context)
+        left = evaluate(ast.left, context)
+        right = evaluate(ast.right, context)
+        case ast.op
+        when :and then left && right
+        when :or then left || right
+        else raise UnsupportedError, "Unknown binary op: #{ast.op}"
+        end
+      end
+
+      def eval_unary(ast, context)
+        case ast.op
+        when :not then !evaluate(ast.operand, context)
+        else raise UnsupportedError, "Unknown unary op: #{ast.op}"
+        end
+      end
+
+      # Bind a variable name in the evaluation context. Uses a small
+      # Struct wrapper so attribute lookups still fall through to the
+      # original context.
+      VarBinding = Struct.new(:context, :var_name, :value, keyword_init: true) do
+        def public_send(method_name, *args)
+          return value if method_name == var_name
+
+          context.public_send(method_name, *args)
+        end
+      end
+
+      def var_binding(context, var_name, value)
+        VarBinding.new(context: context, var_name: var_name, value: value)
+      end
+    end
+  end
+end

data/lib/ea/ocl/nodes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ea
+  module Ocl
+    # AST node types for the parser. Each is a small Struct that the
+    # Evaluator dispatches on by class.
+    module Nodes
+      # `self.<attr>` access — read attribute on the context object.
+      AttributeAccess = Struct.new(:name, keyword_init: true)
+
+      # Literal value (number, string, boolean).
+      Literal = Struct.new(:value, keyword_init: true)
+
+      # `<collection>->exists(var | <pred>)` — true if any element matches.
+      CollectionExists = Struct.new(:collection, :var, :predicate,
+                                    keyword_init: true)
+
+      # `<collection>->forAll(var | <pred>)` — true if all match.
+      CollectionForAll = Struct.new(:collection, :var, :predicate,
+                                    keyword_init: true)
+
+      # `<string>.matches('<regex>')`
+      StringMatches = Struct.new(:string, :pattern, keyword_init: true)
+
+      # `<a> and <b>`, `<a> or <b>`, `not <a>`
+      BinaryOp = Struct.new(:op, :left, :right, keyword_init: true)
+      UnaryOp = Struct.new(:op, :operand, keyword_init: true)
+    end
+  end
+end

data/lib/ea/ocl/parser.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Ea
+  module Ocl
+    # Tokenizer + parser for an OCL invariant subset. Returns an AST
+    # built from Nodes::* structs.
+    #
+    # Supported forms:
+    #   inv: <expr>
+    #   self.<attr>
+    #   "<literal>"
+    #   <collection>->exists(x | <pred>)
+    #   <collection>->forAll(x | <pred>)
+    #   <string>.matches('<regex>')
+    #   <expr> and <expr>
+    #   <expr> or <expr>
+    #   not <expr>
+    module Parser
+      module_function
+
+      # @param source [String] OCL expression with optional `inv:` prefix
+      # @return [Array<Nodes::*>] AST nodes (one per top-level expression)
+      def parse(source)
+        return [] if source.nil? || source.empty?
+
+        body = strip_inv_prefix(source)
+        parse_expression(body)
+      end
+
+      def strip_inv_prefix(source)
+        s = source.strip
+        s.sub(/\Ainv\s*:\s*/, "")
+      end
+
+      # Parse one expression. Returns a single AST node.
+      def parse_expression(source)
+        s = source.strip
+
+        # Strip outer parens
+        s = s[1..-2].strip while s.start_with?("(") && s.end_with?(")")
+
+        # 'not <expr>'
+        if s.start_with?("not ")
+          return Nodes::UnaryOp.new(op: :not,
+                                    operand: parse_expression(s[4..]))
+        end
+
+        # 'and' / 'or' at top level (find the operator not inside parens)
+        if (split = split_on_logical_op(s))
+          op, left, right = split
+          return Nodes::BinaryOp.new(op: op,
+                                     left: parse_expression(left),
+                                     right: parse_expression(right))
+        end
+
+        # Collection ->exists(...) or ->forAll(...)
+        if (m = s.match(/^(.+?)->(exists|forAll)\s*\(\s*(\w+)\s*\|\s*(.+?)\s*\)\z/))
+          return collection_node(m[2].to_sym, m[1], m[3], m[4])
+        end
+
+        # String.matches('regex')
+        if (m = s.match(/^(.+?)\.matches\(\s*['"](.+?)['"]\s*\)\z/))
+          return Nodes::StringMatches.new(string: parse_expression(m[1]),
+                                          pattern: m[2])
+        end
+
+        # Boolean literal — check BEFORE bare identifier
+        return Nodes::Literal.new(value: true) if s == "true"
+        return Nodes::Literal.new(value: false) if s == "false"
+
+        # Numeric literal
+        return Nodes::Literal.new(value: s.to_i) if s.match?(/\A-?\d+\z/)
+        return Nodes::Literal.new(value: s.to_f) if s.match?(/\A-?\d+\.\d+\z/)
+
+        # String literal
+        return Nodes::Literal.new(value: s[1..-2]) if s.match?(/\A['"].*['"]\z/)
+
+        # 'self.<attr>' or '<var>.<attr>' — both produce AttributeAccess.
+        if (m = s.match(/\A(?:self\.|[a-z_]\w*\.)([a-z_]\w*)\z/i))
+          return Nodes::AttributeAccess.new(name: m[1])
+        end
+
+        # Bare identifier — variable reference.
+        if (m = s.match(/\A([a-z_]\w*)\z/))
+          return Nodes::AttributeAccess.new(name: m[1])
+        end
+
+        raise UnsupportedError,
+              "Unsupported OCL expression: #{source.inspect}"
+      end
+
+      def collection_node(kind, collection_src, var, pred_src)
+        Nodes.const_get(kind == :exists ? :CollectionExists : :CollectionForAll)
+             .new(collection: parse_expression(collection_src),
+                  var: var,
+                  predicate: parse_expression(pred_src))
+      end
+
+      # Find the topmost ` and ` or ` or ` outside of parens.
+      # Returns [op, left_str, right_str] or nil.
+      def split_on_logical_op(source)
+        depth = 0
+        # Look for ' or ' first (lower precedence than 'and' in OCL?)
+        # Actually OCL: 'or' < 'xor' < 'and' < 'implies'. We pick the
+        # rightmost top-level operator (left-associative).
+        %i[and or].each do |op|
+          keyword = " #{op} "
+          idx = find_top_level(source, keyword)
+          next unless idx
+
+          return [op, source[0...idx], source[(idx + keyword.length)..]]
+        end
+        nil
+      end
+
+      # Find substring at depth 0 (not inside parens).
+      def find_top_level(source, substring)
+        depth = 0
+        i = 0
+        while i < source.length
+          c = source[i]
+          depth += 1 if c == "("
+          depth -= 1 if c == ")"
+          if depth.zero? && source[i, substring.length] == substring
+            return i
+          end
+          i += 1
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/ea/ocl/unsupported_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ea
+  module Ocl
+    class UnsupportedError < Ea::Error; end
+  end
+end

data/lib/ea/ocl.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Ea
+  # OCL (Object Constraint Language) parser + evaluator namespace.
+  # Supports a subset of OCL invariant syntax sufficient for
+  # evaluating common EA constraints.
+  module Ocl
+    autoload :Parser, "ea/ocl/parser"
+    autoload :Evaluator, "ea/ocl/evaluator"
+    autoload :Nodes, "ea/ocl/nodes"
+    autoload :UnsupportedError, "ea/ocl/unsupported_error"
+  end
+end

data/lib/ea/qea/factory/document_builder.rb

@@ -246,7 +246,7 @@ module Ea
         # @param valid_ids [Set<String>] Set of valid xmi_ids
         # @return [Boolean] True if valid or nil
         def check_association_end_valid?(assoc, attr, valid_ids)
-          value = assoc.public_send(attr)
+          value = association_end_xmi_id(assoc, attr)
           return true if value.nil?
 
           valid_ids.include?(value)
@@ -258,20 +258,34 @@ module Ea
         # @param valid_ids [Set<String>] Set of valid xmi_ids
         # @param warnings [Array<String>] Warning accumulator
         def add_invalid_end_warning(assoc, attr, valid_ids, warnings) # rubocop:disable Metrics/MethodLength
-          value = assoc.public_send(attr)
+          value = association_end_xmi_id(assoc, attr)
           return if value.nil?
 
           unless valid_ids.include?(value)
-            # Get the corresponding name attribute for better error messages
-            name_attr = attr.to_s.gsub("_xmi_id", "").to_sym
-            name_value = begin
-              assoc.public_send(name_attr)
-            rescue StandardError
-              nil
-            end
+            name_value = association_end_name(assoc, attr)
 
             warnings << "Association #{assoc.xmi_id} references " \
-                        "invalid #{name_attr}: #{name_value}"
+                        "invalid #{attr}: #{name_value}"
+          end
+        end
+
+        # Explicit dispatch for association end xmi_id attributes.
+        # Replaces dynamic `public_send(attr)` with a case statement
+        # so callers and types are statically known.
+        def association_end_xmi_id(assoc, attr)
+          case attr
+          when :member_end_xmi_id then assoc.member_end_xmi_id
+          when :owner_end_xmi_id then assoc.owner_end_xmi_id
+          else raise ArgumentError, "unknown association end: #{attr}"
+          end
+        end
+
+        # Explicit dispatch for association end display-name attributes.
+        def association_end_name(assoc, attr)
+          case attr
+          when :member_end_xmi_id then assoc.member_end
+          when :owner_end_xmi_id then assoc.owner_end
+          else raise ArgumentError, "unknown association end: #{attr}"
           end
         end
 

data/lib/ea/qea/factory/generalization_builder.rb

@@ -53,20 +53,18 @@ module Ea
         end
 
         def to_general_attribute(attr)
-          base = base_attr_hash(attr)
-          Lutaml::Uml::GeneralAttribute.new.tap do |gen_attr|
-            base.each { |k, v| gen_attr.public_send(:"#{k}=", v) }
-            gen_attr.is_derived = !!attr.is_derived
-            gen_attr.has_association = !!attr.association
-          end
+          Lutaml::Uml::GeneralAttribute.new(
+            **base_attr_hash(attr),
+            is_derived: !!attr.is_derived,
+            has_association: !!attr.association
+          )
         end
 
         def to_top_element_attribute(attr)
-          base = base_attr_hash(attr)
-          Lutaml::Uml::TopElementAttribute.new.tap do |top_attr|
-            base.each { |k, v| top_attr.public_send(:"#{k}=", v) }
-            top_attr.is_derived = !!attr.is_derived
-          end
+          Lutaml::Uml::TopElementAttribute.new(
+            **base_attr_hash(attr),
+            is_derived: !!attr.is_derived
+          )
         end
 
         def base_attr_hash(attr)

data/lib/ea/qea/infrastructure/table_reader.rb

@@ -35,6 +35,15 @@ module Ea
           @table_name = table_name
         end
 
+        # @return [Boolean] true when the table exists in the database
+        def table_exists?
+          row = @database.get_first_row(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+            [@table_name]
+          )
+          !row.nil?
+        end
+
         # Read all records from the table
         #
         # @param limit [Integer, nil] Maximum number of records to return

data/lib/ea/qea/models/ea_author.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Models
+      # Author / contributor from t_authors.
+      #
+      # Schema:
+      #   (AuthorID INTEGER PRIMARY KEY, Name TEXT, Email TEXT,
+      #    Notes TEXT, ...)
+      class EaAuthor < BaseModel
+        attribute :author_id, :integer
+        attribute :name, :string
+        attribute :email, :string
+        attribute :notes, :string
+
+        def self.primary_key_column
+          :author_id
+        end
+
+        def self.table_name
+          "t_authors"
+        end
+
+        COLUMN_MAP = {
+          "AuthorID" => :author_id
+        }.freeze
+
+        def self.column_map
+          COLUMN_MAP
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/models/ea_glossary.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Models
+      # Glossary term from t_glossary.
+      #
+      # Schema:
+      #   (Term TEXT, Type TEXT, Meaning TEXT, GlossaryID INTEGER PRIMARY KEY)
+      class EaGlossary < BaseModel
+        attribute :glossary_id, :integer
+        attribute :term, :string
+        attribute :type, :string
+        attribute :meaning, :string
+
+        def self.primary_key_column
+          :glossary_id
+        end
+
+        def self.table_name
+          "t_glossary"
+        end
+
+        COLUMN_MAP = {
+          "GlossaryID" => :glossary_id
+        }.freeze
+
+        def self.column_map
+          COLUMN_MAP
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/models/ea_image.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Models
+      # Raw-row model for `t_image`. EA stores pasted images as EMF
+      # (Enhanced Metafile) blobs in this table.
+      #
+      # `type` values observed in real QEAs:
+      #   - "ENHMetafile" — Enhanced Windows Metafile (most common)
+      #   - "Metafile"    — Old-style WMF
+      #   - "Bitmap"      — DIB / PNG bitmap
+      class EaImage < BaseModel
+        attribute :image_id, :integer
+        attribute :name, :string
+        attribute :type, :string
+        attribute :image, :string
+
+        def self.primary_key_column
+          :image_id
+        end
+
+        def self.table_name
+          "t_image"
+        end
+
+        COLUMN_MAP = {
+          "ImageID" => :image_id
+        }.freeze
+
+        def self.column_map
+          COLUMN_MAP
+        end
+
+        # @return [Boolean] true when this row holds an EMF blob
+        def emf?
+          type&.casecmp?("ENHMetafile")
+        end
+
+        # @return [Boolean] true when this row holds a WMF blob
+        def wmf?
+          type&.casecmp?("Metafile")
+        end
+
+        # Raw image bytes. SQLite returns BLOB as ASCII-8BIT String.
+        # @return [String, nil] binary string
+        def bytes
+          image
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/models/ea_implement.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Models
+      # UML-to-code mapping hint from t_implement.
+      class EaImplement < BaseModel
+        attribute :implement_id, :integer
+        attribute :object_id, :integer
+        attribute :language, :string
+        attribute :code, :string
+
+        def self.primary_key_column
+          :implement_id
+        end
+
+        def self.table_name
+          "t_implement"
+        end
+
+        COLUMN_MAP = {
+          "ImplementID" => :implement_id,
+          "Object_ID" => :object_id
+        }.freeze
+
+        def self.column_map
+          COLUMN_MAP
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/models/ea_list.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Models
+      # Enumeration list value from t_lists.
+      #
+      # Schema:
+      #   (ListID TEXT PRIMARY KEY, Category TEXT, Name TEXT,
+      #    NVal INTEGER, Notes TEXT)
+      class EaList < BaseModel
+        attribute :list_id, :string
+        attribute :category, :string
+        attribute :name, :string
+        attribute :nval, :integer
+        attribute :notes, :string
+
+        def self.primary_key_column
+          :list_id
+        end
+
+        def self.table_name
+          "t_lists"
+        end
+
+        COLUMN_MAP = {
+          "ListID" => :list_id,
+          "NVal" => :nval
+        }.freeze
+
+        def self.column_map
+          COLUMN_MAP
+        end
+
+        # @return [Boolean] true when this row carries a numeric value
+        def numeric?
+          !nval.nil?
+        end
+      end
+    end
+  end
+end