Class: Ea::Qea::Factory::BaseTransformer

Inherits:
Object
  • Object
show all
Defined in:
lib/ea/qea/factory/base_transformer.rb

Overview

Abstract base class for all EA to UML transformers Implements the Strategy pattern for model transformation

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(database) ⇒ BaseTransformer

Initialize transformer with database reference

Parameters:



13
14
15
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 13

def initialize(database)
  @database = database
end

Instance Attribute Details

#database ⇒ Object (readonly)

Returns the value of attribute database.



9
10
11
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 9

def database
  @database
end

Instance Method Details

#find_object_by_id(object_id) ⇒ Models::EaObject?

Find object by ID

Parameters:

  • object_id (Integer) —

    Object ID

Returns:



117
118
119
120
121
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 117

def find_object_by_id(object_id)
  return nil if object_id.nil?

  database.find_object(object_id)
end

#load_attributes(object_id) ⇒ Array<Lutaml::Uml::TopElementAttribute>

Load and transform attributes for an object

Parameters:

  • object_id (Integer) —

    Object ID

Returns:

  • (Array<Lutaml::Uml::TopElementAttribute>) —

    UML attributes



136
137
138
139
140
141
142
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 136

def load_attributes(object_id)
  return [] if object_id.nil?

  ea_attributes = database.attributes_for_object(object_id)
    .sort_by { |a| a.pos || 0 }
  AttributeTransformer.new(database).transform_collection(ea_attributes)
end

#load_constraints(object_id) ⇒ Array<Lutaml::Uml::Constraint>

Load and transform constraints for an object

Parameters:

  • object_id (Integer) —

    Object ID

Returns:

  • (Array<Lutaml::Uml::Constraint>) —

    UML constraints



158
159
160
161
162
163
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 158

def load_constraints(object_id)
  return [] if object_id.nil?

  ea_constraints = database.constraints_for_object(object_id)
  ConstraintTransformer.new(database).transform_collection(ea_constraints)
end

#load_object_properties(object_id) ⇒ Array<Lutaml::Uml::TaggedValue>

Load and transform object properties for an object

Parameters:

  • object_id (Integer) —

    Object ID

Returns:

  • (Array<Lutaml::Uml::TaggedValue>) —

    UML tagged values



168
169
170
171
172
173
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 168

def load_object_properties(object_id)
  return [] if object_id.nil?

  ea_props = database.properties_for_object(object_id)
  ObjectPropertyTransformer.new(database).transform_collection(ea_props)
end

#load_operations(object_id) ⇒ Array<Lutaml::Uml::Operation>

Load and transform operations for an object

Parameters:

  • object_id (Integer) —

    Object ID

Returns:

  • (Array<Lutaml::Uml::Operation>) —

    UML operations



147
148
149
150
151
152
153
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 147

def load_operations(object_id)
  return [] if object_id.nil?

  ea_operations = database.operations_for_object(object_id)
    .sort_by { |op| op.pos || 0 }
  OperationTransformer.new(database).transform_collection(ea_operations)
end

#load_tagged_values(ea_guid) ⇒ Array<Lutaml::Uml::TaggedValue>

Load and transform tagged values for an element

Parameters:

  • ea_guid (String) —

    Element GUID

Returns:

  • (Array<Lutaml::Uml::TaggedValue>) —

    UML tagged values



126
127
128
129
130
131
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 126

def load_tagged_values(ea_guid)
  return [] if ea_guid.nil?

  ea_tags = database.tagged_values_for_element(ea_guid)
  TaggedValueTransformer.new(database).transform_collection(ea_tags)
end

#map_visibility(ea_visibility) ⇒ String

Map EA visibility to UML visibility

Parameters:

  • ea_visibility (String) —

    EA visibility value

Returns:

  • (String) —

    UML visibility value



38
39
40
41
42
43
44
45
46
47
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 38

def map_visibility(ea_visibility) # rubocop:disable Metrics/CyclomaticComplexity
  return "public" if ea_visibility.nil? || ea_visibility.empty?

  case ea_visibility.downcase
  when "private" then "private"
  when "protected" then "protected"
  when "package" then "package"
  else "public"
  end
