puppet 4.5.3-x64-mingw32 → 4.6.1-x64-mingw32

data/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -34,7 +34,6 @@ class EvaluatorImpl
   include Runtime3Support
   include ExternalSyntaxSupport
 
-  EMPTY_STRING = ''.freeze
   COMMA_SEPARATOR = ', '.freeze
 
   # Reference to Issues name space makes it easier to refer to issues
@@ -43,20 +42,26 @@ class EvaluatorImpl
   Issues = Issues
 
   def initialize
+    @@initialized ||= static_initialize
+
+    # Use null migration checker unless given in context
+    @migration_checker = Puppet.lookup(:migration_checker) { Migration::MigrationChecker.singleton }
+  end
+
+  # @api private
+  def static_initialize
     @@eval_visitor     ||= Visitor.new(self, "eval", 1, 1)
     @@lvalue_visitor   ||= Visitor.new(self, "lvalue", 1, 1)
     @@assign_visitor   ||= Visitor.new(self, "assign", 3, 3)
     @@string_visitor   ||= Visitor.new(self, "string", 1, 1)
 
-    @@type_calculator  ||= Types::TypeCalculator.new()
-    @@type_parser      ||= Types::TypeParser.new()
-
-    @@compare_operator     ||= CompareOperator.new()
-    @@relationship_operator ||= RelationshipOperator.new()
+    @@type_calculator  ||= Types::TypeCalculator.singleton
 
-    # Use null migration checker unless given in context
-    @migration_checker = (Puppet.lookup(:migration_checker) { Migration::MigrationChecker.new() })
+    @@compare_operator      ||= CompareOperator.new
+    @@relationship_operator ||= RelationshipOperator.new
+    true
   end
+  private :static_initialize
 
   # @api private
   def type_calculator
@@ -300,7 +305,7 @@ class EvaluatorImpl
   # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
   #
   def eval_QualifiedReference(o, scope)
-    type = @@type_parser.interpret(o, scope)
+    type = Types::TypeParser.singleton.interpret(o, scope)
     fail(Issues::UNKNOWN_RESOURCE_TYPE, o, {:type_name => type.type_string }) if type.is_a?(Types::PTypeReferenceType)
     type
   end
@@ -451,7 +456,7 @@ class EvaluatorImpl
     keys = o.keys || []
     if left.is_a?(Types::PHostClassType)
       # Evaluate qualified references without errors no undefined types
-      keys = keys.map {|key| key.is_a?(Model::QualifiedReference) ? @@type_parser.interpret(key, scope) : evaluate(key, scope) }
+      keys = keys.map {|key| key.is_a?(Model::QualifiedReference) ? Types::TypeParser.singleton.interpret(key, scope) : evaluate(key, scope) }
     else
       keys = keys.map {|key| evaluate(key, scope) }
       # Resource[File] becomes File
@@ -917,7 +922,7 @@ class EvaluatorImpl
   private :call_function_with_block
 
   def proc_from_lambda(lambda, scope)
-    closure = Closure.new(self, lambda, scope)
+    closure = Closure::Dynamic.new(self, lambda, scope)
     PuppetProc.new(closure) { |*args| closure.call(*args) }
   end
   private :proc_from_lambda

data/lib/puppet/pops/evaluator/external_syntax_support.rb

@@ -20,7 +20,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
     # Call checker and give it the location information from the expression
     # (as opposed to where the heredoc tag is (somewhere on the line above)).
     acceptor = Puppet::Pops::Validation::Acceptor.new()
-    source_pos = find_closest_positioned(reference_expr)
+    source_pos = Puppet::Pops::Utils.find_closest_positioned(reference_expr)
     checker.check(result, syntax, acceptor, source_pos)
 
     if acceptor.error_count > 0

data/lib/puppet/pops/evaluator/json_strict_literal_evaluator.rb

@@ -21,7 +21,6 @@ require 'rgen/ecore/ecore'
 class Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator
   #include Puppet::Pops::Utils
 
-  EMPTY_STRING = ''.freeze
   COMMA_SEPARATOR = ', '.freeze
 
   def initialize

data/lib/puppet/pops/evaluator/literal_evaluator.rb

@@ -16,7 +16,6 @@ module Evaluator
 #
 class LiteralEvaluator
 
