Class: Lutaml::Uml::QualifiedName

Inherits:
Object
  • Object
show all
Defined in:
lib/lutaml/uml/qualified_name.rb

Overview

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.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(qualified_name) ⇒ QualifiedName

Create a new QualifiedName.

array of segments

(e.g., "i-UR::urf::UrbanPlanningArea" or
["i-UR", "urf", "UrbanPlanningArea"])

Parameters:

  • qualified_name (String, Array<String>) —

    The full qualified name or

Raises:

  • (ArgumentError) —

    if qualified_name is nil



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/lutaml/uml/qualified_name.rb', line 25

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

Instance Attribute Details

#class_name ⇒ Object (readonly)

Returns the value of attribute class_name.



16
17
18
 
# File 'lib/lutaml/uml/qualified_name.rb', line 16

def class_name
  @class_name
end

#package_path ⇒ Object (readonly)

Returns the value of attribute package_path.



16
17
18
 
# File 'lib/lutaml/uml/qualified_name.rb', line 16

def package_path
  @package_path
end

Instance Method Details

#==(other) ⇒ Boolean Also known as: eql?

Check equality with another QualifiedName.

Parameters:

  • other (Object) —

    The object to compare with

Returns:

  • (Boolean) —

    true if equal



159
160
161
162
163
 
# File 'lib/lutaml/uml/qualified_name.rb', line 159

def ==(other)
  other.is_a?(QualifiedName) &&
    @package_path == other.package_path &&
    @class_name == other.class_name
end

#hash ⇒ Integer

Generate hash code for this qualified name.

Returns:

  • (Integer) —

    The hash code



170
171
172
 
# File 'lib/lutaml/uml/qualified_name.rb', line 170

def hash
  [@package_path, @class_name].hash
end

#in_package?(path) ⇒ Boolean

Check if this class is in the specified package.

Examples:

qname = QualifiedName.new("i-UR::urf::UrbanPlanningArea")
qname.in_package?("i-UR::urf") # => true
qname.in_package?("i-UR") # => false

Parameters:

  • path (String, PackagePath) —

    The package path to check

Returns:

  • (Boolean) —

    true if the class is in the package



91
92
93
94
 
# File 'lib/lutaml/uml/qualified_name.rb', line 91

def in_package?(path)
  check_path = path.is_a?(PackagePath) ? path : PackagePath.new(path)
  @package_path == check_path
end

#matches_glob?(pattern) ⇒ Boolean

Check if this qualified name matches a glob pattern.

Examples:

qname = QualifiedName.new("Package1::Package2::ClassName")
qname.matches_glob?("Package1::*::ClassName") # => true

Parameters:

  • pattern (String) —

    The glob pattern to match against

Returns:

  • (Boolean) —

    true if matches



103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/lutaml/uml/qualified_name.rb', line 103

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

#qualified? ⇒ Boolean

Check if this is a qualified name (has a package path).

Examples:

QualifiedName.new("Package::Class").qualified? # => true
QualifiedName.new("Class").qualified? # => false

Returns:

  • (Boolean) —

    true if qualified (has package), false if unqualified



79
80
81
 
# File 'lib/lutaml/uml/qualified_name.rb', line 79

def qualified?
  !@package_path.nil? && !@package_path.empty?
end

#relative_to(base_path_string) ⇒ QualifiedName

Get the relative qualified name from a base package path.

or self if not relative

Examples:

qname = QualifiedName.new("ModelRoot::i-UR::urf::UrbanPlanningArea")
qname.relative_to("ModelRoot::i-UR")
# => QualifiedName("urf::UrbanPlanningArea")

Parameters:

  • base_path_string (String) —

    The base package path

Returns:



141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/lutaml/uml/qualified_name.rb', line 141

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

#to_s ⇒ String

Convert to string representation.

Examples:

qname = QualifiedName.new("i-UR::urf::UrbanPlanningArea")
qname.to_s # => "i-UR::urf::UrbanPlanningArea"

Returns:

  • (String) —

    The fully qualified name (empty string for empty name)



62
63
64
65
66
67
68
69
70
71
 
# File 'lib/lutaml/uml/qualified_name.rb', line 62

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

#with_package(new_package_path) ⇒ QualifiedName

Create a new qualified name with a different package path.

Examples:

qname = QualifiedName.new("Package1::ClassName")
new_path = PackagePath.new("Package2")
qname.with_package(new_path) # => QualifiedName("Package2::ClassName")

Parameters:

  • new_package_path (PackagePath) —

    The new package path

Returns:

  • (QualifiedName) —

    A new qualified name with the package replaced



124
125
126
127
128
129
130
 
# File 'lib/lutaml/uml/qualified_name.rb', line 124

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