lutaml 0.10.18 → 0.11.2

data/lib/lutaml/uml/class.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Class < Classifier
-      attribute :nested_classifier, :string, collection: true,
-                                             default: -> { [] }
-      attribute :stereotype, :string, collection: true, default: -> { [] }
-      attribute :type, :string
-      attribute :attributes, TopElementAttribute, collection: true
-      attribute :modifier, :string
-      attribute :constraints, Constraint, collection: true
-      attribute :operations, Operation, collection: true
-      attribute :data_types, DataType, collection: true
-      attribute :associations, Association, collection: true
-      attribute :generalization, Generalization
-
-      yaml do
-        map "nested_classifier", to: :nested_classifier
-        map "is_abstract", to: :is_abstract
-        map "stereotype", to: :stereotype
-        map "type", to: :type
-        map "attributes", to: :attributes
-        map "modifier", to: :modifier
-        map "constraints", to: :constraints
-        map "operations", to: :operations
-        map "data_types", to: :data_types
-        map "associations", to: :associations, with: {
-          to: :associations_to_yaml, from: :associations_from_yaml
-        }
-      end
-
-      def associations_to_yaml(model, doc)
-        return unless model.associations
-
-        associations = model.associations.map(&:to_hash)
-        doc["associations"] = associations unless associations.empty?
-      end
-
-      def associations_from_yaml(model, values)
-        associations = values.map do |value|
-          value["owner_end"] = model.name if value["owner_end"].nil?
-          Association.from_yaml(value.to_yaml)
-        end
-
-        model.associations = associations
-      end
-    end
-  end
-end

data/lib/lutaml/uml/classifier.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Classifier < TopElement
-      attribute :association_generalization,
-                ::Lutaml::Uml::AssociationGeneralization,
-                collection: true, default: -> { [] }
-      attribute :operations, Operation, collection: true, default: -> { [] }
-      attribute :is_abstract, :boolean, default: false
-
-      yaml do
-        map "generalization", to: :association_generalization
-      end
-    end
-  end
-end

data/lib/lutaml/uml/comment.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Comment < Lutaml::Model::Serializable
-      attribute :text, :string
-
-      yaml do
-        map "text", to: :text
-      end
-    end
-  end
-end

data/lib/lutaml/uml/connector.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Connector < TopElement
-      attribute :kind, :string
-      attribute :connector_end, :string, collection: true, default: -> { [] }
-
-      yaml do
-        map "kind", to: :kind
-        map "connector_end", to: :connector_end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/connector_end.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class ConnectorEnd < TopElement
-      attribute :role, :string
-      attribute :part_with_port, :string
-      attribute :connector, :string
-
-      yaml do
-        map "role", to: :role
-        map "part_with_port", to: :part_with_port
-        map "connector", to: :connector
-      end
-    end
-  end
-end

data/lib/lutaml/uml/constraint.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Constraint < TopElement
-      attribute :body, :string
-      attribute :type, :string
-      attribute :weight, :string
-      attribute :status, :string
-
-      yaml do
-        map "body", to: :body
-        map "type", to: :type
-        map "weight", to: :weight
-        map "status", to: :status
-      end
-    end
-  end
-end

data/lib/lutaml/uml/data_type.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class DataType < Classifier
-      attribute :nested_classifier, :string, collection: true,
-                                             default: -> { [] }
-      attribute :type, :string
-      attribute :attributes, TopElementAttribute, collection: true
-      attribute :modifier, :string
-      attribute :constraints, Constraint, collection: true
-      attribute :operations, Operation, collection: true
-      attribute :data_types, DataType, collection: true
-      attribute :relationships, :string, collection: true, default: -> { [] }
-      attribute :keyword, :string, default: "dataType"
-
-      attribute :associations, Association, collection: true
-
-      yaml do
-        map "nested_classifier", to: :nested_classifier
-        map "is_abstract", to: :is_abstract
-        map "type", to: :type
-
-        map "attributes", to: :attributes
-        map "modifier", to: :modifier
-        map "constraints", to: :constraints
-        map "operations", to: :operations
-        map "data_types", to: :data_types
-
-        map "relationships", to: :relationships
-
-        map "associations", to: :associations, with: {
-          to: :associations_to_yaml, from: :associations_from_yaml
-        }
-      end
-
-      def associations_to_yaml(model, doc)
-        return unless model.associations
-
-        associations = model.associations.map(&:to_hash)
-        doc["associations"] = associations unless associations.empty?
-      end
-
-      def associations_from_yaml(model, values)
-        associations = values.map do |value|
-          value["owner_end"] = model.name if value["owner_end"].nil?
-          Association.from_yaml(value.to_yaml)
-        end
-
-        model.associations = associations
-      end
-    end
-  end
-end