-  EMPTY_STRING = ''.freeze
   COMMA_SEPARATOR = ', '.freeze
 
   def initialize

data/lib/puppet/pops/evaluator/relationship_operator.rb

@@ -32,7 +32,6 @@ class RelationshipOperator
   def initialize
     @type_transformer_visitor = Visitor.new(self, "transform", 1, 1)
     @type_calculator = Types::TypeCalculator.new()
-    @type_parser = Types::TypeParser.new()
 
     tf = Types::TypeFactory
     @catalog_type = tf.variant(tf.catalog_entry, tf.type_type(tf.catalog_entry))
@@ -57,7 +56,7 @@ class RelationshipOperator
   # A string must be a type reference in string format
   # @api private
   def transform_String(o, scope)
-    assert_catalog_type(@type_parser.parse(o, scope), scope)
+    assert_catalog_type(Types::TypeParser.singleton.parse(o, scope), scope)
   end
 
   # A qualified name is short hand for a class with this name

data/lib/puppet/pops/evaluator/runtime3_resource_support.rb

@@ -0,0 +1,119 @@
+module Puppet::Pops
+module Evaluator
+
+# @api private
+module Runtime3ResourceSupport
+  CLASS_STRING = 'class'.freeze
+
+  def self.create_resources(file, line, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
+
+    env = scope.environment
+    #    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope)
+
+    if type_name.is_a?(String) && type_name.casecmp(CLASS_STRING) == 0
+      # Resolve a 'class' and its titles
+      resource_titles = resource_titles.collect do |a_title|
+        hostclass = env.known_resource_types.find_hostclass(a_title)
+        hostclass ?  hostclass.name : a_title
+      end
+      # resolved type is just the string CLASS
+      resolved_type = CLASS_STRING
+    else
+      # resolve a resource type - pcore based, ruby impl, user defined, or application
+      resolved_type = find_resource_type(scope, type_name)
+    end
+
+    # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
+    # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
+    # from the raised exception. (It may be good enough).
+    unless resolved_type
+      # TODO: do this the right way
+      raise ArgumentError, "Unknown resource type: '#{type_name}'"
+    end
+
+    # Build a resource for each title - use the resolved *type* as opposed to a reference
+    # as this makes the created resource retain the type instance.
+    #
+    resource_titles.map do |resource_title|
+        resource = Puppet::Parser::Resource.new(
+          resolved_type, resource_title,
+          :parameters => evaluated_parameters,
+          :file => file,
+          :line => line,
+          :exported => exported,
+          :virtual => virtual,
+          # WTF is this? Which source is this? The file? The name of the context ?
+          :source => scope.source,
+          :scope => scope,
+          :strict => true
+        )
+
+        # If this resource type supports inheritance (e.g. 'class') the parent chain must be walked
+        # This impl delegates to the resource type to figure out what is needed.
+        #
+        if resource.resource_type.is_a? Puppet::Resource::Type
+          resource.resource_type.instantiate_resource(scope, resource)
+        end
+
+        scope.compiler.add_resource(scope, resource)
+
+        # Classes are evaluated immediately
+        scope.compiler.evaluate_classes([resource_title], scope, false) if resolved_type == CLASS_STRING
+
+        # Turn the resource into a PType (a reference to a resource type)
+        # weed out nil's
+        resource_to_ptype(resource)
+    end
+  end
+
+  def self.find_resource_type(scope, type_name)
+    type_name = type_name.to_s.downcase
+    find_builtin_resource_type(scope, type_name) || find_defined_resource_type(scope, type_name)
+  end
+
+  def self.find_resource_type_or_class(scope, name)
+    type_name = type_name.to_s.downcase
+    find_builtin_resource_type(scope, name) || find_defined_resource_type(scope, name) || find_hostclass(scope, name)
+  end
+
+  def self.resource_to_ptype(resource)
+    nil if resource.nil?
+    # inference returns the meta type since the 3x Resource is an alternate way to describe a type
+    Puppet::Pops::Types::TypeCalculator.singleton().infer(resource).type
+  end
+
+  def self.find_main_class(scope)
+    # Find the main class (known as ''), it does not have to be in the catalog
+    scope.environment.known_resource_types.find_hostclass('')
+  end
+
+  def self.find_hostclass(scope, class_name)
+    scope.environment.known_resource_types.find_hostclass(class_name)
+  end
+
+  private
+
+  def self.find_builtin_resource_type(scope, type_name)
+    if type_name.include?(':')
+      # Skip the search for built in types as they are always in global namespace
+      # (At least for now).
+      return nil
+    end
+
+    loader = scope.compiler.loaders.private_environment_loader
+    if loaded = loader.load(:resource_type_pp, type_name)
+      return loaded
+    end
+
+    # horrible - should be loaded by a "last loader" in 4.x loaders instead.
+    Puppet::Type.type(type_name)
+  end
+
+  def self.find_defined_resource_type(scope, type_name)
+    krt = scope.environment.known_resource_types
+    krt.find_definition(type_name) || krt.application(type_name)
+  end
+
+end
+end
+end

data/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -266,10 +266,12 @@ module Runtime3Support
   end
 
   def call_function(name, args, o, scope, &block)
-    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope)
+    file, line = extract_file_line(o)
+    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope, file)
     if loader && func = loader.load(:function, name)
       Puppet::Util::Profiler.profile(name, [:functions, name]) do
