lutaml 0.10.19 → 0.11.2

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,17 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Instance < TopElement
-      skip_reference_registration
-
-      attribute :classifier, :string
-      attribute :slot, :string, collection: true, default: -> { [] }
-
-      yaml do
-        map "classifier", to: :classifier
-        map "slot", to: :slot
-      end
-    end
-  end
-end

data/lib/lutaml/uml/model.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Model < Package
-      skip_reference_registration
-
-      attribute :viewpoint, :string
-
-      yaml do
-        map "viewpoint", to: :viewpoint
-      end
-    end
-  end
-end

data/lib/lutaml/uml/model_helpers.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module ModelHelpers
-      def normalize_stereotypes(stereotype)
-        return [] if stereotype.nil?
-
-        case stereotype
-        when Array then stereotype.map(&:to_s)
-        when String then [stereotype]
-        when Symbol then [stereotype.to_s]
-        else [stereotype.to_s]
-        end
-      end
-
-      def qualified_name_for(uml_element)
-        parts = []
-        current = uml_element
-
-        while current
-          parts.unshift(current.name) if current.name
-          current = current.namespace
-        end
-
-        parts.join("::")
-      end
-
-      def package_path_for(uml_element)
-        parts = []
-        current = uml_element
-
-        while current
-          if current.is_a?(Lutaml::Uml::Package)
-            parts.unshift(current.name) if current.name
-            current = current.namespace
-          elsif current.is_a?(Lutaml::Uml::TopElement)
-            current = current.namespace
-          else
-            break
-          end
-        end
-
-        parts.join("::")
-      end
-
-      def class_type_for(uml_class)
-        case uml_class
-        when String
-          uml_class.split("::").last
-        when Lutaml::Uml::Enum
-          "Enumeration"
-        when Lutaml::Uml::DataType
-          "DataType"
-        when Lutaml::Uml::PrimitiveType
-          "PrimitiveType"
-        when Lutaml::Uml::Class
-          "Class"
-        when Class
-          uml_class.name.split("::").last
-        else
-          uml_class.class.name.split("::").last
-        end
-      end
-
-      def format_cardinality(cardinality)
-        return nil unless cardinality
-
-        min = cardinality.min
-        max = cardinality.max
-        return nil if min.nil? && max.nil?
-
-        min_str = min.nil? ? "0" : min.to_s
-        max_str = max.nil? ? "*" : max.to_s
-        "#{min_str}..#{max_str}"
-      end
-
-      def parse_cardinality(min, max)
-        { min: min, max: max }
-      end
-
-      def format_definition(definition, options = {})
-        return nil if definition.nil? || definition.empty?
-
-        formatted = definition.strip
-        if options[:max_definition_length] &&
-            formatted.length > options[:max_definition_length]
-          formatted = "#{formatted[0...options[:max_definition_length]]}..."
-        end
-        if options[:format_definitions]
-          formatted = formatted.gsub(%r{(https?://[^\s]+)}, '[\1](\1)')
-        end
-        formatted
-      end
-
-      def extract_package_path(qualified_name, default: "")
-        parts = qualified_name.to_s.split("::")
-        return default if parts.size <= 1
-
-        parts[0..-2].join("::")
-      end
-    end
-  end
-end

data/lib/lutaml/uml/namespace.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Namespace < Lutaml::Model::Serializable
-      skip_reference_registration
-
-      attribute :name, :string
-      attribute :namespace, Namespace
-    end
-  end
-end

data/lib/lutaml/uml/node/attribute.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Node
-      class Attribute < Base
-        include HasName
-        include HasType
-
-        def initialize(attributes = {})
-          @access = "public"
-
-          super
-        end
-
-        attr_reader :static, :access
-
-        def static=(value)
-          @static = !!value
-        end
-
-        VALID_ACCESS = %w[public private protected package].freeze
-
-        def access=(value)
-          @access = value.to_s
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/node/base.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Node
-      class Base
-        include ::Lutaml::Uml::HasAttributes
-
-        # rubocop:disable Rails/ActiveRecordAliases
-        def initialize(attributes = {})
-          update_attributes(attributes)
-        end
-        # rubocop:enable Rails/ActiveRecordAliases
-
-        attr_accessor :parent
-      end
-    end
-  end
-end

data/lib/lutaml/uml/node/class_node.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Node
-      class ClassNode < Base
-        include HasName
-
-        attr_reader :modifier, :members
-
-        def modifier=(value)
-          @modifier = value.to_s
-        end
-
-        def members=(value) # rubocop:disable Metrics/MethodLength
-          @members = value.to_a.map do |member|
-            type       = member.keys.first
-            attributes = member.values.first
-            attributes[:parent] = self
-
-            case type
-            when :field              then Attribute.new(attributes)
-            when :method             then Operation.new(attributes)
-            when :relationship       then Relationship.new(attributes)
-            when :class_relationship then ClassRelationship.new(attributes)
-            end
-          end
-        end
-
-        def attributes
-          @members.select { |member| member.instance_of?(Attribute) }
-        end
-
-        def operations
-          @members.select { |member| member.instance_of?(Operation) }
-        end
-
-        def relationships
-          @members.select { |member| member.instance_of?(Relationship) }
-        end
-
-        def class_relationships
-          @members.select { |member| member.instance_of?(ClassRelationship) }
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/node/class_relationship.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Node
-      class ClassRelationship < Relationship
-        include HasName
-      end
-    end
-  end
-end

data/lib/lutaml/uml/node/document.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Node
-      class Document < Base
-        attr_reader :classes
-
-        def classes=(value)
-          @classes = value.to_a.map { |attributes| ClassNode.new(attributes) }
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/node/has_name.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Node
-      module HasName
-        attr_reader :name
-
-        def name=(value)
-          @name = value.to_s
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/node/has_type.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Node
-      module HasType
-        attr_reader :type
-
-        def type=(value)
-          @type = value.to_s
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/node/method_argument.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Node
-      class MethodArgument < Base
-        include HasName
-        include HasType
-      end
-    end
-  end
-end

data/lib/lutaml/uml/node/operation.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Node
-      class Operation < Attribute
-        include HasName
-
-        attr_reader :abstract, :arguments
-
-        def abstract=(value)
-          @abstract = !!value
-        end
-
-        def arguments=(value)
-          @arguments = value.to_a.map do |attributes|
-            MethodArgument.new(attributes)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/node/relationship.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Node
-      class Relationship < Base
-        include HasName
-        include HasType
-
-        attr_reader :from, :to
-
-        def from=(value)
-          @from = value.to_s
-        end
-
-        def to=(value)
-          @to = value.to_s
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/opaque_behavior.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class OpaqueBehavior < Behavior
-      skip_reference_registration
-    end
-  end
-end

data/lib/lutaml/uml/operation.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Operation < TopElement
-      skip_reference_registration
-
-      attribute :id, :string
-      attribute :return_type, :string
-      attribute :parameter_type, :string
-      attribute :is_static, :boolean, default: false
-      attribute :is_abstract, :boolean, default: false
-      attribute :owned_parameter, OperationParameter, collection: true,
-                                                      default: -> { [] }
-
-      yaml do
-        map "id", to: :id
-        map "return_type", to: :return_type
-        map "parameter_type", to: :parameter_type
-      end
-    end
-  end
-end

data/lib/lutaml/uml/operation_parameter.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class OperationParameter < Lutaml::Model::Serializable
-      skip_reference_registration
-
-      attribute :name, :string
-      attribute :type, :string
-      attribute :direction, :string, default: "in"
-
-      yaml do
-        map "name", to: :name
-        map "type", to: :type
-        map "direction", to: :direction
-      end
-    end
-  end
-end

data/lib/lutaml/uml/package.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Package < TopElement
-      skip_reference_registration
-
-      attribute :contents, :string, collection: true, default: -> { [] }
-      attribute :classes, Class, collection: true, default: -> { [] }
-      attribute :enums, Enum, collection: true, default: -> { [] }
-      attribute :data_types, DataType, collection: true, default: -> { [] }
-      attribute :instances, Instance, collection: true, default: -> { [] }
-      attribute :packages, Package, collection: true, default: -> { [] }
-      attribute :diagrams, Diagram, collection: true, default: -> { [] }
-
-      yaml do
-        map "contents", to: :contents
-        map "classes", to: :classes
-        map "enums", to: :enums
-        map "data_types", to: :data_types
-        map "instances", to: :instances
-        map "packages", to: :packages
-        map "diagrams", to: :diagrams
-      end
-
-      def children_packages
-        packages.map do |pkg|
-          [pkg, pkg.packages, pkg.packages.map(&:children_packages)]
-        end.flatten.uniq
-      end
-    end
-  end
-end