lutaml 0.10.18 → 0.11.2

data/lib/lutaml/uml/model.rb

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

data/lib/lutaml/uml/model_helpers.rb

@@ -1,93 +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 then uml_class.split("::").last
-        when Class then 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 = @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,10 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Namespace < Lutaml::Model::Serializable
-      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,11 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class OpaqueBehavior < Behavior
-    end
-  end
-end

data/lib/lutaml/uml/operation.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Operation < TopElement
-      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,17 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class OperationParameter < Lutaml::Model::Serializable
-      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,31 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Package < TopElement
-      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

data/lib/lutaml/uml/package_path.rb

@@ -1,235 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    # Immutable value object representing a UML package path.
-    #
-    # A package path consists of one or more segments separated by "::".
-    # Examples:
-    #   - "ModelRoot"
-    #   - "ModelRoot::Conceptual Models"
-    #   - "ModelRoot::Conceptual Models::i-UR::urf"
-    #
-    # PackagePath objects are immutable and frozen after initialization.
-    class PackagePath
-      SEPARATOR = "::"
-
-      attr_reader :path
-
-      # Create a new PackagePath from a string or array.
-      #
-      # @param path [String, Array<String>]
-      # The package path string or array of segments
-      # @raise [ArgumentError] if path is nil
-      def initialize(path) # rubocop:disable Metrics/MethodLength
-        if path.nil?
-          raise ArgumentError, "Path cannot be nil"
-        end
-
-        # Handle both string and array inputs
-        @segments = if path.is_a?(Array)
-                      path.reject { |s| s.nil? || s.empty? }.freeze
-                    else
-                      # String input - allow empty string
-                      # Filter out empty segments from string paths
-                      path.split(SEPARATOR).reject(&:empty?).freeze
-                    end
-        @path = @segments.join(SEPARATOR).freeze
-
-        freeze
-      end
-
-      # Get the segments of this path.
-      #
-      # @return [Array<String>] The path segments
-      # @example
-      #   PackagePath.new("ModelRoot::i-UR::urf").segments
-      #   # => ["ModelRoot", "i-UR", "urf"]
-      def segments
-        @segments
-      end
-
-      # Get the separator used in package paths.
-      #
-      # @return [String] The separator ("::")
-      def separator
-        SEPARATOR
-      end
-
-      # Check if this is an absolute path (starts with "ModelRoot").
-      #
-      # @return [Boolean] true if absolute, false otherwise
-      def absolute?
-        segments.first == "ModelRoot"
-      end
-
-      # Get the depth of this path.
-      #
-      # Depth is counted as number of separators (segments.size - 1).
-      #
-      # @return [Integer] The depth of the path (0 for single segment)
-      # @example
-      #   PackagePath.new("ModelRoot").depth # => 0
-      #   PackagePath.new("ModelRoot::i-UR").depth # => 1
-      #   PackagePath.new("ModelRoot::i-UR::urf").depth # => 2
-      def depth
-        return 0 if segments.empty?
-
-        segments.size - 1
-      end
-
-      # Get the parent path.
-      #
-      # @return [PackagePath, nil] The parent path, or nil if at root
-      # @example
-      #   PackagePath.new("ModelRoot::i-UR::urf").parent
-      #   # => PackagePath("ModelRoot::i-UR")
-      def parent
-        return nil if segments.size <= 1
-
-        self.class.new(segments[0...-1])
-      end
-
-      # Create a child path by appending a segment.
-      #
-      # @param name [String] The segment name to append
-      # @return [PackagePath] A new PackagePath with the appended segment
-      # @example
-      #   PackagePath.new("ModelRoot::i-UR").child("urf")
-      #   # => PackagePath("ModelRoot::i-UR::urf")
-      def child(name)
-        self.class.new("#{@path}#{SEPARATOR}#{name}")
-      end
-
-      # Get the relative path from a base path.
-      #
-      # @param base_path_string [String, PackagePath]
-      # The base path to calculate relative to
-      # @return [PackagePath] The relative path, or self if not relative
-      # @example
-      #   path = PackagePath.new("ModelRoot::i-UR::urf")
-      #   path.relative_to("ModelRoot::i-UR")
-      #   # => PackagePath("urf")
-      def relative_to(base_path_string)
-        base = if base_path_string.is_a?(PackagePath)
-                 base_path_string
-               else
-                 self.class.new(base_path_string)
-               end
-        return self unless starts_with?(base)
-
-        remaining = segments[base.segments.size..]
-        return self.class.new("") if remaining.empty?
-
-        self.class.new(remaining)
-      end
-
-      # Check if this path starts with another path.
-      #
-      # @param other [PackagePath, String] The path to check against
-      # @return [Boolean] true if this path starts with other
-      # @example
-      #   path = PackagePath.new("ModelRoot::i-UR::urf")
-      #   path.starts_with?("ModelRoot::i-UR") # => true
-      #   path.starts_with?("ModelRoot::CityGML") # => false
-      def starts_with?(other)
-        other_path = other.is_a?(PackagePath) ? other : self.class.new(other)
-        return false if other_path.segments.size > segments.size
-
-        segments[0...other_path.segments.size] == other_path.segments
-      end
-
-      # Check if this path matches a glob pattern.
-      #
-      # Supports:
-      #   - "*" to match a single segment
-      #   - "**" to match zero or more segments
-      #
-      # @param pattern [String] The glob pattern
-      # @return [Boolean] true if the path matches the pattern
-      # @example
-      #   path = PackagePath.new("ModelRoot::i-UR::urf")
-      #   path.matches_glob?("ModelRoot::*::urf") # => true
-      #   path.matches_glob?("ModelRoot::**") # => true
-      #   path.matches_glob?("ModelRoot::*") # => false
-      def matches_glob?(pattern)
-        pattern_segments = pattern.split(SEPARATOR)
-        match_segments(segments, pattern_segments)
-      end
-
-      # Check if this path is empty.
-      #
-      # @return [Boolean] true if empty (no segments)
-      def empty?
-        @segments.empty?
-      end
-
-      # Convert to string representation.
-      #
-      # @return [String] The path as a string
-      def to_s
-        @path
-      end
-
-      # Check equality with another PackagePath.
-      #
-      # @param other [Object] The object to compare with
-      # @return [Boolean] true if equal
-      def ==(other)
-        other.is_a?(PackagePath) && @path == other.path
-      end
-
-      alias eql? ==
-
-      # Generate hash code for this path.
-      #
-      # @return [Integer] The hash code
-      def hash
-        @path.hash
-      end
-
-      private
-
-      # Recursively match path segments against pattern segments.
-      #
-      # @param path_segs [Array<String>] Remaining path segments
-      # @param pattern_segs [Array<String>] Remaining pattern segments
-      # @return [Boolean] true if segments match pattern
-      def match_segments(path_segs, pattern_segs) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        return path_segs.empty? if pattern_segs.empty?
-        return false if path_segs.empty? && !pattern_segs.all?("**")
-
-        pattern_seg = pattern_segs.first
-
-        case pattern_seg
-        when "**"
-          # Match zero or more segments
-          return true if pattern_segs.size == 1
-
-          # Try matching with 0, 1, 2, ... segments consumed
-          (0..path_segs.size).any? do |i|
-            match_segments(path_segs[i..], pattern_segs[1..])
-          end
-        when "*"
-          # Match exactly one segment
-          return false if path_segs.empty?
-
-          match_segments(path_segs[1..], pattern_segs[1..])
-        else
-          # Match segment - support string wildcards like "Class*"
-          return false if path_segs.empty?
-
-          if pattern_seg.include?("*")
-            # Convert glob pattern to regex
-            regex_pattern = Regexp.escape(pattern_seg).gsub('\*', ".*")
-            return false unless path_segs.first.match?(/\A#{regex_pattern}\z/)
-          else
-            return false unless path_segs.first == pattern_seg
-          end
-
-          match_segments(path_segs[1..], pattern_segs[1..])
-        end
-      end
-    end
-  end
-end