Module: Puppet::Pops::Pcore

Includes:
Types::PuppetObject
Defined in:
lib/puppet/pops/pcore.rb

Constant Summary collapse

TYPE_URI_RX = 
Types::TypeFactory.regexp(URI::DEFAULT_PARSER.make_regexp)
TYPE_URI = 
Types::TypeFactory.pattern(TYPE_URI_RX)
TYPE_URI_ALIAS = 
Types::PTypeAliasType.new('Pcore::URI', nil, TYPE_URI)
TYPE_SIMPLE_TYPE_NAME = 
Types::TypeFactory.pattern(/\A[A-Z]\w*\z/)
TYPE_QUALIFIED_REFERENCE = 
Types::TypeFactory.pattern(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/)
TYPE_MEMBER_NAME = 
Types::PPatternType.new([Types::PRegexpType.new(Patterns::PARAM_NAME)])
KEY_PCORE_URI = 
'pcore_uri'
KEY_PCORE_VERSION = 
'pcore_version'
PCORE_URI = 
'http://puppet.com/2016.1/pcore'
PCORE_VERSION = 
SemanticPuppet::Version.new(1, 0, 0)
PARSABLE_PCORE_VERSIONS = 
SemanticPuppet::VersionRange.parse('1.x')
RUNTIME_NAME_AUTHORITY = 
'http://puppet.com/2016.1/runtime'

Class Method Summary collapse

Methods included from Types::PuppetObject

#_pcore_all_contents, #_pcore_contents, #_pcore_init_hash, #_pcore_type, #to_s

Class Method Details

._pcore_type ⇒ Object 

 25 26 27
 
# File 'lib/puppet/pops/pcore.rb', line 25 def self._pcore_type @type end

.add_alias(name, type, loader, name_authority = RUNTIME_NAME_AUTHORITY) ⇒ Object 

 116 117 118
 
# File 'lib/puppet/pops/pcore.rb', line 116 def self.add_alias(name, type, loader, name_authority = RUNTIME_NAME_AUTHORITY) add_type(Types::PTypeAliasType.new(name, nil, type), loader, name_authority) end

.add_object_type(name, body, loader) ⇒ Object 

 112 113 114
 
# File 'lib/puppet/pops/pcore.rb', line 112 def self.add_object_type(name, body, loader) add_type(Types::PObjectType.new(name, Parser::EvaluatingParser.new.parse_string(body).body), loader) end

.add_type(type, loader, name_authority = RUNTIME_NAME_AUTHORITY) ⇒ Object 

 120 121 122 123
 
# File 'lib/puppet/pops/pcore.rb', line 120 def self.add_type(type, loader, name_authority = RUNTIME_NAME_AUTHORITY) loader.set_entry(Loader::TypedName.new(:type, type.name, name_authority), type) type end

.annotate(instance, annotations_hash) ⇒ Object 

 29 30 31 32 33 34
 
# File 'lib/puppet/pops/pcore.rb', line 29 def self.annotate(instance, annotations_hash) annotations_hash.each_pair do |type, init_hash| type.implementation_class.annotate(instance) { init_hash } end instance end

