Module: Puppet::Pops::Types::TypeFactory

Defined in:
lib/puppet/pops/types/type_factory.rb

Class Method Summary collapse

Class Method Details

.all_callables ⇒ Object

Produces a CallableType matching all callables



315
316
317
 
# File 'lib/puppet/pops/types/type_factory.rb', line 315

def self.all_callables
  PCallableType::DEFAULT
end

.any ⇒ Object

Produces the Any type



261
262
263
 
# File 'lib/puppet/pops/types/type_factory.rb', line 261

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.



468
469
470
 
# File 'lib/puppet/pops/types/type_factory.rb', line 468

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



494
495
496
 
# File 'lib/puppet/pops/types/type_factory.rb', line 494

def self.array_of_any
  PArrayType::DEFAULT
end

.array_of_data ⇒ Object

Produces a type for Array



501
502
503
 
# File 'lib/puppet/pops/types/type_factory.rb', line 501

def self.array_of_data
  @array_of_data_t = PArrayType.new(data)
end

.binary ⇒ Object

Creates an instance of the Binary type



409
410
411
 
# File 'lib/puppet/pops/types/type_factory.rb', line 409

def self.binary
  PBinaryType::DEFAULT
end

.boolean(value = nil) ⇒ Object

Produces the Boolean type



250
251
252
253
254
255
256
 
# File 'lib/puppet/pops/types/type_factory.rb', line 250

def self.boolean(value = nil)
  if value.nil?
    PBooleanType::DEFAULT
  else
    value ? PBooleanType::TRUE : PBooleanType::FALSE
  end
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.



335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
 
# File 'lib/puppet/pops/types/type_factory.rb', line 335

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



414
415
416
 
# File 'lib/puppet/pops/types/type_factory.rb', line 414

def self.catalog_entry
  PCatalogEntryType::DEFAULT
end

.clear ⇒ Object

Clears caches - used when testing



12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/puppet/pops/types/type_factory.rb', line 12

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



370
371
372
 
# File 'lib/puppet/pops/types/type_factory.rb', line 370

def self.collection(size_type = nil)
  size_type.nil? ? PCollectionType::DEFAULT : PCollectionType.new(size_type)
end

.data ⇒ Object

Produces the Data type



377
378
379
 
# File 'lib/puppet/pops/types/type_factory.rb', line 377

def self.data
  @data_t ||= TypeParser.singleton.parse('Data', Loaders.static_loader)
end

.default ⇒ Object

Creates an instance of the Default type



403
404
405
 
# File 'lib/puppet/pops/types/type_factory.rb', line 403

def self.default
  PDefaultType::DEFAULT
end

.deferred ⇒ Object 



551
552
553
 
# File 'lib/puppet/pops/types/type_factory.rb', line 551

def self.deferred
  @deferred_t ||= TypeParser.singleton.parse('Deferred')
end

.enum(*values) ⇒ Object

Produces the Enum type, optionally with specific string values



146
147
148
149
150
151
152
153
154
 
# File 'lib/puppet/pops/types/type_factory.rb', line 146

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



543
544
545
 
# File 'lib/puppet/pops/types/type_factory.rb', line 543

def self.error
  @error_t ||= TypeParser.singleton.parse('Error', Loaders.loaders.puppet_system_loader)
end

.float ⇒ Object

Produces the Float type



54
55
56
 
# File 'lib/puppet/pops/types/type_factory.rb', line 54

def self.float
  PFloatType::DEFAULT
end

.float_range(from, to) ⇒ Object

Produces a Float range type



44
45
46
47
48
49
 
# File 'lib/puppet/pops/types/type_factory.rb', line 44

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

Parameters:

Returns:



487
488
489
 
# File 'lib/puppet/pops/types/type_factory.rb', line 487

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.



476
477
478
 
# File 'lib/puppet/pops/types/type_factory.rb', line 476

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



508
509
510
 
# File 'lib/puppet/pops/types/type_factory.rb', line 508

