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



272
273
274
 
# File 'lib/puppet/pops/types/type_factory.rb', line 272

def self.all_callables
  return PCallableType::DEFAULT
end

.any ⇒ Object

Produces the Any type



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

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.



416
417
418
 
# File 'lib/puppet/pops/types/type_factory.rb', line 416

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



442
443
444
 
# File 'lib/puppet/pops/types/type_factory.rb', line 442

def self.array_of_any
  PArrayType::DEFAULT
end

.array_of_data ⇒ Object

Produces a type for Array



449
450
451
 
# File 'lib/puppet/pops/types/type_factory.rb', line 449

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

.binary ⇒ Object

Creates an instance of the Binary type



359
360
361
 
# File 'lib/puppet/pops/types/type_factory.rb', line 359

def self.binary
  PBinaryType::DEFAULT
end

.boolean ⇒ Object

Produces the Boolean type



211
212
213
 
# File 'lib/puppet/pops/types/type_factory.rb', line 211

def self.boolean
  PBooleanType::DEFAULT
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.



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
321
322
 
# File 'lib/puppet/pops/types/type_factory.rb', line 292

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



364
365
366
 
# File 'lib/puppet/pops/types/type_factory.rb', line 364

def self.catalog_entry
  PCatalogEntryType::DEFAULT
end

.collection(size_type = nil) ⇒ Object

Produces the abstract type Collection



327
328
329
 
# File 'lib/puppet/pops/types/type_factory.rb', line 327

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

.data ⇒ Object

Produces the Data type



334
335
336
 
# File 'lib/puppet/pops/types/type_factory.rb', line 334

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

.default ⇒ Object

Creates an instance of the Default type



353
354
355
 
# File 'lib/puppet/pops/types/type_factory.rb', line 353

def self.default
  PDefaultType::DEFAULT
end

.enum(*values) ⇒ Object

Produces the Enum type, optionally with specific string values



110
111
112
 
# File 'lib/puppet/pops/types/type_factory.rb', line 110

def self.enum(*values)
  PEnumType.new(values)
end

.float ⇒ Object

Produces the Float type



39
40
41
 
# File 'lib/puppet/pops/types/type_factory.rb', line 39

def self.float
  PFloatType::DEFAULT
end

.float_range(from, to) ⇒ Object

Produces a Float range type



29
30
31
32
33
34
 
# File 'lib/puppet/pops/types/type_factory.rb', line 29

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:



435
436
437
 
# File 'lib/puppet/pops/types/type_factory.rb', line 435

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.



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

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



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

def self.hash_of_any
  PHashType::DEFAULT
end

.hash_of_data ⇒ Object

Produces a type for Hash



463
464
465
 
# File 'lib/puppet/pops/types/type_factory.rb', line 463

def self.hash_of_data
  @hash_of_data_t = PHashType.new(string, data)
end

.host_class(class_name = nil) ⇒ Object

Produces PHostClassType with a string class_name. A PHostClassType with nil or empty name is compatible with any other PHostClassType. A PHostClassType with a given name is only compatible with a PHostClassType with the same name.



404
405
406
407
408
409
410
 
# File 'lib/puppet/pops/types/type_factory.rb', line 404

def self.host_class(class_name = nil)
  if class_name.nil?
    PHostClassType::DEFAULT
  else
    PHostClassType.new(class_name.sub(/^::/, ''))
  end
end

.integer ⇒ Object

Produces the Integer type



12
13
14
 
# File 'lib/puppet/pops/types/type_factory.rb', line 12

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) 


560
561
562
 
# File 'lib/puppet/pops/types/type_factory.rb', line 560

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

.iterable(elem_type = nil) ⇒ Object

Produces the Iterable type



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

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



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

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



74
75
76
 
# File 'lib/puppet/pops/types/type_factory.rb', line 74

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:



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

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



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

def self.numeric
  PNumericType::DEFAULT
end

.object(hash = 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:



174
175
176
 
# File 'lib/puppet/pops/types/type_factory.rb', line 174

def self.object(hash = nil)
  hash.nil? || hash.empty? ? PObjectType::DEFAULT : PObjectType.new(hash)
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:



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

def self.optional(optional_type = nil)
  POptionalType.new(type_of(optional_type.is_a?(String) ? string(optional_type) : type_of(optional_type)))
end

.pattern(*regular_expressions) ⇒ Object 



231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/puppet/pops/types/type_factory.rb', line 231

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



19
20
21
22
23
24
 
# File 'lib/puppet/pops/types/type_factory.rb', line 19

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



227
228
229
 
# File 'lib/puppet/pops/types/type_factory.rb', line 227

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



383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
 
# File 'lib/puppet/pops/types/type_factory.rb', line 383

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



341
342
343
 
# File 'lib/puppet/pops/types/type_factory.rb', line 341

def self.rich_data
  @rich_data_t ||= TypeParser.singleton.parse('RichData', 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)



518
519
520
521
522
523
524
 
# File 'lib/puppet/pops/types/type_factory.rb', line 518

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.



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

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



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

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



258
259
260
 
# File 'lib/puppet/pops/types/type_factory.rb', line 258

def self.scalar
  PScalarType::DEFAULT
end

.scalar_data ⇒ Object

Produces the ScalarData type



265
266
267
 
# File 'lib/puppet/pops/types/type_factory.rb', line 265

def self.scalar_data
  PScalarDataType::DEFAULT
end

.sem_ver(*ranges) ⇒ Object

Produces an instance of the SemVer type



374
375
376
 
# File 'lib/puppet/pops/types/type_factory.rb', line 374

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

.sem_ver_range ⇒ Object

Produces an instance of the SemVerRange type



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

def self.sem_ver_range
  PSemVerRangeType::DEFAULT
end

.sensitive(type = nil) ⇒ Object

Produces the Sensitive type



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

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.



83
84
85
86
87
88
89
90
91
92
 
# File 'lib/puppet/pops/types/type_factory.rb', line 83

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



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
167
 
# File 'lib/puppet/pops/types/type_factory.rb', line 132

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

.timespan(*args) ⇒ Object 



193
194
195
196
197
198
199
200
201
202
 
# File 'lib/puppet/pops/types/type_factory.rb', line 193

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

.timestamp(*args) ⇒ Object 



182
183
184
185
186
187
188
189
190
191
 
# File 'lib/puppet/pops/types/type_factory.rb', line 182

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

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



204
205
206
 
# File 'lib/puppet/pops/types/type_factory.rb', line 204

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:



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

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.



492
493
494
495
496
497
498
499
500
501
502
 
# File 'lib/puppet/pops/types/type_factory.rb', line 492

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.

Parameters:

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

    the string form of the type

Returns:



554
555
556
 
# File 'lib/puppet/pops/types/type_factory.rb', line 554

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

.type_set(hash = nil) ⇒ Object 



178
179
180
 
# File 'lib/puppet/pops/types/type_factory.rb', line 178

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



484
485
486
 
# File 'lib/puppet/pops/types/type_factory.rb', line 484

def self.type_type(inst_type = nil)
  inst_type.nil? ? PType::DEFAULT : PType.new(inst_type)
end

.undef ⇒ Object

Creates an instance of the Undef type



347
348
349
 
# File 'lib/puppet/pops/types/type_factory.rb', line 347

def self.undef
  PUndefType::DEFAULT
end

.variant(*types) ⇒ Object

Produces the Variant type, optionally with the “one of” types



117
118
119
 
# File 'lib/puppet/pops/types/type_factory.rb', line 117

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