module Puppet::Pops::Types::TypeParser::TYPES

all_callables() click to toggle source

Produces a CallableType matching all callables @api public

# File lib/puppet/pops/types/type_factory.rb, line 232
def self.all_callables()
  return Puppet::Pops::Types::PCallableType.new
end

any() click to toggle source

Produces the Any type @api public

# File lib/puppet/pops/types/type_factory.rb, line 171
def self.any()
  Types::PAnyType.new()
end

array_of(o) click to toggle source

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

# File lib/puppet/pops/types/type_factory.rb, line 361
def self.array_of(o)
  type = Types::PArrayType.new()
  type.element_type = type_of(o)
  type
end

array_of_data() click to toggle source

Produces a type for Array @api public

# File lib/puppet/pops/types/type_factory.rb, line 381
def self.array_of_data()
  type = Types::PArrayType.new()
  type.element_type = data()
  type
end

boolean() click to toggle source

Produces the Boolean type @api public

# File lib/puppet/pops/types/type_factory.rb, line 164
def self.boolean()
  Types::PBooleanType.new()
end

callable(*params) click to toggle source

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

# File lib/puppet/pops/types/type_factory.rb, line 252
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() click to toggle source

Produces an instance of the abstract type PCatalogEntryType

# File lib/puppet/pops/types/type_factory.rb, line 320
def self.catalog_entry()
  Types::PCatalogEntryType.new()
end

collection() click to toggle source

Produces the abstract type Collection @api public

# File lib/puppet/pops/types/type_factory.rb, line 296
def self.collection()
  Types::PCollectionType.new()
end

constrain_size(collection_t, from, to) click to toggle source

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

# File lib/puppet/pops/types/type_factory.rb, line 480
def self.constrain_size(collection_t, from, to)
  collection_t.size_type = range(from, to)
  collection_t
end

data() click to toggle source

Produces the Data type @api public

# File lib/puppet/pops/types/type_factory.rb, line 303
def self.data()
  Types::PDataType.new()
end

default() click to toggle source

Creates an instance of the Default type @api public

# File lib/puppet/pops/types/type_factory.rb, line 315
def self.default()
  Types::PDefaultType.new()
end

enum(*values) click to toggle source

Produces the Enum type, optionally with specific string values @api public

# File lib/puppet/pops/types/type_factory.rb, line 92
def self.enum(*values)
  t = Types::PEnumType.new()
  values.each {|v| t.addValues(v) }
  t
end

float() click to toggle source

Produces the Float type @api public

# File lib/puppet/pops/types/type_factory.rb, line 47
def self.float()
  Types::PFloatType.new()
end

float_range(from, to) click to toggle source

Produces a Float range type @api public

# File lib/puppet/pops/types/type_factory.rb, line 33
def self.float_range(from, to)
  # NOTE! Do not merge the following line to 4.x. It has the same check in the initialize method
  raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{from}, #{to}" if from.is_a?(Numeric) && to.is_a?(Numeric) && 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()) click to toggle source

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

# File lib/puppet/pops/types/type_factory.rb, line 371
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() click to toggle source

Produces a type for Hash[Scalar, Data] @api public

# File lib/puppet/pops/types/type_factory.rb, line 390
def self.hash_of_data()
  type = Types::PHashType.new()
  type.key_type = scalar()
  type.element_type = data()
  type
end

host_class(class_name = nil) click to toggle source

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.

# File lib/puppet/pops/types/type_factory.rb, line 349
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() click to toggle source

Produces the Integer type @api public

# File lib/puppet/pops/types/type_factory.rb, line 12
def self.integer()
  Types::PIntegerType.new()
end

is_range_parameter?(t) click to toggle source

Returns true if the given type t is of valid range parameter type (integer or literal default).

# File lib/puppet/pops/types/type_factory.rb, line 487
def self.is_range_parameter?(t)
  t.is_a?(Integer) || t == 'default' || :default == t
end

label(t) click to toggle source

Produces a string representation of the type @api public

# File lib/puppet/pops/types/type_factory.rb, line 61
def self.label(t)
  @type_calculator.string(t)
end

not_undef(inst_type = nil) click to toggle source

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

@param inst_type [Type,String] the type to qualify @return [Puppet::Pops::Types::PNotUndefType] the NotUndef type

@api public

# File lib/puppet/pops/types/type_factory.rb, line 406
def self.not_undef(inst_type = nil)
  type = Types::PNotUndefType.new()
  inst_type = string(inst_type) if inst_type.is_a?(String)
  type.type = inst_type
  type
end

numeric() click to toggle source

Produces the Numeric type @api public

# File lib/puppet/pops/types/type_factory.rb, line 54
def self.numeric()
  Types::PNumericType.new()
end

optional(optional_type = nil) click to toggle source

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.

@param optional_type [String,PAnyType,nil] the optional type @return [POptionalType] the created type

@api public