data/lib/lutaml/uml/dependency.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Dependency < TopElement
-      attribute :client, :string, collection: true, default: -> { [] }
-      attribute :supplier, :string, collection: true, default: -> { [] }
-
-      yaml do
-        map "client", to: :client
-        map "supplier", to: :supplier
-      end
-    end
-  end
-end

data/lib/lutaml/uml/diagram.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Diagram < TopElement
-      attribute :package_id, :string
-      attribute :package_name, :string
-      attribute :diagram_type, :string
-      attribute :diagram_objects, DiagramObject, collection: true,
-                                                 default: -> { [] }
-      attribute :diagram_links, DiagramLink, collection: true,
-                                             default: -> { [] }
-
-      yaml do
-        map "package_id", to: :package_id
-        map "package_name", to: :package_name
-        map "diagram_type", to: :diagram_type
-        map "diagram_objects", to: :diagram_objects
-        map "diagram_links", to: :diagram_links
-      end
-    end
-  end
-end

data/lib/lutaml/uml/diagram_link.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Lutaml
-  module Uml
-    # Represents visual routing of a connector on a diagram
-    class DiagramLink < Lutaml::Model::Serializable
-      attribute :connector_id, :string
-      attribute :connector_xmi_id, :string
-      attribute :geometry, :string
-      attribute :style, :string
-      attribute :hidden, :boolean, default: -> { false }
-      attribute :path, :string
-
-      yaml do
-        map "connector_id", to: :connector_id
-        map "connector_xmi_id", to: :connector_xmi_id
-        map "geometry", to: :geometry
-        map "style", to: :style
-        map "hidden", to: :hidden
-        map "path", to: :path
-      end
-    end
-  end
-end

data/lib/lutaml/uml/diagram_object.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Lutaml
-  module Uml
-    # Represents visual placement of an element on a diagram
-    class DiagramObject < Lutaml::Model::Serializable
-      attribute :diagram_object_id, :string
-      attribute :object_xmi_id, :string
-      attribute :left, :integer
-      attribute :top, :integer
-      attribute :right, :integer
-      attribute :bottom, :integer
-      attribute :sequence, :integer
-      attribute :style, :string
-
-      yaml do
-        map "object_id", to: :diagram_object_id
-        map "object_xmi_id", to: :object_xmi_id
-        map "left", to: :left
-        map "top", to: :top
-        map "right", to: :right
-        map "bottom", to: :bottom
-        map "sequence", to: :sequence
-        map "style", to: :style
-      end
-    end
-  end
-end

data/lib/lutaml/uml/document.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Document < Lutaml::Model::Serializable
-      attribute :name, :string
-      attribute :title, :string
-      attribute :caption, :string
-      attribute :groups, Group, collection: true
-      attribute :fidelity, Fidelity
-      attribute :fontname, :string
-      attribute :comments, :string, collection: true
-
-      attribute :classes, Class, collection: true, default: -> { [] }
-      attribute :data_types, DataType, collection: true, default: -> { [] }
-      attribute :enums, Enum, collection: true, default: -> { [] }
-      attribute :packages, Package, collection: true, default: -> { [] }
-      attribute :primitives, PrimitiveType, collection: true, default: -> { [] }
-      attribute :instances, Instance, collection: true, default: -> { [] }
-      attribute :associations, Association, collection: true, default: -> { [] }
-      attribute :diagrams, Diagram, collection: true, default: -> { [] }
-
-      yaml do
-        map "name", to: :name
-        map "title", to: :title
-        map "caption", to: :caption
-        map "groups", to: :groups
-        map "fidelity", to: :fidelity
-        map "fontname", to: :fontname
-        map "comments", to: :comments
-
-        map "classes", to: :classes
-        map "data_types", to: :data_types
-        map "enums", to: :enums
-        map "packages", to: :packages
-        map "primitives", to: :primitives
-        map "instances", to: :instances
-        map "diagrams", to: :diagrams
-
-        map "associations", to: :associations, with: {
-          to: :associations_to_yaml, from: :associations_from_yaml
-        }
-      end
-
-      def associations_to_yaml(model, doc)
-        return unless model.associations
-
-        associations = model.associations.map(&:to_hash)
-        doc["associations"] = associations unless associations.empty?
-      end
-
-      def associations_from_yaml(model, values)
-        associations = values.map do |value|
-          value["owner_end"] = model.name if value["owner_end"].nil?
-          Association.from_yaml(value.to_yaml)
-        end
-
-        model.associations = associations
-      end
-    end
-  end
-end