-        return func.call(scope, *args, &block)
+        # Add stack frame when calling. See Puppet::Pops::PuppetStack
+        return Kernel.eval('func.call(scope, *args, &block)', Kernel.binding, file || '', line)
       end
     end
     # Call via 3x API if function exists there
@@ -278,7 +280,7 @@ module Runtime3Support
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
     mapped_args = Runtime3Converter.map_args(args, scope, '')
-    result = scope.send("function_#{name}", mapped_args, &block)
+    result = Puppet::Pops::PuppetStack.stack(file, line, scope, "function_#{name}", [mapped_args], &block)
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
     Puppet::Parser::Functions.rvalue?(name) ? result : nil
   end
@@ -298,48 +300,14 @@ module Runtime3Support
     Runtime3Converter.convert(value, scope, undef_value)
   end
 
-  CLASS_STRING = 'class'.freeze
-
   def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
-
-    # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
-    # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
-    # from the raised exception. (It may be good enough).
-
-
-    # resolve in scope.
-    fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type_name, resource_titles)
-
     # Not 100% accurate as this is the resource expression location and each title is processed separately
     # The titles are however the result of evaluation and they have no location at this point (an array
     # of positions for the source expressions are required for this to work).
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
-    # Build a resource for each title
-    resource_titles.map do |resource_title|
-        resource = Puppet::Parser::Resource.new(
-          fully_qualified_type, resource_title,
-          :parameters => evaluated_parameters,
-          :file => file,
-          :line => line,
-          :exported => exported,
-          :virtual => virtual,
-          # WTF is this? Which source is this? The file? The name of the context ?
-          :source => scope.source,
-          :scope => scope,
-          :strict => true
-        )
-
-        if resource.resource_type.is_a? Puppet::Resource::Type
-          resource.resource_type.instantiate_resource(scope, resource)
-        end
-        scope.compiler.add_resource(scope, resource)
-        scope.compiler.evaluate_classes([resource_title], scope, false) if fully_qualified_type == CLASS_STRING
-        # Turn the resource into a PType (a reference to a resource type)
-        # weed out nil's
-        resource_to_ptype(resource)
-    end
+    Runtime3ResourceSupport.create_resources(file, line, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
   end
 
   # Defines default parameters for a type with the given name.
@@ -465,14 +433,21 @@ module Runtime3Support
   end
 
   def extract_file_line(o)
-    source_pos = Utils.find_closest_positioned(o)
-    return [nil, -1] unless source_pos
-    [source_pos.locator.file, source_pos.line]
+    positioned = find_closest_with_offset(o)
+    unless positioned.nil?
+      locator = Adapters::SourcePosAdapter.find_locator(positioned)
+      return [locator.file, locator.line_for_offset(positioned.offset)] unless locator.nil?
+    end
+    [nil, -1]
   end
 
-  def find_closest_positioned(o)
-    return nil if o.nil? || o.is_a?(Model::Program)
-    o.offset.nil? ? find_closest_positioned(o.eContainer) : Adapters::SourcePosAdapter.adapt(o)
+  def find_closest_with_offset(o)
+    if o.offset.nil?
+      c = o.eContainer
+      c.nil? ? nil : find_closest_with_offset(c)
+    else
+      o
+    end
   end
 
   # Creates a diagnostic producer
@@ -505,7 +480,6 @@ module Runtime3Support
       elsif Puppet[:strict] == :off
         p[Issues::UNKNOWN_VARIABLE] = :ignore
       else
-        Puppet[:strict_variables]
         p[Issues::UNKNOWN_VARIABLE] = Puppet[:strict]
       end
 

data/lib/puppet/pops/functions/function.rb

@@ -57,6 +57,11 @@ class Puppet::Pops::Functions::Function
     internal_call_function(closure_scope, function_name, args, &block)
   end
 
+  def closure_scope
+    # If closure scope is explicitly set to not nil, if there is a global scope, otherwise an empty hash
+    @closure_scope || Puppet.lookup(:global_scope) { {} }
+  end
+
   # The dispatcher for the function
   #
   # @api private

data/lib/puppet/pops/issues.rb

@@ -351,7 +351,7 @@ module Issues
     "Illegal variable expression. #{label.a_an_uc(semantic)} did not produce a variable name (String or Numeric)."
   end
 
-  # Issues when an expression is used illegaly in a query.
+  # Issues when an expression is used illegally in a query.
   # query only supports == and !=, and not <, > etc.
   #
   ILLEGAL_QUERY_EXPRESSION = hard_issue :ILLEGAL_QUERY_EXPRESSION do

data/lib/puppet/pops/label_provider.rb

@@ -25,12 +25,12 @@ module Puppet::Pops::LabelProvider
     "#{article(text).capitalize} #{text}"
   end
 
-  # Produces a label for the given text with *definitie article* (the).
+  # Produces a label for the given text with *definite article* (the).
   def the o
     "the #{label(o)}"
   end
 
-  # Produces a label for the given text with *definitie article* (The).
+  # Produces a label for the given text with *definite article* (The).
   def the_uc o
     "The #{label(o)}"
   end

data/lib/puppet/pops/loader/base_loader.rb

@@ -1,25 +1,23 @@
+module Puppet::Pops
+module Loader
 # BaseLoader
 # ===
-# An abstract implementation of Puppet::Pops::Loader::Loader
+# An abstract implementation of Loader
 #
 # A derived class should implement `find(typed_name)` and set entries, and possible handle "miss caching".
 #
 # @api private
 #
-class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
+class BaseLoader < Loader
 
   # The parent loader
   attr_reader :parent
 
-  # An internal name used for debugging and error message purposes
-  attr_reader :loader_name
-
   def initialize(parent_loader, loader_name)
+    super(loader_name)
     @parent = parent_loader # the higher priority loader to consult
     @named_values = {}      # hash name => NamedEntry
-    @last_name = nil        # the last name asked for (optimization)
     @last_result = nil      # the value of the last name (optimization)
-    @loader_name = loader_name # the name of the loader (not the name-space it is a loader for)
   end
 
   # @api public
@@ -30,11 +28,10 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
     # These modules are typically parented by the same
     # loader as the one initiating the search. It is inefficient to again try to search the same loader for
     # the same name.
-    if typed_name == @last_name
-      @last_result
-    else
-      @last_name = typed_name
+    if @last_result.nil? || typed_name != @last_result.typed_name
       @last_result = internal_load(typed_name)
+    else
+      @last_result
     end
   end
 
@@ -61,7 +58,6 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
   # @api private
   #
   def set_entry(typed_name, value, origin = nil)
-
     # It is never ok to redefine in the very same loader unless redefining a 'not found'
     if entry = @named_values[typed_name]
       fail_redefine(entry) unless entry.value.nil?
@@ -76,15 +72,14 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
       end
     end
 
-    @last_result = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, value, origin)
-    @last_name = typed_name
+    @last_result = Loader::NamedEntry.new(typed_name, value, origin)
     @named_values[typed_name] = @last_result
   end
 
   # @api private
   #
   def add_entry(type, name, value, origin)
-    set_entry(Puppet::Pops::Loader::Loader::TypedName.new(type, name), value, origin)
+    set_entry(TypedName.new(type, name), value, origin)
   end
 
   # Promotes an already created entry (typically from another loader) to this loader
@@ -141,3 +136,5 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
   end
 
 end
+end
+end