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

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

Overview

Helper module that makes creation of type objects simpler.

Constant Summary collapse

Types = 
Puppet::Pops::Types

Class Method Summary collapse

Class Method Details

.all_callables ⇒ Object

Produces a CallableType matching all callables



189
190
191
 
# File 'lib/puppet/pops/types/type_factory.rb', line 189

def self.all_callables()
  return Puppet::Pops::Types::PCallableType.new
end

.any ⇒ Object

Produces the Any type



128
129
130
 
# File 'lib/puppet/pops/types/type_factory.rb', line 128

def self.any()
  Types::PAnyType.new()
end

.array_of(o) ⇒ Object

Produces a type for Array where o is either a type, or an instance for which a type is inferred.



318
319
320
321
322
 
# File 'lib/puppet/pops/types/type_factory.rb', line 318

def self.array_of(o)
  type = Types::PArrayType.new()
  type.element_type = type_of(o)
  type
end

.array_of_data ⇒ Object

Produces a type for Array



338
339
340
341
342
 
# File 'lib/puppet/pops/types/type_factory.rb', line 338

def self.array_of_data()
  type = Types::PArrayType.new()
  type.element_type = data()
  type
end

.boolean ⇒ Object

Produces the Boolean type



121
122
123
 
# File 'lib/puppet/pops/types/type_factory.rb', line 121

def self.boolean()
  Types::PBooleanType.new()
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.



209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
 
# File 'lib/puppet/pops/types/type_factory.rb', line 209

def self.callable(*params)
  if Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(params.last)
    last_callable = true
  end
  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]
  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 << Types::PUnitType.new
  end
  # create a signature
  callable_t = Types::PCallableType.new()
  tuple_t = tuple(*types)
  tuple_t.size_type = size_type unless size_type.nil?
  callable_t.param_types = tuple_t

  callable_t.block_type = block_t
  callable_t
end

.catalog_entry ⇒ Object

Produces an instance of the abstract type PCatalogEntryType



277
278
279
 
# File 'lib/puppet/pops/types/type_factory.rb', line 277

def self.catalog_entry()
  Types::PCatalogEntryType.new()
end

.collection ⇒ Object

Produces the abstract type Collection



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

def self.collection()
  Types::PCollectionType.new()
end

.constrain_size(collection_t, from, to) ⇒ Object

Sets the accepted size range of a collection if something other than the default 0 to Infinity is wanted. The semantics for from/to are the same as for #range



421
422
423
424
 
# File 'lib/puppet/pops/types/type_factory.rb', line 421

def self.constrain_size(collection_t, from, to)
  collection_t.size_type = range(from, to)
  collection_t
end

.data ⇒ Object

Produces the Data type



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

def self.data()
  Types::PDataType.new()
end

.default ⇒ Object

Creates an instance of the Default type



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

def self.default()
  Types::PDefaultType.new()
end

.enum(*values) ⇒ Object

Produces the Enum type, optionally with specific string values



78
79
80
81
82
 
# File 'lib/puppet/pops/types/type_factory.rb', line 78

def self.enum(*values)
  t = Types::PEnumType.new()
  values.each {|v| t.addValues(v) }
  t
end

.float ⇒ Object

Produces the Float type



41
42
43
 
# File 'lib/puppet/pops/types/type_factory.rb', line 41

def self.float()
  Types::PFloatType.new()
end

.float_range(from, to) ⇒ Object

Produces a Float range type



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

def self.float_range(from, to)
  t = Types::PFloatType.new()
  # optimize eq with symbol (faster when it is left)
  t.from = Float(from) unless :default == from || from.nil?
  t.to = Float(to) unless :default == to || to.nil?
  t
end

.hash_of(value, key = scalar()) ⇒ Object

Produces a type for Hash[Scalar, o] where o is either a type, or an instance for which a type is inferred.



328
329
330
331
332
333
 
# File 'lib/puppet/pops/types/type_factory.rb', line 328

def self.hash_of(value, key = scalar())
  type = Types::PHashType.new()
  type.key_type = type_of(key)
  type.element_type = type_of(value)
  type
end

.hash_of_data ⇒ Object

Produces a type for Hash[Scalar, Data]



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

def self.hash_of_data()
  type = Types::PHashType.new()
  type.key_type = scalar()
  type.element_type = data()
  type
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.



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

def self.host_class(class_name = nil)
  type = Types::PHostClassType.new()
  unless class_name.nil?
    type.class_name = class_name.sub(/^::/, '')
  end
  type
end

.integer ⇒ Object

Produces the Integer type



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

def self.integer()
  Types::PIntegerType.new()
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) 


428
429
430
 
# File 'lib/puppet/pops/types/type_factory.rb', line 428

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

.label(t) ⇒ Object

Produces a string representation of the type



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

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

.numeric ⇒ Object

Produces the Numeric type



48
49
50
 
# File 'lib/puppet/pops/types/type_factory.rb', line 48

def self.numeric()
  Types::PNumericType.new()
end

.optional(optional_type = nil) ⇒ Object

Produces the Optional type, i.e. a short hand for Variant[T, Undef]



69
70
71
72
73
 
# File 'lib/puppet/pops/types/type_factory.rb', line 69

def self.optional(optional_type = nil)
  t = Types::POptionalType.new
  t.optional_type = type_of(optional_type)
  t
end

.pattern(*regular_expressions) ⇒ Object 



146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/puppet/pops/types/type_factory.rb', line 146