end

#normalize_guid_to_xmi_format(ea_guid, prefix = "EAID") ⇒ String?

Normalize EA GUID to XMI ID format Converts GUID-WITH-HYPHENS to PREFIX_GUID_WITH_UNDERSCORES "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" "PREFIX_XXXXXXXX_XXXX_XXXX_XXXX_XXXXXXXXXXXX"

Parameters:

  • ea_guid (String) —

    EA GUID in format

  • prefix (String) (defaults to: "EAID") —

    Prefix to add (e.g., "EAID", "EAPK")

Returns:

  • (String, nil) —

    XMI ID in format



84
85
86
87
88
89
90
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 84

def normalize_guid_to_xmi_format(ea_guid, prefix = "EAID")
  return nil if ea_guid.nil? || ea_guid.empty?

  # Remove braces and replace hyphens with underscores
  clean = ea_guid.tr("{}", "").tr("-", "_")
  "#{prefix}_#{clean}"
end

#normalize_guid_to_xmi_src_dst_format(ea_guid, prefix = "EAID", is_src = true) ⇒ Object

Convert ea_guid to XMI SRC ID format



93
94
95
96
97
98
99
100
101
102
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 93

def normalize_guid_to_xmi_src_dst_format(
  ea_guid, prefix = "EAID", is_src = true # rubocop:disable Style/OptionalBooleanParameter
)
  xmi_id = normalize_guid_to_xmi_format(ea_guid, prefix)

  # Trim prefix and add _src or _dst
  src_dst = is_src ? "src" : "dst"
  clean = xmi_id[(prefix.length + 3), xmi_id.length]
  "#{prefix}_#{src_dst}#{clean}"
end

#normalize_line_endings(text) ⇒ String?

Normalize line endings from Windows (\r\n) to Unix (\n) EA database stores text with Windows line endings, but XMI uses Unix

Parameters:

  • text (String, nil) —

    Text to normalize

Returns:

  • (String, nil) —

    Text with normalized line endings



108
109
110
111
112
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 108

def normalize_line_endings(text)
  return nil if text.nil?

  text.gsub("\r\n", "\n")
end

#parse_cardinality(cardinality_str) ⇒ Hash

Parse cardinality string to min/max values

Parameters:

  • cardinality_str (String) —

    Cardinality string (e.g., "0..1", "1..*")

Returns:

  • (Hash) —

    Hash with :min and :max keys



53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 53

def parse_cardinality(cardinality_str)
  return { min: nil, max: nil } if cardinality_str.nil? ||
    cardinality_str.empty?

  parts = cardinality_str.split("..")
  if parts.size == 2
    { min: parts[0], max: parts[1] }
  elsif parts.size == 1
    { min: parts[0], max: parts[0] }
  else
    { min: nil, max: nil }
  end
end

#to_boolean(value) ⇒ Boolean

Convert boolean-like values to actual boolean

Parameters:

  • value (Object) —

    Value to convert

Returns:

  • (Boolean) —

    Boolean value



70
71
72
73
74
75
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 70

def to_boolean(value)
  return false if value.nil?
  return value if [true, false].include?(value)

  value.to_s == "1" || value.to_s.downcase == "true"
end

#transform(ea_model) ⇒ Object

Transform a single EA model to UML model

Parameters:

  • ea_model (BaseModel) —

    EA model instance

Returns:

  • (Object) —

    UML model instance

Raises:

  • (NotImplementedError) —

    Must be implemented by subclasses



21
22
23
24
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 21

def transform(ea_model)
  raise NotImplementedError,
        "#{self.class} must implement #transform"
end

#transform_collection(collection) ⇒ Array<Object>

Transform a collection of EA models to UML models

Parameters:

  • collection (Array<BaseModel>) —

    Collection of EA models

Returns:

  • (Array<Object>) —

    Collection of UML models



29
30
31
32
33
 
# File 'lib/ea/qea/factory/base_transformer.rb', line 29

def transform_collection(collection)
  return [] if collection.nil? || collection.empty?

  collection.filter_map { |item| transform(item) }
end