Module: Puppet::Pops::Types::TypeFactory
- Defined in:
- lib/puppet/pops/types/type_factory.rb
Class Method Summary collapse
-
.all_callables ⇒ Object
Produces a CallableType matching all callables.
-
.any ⇒ Object
Produces the Any type.
-
.array_of(o, size_type = nil) ⇒ Object
Produces a type for Array where o is either a type, or an instance for which a type is inferred.
-
.array_of_any ⇒ Object
Produces a type for Array.
-
.array_of_data ⇒ Object
Produces a type for Array.
-
.binary ⇒ Object
Creates an instance of the Binary type.
-
.boolean(value = nil) ⇒ Object
Produces the Boolean type.
-
.callable(*params) ⇒ Object
Produces a Callable type with one signature without support for a block Use #with_block, or #with_optional_block to add a block to the callable If no parameters are given, the Callable will describe a signature that does not accept parameters.
-
.catalog_entry ⇒ Object
Produces an instance of the abstract type PCatalogEntryType.
-
.clear ⇒ Object
Clears caches - used when testing.
-
.collection(size_type = nil) ⇒ Object
Produces the abstract type Collection.
-
.data ⇒ Object
Produces the Data type.
-
.default ⇒ Object
Creates an instance of the Default type.
- .deferred ⇒ Object
-
.enum(*values) ⇒ Object
Produces the Enum type, optionally with specific string values.
-
.error ⇒ Object
Produces a type for Error.
-
.float ⇒ Object
Produces the Float type.
-
.float_range(from, to) ⇒ Object
Produces a Float range type.
-
.hash_kv(key_type, value_type, size_type = nil) ⇒ PHashType
Produces a type for Hash.
-
.hash_of(value, key = scalar, size_type = nil) ⇒ Object
Produces a type for Hash[Scalar, o] where o is either a type, or an instance for which a type is inferred.
-
.hash_of_any ⇒ Object
Produces a type for Hash.
-
.hash_of_data ⇒ Object
Produces a type for Hash.
-
.host_class(class_name = nil) ⇒ Object
Produces PClassType with a string class_name.
-
.init(*args) ⇒ Object
Produces the Init type.
-
.integer ⇒ Object
Produces the Integer type.
-
.is_range_parameter?(t) ⇒ Boolean
Returns true if the given type t is of valid range parameter type (integer or literal default).
-
.iterable(elem_type = nil) ⇒ Object
Produces the Iterable type.
-
.iterator(elem_type = nil) ⇒ Object
Produces the Iterator type.
-
.label(t) ⇒ Object
Produces a string representation of the type.
- .not_undef(inst_type = nil) ⇒ PNotUndefType
-
.numeric ⇒ Object
Produces the Numeric type.
-
.object(hash = nil, loader = nil) ⇒ PObjectType
Produces an ‘Object` type from the given hash that represents the features of the object.
-
.optional(optional_type = nil) ⇒ POptionalType
Produces the Optional type, i.e.
- .pattern(*regular_expressions) ⇒ Object
-
.range(from, to) ⇒ Object
Produces an Integer range type.
-
.regexp(pattern = nil) ⇒ Object
Produces the Regexp type.
-
.resource(type_name = nil, title = nil) ⇒ Object
Produces a PResourceType with a String type_name A PResourceType with a nil or empty name is compatible with any other PResourceType.
-
.rich_data ⇒ Object
Produces the RichData type.
-
.rich_data_key ⇒ Object
Produces the RichData type.
-
.ruby(o) ⇒ Object
Produces a type for a class or infers a type for something that is not a class.
-
.ruby_type(class_name = nil) ⇒ Object
Generic creator of a RuntimeType - allows creating the Ruby type with nil name, or String name.
-
.runtime(runtime = nil, runtime_type_name = nil) ⇒ Object
Generic creator of a RuntimeType - allows creating the type with nil or String runtime_type_name.
-
.scalar ⇒ Object
Produces the Scalar type.
-
.scalar_data ⇒ Object
Produces the ScalarData type.
-
.sem_ver(*ranges) ⇒ Object
Produces an instance of the SemVer type.
-
.sem_ver_range ⇒ Object
Produces an instance of the SemVerRange type.
-
.sensitive(type = nil) ⇒ Object
Produces the Sensitive type.
-
.string(size_type_or_value = nil, *deprecated_second_argument) ⇒ Object
Produces the String type based on nothing, a string value that becomes an exact match constraint, or a parameterized Integer type that constraints the size.
-
.struct(hash = {}) ⇒ PStructType
Produces the Struct type, either a non parameterized instance representing all structs (i.e. all hashes) or a hash with entries where the key is either a literal String, an Enum with one entry, or a String representing exactly one value.
- .task ⇒ Object
- .timespan(*args) ⇒ Object
- .timestamp(*args) ⇒ Object
- .tuple(types = [], size_type = nil) ⇒ Object
-
.type_alias(name = nil, expression = nil) ⇒ PTypeAliasType
Returns the type alias for the given expression.
-
.type_of(o) ⇒ Object
Produce a type corresponding to the class of given unless given is a String, Class or a PAnyType.
-
.type_reference(type_string = nil) ⇒ PTypeReferenceType
Returns the type that represents a type reference with a given name and optional parameters.
- .type_set(hash = nil) ⇒ Object
-
.type_type(inst_type = nil) ⇒ Object
Produces a type for Type.
-
.undef ⇒ Object
Creates an instance of the Undef type.
-
.uri(string_uri_or_hash = nil) ⇒ Object
Produces a type for URI[String or Hash].
-
.variant(*types) ⇒ Object
Produces the Variant type, optionally with the “one of” types.
Class Method Details
.all_callables ⇒ Object
Produces a CallableType matching all callables
308 309 310 |
# File 'lib/puppet/pops/types/type_factory.rb', line 308 def self.all_callables return PCallableType::DEFAULT end |
.any ⇒ Object
Produces the Any type
254 255 256 |
# File 'lib/puppet/pops/types/type_factory.rb', line 254 def self.any PAnyType::DEFAULT end |
.array_of(o, size_type = nil) ⇒ Object
Produces a type for Array where o is either a type, or an instance for which a type is inferred.
459 460 461 |
# File 'lib/puppet/pops/types/type_factory.rb', line 459 def self.array_of(o, size_type = nil) PArrayType.new(type_of(o), size_type) end |
.array_of_any ⇒ Object
Produces a type for Array
485 486 487 |
# File 'lib/puppet/pops/types/type_factory.rb', line 485 def self.array_of_any PArrayType::DEFAULT end |
.array_of_data ⇒ Object
Produces a type for Array
492 493 494 |
# File 'lib/puppet/pops/types/type_factory.rb', line 492 def self.array_of_data @array_of_data_t = PArrayType.new(data) end |
.binary ⇒ Object
Creates an instance of the Binary type
402 403 404 |
# File 'lib/puppet/pops/types/type_factory.rb', line 402 def self.binary PBinaryType::DEFAULT end |
.boolean(value = nil) ⇒ Object
Produces the Boolean type
247 248 249 |
# File 'lib/puppet/pops/types/type_factory.rb', line 247 def self.boolean(value = nil) value.nil? ? PBooleanType::DEFAULT : (value ? PBooleanType::TRUE : PBooleanType::FALSE) end |
.callable(*params) ⇒ Object
Produces a Callable type with one signature without support for a block Use #with_block, or #with_optional_block to add a block to the callable If no parameters are given, the Callable will describe a signature that does not accept parameters. To create a Callable that matches all callables use #all_callables.
The params is a list of types, where the three last entries may be optionally followed by min, max count, and a Callable which is taken as the block_type. If neither min or max are specified the parameters must match exactly. A min < params.size means that the difference are optional. If max > params.size means that the last type repeats. if max is :default, the max value is unbound (infinity).
Params are given as a sequence of arguments to #type_of.
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 |
# File 'lib/puppet/pops/types/type_factory.rb', line 328 def self.callable(*params) if params.size == 2 && params[0].is_a?(Array) return_t = type_of(params[1]) params = params[0] else return_t = nil end last_callable = TypeCalculator.is_kind_of_callable?(params.last) block_t = last_callable ? params.pop : nil # compute a size_type for the signature based on the two last parameters if is_range_parameter?(params[-2]) && is_range_parameter?(params[-1]) size_type = range(params[-2], params[-1]) params = params[0, params.size - 2] elsif is_range_parameter?(params[-1]) size_type = range(params[-1], :default) params = params[0, params.size - 1] else size_type = nil end types = params.map {|p| type_of(p) } # If the specification requires types, and none were given, a Unit type is used if types.empty? && !size_type.nil? && size_type.range[1] > 0 types << PUnitType::DEFAULT end # create a signature tuple_t = tuple(types, size_type) PCallableType.new(tuple_t, block_t, return_t) end |
.catalog_entry ⇒ Object
Produces an instance of the abstract type PCatalogEntryType
407 408 409 |
# File 'lib/puppet/pops/types/type_factory.rb', line 407 def self.catalog_entry PCatalogEntryType::DEFAULT end |
.clear ⇒ Object
Clears caches - used when testing
10 11 12 13 14 15 16 17 18 19 20 |
# File 'lib/puppet/pops/types/type_factory.rb', line 10 def self.clear # these types are cached and needs to be nulled as the representation may change if loaders are cleared @data_t = nil @rich_data_t = nil @rich_data_key_t = nil @array_of_data_t = nil @hash_of_data_t = nil @error_t = nil @task_t = nil @deferred_t = nil end |
.collection(size_type = nil) ⇒ Object
Produces the abstract type Collection
363 364 365 |
# File 'lib/puppet/pops/types/type_factory.rb', line 363 def self.collection(size_type = nil) size_type.nil? ? PCollectionType::DEFAULT : PCollectionType.new(size_type) end |
.data ⇒ Object
Produces the Data type
370 371 372 |
# File 'lib/puppet/pops/types/type_factory.rb', line 370 def self.data @data_t ||= TypeParser.singleton.parse('Data', Loaders.static_loader) end |
.default ⇒ Object
Creates an instance of the Default type
396 397 398 |
# File 'lib/puppet/pops/types/type_factory.rb', line 396 def self.default PDefaultType::DEFAULT end |
.deferred ⇒ Object
542 543 544 |
# File 'lib/puppet/pops/types/type_factory.rb', line 542 def self.deferred @deferred_t ||= TypeParser.singleton.parse('Deferred') end |
.enum(*values) ⇒ Object
Produces the Enum type, optionally with specific string values
144 145 146 147 148 149 150 151 152 |
# File 'lib/puppet/pops/types/type_factory.rb', line 144 def self.enum(*values) last = values.last case_insensitive = false if last == true || last == false case_insensitive = last values = values[0...-1] end PEnumType.new(values, case_insensitive) end |
.error ⇒ Object
Produces a type for Error
534 535 536 |
# File 'lib/puppet/pops/types/type_factory.rb', line 534 def self.error @error_t ||= TypeParser.singleton.parse('Error', Loaders.loaders.puppet_system_loader) end |
.float ⇒ Object
Produces the Float type
52 53 54 |
# File 'lib/puppet/pops/types/type_factory.rb', line 52 def self.float PFloatType::DEFAULT end |
.float_range(from, to) ⇒ Object
Produces a Float range type
42 43 44 45 46 47 |
# File 'lib/puppet/pops/types/type_factory.rb', line 42 def self.float_range(from, to) # optimize eq with symbol (faster when it is left) from = Float(from) unless :default == from || from.nil? to = Float(to) unless :default == to || to.nil? PFloatType.new(from, to) end |
.hash_kv(key_type, value_type, size_type = nil) ⇒ PHashType
Produces a type for Hash
478 479 480 |
# File 'lib/puppet/pops/types/type_factory.rb', line 478 def self.hash_kv(key_type, value_type, size_type = nil) PHashType.new(key_type, value_type, size_type) end |
.hash_of(value, key = scalar, size_type = nil) ⇒ Object
Produces a type for Hash[Scalar, o] where o is either a type, or an instance for which a type is inferred.
467 468 469 |
# File 'lib/puppet/pops/types/type_factory.rb', line 467 def self.hash_of(value, key = scalar, size_type = nil) PHashType.new(type_of(key), type_of(value), size_type) end |
.hash_of_any ⇒ Object
Produces a type for Hash
499 500 501 |
# File 'lib/puppet/pops/types/type_factory.rb', line 499 def self.hash_of_any PHashType::DEFAULT end |
.hash_of_data ⇒ Object
Produces a type for Hash
506 507 508 |
# File 'lib/puppet/pops/types/type_factory.rb', line 506 def self.hash_of_data @hash_of_data_t = PHashType.new(string, data) end |
.host_class(class_name = nil) ⇒ Object
Produces PClassType with a string class_name. A PClassType with nil or empty name is compatible with any other PClassType. A PClassType with a given name is only compatible with a PClassType with the same name.
447 448 449 450 451 452 453 |
# File 'lib/puppet/pops/types/type_factory.rb', line 447 def self.host_class(class_name = nil) if class_name.nil? PClassType::DEFAULT else PClassType.new(class_name.sub(/^::/, '')) end end |
.init(*args) ⇒ Object
Produces the Init type
72 73 74 75 76 77 78 79 80 81 82 83 |
# File 'lib/puppet/pops/types/type_factory.rb', line 72 def self.init(*args) case args.size when 0 PInitType::DEFAULT when 1 type = args[0] type.nil? ? PInitType::DEFAULT : PInitType.new(type, EMPTY_ARRAY) else type = args.shift PInitType.new(type, args) end end |
.integer ⇒ Object
Produces the Integer type
25 26 27 |
# File 'lib/puppet/pops/types/type_factory.rb', line 25 def self.integer PIntegerType::DEFAULT end |
.is_range_parameter?(t) ⇒ Boolean
Returns true if the given type t is of valid range parameter type (integer or literal default).
625 626 627 |
# File 'lib/puppet/pops/types/type_factory.rb', line 625 def self.is_range_parameter?(t) t.is_a?(Integer) || t == 'default' || :default == t end |
.iterable(elem_type = nil) ⇒ Object
Produces the Iterable type
88 89 90 |
# File 'lib/puppet/pops/types/type_factory.rb', line 88 def self.iterable(elem_type = nil) elem_type.nil? ? PIterableType::DEFAULT : PIterableType.new(elem_type) end |
.iterator(elem_type = nil) ⇒ Object
Produces the Iterator type
95 96 97 |
# File 'lib/puppet/pops/types/type_factory.rb', line 95 def self.iterator(elem_type = nil) elem_type.nil? ? PIteratorType::DEFAULT : PIteratorType.new(elem_type) end |
.label(t) ⇒ Object
Produces a string representation of the type
102 103 104 |
# File 'lib/puppet/pops/types/type_factory.rb', line 102 def self.label(t) @type_calculator.string(t) end |
.not_undef(inst_type = nil) ⇒ PNotUndefType
519 520 521 522 |
# File 'lib/puppet/pops/types/type_factory.rb', line 519 def self.not_undef(inst_type = nil) inst_type = string(inst_type) if inst_type.is_a?(String) PNotUndefType.new(inst_type) end |
.numeric ⇒ Object
Produces the Numeric type
66 67 68 |
# File 'lib/puppet/pops/types/type_factory.rb', line 66 def self.numeric PNumericType::DEFAULT end |
.object(hash = nil, loader = nil) ⇒ PObjectType
Produces an ‘Object` type from the given hash that represents the features of the object
214 215 216 |
# File 'lib/puppet/pops/types/type_factory.rb', line 214 def self.object(hash = nil, loader = nil) hash.nil? || hash.empty? ? PObjectType::DEFAULT : PObjectType.new(hash, loader) end |
.optional(optional_type = nil) ⇒ POptionalType
Produces the Optional type, i.e. a short hand for Variant[T, Undef] If the given ‘optional_type’ argument is a String, then it will be converted into a String type that represents that string.
133 134 135 136 137 138 139 |
# File 'lib/puppet/pops/types/type_factory.rb', line 133 def self.optional(optional_type = nil) if optional_type.nil? POptionalType::DEFAULT else POptionalType.new(type_of(optional_type.is_a?(String) ? string(optional_type) : type_of(optional_type))) end end |
.pattern(*regular_expressions) ⇒ Object
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 |
# File 'lib/puppet/pops/types/type_factory.rb', line 267 def self.pattern(*regular_expressions) patterns = regular_expressions.map do |re| case re when String re_t = PRegexpType.new(re) re_t.regexp # compile it to catch errors re_t when Regexp PRegexpType.new(re) when PRegexpType re when PPatternType re.patterns else raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}" end end.flatten.uniq PPatternType.new(patterns) end |
.range(from, to) ⇒ Object
Produces an Integer range type
32 33 34 35 36 37 |
# File 'lib/puppet/pops/types/type_factory.rb', line 32 def self.range(from, to) # optimize eq with symbol (faster when it is left) from = :default == from if from == 'default' to = :default if to == 'default' PIntegerType.new(from, to) end |
.regexp(pattern = nil) ⇒ Object
Produces the Regexp type
263 264 265 |
# File 'lib/puppet/pops/types/type_factory.rb', line 263 def self.regexp(pattern = nil) pattern ? PRegexpType.new(pattern) : PRegexpType::DEFAULT end |
.resource(type_name = nil, title = nil) ⇒ Object
Produces a PResourceType with a String type_name A PResourceType with a nil or empty name is compatible with any other PResourceType. A PResourceType with a given name is only compatible with a PResourceType with the same name. (There is no resource-type subtyping in Puppet (yet)).
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 |
# File 'lib/puppet/pops/types/type_factory.rb', line 426 def self.resource(type_name = nil, title = nil) case type_name when PResourceType PResourceType.new(type_name.type_name, title) when String type_name = TypeFormatter.singleton.capitalize_segments(type_name) raise ArgumentError, "Illegal type name '#{type_name}'" unless type_name =~ Patterns::CLASSREF_EXT PResourceType.new(type_name, title) when nil raise ArgumentError, 'The type name cannot be nil, if title is given' unless title.nil? PResourceType::DEFAULT else raise ArgumentError, "The type name cannot be a #{type_name.class.name}" end end |
.rich_data ⇒ Object
Produces the RichData type
377 378 379 |
# File 'lib/puppet/pops/types/type_factory.rb', line 377 def self.rich_data @rich_data_t ||= TypeParser.singleton.parse('RichData', Loaders.static_loader) end |
.rich_data_key ⇒ Object
Produces the RichData type
384 385 386 |
# File 'lib/puppet/pops/types/type_factory.rb', line 384 def self.rich_data_key @rich_data_key_t ||= TypeParser.singleton.parse('RichDataKey', Loaders.static_loader) end |
.ruby(o) ⇒ Object .ruby(o) ⇒ Object
To get the type for the class’ class use ‘TypeCalculator.infer©`
Produces a type for a class or infers a type for something that is not a class
583 584 585 586 587 588 589 |
# File 'lib/puppet/pops/types/type_factory.rb', line 583 def self.ruby(o) if o.is_a?(Class) @type_calculator.type(o) else PRuntimeType.new(:ruby, o.class.name) end end |
.ruby_type(class_name = nil) ⇒ Object
Generic creator of a RuntimeType - allows creating the Ruby type with nil name, or String name. Also see ruby(o) which performs inference, or mapps a Ruby Class to its name.
595 596 597 |
# File 'lib/puppet/pops/types/type_factory.rb', line 595 def self.ruby_type(class_name = nil) PRuntimeType.new(:ruby, class_name) end |
.runtime(runtime = nil, runtime_type_name = nil) ⇒ Object
Generic creator of a RuntimeType - allows creating the type with nil or String runtime_type_name. Also see ruby_type(o) and ruby(o).
602 603 604 605 |
# File 'lib/puppet/pops/types/type_factory.rb', line 602 def self.runtime(runtime=nil, runtime_type_name = nil) runtime = runtime.to_sym if runtime.is_a?(String) PRuntimeType.new(runtime, runtime_type_name) end |
.scalar ⇒ Object
Produces the Scalar type
294 295 296 |
# File 'lib/puppet/pops/types/type_factory.rb', line 294 def self.scalar PScalarType::DEFAULT end |
.scalar_data ⇒ Object
Produces the ScalarData type
301 302 303 |
# File 'lib/puppet/pops/types/type_factory.rb', line 301 def self.scalar_data PScalarDataType::DEFAULT end |
.sem_ver(*ranges) ⇒ Object
Produces an instance of the SemVer type
417 418 419 |
# File 'lib/puppet/pops/types/type_factory.rb', line 417 def self.sem_ver(*ranges) ranges.empty? ? PSemVerType::DEFAULT : PSemVerType::new(ranges) end |
.sem_ver_range ⇒ Object
Produces an instance of the SemVerRange type
412 413 414 |
# File 'lib/puppet/pops/types/type_factory.rb', line 412 def self.sem_ver_range PSemVerRangeType::DEFAULT end |
.sensitive(type = nil) ⇒ Object
Produces the Sensitive type
59 60 61 |
# File 'lib/puppet/pops/types/type_factory.rb', line 59 def self.sensitive(type = nil) PSensitiveType.new(type) end |
.string(size_type_or_value = nil, *deprecated_second_argument) ⇒ Object
Produces the String type based on nothing, a string value that becomes an exact match constraint, or a parameterized Integer type that constraints the size.
111 112 113 114 115 116 117 118 119 120 121 122 |
# File 'lib/puppet/pops/types/type_factory.rb', line 111 def self.string(size_type_or_value = nil, *deprecated_second_argument) if deprecated_second_argument.empty? size_type_or_value.nil? ? PStringType::DEFAULT : PStringType.new(size_type_or_value) else if Puppet[:strict] != :off #TRANSLATORS 'TypeFactory#string' is a class and method name and should not be translated = _("Passing more than one argument to TypeFactory#string is deprecated") Puppet.warn_once('deprecations', "TypeFactory#string_multi_args", ) end deprecated_second_argument.size == 1 ? PStringType.new(deprecated_second_argument[0]) : PEnumType.new(*deprecated_second_argument) end end |
.struct(hash = {}) ⇒ PStructType
Produces the Struct type, either a non parameterized instance representing all structs (i.e. all hashes) or a hash with entries where the key is either a literal String, an Enum with one entry, or a String representing exactly one value. The key type may also be wrapped in a NotUndef or an Optional.
The value can be a ruby class, a String (interpreted as the name of a ruby class) or a Type.
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 |
# File 'lib/puppet/pops/types/type_factory.rb', line 172 def self.struct(hash = {}) tc = @type_calculator elements = hash.map do |key_type, value_type| value_type = type_of(value_type) raise ArgumentError, 'Struct element value_type must be a Type' unless value_type.is_a?(PAnyType) # TODO: Should have stricter name rule if key_type.is_a?(String) raise ArgumentError, 'Struct element key cannot be an empty String' if key_type.empty? key_type = string(key_type) # Must make key optional if the value can be Undef key_type = optional(key_type) if tc.assignable?(value_type, PUndefType::DEFAULT) else # assert that the key type is one of String[1], NotUndef[String[1]] and Optional[String[1]] case key_type when PNotUndefType # We can loose the NotUndef wrapper here since String[1] isn't optional anyway key_type = key_type.type s = key_type when POptionalType s = key_type.optional_type when PStringType s = key_type when PEnumType s = key_type.values.size == 1 ? PStringType.new(key_type.values[0]) : nil else raise ArgumentError, "Illegal Struct member key type. Expected NotUndef, Optional, String, or Enum. Got: #{key_type.class.name}" end unless s.is_a?(PStringType) && !s.value.nil? raise ArgumentError, "Unable to extract a non-empty literal string from Struct member key type #{tc.string(key_type)}" end end PStructElement.new(key_type, value_type) end PStructType.new(elements) end |
.task ⇒ Object
538 539 540 |
# File 'lib/puppet/pops/types/type_factory.rb', line 538 def self.task @task_t ||= TypeParser.singleton.parse('Task') end |
.timespan(*args) ⇒ Object
231 232 233 234 235 236 237 238 |
# File 'lib/puppet/pops/types/type_factory.rb', line 231 def self.timespan(*args) case args.size when 0 PTimespanType::DEFAULT else PTimespanType.new(*args) end end |
.timestamp(*args) ⇒ Object
222 223 224 225 226 227 228 229 |
# File 'lib/puppet/pops/types/type_factory.rb', line 222 def self.(*args) case args.size when 0 PTimestampType::DEFAULT else PTimestampType.new(*args) end end |
.tuple(types = [], size_type = nil) ⇒ Object
240 241 242 |
# File 'lib/puppet/pops/types/type_factory.rb', line 240 def self.tuple(types = [], size_type = nil) PTupleType.new(types.map {|elem| type_of(elem) }, size_type) end |
.type_alias(name = nil, expression = nil) ⇒ PTypeAliasType
Returns the type alias for the given expression
611 612 613 |
# File 'lib/puppet/pops/types/type_factory.rb', line 611 def self.type_alias(name = nil, expression = nil) name.nil? ? PTypeAliasType::DEFAULT : PTypeAliasType.new(name, expression) end |
.type_of(o) ⇒ Object
Produce a type corresponding to the class of given unless given is a String, Class or a PAnyType. When a String is given this is taken as a classname.
557 558 559 560 561 562 563 564 565 566 567 |
# File 'lib/puppet/pops/types/type_factory.rb', line 557 def self.type_of(o) if o.is_a?(Class) @type_calculator.type(o) elsif o.is_a?(PAnyType) o elsif o.is_a?(String) PRuntimeType.new(:ruby, o) else @type_calculator.infer_generic(o) end end |
.type_reference(type_string = nil) ⇒ PTypeReferenceType
Returns the type that represents a type reference with a given name and optional parameters.
619 620 621 |
# File 'lib/puppet/pops/types/type_factory.rb', line 619 def self.type_reference(type_string = nil) type_string == nil ? PTypeReferenceType::DEFAULT : PTypeReferenceType.new(type_string) end |
.type_set(hash = nil) ⇒ Object
218 219 220 |
# File 'lib/puppet/pops/types/type_factory.rb', line 218 def self.type_set(hash = nil) hash.nil? || hash.empty? ? PTypeSetType::DEFAULT : PTypeSetType.new(hash) end |
.type_type(inst_type = nil) ⇒ Object
Produces a type for Type
527 528 529 |
# File 'lib/puppet/pops/types/type_factory.rb', line 527 def self.type_type(inst_type = nil) inst_type.nil? ? PTypeType::DEFAULT : PTypeType.new(inst_type) end |
.undef ⇒ Object
Creates an instance of the Undef type
390 391 392 |
# File 'lib/puppet/pops/types/type_factory.rb', line 390 def self.undef PUndefType::DEFAULT end |
.uri(string_uri_or_hash = nil) ⇒ Object
Produces a type for URI[String or Hash]
549 550 551 |
# File 'lib/puppet/pops/types/type_factory.rb', line 549 def self.uri(string_uri_or_hash = nil) string_uri_or_hash.nil? ? PURIType::DEFAULT : PURIType.new(string_uri_or_hash) end |
.variant(*types) ⇒ Object
Produces the Variant type, optionally with the “one of” types
157 158 159 |
# File 'lib/puppet/pops/types/type_factory.rb', line 157 def self.variant(*types) PVariantType.maybe_create(types.map {|v| type_of(v) }) end |