.create_object_type(loader, ir, impl_class, type_name, parent_name, attributes_hash = EMPTY_HASH, functions_hash = EMPTY_HASH, equality = nil) ⇒ PObjectType

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Create and register a new ‘Object` type in the Puppet Type System and map it to an implementation class

Parameters:

  • loader (Loader::Loader) —

    The loader where the new type will be registered

  • ir (ImplementationRegistry) —

    The implementation registry that maps this class to the new type

  • impl_class (Class) —

    The class that is the implementation of the type

  • type_name (String) —

    The fully qualified name of the new type

  • parent_name (String, nil) —

    The fully qualified name of the parent type

  • attributes_hash (Hash{String => Object}) (defaults to: EMPTY_HASH) —

    A hash of attribute definitions for the new type

  • functions_hash (Hash{String => Object}) (defaults to: EMPTY_HASH) —

    A hash of function definitions for the new type

  • equality (Array<String>) (defaults to: nil) —

    An array with names of attributes that participate in equality comparison

Returns:

  • (PObjectType) —

    the created type. Not yet resolved

 102 103 104 105 106 107 108 109 110
 
# File 'lib/puppet/pops/pcore.rb', line 102 def self.create_object_type(loader, ir, impl_class, type_name, parent_name, attributes_hash = EMPTY_HASH, functions_hash = EMPTY_HASH, equality = nil) init_hash = {} init_hash[Types::KEY_PARENT] = Types::PTypeReferenceType.new(parent_name) unless parent_name.nil? init_hash[Types::KEY_ATTRIBUTES] = attributes_hash unless attributes_hash.empty? init_hash[Types::KEY_FUNCTIONS] = functions_hash unless functions_hash.empty? init_hash[Types::KEY_EQUALITY] = equality unless equality.nil? ir.register_implementation(type_name, impl_class) add_type(Types::PObjectType.new(type_name, init_hash), loader) end

.init(loader, ir) ⇒ Object 

 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
 
# File 'lib/puppet/pops/pcore.rb', line 60 def self.init(loader, ir) add_alias('Pcore::URI_RX', TYPE_URI_RX, loader) add_type(TYPE_URI_ALIAS, loader) add_alias('Pcore::SimpleTypeName', TYPE_SIMPLE_TYPE_NAME, loader) add_alias('Pcore::MemberName', TYPE_MEMBER_NAME, loader) add_alias('Pcore::TypeName', TYPE_QUALIFIED_REFERENCE, loader) add_alias('Pcore::QRef', TYPE_QUALIFIED_REFERENCE, loader) Types::TypedModelObject.register_ptypes(loader, ir) @type = create_object_type(loader, ir, Pcore, 'Pcore', nil) ir.register_implementation_namespace('Pcore', 'Puppet::Pops::Pcore') ir.register_implementation_namespace('Puppet::AST', 'Puppet::Pops::Model') ir.register_implementation('Puppet::AST::Locator', 'Puppet::Pops::Parser::Locator::Locator19') Resource.register_ptypes(loader, ir) Lookup::Context.register_ptype(loader, ir); Lookup::DataProvider.register_types(loader) add_object_type('Deferred', <<-PUPPET, loader)  { attributes => { # Fully qualified name of the function name => { type => Pattern[/\\A[$]?[a-z][a-z0-9_]*(?:::[a-z][a-z0-9_]*)*\\z/] }, arguments => { type => Optional[Array[Any]], value => undef}, } }  PUPPET end

.init_env(loader) ⇒ Object 

 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
 
# File 'lib/puppet/pops/pcore.rb', line 36 def self.init_env(loader) if Puppet[:tasks] add_object_type('Task', <<-PUPPET, loader)  { attributes => { # Fully qualified name of the task name => { type => Pattern[/\\A[a-z][a-z0-9_]*(?:::[a-z][a-z0-9_]*)*\\z/] }, # List of file references referenced by metadata and their paths on disk. # If there are no implementations listed in metadata, the first file is always # the task executable. files => { type => Array[Struct[name => String, path => String]] }, # Task metadata metadata => { type => Hash[String, Any] }, # Map parameter names to their parsed data type parameters => { type => Optional[Hash[Pattern[/\\A[a-z][a-z0-9_]*\\z/], Type]], value => undef }, } }  PUPPET  end end

.register_aliases(aliases, name_authority = RUNTIME_NAME_AUTHORITY, loader = Loaders.loaders.private_environment_loader) ⇒ Object 

 129 130 131 132 133 134
 
# File 'lib/puppet/pops/pcore.rb', line 129 def self.register_aliases(aliases, name_authority = RUNTIME_NAME_AUTHORITY, loader = Loaders.loaders.private_environment_loader) aliases.each do |name, type_string| add_type(Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(type_string), nil), loader, name_authority) end aliases.each_key.map { |name| loader.load(:type, name).resolve(loader) } end

.register_implementations(impls, name_authority = RUNTIME_NAME_AUTHORITY) ⇒ Object 

 125 126 127
 
# File 'lib/puppet/pops/pcore.rb', line 125 def self.register_implementations(impls, name_authority = RUNTIME_NAME_AUTHORITY) Loaders.loaders.register_implementations(impls, name_authority) end