lutaml 0.10.18 → 0.11.2

data/lib/lutaml/uml/qualified_name.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    # Immutable value object representing a UML qualified class name.
-    #
-    # A qualified name consists of a package path and a class name.
-    # Examples:
-    #   - "i-UR::urf::UrbanPlanningArea"
-    #     (package: "i-UR::urf", class: "UrbanPlanningArea")
-    #   - "ModelRoot::CityGML::Building"
-    #     (package: "ModelRoot::CityGML", class: "Building")
-    #
-    # QualifiedName objects are immutable and frozen after initialization.
-    class QualifiedName
-      attr_reader :package_path, :class_name
-
-      # Create a new QualifiedName.
-      #
-      # @param qualified_name [String, Array<String>] The full qualified name or
-      # array of segments
-      #   (e.g., "i-UR::urf::UrbanPlanningArea" or
-      #   ["i-UR", "urf", "UrbanPlanningArea"])
-      # @raise [ArgumentError] if qualified_name is nil
-      def initialize(qualified_name) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        if qualified_name.nil?
-          raise ArgumentError, "Qualified name cannot be nil"
-        end
-
-        # Handle both string and array inputs
-        parts = if qualified_name.is_a?(Array)
-                  qualified_name.reject { |s| s.nil? || s.empty? }
-                else
-                  qualified_name.split(PackagePath::SEPARATOR).reject(&:empty?)
-                end
-
-        # Allow empty qualified names
-        if parts.empty?
-          @class_name = ""
-          @package_path = PackagePath.new("")
-        else
-          @class_name = parts.last.freeze
-
-          # Package path can be empty for unqualified names
-          @package_path = if parts.size > 1
-                            PackagePath.new(parts[0...-1])
-                          else
-                            # Create empty package path
-                            PackagePath.new("")
-                          end
-        end
-
-        freeze
-      end
-
-      # Convert to string representation.
-      #
-      # @return [String] The fully qualified name (empty string for empty name)
-      # @example
-      #   qname = QualifiedName.new("i-UR::urf::UrbanPlanningArea")
-      #   qname.to_s # => "i-UR::urf::UrbanPlanningArea"
-      def to_s
-        return "" if @class_name.nil? || @class_name.empty?
-
-        # Check if package path is empty
-        if @package_path.nil? || @package_path.empty?
-          return @class_name
-        end
-
-        "#{@package_path}#{PackagePath::SEPARATOR}#{@class_name}"
-      end
-
-      # Check if this is a qualified name (has a package path).
-      #
-      # @return [Boolean] true if qualified (has package), false if unqualified
-      # @example
-      #   QualifiedName.new("Package::Class").qualified? # => true
-      #   QualifiedName.new("Class").qualified? # => false
-      def qualified?
-        !@package_path.nil? && !@package_path.empty?
-      end
-
-      # Check if this class is in the specified package.
-      #
-      # @param path [String, PackagePath] The package path to check
-      # @return [Boolean] true if the class is in the package
-      # @example
-      #   qname = QualifiedName.new("i-UR::urf::UrbanPlanningArea")
-      #   qname.in_package?("i-UR::urf") # => true
-      #   qname.in_package?("i-UR") # => false
-      def in_package?(path)
-        check_path = path.is_a?(PackagePath) ? path : PackagePath.new(path)
-        @package_path == check_path
-      end
-
-      # Check if this qualified name matches a glob pattern.
-      #
-      # @param pattern [String] The glob pattern to match against
-      # @return [Boolean] true if matches
-      # @example
-      #   qname = QualifiedName.new("Package1::Package2::ClassName")
-      #   qname.matches_glob?("Package1::*::ClassName") # => true
-      def matches_glob?(pattern)
-        # Create a full path for matching (package + class)
-        full_segments = if @package_path.is_a?(PackagePath) &&
-            !@package_path.segments.empty?
-                          @package_path.segments + [@class_name]
-                        else
-                          [@class_name]
-                        end
-
-        full_path = PackagePath.new(full_segments)
-        full_path.matches_glob?(pattern)
-      end
-
-      # Create a new qualified name with a different package path.
-      #
-      # @param new_package_path [PackagePath] The new package path
-      # @return [QualifiedName] A new qualified name with the package replaced
-      # @example
-      #   qname = QualifiedName.new("Package1::ClassName")
-      #   new_path = PackagePath.new("Package2")
-      #   qname.with_package(new_path) # => QualifiedName("Package2::ClassName")
-      def with_package(new_package_path)
-        if new_package_path.empty?
-          self.class.new(@class_name)
-        else
-          self.class.new("#{new_package_path}#{PackagePath::SEPARATOR}#{@class_name}")
-        end
-      end
-
-      # Get the relative qualified name from a base package path.
-      #
-      # @param base_path_string [String] The base package path
-      # @return [QualifiedName] The relative qualified name,
-      # or self if not relative
-      # @example
-      #   qname = QualifiedName.new("ModelRoot::i-UR::urf::UrbanPlanningArea")
-      #   qname.relative_to("ModelRoot::i-UR")
-      #   # => QualifiedName("urf::UrbanPlanningArea")
-      def relative_to(base_path_string)
-        relative_path = @package_path.relative_to(base_path_string)
-
-        # If package path didn't change, return self
-        return self if relative_path == @package_path
-
-        # Otherwise create new qualified name with relative path
-        if relative_path.empty?
-          self.class.new(@class_name)
-        else
-          self.class.new("#{relative_path}#{PackagePath::SEPARATOR}#{@class_name}")
-        end
-      end
-
-      # Check equality with another QualifiedName.
-      #
-      # @param other [Object] The object to compare with
-      # @return [Boolean] true if equal
-      def ==(other)
-        other.is_a?(QualifiedName) &&
-          @package_path == other.package_path &&
-          @class_name == other.class_name
-      end
-
-      alias eql? ==
-
-      # Generate hash code for this qualified name.
-      #
-      # @return [Integer] The hash code
-      def hash
-        [@package_path, @class_name].hash
-      end
-    end
-  end
-end