data/lib/lutaml/uml/enum.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Enum < Classifier
-      attribute :attributes, TopElementAttribute, collection: true,
-                                                  default: -> { [] }
-      attribute :modifier, :string
-      attribute :keyword, :string, default: "enumeration"
-      attribute :values, Value, collection: true, default: -> { [] }
-      yaml do
-        map "attributes", to: :attributes
-        map "modifier", to: :modifier
-        map "keyword", to: :keyword
-        map "values", to: :values
-      end
-    end
-  end
-end

data/lib/lutaml/uml/event.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Event < TopElement
-    end
-  end
-end

data/lib/lutaml/uml/fidelity.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Fidelity < Lutaml::Model::Serializable
-      attribute :hideMembers, :boolean
-      attribute :hideOtherClasses, :boolean
-    end
-  end
-end

data/lib/lutaml/uml/final_state.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class FinalState < State
-    end
-  end
-end

data/lib/lutaml/uml/fontname.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Fontname < Lutaml::Model::Serializable
-      attribute :name, :string
-
-      yaml do
-        map "name", to: :name
-      end
-    end
-  end
-end

data/lib/lutaml/uml/general_attribute.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class GeneralAttribute < Lutaml::Model::Serializable
-      attribute :id, :string
-      attribute :name, :string
-      attribute :type, :string
-      attribute :xmi_id, :string
-      attribute :is_derived, :boolean, default: false
-      attribute :cardinality, Cardinality
-      attribute :definition, :string
-      attribute :association, :string
-      attribute :has_association, :boolean, default: false
-      attribute :type_ns, :string
-      attribute :name_ns, :string
-      attribute :gen_name, :string
-      attribute :upper_klass, :string
-      attribute :level, :integer
-    end
-  end
-end

data/lib/lutaml/uml/generalization.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Generalization < Lutaml::Model::Serializable
-      attribute :general_id, :string
-      attribute :general_name, :string
-      attribute :general_attributes,
-                ::Lutaml::Uml::GeneralAttribute,
-                collection: true, default: -> { [] }
-      attribute :general_upper_klass, :string
-      attribute :has_general, :boolean, default: false
-      attribute :general, ::Lutaml::Uml::Generalization
-      attribute :name, :string
-      attribute :type, :string
-      attribute :definition, :string
-      attribute :stereotype, :string
-      attribute :attributes,
-                ::Lutaml::Uml::GeneralAttribute,
-                collection: true, default: -> { [] }
-      attribute :owned_props,
-                ::Lutaml::Uml::GeneralAttribute,
-                collection: true, default: -> { [] }
-      attribute :assoc_props,
-                ::Lutaml::Uml::GeneralAttribute,
-                collection: true, default: -> { [] }
-      attribute :inherited_props,
-                ::Lutaml::Uml::GeneralAttribute,
-                collection: true, default: -> { [] }
-      attribute :inherited_assoc_props,
-                ::Lutaml::Uml::GeneralAttribute,
-                collection: true, default: -> { [] }
-    end
-  end
-end

data/lib/lutaml/uml/group.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Lutaml
-  module Uml
-    class Group < Lutaml::Model::Serializable
-      attribute :id, :string
-      attribute :values, :string, collection: true
-      attribute :groups, Group, collection: true
-
-      yaml do
-        map "id", to: :id
-        map "values", to: :values
-        map "groups", to: :groups
-      end
-    end
-  end
-end

