Class: Puppet::Pops::Types::PTypeSetType
- Inherits:
-
PMetaType
- Object
- TypedModelObject
- PAnyType
- PMetaType
- Puppet::Pops::Types::PTypeSetType
- Defined in:
- lib/puppet/pops/types/p_type_set_type.rb
Defined Under Namespace
Classes: TypeSetLoader
Constant Summary collapse
- TYPE_STRING_OR_VERSION =
TypeFactory.variant(PStringType::NON_EMPTY, TypeFactory.sem_ver)
- TYPE_STRING_OR_RANGE =
TypeFactory.variant(PStringType::NON_EMPTY, TypeFactory.sem_ver_range)
- TYPE_TYPE_REFERENCE_I12N =
TypeFactory.struct({ KEY_NAME => Pcore::TYPE_QUALIFIED_REFERENCE, KEY_VERSION_RANGE => TYPE_STRING_OR_RANGE, TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI, TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS })
- TYPE_TYPESET_I12N =
TypeFactory.struct({ TypeFactory.optional(Pcore::KEY_PCORE_URI) => Pcore::TYPE_URI, Pcore::KEY_PCORE_VERSION => TYPE_STRING_OR_VERSION, TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI, TypeFactory.optional(KEY_NAME) => Pcore::TYPE_QUALIFIED_REFERENCE, TypeFactory.optional(KEY_VERSION) => TYPE_STRING_OR_VERSION, TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PVariantType.new([PTypeType::DEFAULT, PObjectType::TYPE_OBJECT_I12N]), PCollectionType::NOT_EMPTY_SIZE), TypeFactory.optional(KEY_REFERENCES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, TYPE_TYPE_REFERENCE_I12N, PCollectionType::NOT_EMPTY_SIZE), TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS, })
- DEFAULT =
self.new({ KEY_NAME => 'DefaultTypeSet', KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY, Pcore::KEY_PCORE_URI => Pcore::PCORE_URI, Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION, KEY_VERSION => SemanticPuppet::Version.new(0,0,0) })
Constants included from Annotatable
Instance Attribute Summary collapse
-
#annotations ⇒ Object
readonly
Returns the value of attribute annotations.
-
#name ⇒ Object
readonly
Returns the value of attribute name.
-
#name_authority ⇒ Object
readonly
Returns the value of attribute name_authority.
-
#pcore_uri ⇒ Object
readonly
Returns the value of attribute pcore_uri.
-
#pcore_version ⇒ Object
readonly
Returns the value of attribute pcore_version.
-
#references ⇒ Object
readonly
Returns the value of attribute references.
-
#types ⇒ Object
readonly
Returns the value of attribute types.
-
#version ⇒ Object
readonly
Returns the value of attribute version.
Attributes inherited from PMetaType
Class Method Summary collapse
Instance Method Summary collapse
-
#[](qname) ⇒ PAnyType?
Resolve a type in this type set using a qualified name.
- #_pcore_init_from_hash(init_hash) ⇒ Object private
-
#_pcore_init_hash ⇒ Hash{String => Object}
private
Produce a hash suitable for the initializer.
- #accept(visitor, guard) ⇒ Object
- #defines_type?(t) ⇒ Boolean
- #eql?(o) ⇒ Boolean
- #hash ⇒ Object
-
#initialize(name_or_init_hash, init_hash_expression = nil, name_authority = nil) ⇒ PTypeSetType
constructor
private
Initialize a TypeSet Type instance.
- #label ⇒ Object private
-
#name_for(t, default_name) ⇒ String
private
Returns the name by which the given type is referenced from within this type set.
- #resolve(loader) ⇒ Object private
- #resolve_hash(loader, init_hash) ⇒ Object private
- #resolve_literal_hash(loader, init_hash_expression) ⇒ Object private
Methods inherited from PMetaType
#instance?, #resolve_type_refs, #resolved?, #to_s
Methods included from Annotatable
#annotatable_accept, #init_annotatable
Methods inherited from PAnyType
#==, #assignable?, #callable?, #callable_args?, #callable_with?, #check_self_recursion, create, #create, #generalize, #instance?, #iterable?, #iterable_type, #kind_of_callable?, #loader, new_function, #new_function, #normalize, #really_instance?, #roundtrip_with_string?, simple_name, #simple_name, #to_alias_expanded_s, #to_s
Methods inherited from TypedModelObject
_pcore_type, create_ptype, register_ptypes
Methods included from PuppetObject
#_pcore_all_contents, #_pcore_contents, #_pcore_type, #to_s
Constructor Details
#initialize(name, init_hash_expression) ⇒ PTypeSetType #initialize(init_hash) ⇒ PTypeSetType
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Initialize a TypeSet Type instance. The initialization will use either a name and an initialization hash expression, or a fully resolved initialization hash.
90 91 92 93 94 95 96 97 98 99 100 101 102 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 90 def initialize(name_or_init_hash, init_hash_expression = nil, = nil) @types = EMPTY_HASH @references = EMPTY_HASH if name_or_init_hash.is_a?(Hash) _pcore_init_from_hash(name_or_init_hash) else # Creation using "type XXX = TypeSet[{}]". This means that the name is given @name = TypeAsserter.assert_instance_of('TypeSet name', Pcore::TYPE_QUALIFIED_REFERENCE, name_or_init_hash) @name_authority = TypeAsserter.assert_instance_of('TypeSet name_authority', Pcore::TYPE_URI, , true) @init_hash_expression = init_hash_expression end end |
Instance Attribute Details
#annotations ⇒ Object (readonly)
Returns the value of attribute annotations.
71 72 73 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 71 def annotations @annotations end |
#name ⇒ Object (readonly)
Returns the value of attribute name.
67 68 69 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 67 def name @name end |
#name_authority ⇒ Object (readonly)
Returns the value of attribute name_authority.
66 67 68 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 66 def @name_authority end |
#pcore_uri ⇒ Object (readonly)
Returns the value of attribute pcore_uri.
64 65 66 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 64 def pcore_uri @pcore_uri end |
#pcore_version ⇒ Object (readonly)
Returns the value of attribute pcore_version.
65 66 67 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 65 def pcore_version @pcore_version end |
#references ⇒ Object (readonly)
Returns the value of attribute references.
70 71 72 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 70 def references @references end |
#types ⇒ Object (readonly)
Returns the value of attribute types.
69 70 71 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 69 def types @types end |
#version ⇒ Object (readonly)
Returns the value of attribute version.
68 69 70 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 68 def version @version end |
Class Method Details
.register_ptype(loader, ir) ⇒ Object
60 61 62 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 60 def self.register_ptype(loader, ir) create_ptype(loader, ir, 'AnyType', '_pcore_init_hash' => TYPE_TYPESET_I12N.resolve(loader)) end |
Instance Method Details
#[](qname) ⇒ PAnyType?
Resolve a type in this type set using a qualified name. The resolved type may either be a type defined in this type set or a type defined in a type set that is referenced by this type set (nesting may occur to any level). The name resolution is case insensitive.
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 192 def [](qname) if qname.is_a?(Loader::TypedName) return nil unless qname.type == :type && qname. == @name_authority qname = qname.name end type = @types[qname] || @types[@dc_to_cc_map[qname.downcase]] if type.nil? && !@references.empty? segments = qname.split(TypeFormatter::NAME_SEGMENT_SEPARATOR) first = segments[0] type_set_ref = @references[first] || @references[@dc_to_cc_map[first.downcase]] if type_set_ref.nil? nil else type_set = type_set_ref.type_set case segments.size when 1 type_set when 2 type_set[segments[1]] else segments.shift type_set[segments.join(TypeFormatter::NAME_SEGMENT_SEPARATOR)] end end else type end end |
#_pcore_init_from_hash(init_hash) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 105 def _pcore_init_from_hash(init_hash) TypeAsserter.assert_instance_of('TypeSet initializer', TYPE_TYPESET_I12N, init_hash) # Name given to the loader have higher precedence than a name declared in the type @name ||= init_hash[KEY_NAME].freeze @name_authority ||= init_hash[KEY_NAME_AUTHORITY].freeze @pcore_version = PSemVerType.convert(init_hash[Pcore::KEY_PCORE_VERSION]).freeze unless Pcore::PARSABLE_PCORE_VERSIONS.include?(@pcore_version) raise ArgumentError, "The pcore version for TypeSet '#{@name}' is not understood by this runtime. Expected range #{Pcore::PARSABLE_PCORE_VERSIONS}, got #{@pcore_version}" end @pcore_uri = init_hash[Pcore::KEY_PCORE_URI].freeze @version = PSemVerType.convert(init_hash[KEY_VERSION]) @types = init_hash[KEY_TYPES] || EMPTY_HASH @types.freeze # Map downcase names to their camel-cased equivalent @dc_to_cc_map = {} @types.keys.each { |key| @dc_to_cc_map[key.downcase] = key } refs = init_hash[KEY_REFERENCES] if refs.nil? @references = EMPTY_HASH else ref_map = {} root_map = Hash.new { |h, k| h[k] = {} } refs.each do |ref_alias, ref| ref = TypeSetReference.new(self, ref) # Protect against importing the exact same name_authority/name combination twice if the version ranges intersect ref_name = ref.name ref_na = ref. || @name_authority na_roots = root_map[ref_na] ranges = na_roots[ref_name] if ranges.nil? na_roots[ref_name] = [ref.version_range] else unless ranges.all? { |range| (range & ref.version_range).nil? } raise ArgumentError, "TypeSet '#{@name}' references TypeSet '#{ref_na}/#{ref_name}' more than once using overlapping version ranges" end ranges << ref.version_range end if ref_map.has_key?(ref_alias) raise ArgumentError, "TypeSet '#{@name}' references a TypeSet using alias '#{ref_alias}' more than once" end if @types.has_key?(ref_alias) raise ArgumentError, "TypeSet '#{@name}' references a TypeSet using alias '#{ref_alias}'. The alias collides with the name of a declared type" end ref_map[ref_alias] = ref @dc_to_cc_map[ref_alias.downcase] = ref_alias ref_map[ref_alias] = ref end @references = ref_map.freeze end @dc_to_cc_map.freeze init_annotatable(init_hash) end |
#_pcore_init_hash ⇒ Hash{String => Object}
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Produce a hash suitable for the initializer
172 173 174 175 176 177 178 179 180 181 182 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 172 def _pcore_init_hash result = super() result[Pcore::KEY_PCORE_URI] = @pcore_uri unless @pcore_uri.nil? result[Pcore::KEY_PCORE_VERSION] = @pcore_version.to_s result[KEY_NAME_AUTHORITY] = @name_authority unless @name_authority.nil? result[KEY_NAME] = @name result[KEY_VERSION] = @version.to_s unless @version.nil? result[KEY_TYPES] = @types unless @types.empty? result[KEY_REFERENCES] = Hash[@references.map { |ref_alias, ref| [ref_alias, ref._pcore_init_hash] }] unless @references.empty? result end |
#accept(visitor, guard) ⇒ Object
248 249 250 251 252 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 248 def accept(visitor, guard) super @types.each_value { |type| type.accept(visitor, guard) } @references.each_value { |ref| ref.accept(visitor, guard) } end |
#defines_type?(t) ⇒ Boolean
222 223 224 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 222 def defines_type?(t) !@types.key(t).nil? end |
#eql?(o) ⇒ Boolean
348 349 350 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 348 def eql?(o) self.class == o.class && @name_authority == o. && @name == o.name && @version == o.version end |
#hash ⇒ Object
344 345 346 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 344 def hash @name_authority.hash ^ @name.hash ^ @version.hash end |
#label ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
255 256 257 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 255 def label "TypeSet '#{@name}'" end |
#name_for(t, default_name) ⇒ String
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Returns the name by which the given type is referenced from within this type set
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 231 def name_for(t, default_name) key = @types.key(t) if key.nil? if @references.empty? default_name else @references.each_pair do |ref_key, ref| ref_name = ref.type_set.name_for(t, nil) return "#{ref_key}::#{ref_name}" unless ref_name.nil? end default_name end else key end end |
#resolve(loader) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
260 261 262 263 264 265 266 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 260 def resolve(loader) super @references.each_value { |ref| ref.resolve(loader) } tsa_loader = TypeSetLoader.new(self, loader) @types.values.each { |type| type.resolve(tsa_loader) } self end |
#resolve_hash(loader, init_hash) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 323 def resolve_hash(loader, init_hash) result = Hash[init_hash.map do |key, value| key = resolve_type_refs(loader, key) value = resolve_type_refs(loader, value) unless key == KEY_TYPES && value.is_a?(Hash) [key, value] end] name_auth = (result, loader) types = result[KEY_TYPES] if types.is_a?(Hash) types.each do |type_name, value| full_name = "#{@name}::#{type_name}".freeze typed_name = Loader::TypedName.new(:type, full_name, name_auth) = value.is_a?(Hash) ? 'Object' : 'TypeAlias' type = Loader::TypeDefinitionInstantiator.create_named_type(full_name, , value, name_auth) loader.set_entry(typed_name, type) types[type_name] = type end end result end |
#resolve_literal_hash(loader, init_hash_expression) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 |
# File 'lib/puppet/pops/types/p_type_set_type.rb', line 269 def resolve_literal_hash(loader, init_hash_expression) result = {} type_parser = TypeParser.singleton init_hash_expression.entries.each do |entry| key = type_parser.interpret_any(entry.key, loader) if (key == KEY_TYPES || key == KEY_REFERENCES) && entry.value.is_a?(Model::LiteralHash) # Skip type parser interpretation and convert qualified references directly to String keys. hash = {} entry.value.entries.each do |he| kex = he.key name = kex.is_a?(Model::QualifiedReference) ? kex.cased_value : type_parser.interpret_any(kex, loader) hash[name] = key == KEY_TYPES ? he.value : type_parser.interpret_any(he.value, loader) end result[key] = hash else result[key] = type_parser.interpret_any(entry.value, loader) end end name_auth = (result, loader) types = result[KEY_TYPES] if types.is_a?(Hash) types.each do |type_name, value| full_name = "#{@name}::#{type_name}".freeze typed_name = Loader::TypedName.new(:type, full_name, name_auth) if value.is_a?(Model::ResourceDefaultsExpression) # This is actually a <Parent> { <key-value entries> } notation. Convert to a literal hash that contains the parent n = value.type_ref name = n.cased_value entries = [] unless name == 'Object' or name == 'TypeSet' if value.operations.any? { |op| op.attribute_name == KEY_PARENT } case Puppet[:strict] when :warning IssueReporter.warning(value, Issues::DUPLICATE_KEY, :key => KEY_PARENT) when :error IssueReporter.error(Puppet::ParseErrorWithIssue, value, Issues::DUPLICATE_KEY, :key => KEY_PARENT) end end entries << Model::KeyedEntry.new(n.locator, n.offset, n.length, KEY_PARENT, n) end value.operations.each { |op| entries << Model::KeyedEntry.new(op.locator, op.offset, op.length, op.attribute_name, op.value_expr) } value = Model::LiteralHash.new(value.locator, value.offset, value.length, entries) end type = Loader::TypeDefinitionInstantiator.create_type(full_name, value, name_auth) loader.set_entry(typed_name, type, value.locator.to_uri(value)) types[type_name] = type end end result end |