def self.hash_of_any
  PHashType::DEFAULT
end

.hash_of_data ⇒ Object

Produces a type for Hash



515
516
517
 
# File 'lib/puppet/pops/types/type_factory.rb', line 515

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.



456
457
458
459
460
461
462
 
# File 'lib/puppet/pops/types/type_factory.rb', line 456

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



74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/puppet/pops/types/type_factory.rb', line 74

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



27
28
29
 
# File 'lib/puppet/pops/types/type_factory.rb', line 27

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).

Returns:

  • (Boolean) 


635
636
637
 
# File 'lib/puppet/pops/types/type_factory.rb', line 635

def self.is_range_parameter?(t)
  t.is_a?(Integer) || t == 'default' || :default == t
end

.iterable(elem_type = nil) ⇒ Object

Produces the Iterable type



90
91
92
 
# File 'lib/puppet/pops/types/type_factory.rb', line 90

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



97
98
99
 
# File 'lib/puppet/pops/types/type_factory.rb', line 97

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



104
105
106
 
# File 'lib/puppet/pops/types/type_factory.rb', line 104

def self.label(t)
  @type_calculator.string(t)
end

.not_undef(inst_type = nil) ⇒ PNotUndefType

Produces a type for NotUndef The given ‘inst_type’ can be a string in which case it will be converted into the type String.

Parameters:

  • inst_type (Type, String) (defaults to: nil) —

    the type to qualify

Returns:



528
529
530
531
 
# File 'lib/puppet/pops/types/type_factory.rb', line 528

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



68
69
70
 
# File 'lib/puppet/pops/types/type_factory.rb', line 68

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

Parameters:

  • hash ({String=>Object}) (defaults to: nil) —

    the hash of feature groups

Returns:



217
218
219
 
# File 'lib/puppet/pops/types/type_factory.rb', line 217

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.

Parameters:

  • optional_type (String, PAnyType, nil) (defaults to: nil) —

    the optional type

Returns:



135
136
137
138
139
140
141
 
# File 'lib/puppet/pops/types/type_factory.rb', line 135

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 



274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'lib/puppet/pops/types/type_factory.rb', line 274

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



34
35
36
37
38
39
 
# File 'lib/puppet/pops/types/type_factory.rb', line 34

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

Parameters:

  • pattern (Regexp, String, nil) (defaults to: nil) —

    (nil) The regular expression object or a regexp source string, or nil for bare type



270
271
272
 
# File 'lib/puppet/pops/types/type_factory.rb', line 270

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)).



433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
 
# File 'lib/puppet/pops/types/type_factory.rb', line 433

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



384
385
386
 
# File 'lib/puppet/pops/types/type_factory.rb', line 384

def self.rich_data
  @rich_data_t ||= TypeParser.singleton.parse('RichData', Loaders.static_loader)
end

.rich_data_key ⇒ Object

Produces the RichData type



391
392
393
 
# File 'lib/puppet/pops/types/type_factory.rb', line 391

def self.rich_data_key
  @rich_data_key_t ||= TypeParser.singleton.parse('RichDataKey', Loaders.static_loader)
end

.ruby(o) ⇒ Object .ruby(o) ⇒ Object

Note:

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

Overloads:

  • .ruby(o) ⇒ Object

    Parameters:

    • o (Class) —

      produces the type corresponding to the class (e.g. Integer becomes PIntegerType)

  • .ruby(o) ⇒ Object

    Parameters:

    • o (Object) —

      produces the type corresponding to the instance class (e.g. 3 becomes PIntegerType)



593
594
595
596
597
598
599
 
# File 'lib/puppet/pops/types/type_factory.rb', line 593

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.



605
606
607
 
# File 'lib/puppet/pops/types/type_factory.rb', line 605

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).



612
613
614
615
 
# File 'lib/puppet/pops/types/type_factory.rb', line 612

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



301
302
303
 
# File 'lib/puppet/pops/types/type_factory.rb', line 301

def self.scalar
  PScalarType::DEFAULT
