lutaml 0.9.43 → 0.10.1

data/lib/lutaml/qea/models/ea_object_type.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "base_model"
+
+module Lutaml
+  module Qea
+    module Models
+      # Represents an object type definition from t_objecttypes table
+      #
+      # This table provides reference data for object/class types available
+      # in EA. These define what kinds of UML elements can be created.
+      #
+      # @example
+      #   object_type = EaObjectType.new
+      #   object_type.object_type #=> "Class"
+      #   object_type.description #=> "UML Class"
+      #   object_type.design_object? #=> false
+      class EaObjectType < BaseModel
+        attribute :object_type, Lutaml::Model::Type::String
+        attribute :description, Lutaml::Model::Type::String
+        attribute :designobject, Lutaml::Model::Type::Integer
+        attribute :imageid, Lutaml::Model::Type::Integer
+
+        def self.table_name
+          "t_objecttypes"
+        end
+
+        # Primary key is Object_Type (text)
+        def self.primary_key_column
+          "Object_Type"
+        end
+
+        # Friendly name for object type
+        # @return [String]
+        def name
+          object_type
+        end
+
+        # Check if this is a design object
+        # @return [Boolean]
+        def design_object?
+          designobject == 1
+        end
+
+        # Alias for readability
+        alias design_object designobject
+        alias image_id imageid
+
+        # Check if this is a Class type
+        # @return [Boolean]
+        def class_type?
+          object_type == "Class"
+        end
+
+        # Check if this is an Interface type
+        # @return [Boolean]
+        def interface_type?
+          object_type == "Interface"
+        end
+
+        # Check if this is a Package type
+        # @return [Boolean]
+        def package_type?
+          object_type == "Package"
+        end
+
+        # Check if this is an Actor type
+        # @return [Boolean]
+        def actor_type?
+          object_type == "Actor"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/models/ea_operation.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "base_model"
+
+module Lutaml
+  module Qea
+    module Models
+      # Represents an operation from the t_operation table in EA database
+      # This represents class methods/operations
+      class EaOperation < BaseModel
+        attribute :operationid, Lutaml::Model::Type::Integer
+        attribute :ea_object_id, Lutaml::Model::Type::Integer
+        attribute :name, Lutaml::Model::Type::String
+        attribute :scope, Lutaml::Model::Type::String
+        attribute :type, Lutaml::Model::Type::String
+        attribute :returnarray, Lutaml::Model::Type::String
+        attribute :stereotype, Lutaml::Model::Type::String
+        attribute :isstatic, Lutaml::Model::Type::String
+        attribute :concurrency, Lutaml::Model::Type::String
+        attribute :notes, Lutaml::Model::Type::String
+        attribute :behaviour, Lutaml::Model::Type::String
+        attribute :abstract, Lutaml::Model::Type::String
+        attribute :genoption, Lutaml::Model::Type::String
+        attribute :synchronized, Lutaml::Model::Type::String
+        attribute :pos, Lutaml::Model::Type::Integer
+        attribute :const, Lutaml::Model::Type::Integer
+        attribute :style, Lutaml::Model::Type::String
+        attribute :pure, Lutaml::Model::Type::Integer
+        attribute :throws, Lutaml::Model::Type::String
+        attribute :classifier, Lutaml::Model::Type::String
+        attribute :code, Lutaml::Model::Type::String
+        attribute :isroot, Lutaml::Model::Type::Integer
+        attribute :isleaf, Lutaml::Model::Type::Integer
+        attribute :isquery, Lutaml::Model::Type::Integer
+        attribute :stateflags, Lutaml::Model::Type::String
+        attribute :ea_guid, Lutaml::Model::Type::String
+        attribute :styleex, Lutaml::Model::Type::String
+
+        def self.primary_key_column
+          :operationid
+        end
+
+        def self.table_name
+          "t_operation"
+        end
+
+        # Create from database row
+        #
+        # @param row [Hash] Database row with string keys
+        # @return [EaOperation, nil] New instance or nil if row is nil
+        def self.from_db_row(row) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          return nil if row.nil?
+
+          new(
+            operationid: row["OperationID"],
+            ea_object_id: row["Object_ID"],
+            name: row["Name"],
+            scope: row["Scope"],
+            type: row["Type"],
+            returnarray: row["ReturnArray"],
+            stereotype: row["Stereotype"],
+            isstatic: row["IsStatic"],
+            concurrency: row["Concurrency"],
+            notes: row["Notes"],
+            behaviour: row["Behaviour"],
+            abstract: row["Abstract"],
+            genoption: row["GenOption"],
+            synchronized: row["Synchronized"],
+            pos: row["Pos"],
+            const: row["Const"],
+            style: row["Style"],
+            pure: row["Pure"],
+            throws: row["Throws"],
+            classifier: row["Classifier"],
+            code: row["Code"],
+            isroot: row["IsRoot"],
+            isleaf: row["IsLeaf"],
+            isquery: row["IsQuery"],
+            stateflags: row["StateFlags"],
+            ea_guid: row["ea_guid"],
+            styleex: row["StyleEx"],
+          )
+        end
+
+        # Check if operation is static
+        # @return [Boolean]
+        def static?
+          isstatic == "1"
+        end
+
+        # Check if operation is abstract
+        # @return [Boolean]
+        def abstract?
+          abstract == "1"
+        end
+
+        # Check if operation is synchronized
+        # @return [Boolean]
+        def synchronized?
+          synchronized == "1"
+        end
+
+        # Check if operation is pure virtual
+        # @return [Boolean]
+        def pure?
+          pure == 1
+        end
+
+        # Check if operation is a query
+        # @return [Boolean]
+        def query?
+          isquery == 1
+        end
+
+        # Check if operation is root
+        # @return [Boolean]
+        def root?
+          isroot == 1
+        end
+
+        # Check if operation is leaf
+        # @return [Boolean]
+        def leaf?
+          isleaf == 1
+        end
+
+        # Check if operation is constant
+        # @return [Boolean]
+        def constant?
+          const == 1
+        end
+
+        # Check if operation is public
+        # @return [Boolean]
+        def public?
+          scope&.downcase == "public"
+        end
+
+        # Check if operation is private
+        # @return [Boolean]
+        def private?
+          scope&.downcase == "private"
+        end
+
+        # Check if operation is protected
+        # @return [Boolean]
+        def protected?
+          scope&.downcase == "protected"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/models/ea_operation_param.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "base_model"
+
+module Lutaml
+  module Qea
+    module Models
+      # Represents an operation parameter from the t_operationparams table
+      # This represents method/operation parameters
+      # Note: Has composite primary key (OperationID + Name)
+      class EaOperationParam < BaseModel
+        attribute :operationid, Lutaml::Model::Type::Integer
+        attribute :name, Lutaml::Model::Type::String
+        attribute :type, Lutaml::Model::Type::String
+        attribute :default, Lutaml::Model::Type::String
+        attribute :notes, Lutaml::Model::Type::String
+        attribute :pos, Lutaml::Model::Type::Integer
+        attribute :const, Lutaml::Model::Type::Integer
+        attribute :style, Lutaml::Model::Type::String
+        attribute :kind, Lutaml::Model::Type::String
+        attribute :classifier, Lutaml::Model::Type::String
+        attribute :ea_guid, Lutaml::Model::Type::String
+        attribute :styleex, Lutaml::Model::Type::String
+
+        def self.primary_key_column
+          # Composite key: [:operationid, :name]
+          # Return first component for compatibility
+          :operationid
+        end
+
+        def self.table_name
+          "t_operationparams"
+        end
+
+        # Returns composite primary key as array
+        # @return [Array] [operationid, name]
+        def composite_key
+          [operationid, name]
+        end
+
+        # Check if parameter is constant
+        # @return [Boolean]
+        def constant?
+          const == 1
+        end
+
+        # Check if parameter is input parameter
+        # @return [Boolean]
+        def input?
+          kind&.downcase == "in"
+        end
+
+        # Check if parameter is output parameter
+        # @return [Boolean]
+        def output?
+          kind&.downcase == "out"
+        end
+
+        # Check if parameter is input/output parameter
+        # @return [Boolean]
+        def inout?
+          kind&.downcase == "inout"
+        end
+
+        # Check if parameter is return parameter
+        # @return [Boolean]
+        def return?
+          kind&.downcase == "return"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/models/ea_package.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "base_model"
+
+module Lutaml
+  module Qea
+    module Models
+      # Represents a package from the t_package table in EA database
+      # This represents packages/namespaces in the model
+      class EaPackage < BaseModel
+        attribute :package_id, Lutaml::Model::Type::Integer
+        attribute :name, Lutaml::Model::Type::String
+        attribute :parent_id, Lutaml::Model::Type::Integer
+        attribute :createddate, Lutaml::Model::Type::String
+        attribute :modifieddate, Lutaml::Model::Type::String
+        attribute :notes, Lutaml::Model::Type::String
+        attribute :ea_guid, Lutaml::Model::Type::String
+        attribute :xmlpath, Lutaml::Model::Type::String
+        attribute :iscontrolled, Lutaml::Model::Type::Integer
+        attribute :lastloaddate, Lutaml::Model::Type::String
+        attribute :lastsavedate, Lutaml::Model::Type::String
+        attribute :version, Lutaml::Model::Type::String
+        attribute :protected, Lutaml::Model::Type::Integer
+        attribute :pkgowner, Lutaml::Model::Type::String
+        attribute :umlversion, Lutaml::Model::Type::String
+        attribute :usedtd, Lutaml::Model::Type::Integer
+        attribute :logxml, Lutaml::Model::Type::Integer
+        attribute :codepath, Lutaml::Model::Type::String
+        attribute :namespace, Lutaml::Model::Type::String
+        attribute :tpos, Lutaml::Model::Type::Integer
+        attribute :packageflags, Lutaml::Model::Type::String
+        attribute :batchsave, Lutaml::Model::Type::Integer
+        attribute :batchload, Lutaml::Model::Type::Integer
+
+        def self.primary_key_column
+          :package_id
+        end
+
+        def self.table_name
+          "t_package"
+        end
+
+        # Check if package is controlled
+        # @return [Boolean]
+        def controlled?
+          iscontrolled == 1
+        end
+
+        # Check if package is protected
+        # @return [Boolean]
+        def protected?
+          protected == 1
+        end
+
+        # Check if package uses DTD
+        # @return [Boolean]
+        def use_dtd?
+          usedtd == 1
+        end
+
+        # Check if package logs XML
+        # @return [Boolean]
+        def log_xml?
+          logxml == 1
+        end
+
+        # Check if package is root (has no parent)
+        # @return [Boolean]
+        def root?
+          parent_id.nil? || parent_id.zero?
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/models/ea_script.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "base_model"
+
+module Lutaml
+  module Qea
+    module Models
+      # Represents a script from the t_script table in EA database
+      # Stores behavioral scripts and debugging configurations
+      class EaScript < BaseModel
+        attribute :script_id, Lutaml::Model::Type::Integer
+        attribute :script_category, Lutaml::Model::Type::String
+        attribute :script_name, Lutaml::Model::Type::String
+        attribute :script_author, Lutaml::Model::Type::String
+        attribute :notes, Lutaml::Model::Type::String
+        attribute :script, Lutaml::Model::Type::String
+
+        def self.primary_key_column
+          :script_id
+        end
+
+        def self.table_name
+          "t_script"
+        end
+
+        # Create from database row
+        #
+        # @param row [Hash] Database row with string keys
+        # @return [EaScript, nil] New instance or nil if row is nil
+        def self.from_db_row(row)
+          return nil if row.nil?
+
+          new(
+            script_id: row["ScriptID"],
+            script_category: row["ScriptCategory"],
+            script_name: row["ScriptName"],
+            script_author: row["ScriptAuthor"],
+            notes: row["Notes"],
+            script: row["Script"],
+          )
+        end
+
+        # Convenience aliases
+        alias_method :id, :script_id
+        alias_method :name, :script_name
+        alias_method :category, :script_category
+        alias_method :author, :script_author
+
+        # Check if this is a debugging script
+        # @return [Boolean]
+        def debugging_script?
+          script_category == "ScriptDebugging"
+        end
+
+        # Check if script has content
+        # @return [Boolean]
+        def has_content?
+          !script.nil? && !script.empty?
+        end
+
+        # Check if script has notes
+        # @return [Boolean]
+        def has_notes?
+          !notes.nil? && !notes.empty?
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/models/ea_status_type.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "base_model"
+
+module Lutaml
+  module Qea
+    module Models
+      # Represents a status type definition from t_statustypes table
+      #
+      # This table provides reference data for status values that can be
+      # assigned to UML elements (Approved, Implemented, Mandatory, etc.).
+      #
+      # @example
+      #   status_type = EaStatusType.new
+      #   status_type.status #=> "Approved"
+      #   status_type.description #=> "Item is approved"
+      class EaStatusType < BaseModel
+        attribute :status, Lutaml::Model::Type::String
+        attribute :description, Lutaml::Model::Type::String
+
+        def self.table_name
+          "t_statustypes"
+        end
+
+        # Primary key is Status (text)
+        def self.primary_key_column
+          "Status"
+        end
+
+        # Friendly name for status
+        # @return [String]
+        def name
+          status
+        end
+
+        # Check if this is the Approved status
+        # @return [Boolean]
+        def approved?
+          status == "Approved"
+        end
+
+        # Check if this is the Implemented status
+        # @return [Boolean]
+        def implemented?
+          status == "Implemented"
+        end
+
+        # Check if this is the Mandatory status
+        # @return [Boolean]
+        def mandatory?
+          status == "Mandatory"
+        end
+
+        # Check if this is the Proposed status
+        # @return [Boolean]
+        def proposed?
+          status == "Proposed"
+        end
+
+        # Check if this is the Validated status
+        # @return [Boolean]
+        def validated?
+          status == "Validated"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/models/ea_stereotype.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "base_model"
+
+module Lutaml
+  module Qea
+    module Models
+      # Represents a stereotype definition from t_stereotypes table
+      #
+      # Stereotypes are UML profile extensions that classify elements.
+      # This table stores stereotype DEFINITIONS (not instances).
+      # Individual elements reference these stereotypes by name.
+      #
+      # @example
+      #   stereotype = EaStereotype.new
+      #   stereotype.stereotype #=> "CodeList"
+      #   stereotype.applies_to #=> "Class"
+      #   stereotype.description #=> "A list of codes"
+      class EaStereotype < BaseModel
+        attribute :stereotype, Lutaml::Model::Type::String
+        attribute :appliesto, Lutaml::Model::Type::String
+        attribute :description, Lutaml::Model::Type::String
+        attribute :mfenabled, Lutaml::Model::Type::Integer
+        attribute :mfpath, Lutaml::Model::Type::String
+        attribute :metafile, Lutaml::Model::Type::String
+        attribute :style, Lutaml::Model::Type::String
+        attribute :ea_guid, Lutaml::Model::Type::String
+        attribute :visualtype, Lutaml::Model::Type::String
+
+        def self.table_name
+          "t_stereotypes"
+        end
+
+        # No primary key - this is a lookup/reference table
+        def self.primary_key_column
+          nil
+        end
+
+        # Check if stereotype is enabled for metafile
+        # @return [Boolean]
+        def metafile_enabled?
+          mfenabled == 1
+        end
+
+        # Get friendly name for applies_to
+        # @return [String]
+        def element_type
+          appliesto
+        end
+
+        # Alias for readability
+        alias applies_to appliesto
+        alias mf_enabled mfenabled
+        alias mf_path mfpath
+        alias visual_type visualtype
+      end
+    end
+  end
+end

