module Puppet::Pops::Evaluator::Runtime3ResourceSupport

   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
 9 def self.create_resources(file, line, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
10 
11   env = scope.environment
12   #    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope)
13 
14   if type_name.is_a?(String) && type_name.casecmp(CLASS_STRING) == 0
15     # Resolve a 'class' and its titles
16     resource_titles = resource_titles.collect do |a_title|
17       hostclass = env.known_resource_types.find_hostclass(a_title)
18       hostclass ?  hostclass.name : a_title
19     end
20     # resolved type is just the string CLASS
21     resolved_type = CLASS_STRING
22   else
23     # resolve a resource type - pcore based, ruby impl or user defined
24     resolved_type = find_resource_type(scope, type_name)
25   end
26 
27   # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
28   # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
29   # from the raised exception. (It may be good enough).
30   unless resolved_type
31     # TODO: do this the right way
32     raise ArgumentError, _("Unknown resource type: '%{type}'") % { type: type_name }
33   end
34 
35   # Build a resource for each title - use the resolved *type* as opposed to a reference
36   # as this makes the created resource retain the type instance.
37   #
38   resource_titles.map do |resource_title|
39       resource = Puppet::Parser::Resource.new(
40         resolved_type, resource_title,
41         :parameters => evaluated_parameters,
42         :file => file,
43         :line => line,
44         :kind => Puppet::Resource.to_kind(resolved_type),
45         :exported => exported,
46         :virtual => virtual,
47         # WTF is this? Which source is this? The file? The name of the context ?
48         :source => scope.source,
49         :scope => scope,
50         :strict => true
51       )
52 
53       # If this resource type supports inheritance (e.g. 'class') the parent chain must be walked
54       # This impl delegates to the resource type to figure out what is needed.
55       #
56       if resource.resource_type.is_a? Puppet::Resource::Type
57         resource.resource_type.instantiate_resource(scope, resource)
58       end
59 
60       scope.compiler.add_resource(scope, resource)
61 
62       # Classes are evaluated immediately
63       scope.compiler.evaluate_classes([resource_title], scope, false) if resolved_type == CLASS_STRING
64 
65       # Turn the resource into a PTypeType (a reference to a resource type)
66       # weed out nil's
67       resource_to_ptype(resource)
68   end
69 end

   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
90 def self.find_hostclass(scope, class_name)
91   scope.environment.known_resource_types.find_hostclass(class_name)
92 end

   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
85 def self.find_main_class(scope)
86   # Find the main class (known as ''), it does not have to be in the catalog
87   scope.environment.known_resource_types.find_hostclass('')
88 end

   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
71 def self.find_resource_type(scope, type_name)
72   find_builtin_resource_type(scope, type_name) || find_defined_resource_type(scope, type_name)
73 end

   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
75 def self.find_resource_type_or_class(scope, name)
76   find_builtin_resource_type(scope, name) || find_defined_resource_type(scope, name) || find_hostclass(scope, name)
77 end

   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
79 def self.resource_to_ptype(resource)
80   nil if resource.nil?
81   # inference returns the meta type since the 3x Resource is an alternate way to describe a type
82   Puppet::Pops::Types::TypeCalculator.singleton().infer(resource).type
83 end

    # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
 94 def self.find_builtin_resource_type(scope, type_name)
 95   if type_name.include?(':')
 96     # Skip the search for built in types as they are always in global namespace
 97     # (At least for now).
 98     return nil
 99   end
100 
101   loader = scope.compiler.loaders.private_environment_loader
102   loaded = loader.load(:resource_type_pp, type_name)
103   if loaded
104     return loaded
105   end
106 
107   # horrible - should be loaded by a "last loader" in 4.x loaders instead.
108   Puppet::Type.type(type_name)
109 end

    # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
112 def self.find_defined_resource_type(scope, type_name)
113   krt = scope.environment.known_resource_types
114   krt.find_definition(type_name)
115 end