end

.scalar_data ⇒ Object

Produces the ScalarData type



308
309
310
 
# File 'lib/puppet/pops/types/type_factory.rb', line 308

def self.scalar_data
  PScalarDataType::DEFAULT
end

.sem_ver(*ranges) ⇒ Object

Produces an instance of the SemVer type



424
425
426
 
# File 'lib/puppet/pops/types/type_factory.rb', line 424

def self.sem_ver(*ranges)
  ranges.empty? ? PSemVerType::DEFAULT : PSemVerType.new(ranges)
end

.sem_ver_range ⇒ Object

Produces an instance of the SemVerRange type



419
420
421
 
# File 'lib/puppet/pops/types/type_factory.rb', line 419

def self.sem_ver_range
  PSemVerRangeType::DEFAULT
end

.sensitive(type = nil) ⇒ Object

Produces the Sensitive type



61
62
63
 
# File 'lib/puppet/pops/types/type_factory.rb', line 61

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.



113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/puppet/pops/types/type_factory.rb', line 113

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
      message = _("Passing more than one argument to TypeFactory#string is deprecated")
      Puppet.warn_once('deprecations', "TypeFactory#string_multi_args", message)
    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.

Parameters:

Returns:



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
208
209
210
 
# File 'lib/puppet/pops/types/type_factory.rb', line 174

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 



547
548
549
 
# File 'lib/puppet/pops/types/type_factory.rb', line 547

def self.task
  @task_t ||= TypeParser.singleton.parse('Task')
end

.timespan(*args) ⇒ Object 



234
235
236
237
238
239
240
241
 
# File 'lib/puppet/pops/types/type_factory.rb', line 234

def self.timespan(*args)
  case args.size
  when 0
    PTimespanType::DEFAULT
  else
    PTimespanType.new(*args)
  end
end

.timestamp(*args) ⇒ Object 



225
226
227
228
229
230
231
232
 
# File 'lib/puppet/pops/types/type_factory.rb', line 225

def self.timestamp(*args)
  case args.size
  when 0
    PTimestampType::DEFAULT
  else
    PTimestampType.new(*args)
  end
end

.tuple(types = [], size_type = nil) ⇒ Object 



243
244
245
 
# File 'lib/puppet/pops/types/type_factory.rb', line 243

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

Parameters:

  • name (String) (defaults to: nil) —

    the name of the unresolved type

  • expression (Model::Expression) (defaults to: nil) —

    an expression that will evaluate to a type

Returns:



621
622
623
 
# File 'lib/puppet/pops/types/type_factory.rb', line 621

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.



566
567
568
569
570
571
572
573
574
575
576
577
 
# File 'lib/puppet/pops/types/type_factory.rb', line 566

def self.type_of(o)
  case o
  when Class
    @type_calculator.type(o)
  when PAnyType
    o
  when 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.

Parameters:

  • type_string (String) (defaults to: nil) —

    the string form of the type

Returns:



629
630
631
 
# File 'lib/puppet/pops/types/type_factory.rb', line 629

def self.type_reference(type_string = nil)
  type_string.nil? ? PTypeReferenceType::DEFAULT : PTypeReferenceType.new(type_string)
end

.type_set(hash = nil) ⇒ Object 



221
222
223
 
# File 'lib/puppet/pops/types/type_factory.rb', line 221

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



536
537
538
 
# File 'lib/puppet/pops/types/type_factory.rb', line 536

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



397
398
399
 
# File 'lib/puppet/pops/types/type_factory.rb', line 397

def self.undef
  PUndefType::DEFAULT
end

.uri(string_uri_or_hash = nil) ⇒ Object

Produces a type for URI[String or Hash]



558
559
560
 
# File 'lib/puppet/pops/types/type_factory.rb', line 558

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



159
160
161
 
# File 'lib/puppet/pops/types/type_factory.rb', line 159

def self.variant(*types)
  PVariantType.maybe_create(types.map { |v| type_of(v) })
end