data/lib/lutaml/uml/realization.rb

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

data/lib/lutaml/uml/region.rb

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

data/lib/lutaml/uml/state.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class State < Vertex
-      attribute :exit, :string
-      attribute :entry, :string
-      attribute :do_activity, :string
-
-      yaml do
-        map "exit", to: :exit
-        map "entry", to: :entry
-        map "do_activity", to: :do_activity
-      end
-    end
-  end
-end

data/lib/lutaml/uml/state_machine.rb

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

data/lib/lutaml/uml/tagged_value.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    # Represents a tagged value (custom metadata) in UML
-    #
-    # Tagged values are name-value pairs that provide additional metadata
-    # for UML elements beyond the standard UML metamodel.
-    class TaggedValue < Lutaml::Model::Serializable
-      attribute :name, :string
-      attribute :value, :string
-      attribute :notes, :string
-
-      yaml do
-        map "name", to: :name
-        map "value", to: :value
-        map "notes", to: :notes
-      end
-    end
-  end
-end

data/lib/lutaml/uml/top_element.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class TopElement < Lutaml::Model::Serializable
-      attribute :name, :string
-      attribute :xmi_id, :string
-      attribute :xmi_uuid, :string
-      attribute :namespace, Namespace
-      attribute :keyword, :string
-      attribute :stereotype, :string, collection: true, default: -> { [] }
-      attribute :href, :string
-      attribute :visibility, :string, default: "public"
-      attribute :comments, :string, collection: true
-      attribute :tagged_values, TaggedValue, collection: true,
-                                             default: -> { [] }
-
-      attribute :definition, :string
-      attribute :full_name, :string
-
-      yaml do
-        map "name", to: :name
-        map "xmi_id", to: :xmi_id
-        map "xmi_uuid", to: :xmi_uuid
-        map "namespace", to: :namespace
-        map "keyword", to: :keyword
-        map "stereotype", to: :stereotype
-        map "href", to: :href
-        map "visibility", to: :visibility
-        map "comments", to: :comments
-        map "tagged_values", to: :tagged_values
-
-        map "definition", to: :definition, with: {
-          to: :definition_to_yaml, from: :definition_from_yaml
-        }
-        map "full_name", with: {
-          to: :full_name_to_yaml, from: :full_name_from_yaml
-        }
-      end
-
-      def definition_to_yaml(model, doc)
-        doc["definition"] = model.definition if model.definition
-      end
-
-      def definition_from_yaml(model, value)
-        model.definition = value.to_s
-          .gsub(/\\}/, "}")
-          .gsub(/\\{/, "{")
-          .split("\n")
-          .map(&:strip)
-          .join("\n")
-      end
-
-      def full_name_to_yaml(model, doc) # rubocop:disable Metrics/MethodLength
-        return model.full_name if model.full_name
-
-        # If full_name is not set, calculate it
-        full_name = nil
-        if model.name == nil
-          return full_name
-        end
-
-        full_name = model.name
-        next_namespace = model.namespace
-
-        while !next_namespace.nil?
-          full_name = if next_namespace.name.nil?
-                        "::#{full_name}"
-                      else
-                        "#{next_namespace.name}::#{full_name}"
-                      end
-          next_namespace = next_namespace.namespace
-        end
-
-        doc["full_name"] = full_name
-      end
-
-      def full_name_from_yaml(model, value)
-        model.full_name = value
-      end
-    end
-  end
-end

data/lib/lutaml/uml/top_element_attribute.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class TopElementAttribute < Lutaml::Model::Serializable
-      attribute :name, :string
-      attribute :visibility, :string, default: "public"
-      attribute :type, :string
-      attribute :id, :string
-      attribute :xmi_id, :string
-      attribute :contain, :string
-      attribute :static, :string
-      attribute :cardinality, Cardinality
-      attribute :keyword, :string
-      attribute :is_derived, :boolean, default: false
-      attribute :is_static, :boolean, default: false
-      attribute :is_read_only, :boolean, default: false
-      attribute :default, :string
-      attribute :stereotype, :string, collection: true, default: -> { [] }
-
-      attribute :definition, :string
-      attribute :association, :string
-      attribute :type_ns, :string
-      attribute :tagged_values, TaggedValue, collection: true, default: -> {
-        []
-      }
-
-      yaml do
-        map "name", to: :name
-        map "visibility", to: :visibility
-        map "type", to: :type
-        map "id", to: :id
-        map "xmi_id", to: :xmi_id
-        map "contain", to: :contain
-        map "static", to: :static
-        map "cardinality", to: :cardinality
-        map "keyword", to: :keyword
-        map "is_derived", to: :is_derived
-
-        map "definition", to: :definition, with: {
-          to: :definition_to_yaml, from: :definition_from_yaml
-        }
-        map "association", to: :association
-        map "type_ns", to: :type_ns
-        map "tagged_values", to: :tagged_values
-      end
-
-      def definition_to_yaml(model, doc)
-        doc["definition"] = model.definition if model.definition
-      end
-
-      def definition_from_yaml(model, value)
-        model.definition = value.to_s
-          .gsub(/\\}/, "}")
-          .gsub(/\\{/, "{")
-          .split("\n")
-          .map(&:strip)
-          .join("\n")
-      end
-    end
-  end
-end

data/lib/lutaml/uml/transition.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Transition < TopElement
-      attribute :source, :string
-      attribute :target, :string
-      attribute :guard, :string
-      attribute :effect, :string
-
-      yaml do
-        map "source", to: :source
-        map "target", to: :target
-        map "guard", to: :guard
-        map "effect", to: :effect
-      end
-    end
-  end
-end

data/lib/lutaml/uml/trigger.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Trigger < TopElement
-      attribute :event, :string
-
-      yaml do
-        map "event", to: :event
-      end
-    end
-  end
-end