# File lib/puppet/pops/types/type_factory.rb, line 83
def self.optional(optional_type = nil)
  t = Types::POptionalType.new
  t.optional_type = optional_type.is_a?(String) ? string(optional_type) : type_of(optional_type)
  t
end

pattern(*regular_expressions) click to toggle source

# File lib/puppet/pops/types/type_factory.rb, line 189
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) click to toggle source

Produces an Integer range type @api public

# File lib/puppet/pops/types/type_factory.rb, line 19
def self.range(from, to)
  # NOTE! Do not merge the following line to 4.x. It has the same check in the initialize method
  raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{from}, #{to}" if from.is_a?(Numeric) && to.is_a?(Numeric) && 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) click to toggle source

Produces the Regexp type @param pattern [Regexp, String, nil] (nil) The regular expression object or

a regexp source string, or nil for bare type

@api public

# File lib/puppet/pops/types/type_factory.rb, line 180
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) click to toggle source

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

# File lib/puppet/pops/types/type_factory.rb, line 329
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) click to toggle source

Produces a type for a class or infers a type for something that is not a class @note

To get the type for the class' class use `TypeCalculator.infer(c)`

@overload ruby(o)

@param o [Class] produces the type corresponding to the class (e.g.
  Integer becomes PIntegerType)

@overload ruby(o)

@param o [Object] produces the type corresponding to the instance class
  (e.g. 3 becomes PIntegerType)

@api public

# File lib/puppet/pops/types/type_factory.rb, line 452
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) click to toggle source

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.

# File lib/puppet/pops/types/type_factory.rb, line 464
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) click to toggle source

Generic creator of a RuntimeType - allows creating the type with nil or String runtime_type_name. Also see ::ruby_type(o) and ruby(o).

# File lib/puppet/pops/types/type_factory.rb, line 471
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() click to toggle source

Produces the Literal type @api public

# File lib/puppet/pops/types/type_factory.rb, line 225
def self.scalar()
  Types::PScalarType.new()
end

string(*values) click to toggle source

Produces the String type, optionally with specific string values @api public

# File lib/puppet/pops/types/type_factory.rb, line 68
def self.string(*values)
  t = Types::PStringType.new()
  values.each {|v| t.addValues(v) }
  t
end

struct(hash = {}) click to toggle source

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.

@param hash [Hash<Object, Object>] key => value hash @return [PStructType] the created Struct type

# File lib/puppet/pops/types/type_factory.rb, line 118
def self.struct(hash = {})
  tc = @type_calculator
  t = Types::PStructType.new
  t.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?(Types::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, @undef_t)
    else
      # assert that the key type is one of String[1], NotUndef[String[1]] and Optional[String[1]]
      case key_type
      when Types::PNotUndefType
        # We can loose the NotUndef wrapper here since String[1] isn't optional anyway
        key_type = key_type.type
        s = key_type
      when Types::POptionalType
        s = key_type.optional_type
      else
        s = key_type
      end
      unless (s.is_a?(Puppet::Pops::Types::PStringType) || s.is_a?(Puppet::Pops::Types::PEnumType)) && s.values.size == 1 && !s.values[0].empty?
        raise ArgumentError, 'Unable to extract a non-empty literal string from Struct member key type' if key_type.empty?
      end
    end
    elem = Types::PStructElement.new
    elem.key_type = key_type
    elem.value_type = value_type
    elem
  end
  t
end

tuple(*types) click to toggle source

# File lib/puppet/pops/types/type_factory.rb, line 155
def self.tuple(*types)
  t = Types::PTupleType.new
  types.each {|elem| t.addTypes(type_of(elem)) }
  t
end

type_of(o) click to toggle source

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.

# File lib/puppet/pops/types/type_factory.rb, line 426
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) click to toggle source

Produces a type for Type @api public

# File lib/puppet/pops/types/type_factory.rb, line 416
def self.type_type(inst_type = nil)
  type = Types::PType.new()
  type.type = inst_type
  type
end

undef() click to toggle source

Creates an instance of the Undef type @api public

# File lib/puppet/pops/types/type_factory.rb, line 309
def self.undef()
  Types::PUndefType.new()
end

variant(*types) click to toggle source

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

# File lib/puppet/pops/types/type_factory.rb, line 101
def self.variant(*types)
  t = Types::PVariantType.new()
  types.each {|v| t.addTypes(type_of(v)) }
  t
end

with_block(callable, *block_params) click to toggle source

# File lib/puppet/pops/types/type_factory.rb, line 283
def self.with_block(callable, *block_params)
  callable.block_type = callable(*block_params)
  callable
end

with_optional_block(callable, *block_params) click to toggle source

# File lib/puppet/pops/types/type_factory.rb, line 288
def self.with_optional_block(callable, *block_params)
  callable.block_type = optional(callable(*block_params))
  callable
end

module Puppet::Pops::Types::TypeParser::TYPES

Constants

Public Class Methods