Module: Xmi::Versioned

Included in:
V20110701, V20131001, V20161101
Defined in:
lib/xmi/versioned.rb

Overview

Base module for version-specific XMI model trees.

Each version module (V20110701, V20131001, V20161101) extends this and declares its table entry via define_version, keeping only its real delta (version-specific model classes and what to register).

Examples:

module Xmi::V20131001
  extend Xmi::Versioned

  define_version(
    register_id: :xmi_20131001,
    namespaces: [Xmi::Namespace::Omg::Xmi20131001,
                 Xmi::Namespace::Omg::Uml20131001],
    fallbacks: %i[xmi_20110701 xmi_common default],
  )

  def self.register_models!
    register_models documentation: Documentation
  end
end

Constant Summary collapse

DEFAULT_FALLBACKS =

Fallback chain used when a version declares none: the common register, then the default register.

%i[xmi_common default].freeze

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.extended(base) ⇒ Object

Called when a module extends Versioned



33
34
35
36
37
38
 
# File 'lib/xmi/versioned.rb', line 33

def self.extended(base)
  base.class_eval do
    @version_register = nil
    @initialized = false
  end
end

Instance Method Details

#create_register ⇒ Lutaml::Model::Register

Create and configure the register

Returns:

  • (Lutaml::Model::Register) 


69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/xmi/versioned.rb', line 69

def create_register
  reg = Lutaml::Model::Register.new(register_id,
                                    fallback: fallback_registers)

  # Register in GlobalRegister first
  Lutaml::Model::GlobalRegister.register(reg)

  # Bind to all namespaces this version handles
  namespace_classes.each do |ns_class|
    reg.bind_namespace(ns_class)
  end

  @version_register = reg
end

#define_version(register_id:, namespaces:, fallbacks: DEFAULT_FALLBACKS) ⇒ void

This method returns an undefined value.

Declare this version's table entry.

Defines register_id, namespace_classes, and fallback_registers on the extending module. Versions that extend Versioned without calling this keep the NotImplementedError contract below.

Parameters:

  • register_id (Symbol) —

    Register ID for this version

  • namespaces (Array<Class>) —

    XmlNamespace classes to bind

  • fallbacks (Array<Symbol>) (defaults to: DEFAULT_FALLBACKS) —

    Fallback register IDs



51
52
53
54
55
 
# File 'lib/xmi/versioned.rb', line 51

def define_version(register_id:, namespaces:, fallbacks: DEFAULT_FALLBACKS)
  define_singleton_method(:register_id) { register_id }
  define_singleton_method(:namespace_classes) { namespaces }
  define_singleton_method(:fallback_registers) { fallbacks }
end

#fallback_registers ⇒ Array<Symbol>

Get fallback register IDs for this version

Default: fall back to common, then default. Override for version chains (e.g., V20161101 falls back to V20131001).

Returns:

  • (Array<Symbol>) 


145
146
147
 
# File 'lib/xmi/versioned.rb', line 145

def fallback_registers
  %i[xmi_common default]
end

#init_models! ⇒ void

This method returns an undefined value.

Initialize this version's model tree

This should be called after all version-specific models are defined. It registers all models in this version's register.



91
92
93
94
95
96
97
98
 
# File 'lib/xmi/versioned.rb', line 91

def init_models!
  return if @initialized

  register
  register_models!

  @initialized = true
end

#initialized? ⇒ Boolean

Check if this version has been initialized

Returns:

  • (Boolean) 


171
172
173
 
# File 'lib/xmi/versioned.rb', line 171

def initialized?
  @initialized
end

#namespace_classes ⇒ Array<Class>

Get namespace classes this version binds to

Returns:

  • (Array<Class>) —

    Array of Lutaml::Xml::Namespace subclasses

Raises:

  • (NotImplementedError) 


133
134
135
136
 
# File 'lib/xmi/versioned.rb', line 133

def namespace_classes
  raise NotImplementedError,
        "Each version must implement #namespace_classes"
end

#register ⇒ Lutaml::Model::Register

Get the register for this version

Returns:

  • (Lutaml::Model::Register) —

    The version-specific register



61
62
63
 
# File 'lib/xmi/versioned.rb', line 61

def register
  @register ||= create_register
end

#register_id ⇒ Symbol

Get the register ID for this version

Returns:

  • (Symbol)

Raises:

  • (NotImplementedError) 


124
125
126
127
 
# File 'lib/xmi/versioned.rb', line 124

def register_id
  raise NotImplementedError,
        "Each version must implement #register_id"
end

#register_models(models) ⇒ void

This method returns an undefined value.

Bulk-register models from a table.

Parameters:

  • models (Hash{Symbol => Class}) —

    id → model class



116
117
118
 
# File 'lib/xmi/versioned.rb', line 116

def register_models(models)
  models.each { |id, klass| register.register_model(klass, id: id) }
end

#register_models! ⇒ void

This method returns an undefined value.

Register all models for this version

Override in each version module to register specific models.

Raises:

  • (NotImplementedError) 


106
107
108
109
 
# File 'lib/xmi/versioned.rb', line 106

def register_models!
  raise NotImplementedError,
        "Each version must implement #register_models!"
end

#uml_namespace ⇒ Class?

Get the UML namespace class for this version

Returns:

  • (Class, nil) 


161
162
163
164
165
 
# File 'lib/xmi/versioned.rb', line 161

def uml_namespace
  namespace_classes.find do |ns|
    ns.uri.include?("/UML/") && !ns.uri.include?("UMLD")
  end
end

#xmi_namespace ⇒ Class?

Get the XMI namespace class for this version

Returns:

  • (Class, nil) 


153
154
155
 
# File 'lib/xmi/versioned.rb', line 153

def xmi_namespace
  namespace_classes.find { |ns| ns.uri.include?("/XMI/") }
end