data/lib/lutaml/uml/has_attributes.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module HasAttributes
-      def update_attributes(attributes = {})
-        attributes.to_h.each do |name, value|
-          value = value.str if value.is_a?(Parslet::Slice)
-          public_send(:"#{name}=", value)
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/has_members.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module HasMembers
-      class UnknownMemberTypeError < Lutaml::Error; end
-
-      def members=(value) # rubocop:disable Metrics/AbcSize
-        value.group_by { |member| member.keys.first }
-          .each do |(type, group)|
-            attribute_value = group.map(&:values).flatten
-            if attribute_value.length == 1 && !attribute_value.first.is_a?(Hash)
-              next public_send(:"#{association_type(type)}=",
-                               attribute_value.first)
-            end
-
-            public_send(:"#{association_type(type)}=", attribute_value)
-          end
-      end
-
-      private
-
-      def association_type(type)
-        return type if self.class.attributes.key?(type.to_sym)
-
-        raise(UnknownMemberTypeError, "Unknown member type: #{type}")
-      end
-    end
-  end
-end

data/lib/lutaml/uml/inheritance_walker.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    # Service class for safely walking UML generalization chains.
-    #
-    # Walks from a class up through its generalization hierarchy (parent classes),
-    # collecting information about each ancestor. Supports cycle detection to
-    # prevent infinite loops in malformed models.
-    #
-    # @example
-    #   walker = InheritanceWalker.new(repository)
-    #   walker.walk(klass) do |ancestor, level|
-    #     puts "#{'-' * level} #{ancestor.name}"
-    #   end
-    class InheritanceWalker
-      # @param repository [#supertype_of] Object responding to #supertype_of(class)
-      def initialize(repository)
-        @repository = repository
-        @visited = Set.new
-      end
-
-      # Walk the generalization chain from a starting class.
-      #
-      # @param klass [Lutaml::Uml::Class] The class to start from
-      # @yield [ancestor, level] Yields each ancestor class and its depth (1-based)
-      # @return [Array<[klass, level]>] Array of [ancestor_class, level] pairs in visiting order
-      #
-      # @example
-      #   walker.walk(D.class) do |parent, level|
-      #     puts "#{'  ' * (level - 1)}Parent #{level}: #{parent.name}"
-      #   end
-      def walk(klass)
-        return [] unless klass.is_a?(Lutaml::Uml::Class) && klass.generalization
-
-        ancestors = []
-        @visited.clear
-        collect_ancestors(klass, ancestors)
-        yield_ancestors(ancestors)
-      end
-
-      # Get the direct supertype (immediate parent) of a class.
-      #
-      # @param klass [Lutaml::Uml::Class]
-      # @return [Lutaml::Uml::Class, nil]
-      def supertype_of(klass)
-        @repository.supertype_of(klass)
-      end
-
-      # Get all ancestors of a class in order (immediate parent first).
-      #
-      # @param klass [Lutaml::Uml::Class]
-      # @return [Array<Lutaml::Uml::Class>]
-      def ancestors_of(klass)
-        result = []
-        walk(klass) { |ancestor, _level| result << ancestor }
-        result
-      end
-
-      private
-
-      def yield_ancestors(ancestors)
-        ancestors.reverse_each.with_index(1) do |ancestor, level|
-          break if @visited.include?(ancestor.xmi_id)
-
-          @visited.add(ancestor.xmi_id)
-          yield(ancestor, level) if block_given?
-        end
-        ancestors.reverse_each.with_index(1)
-      end
-
-      # Collect ancestors recursively into the result array.
-      # Uses a trail set for cycle detection (avoids Set mutation issues across calls).
-      def collect_ancestors(klass, result, trail = [])
-        return [] if trail.include?(klass.xmi_id) # cycle guard
-        return [] unless klass.is_a?(Lutaml::Uml::Class) && klass.generalization
-
-        trail = trail.dup
-        trail << klass.xmi_id
-
-        general_id = klass.generalization.general_id
-        parent = general_id ? find_class_by_id(general_id) : nil
-
-        return [] unless parent
-
-        result << parent
-        collect_ancestors(parent, result, trail)
-      end
-
-      def find_class_by_id(xmi_id)
-        @repository.indexes&.dig(:qualified_names, xmi_id) ||
-          @repository.classes_index&.find { |c| c.xmi_id == xmi_id }
-      end
-    end
-  end
-end

data/lib/lutaml/uml/instance.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Instance < TopElement
-      attribute :classifier, :string
-      attribute :slot, :string, collection: true, default: -> { [] }
-
-      yaml do
-        map "classifier", to: :classifier
-        map "slot", to: :slot
-      end
-    end
-  end
-end