def self.pattern(*regular_expressions)
  t = Types::PPatternType.new()
  regular_expressions.each do |re|
    case re
    when String
      re_T = Types::PRegexpType.new()
      re_T.pattern = re
      re_T.regexp()  # compile it to catch errors
      t.addPatterns(re_T)

    when Regexp
      re_T = Types::PRegexpType.new()
      # Regep.to_s includes options user did not enter and does not escape source
      # to work either as a string or as a // regexp. The inspect method does a better
      # job, but includes the //
      re_T.pattern = re.inspect[1..-2]
      t.addPatterns(re_T)

    when Types::PRegexpType
      t.addPatterns(re.copy)

    when Types::PPatternType
      re.patterns.each do |p|
        t.addPatterns(p.copy)
      end

   else
     raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}"
    end
  end
  t
end

.range(from, to) ⇒ Object

Produces an Integer range type



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

def self.range(from, to)
  t = Types::PIntegerType.new()
  # optimize eq with symbol (faster when it is left)
  t.from = from unless (:default == from || from == 'default')
  t.to = to unless (:default == to || to == 'default')
  t
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



137
138
139
140
141
142
143
144
 
# File 'lib/puppet/pops/types/type_factory.rb', line 137

def self.regexp(pattern = nil)
  t = Types::PRegexpType.new()
  if pattern
    t.pattern = pattern.is_a?(Regexp) ? pattern.inspect[1..-2] : pattern
  end
  t.regexp() unless pattern.nil? # compile pattern to catch errors
  t
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)).



286
287
288
289
290
291
292
293
294
295
296
297
298
299
 
# File 'lib/puppet/pops/types/type_factory.rb', line 286

def self.resource(type_name = nil, title = nil)
  type = Types::PResourceType.new()
  type_name = type_name.type_name if type_name.is_a?(Types::PResourceType)
  type_name = type_name.downcase unless type_name.nil?
  type.type_name = type_name
  unless type_name.nil? || type_name =~ Puppet::Pops::Patterns::CLASSREF
    raise ArgumentError, "Illegal type name '#{type.type_name}'"
  end
  if type_name.nil? && !title.nil?
    raise ArgumentError, "The type name cannot be nil, if title is given"
  end
  type.title = title
  type
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)



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

def self.ruby(o)
  if o.is_a?(Class)
    @type_calculator.type(o)
  else
    Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => 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.



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

def self.ruby_type(class_name = nil)
  Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => 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).



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

def self.runtime(runtime=nil, runtime_type_name = nil)
  runtime = runtime.to_sym if runtime.is_a?(String)
  Types::PRuntimeType.new(:runtime => runtime, :runtime_type_name => runtime_type_name)
end

.scalar ⇒ Object

Produces the Literal type



182
183
184
 
# File 'lib/puppet/pops/types/type_factory.rb', line 182

def self.scalar()
  Types::PScalarType.new()
end

.string(*values) ⇒ Object

Produces the String type, optionally with specific string values



62
63
64
65
66
 
# File 'lib/puppet/pops/types/type_factory.rb', line 62

def self.string(*values)
  t = Types::PStringType.new()
  values.each {|v| t.addValues(v) }
  t
end

.struct(name_type_hash = {}) ⇒ Object

Produces the Struct type, either a non parameterized instance representing all structs (i.e. all hashes) or a hash with a given set of keys of String type (names), bound to a value of a given type. Type may be a Ruby Class, a Puppet Type, or an instance from which the type is inferred.



98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/puppet/pops/types/type_factory.rb', line 98

def self.struct(name_type_hash = {})
  t = Types::PStructType.new
  name_type_hash.map do |name, type|
    elem = Types::PStructElement.new
    if name.is_a?(String) && name.empty?
      raise ArgumentError, "An empty String can not be used where a String[1, default] is expected"
    end
    elem.name = name
    elem.type = type_of(type)
    elem
  end.each {|elem| t.addElements(elem) }
  t
end

.tuple(*types) ⇒ Object 



112
113
114
115
116
 
# File 'lib/puppet/pops/types/type_factory.rb', line 112

def self.tuple(*types)
  t = Types::PTupleType.new
  types.each {|elem| t.addTypes(type_of(elem)) }
  t
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.



367
368
369
370
371
372
373
374
375
376
377
 
# File 'lib/puppet/pops/types/type_factory.rb', line 367

def self.type_of(o)
  if o.is_a?(Class)
    @type_calculator.type(o)
  elsif o.is_a?(Types::PAnyType)
    o
  elsif o.is_a?(String)
    Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => o)
  else
    @type_calculator.infer_generic(o)
  end
end

.type_type(inst_type = nil) ⇒ Object

Produces a type for Type



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

def self.type_type(inst_type = nil)
  type = Types::PType.new()
  type.type = inst_type
  type
end

.undef ⇒ Object

Creates an instance of the Undef type



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

def self.undef()
  Types::PNilType.new()
end

.variant(*types) ⇒ Object

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



87
88
89
90
91
 
# File 'lib/puppet/pops/types/type_factory.rb', line 87

def self.variant(*types)
  t = Types::PVariantType.new()
  types.each {|v| t.addTypes(type_of(v)) }
  t
end

.with_block(callable, *block_params) ⇒ Object 



240
241
242
243
 
# File 'lib/puppet/pops/types/type_factory.rb', line 240

def self.with_block(callable, *block_params)
  callable.block_type = callable(*block_params)
  callable
end

.with_optional_block(callable, *block_params) ⇒ Object 



245
246
247
248
 
# File 'lib/puppet/pops/types/type_factory.rb', line 245

def self.with_optional_block(callable, *block_params)
  callable.block_type = optional(callable(*block_params))
  callable
end