data/lib/lutaml/qea/models/ea_tagged_value.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "base_model"
+
+module Lutaml
+  module Qea
+    module Models
+      # EA Tagged Value model
+      #
+      # Represents tagged values (custom metadata) attached to UML elements
+      # in the t_taggedvalue table.
+      #
+      # @example Create from database row
+      #   row = {
+      #     "PropertyID" => "{GUID}",
+      #     "ElementID" => "{ELEMENT-GUID}",
+      #     "BaseClass" => "ASSOCIATION_SOURCE",
+      #     "TagValue" => "sequenceNumber|15$ea_notes=Unique integer...",
+      #     "Notes" => nil
+      #   }
+      #   tagged_value = EaTaggedValue.from_db_row(row)
+      class EaTaggedValue < BaseModel
+        attribute :property_id, :string
+        attribute :element_id, :string
+        attribute :base_class, :string
+        attribute :tag_value, :string
+        attribute :notes, :string
+
+        # @return [Symbol] Primary key column name
+        def self.primary_key_column
+          :property_id
+        end
+
+        # @return [String] Database table name
+        def self.table_name
+          "t_taggedvalue"
+        end
+
+        # Create from database row
+        #
+        # @param row [Hash] Database row with string keys
+        # @return [EaTaggedValue, nil] New instance or nil if row is nil
+        def self.from_db_row(row)
+          return nil if row.nil?
+
+          new(
+            property_id: row["PropertyID"],
+            element_id: row["ElementID"],
+            base_class: row["BaseClass"],
+            tag_value: row["TagValue"],
+            notes: row["Notes"],
+          )
+        end
+
+        # Parse tag name from TagValue field
+        #
+        # TagValue format: "tagName|value$ea_notes=description"
+        # or "tagName$ea_notes=description"
+        #
+        # @return [String, nil] Tag name
+        def tag_name
+          return nil unless tag_value
+
+          # Split on | or $ to get the tag name
+          parts = tag_value.split(/[|$]/, 2)
+          parts[0]&.strip
+        end
+
+        # Parse tag value from TagValue field
+        #
+        # TagValue format: "tagName|value$ea_notes=description"
+        #
+        # @return [String, nil] Tag value
+        def parsed_value
+          return nil unless tag_value
+
+          # Check if there's a pipe separator
+          return nil unless tag_value.include?("|")
+
+          # Split on pipe first
+          parts = tag_value.split("|", 2)
+          return nil if parts.length < 2
+
+          # Get the value part (before $)
+          value_part = parts[1].split("$", 2)[0]
+          value_part&.strip
+        end
+
+        # Parse notes from TagValue field
+        #
+        # Extract ea_notes if present in TagValue
+        #
+        # @return [String, nil] Extracted notes
+        def parsed_notes # rubocop:disable Metrics/CyclomaticComplexity
+          return notes if notes && !notes.empty?
+          return nil unless tag_value&.include?("$ea_notes=")
+
+          # Extract ea_notes value
+          parts = tag_value.split("$ea_notes=", 2)
+          parts[1]&.strip if parts.length > 1
+        end
+      end
+    end
+  end
+end