puppet 4.5.3-universal-darwin → 4.6.1-universal-darwin

data/lib/puppet/parser/type_loader.rb

@@ -71,7 +71,7 @@ class Puppet::Parser::TypeLoader
           return result
         end
       rescue TypeLoaderError => detail
-        # I'm not convienced we should just drop these errors, but this
+        # I'm not convinced we should just drop these errors, but this
         # preserves existing behaviours.
       end
     end

data/lib/puppet/plugins/data_providers/data_provider.rb

@@ -158,7 +158,7 @@ module Puppet::Plugins::DataProviders
     attr_reader :original_path, :path
 
     # @param original_path [String] path as found in declaration. May contain interpolation expressions
-    # @param path [Pathname] the expanded absolue path
+    # @param path [Pathname] the expanded absolute path
     # @api public
     def initialize(original_path, path)
       @original_path = original_path

data/lib/puppet/pops.rb

@@ -10,10 +10,15 @@ module Puppet
   #
   # @api public
   module Pops
+    EMPTY_HASH = {}.freeze
+    EMPTY_ARRAY = [].freeze
+    EMPTY_STRING = ''.freeze
+
     require 'semantic'
 
     require 'puppet/pops/patterns'
     require 'puppet/pops/utils'
+    require 'puppet/pops/puppet_stack'
 
     require 'puppet/pops/adaptable'
     require 'puppet/pops/adapters'
@@ -81,10 +86,14 @@ module Puppet
       end
     end
 
+    module Resource
+      require 'puppet/pops/resource/resource_type_impl'
+    end
     module Evaluator
       require 'puppet/pops/evaluator/literal_evaluator'
       require 'puppet/pops/evaluator/callable_signature'
       require 'puppet/pops/evaluator/runtime3_converter'
+      require 'puppet/pops/evaluator/runtime3_resource_support'
       require 'puppet/pops/evaluator/runtime3_support'
       require 'puppet/pops/evaluator/evaluator_impl'
       require 'puppet/pops/evaluator/epp_evaluator'
@@ -126,6 +135,10 @@ module Puppet
     module Migration
       require 'puppet/pops/migration/migration_checker'
     end
+
+    module Serialization
+      require 'puppet/pops/serialization'
+    end
   end
 
   require 'puppet/parser/ast/pops_bridge'

data/lib/puppet/pops/adapters.rb

@@ -38,26 +38,19 @@ module Adapters
       # The locator is always the parent locator, all positioned objects are positioned within their
       # parent. If a positioned object also has a locator that locator is for its children!
       #
-      @locator ||= find_locator(@adapted.eContainer)
+      @locator ||= self.class.find_locator(@adapted.eContainer)
     end
 
-    def find_locator(o)
-      if o.nil?
-        raise ArgumentError, "InternalError: SourcePosAdapter for something that has no locator among parents"
-      end
-      case
-      when o.is_a?(Model::Program)
-        return o.locator
-      # TODO_HEREDOC use case of SubLocator instead
-      when o.is_a?(Model::SubLocatedExpression) && !(found_locator = o.locator).nil?
-        return found_locator
-      when adapter = self.class.get(o)
-        return adapter.locator
-      else
-        find_locator(o.eContainer)
-      end
+    # @api private
+    def self.find_locator(o)
+      raise ArgumentError, 'InternalError: SourcePosAdapter for something that has no locator among parents' if o.nil?
+      found_locator = o.respond_to?(:locator) ? o.locator : nil
+      return found_locator unless found_locator.nil?
+      adapter = get(o)
+      return adapter.locator unless adapter.nil?
+      container = o.eContainer
+      container.nil? ? nil : find_locator(container)
     end
-    private :find_locator
 
     def offset
       @adapted.offset
@@ -71,8 +64,7 @@ module Adapters
     # @note This is an expensive operation
     #
     def line
-      # Optimization: manual inlining of locator accessor since this method is frequently called
-      (@locator ||= find_locator(@adapted.eContainer)).line_for_offset(offset)
+      locator.line_for_offset(offset)
     end
 
     # Produces the position on the line of the given offset.
@@ -120,33 +112,32 @@ module Adapters
   # object is adapted with the correct loader.
   #
   # @see Utils#find_adapter
-  #
+  # @api private
   class LoaderAdapter < Adaptable::Adapter
-    # @return [Loader::Loader] the loader
-    attr_accessor :loader
+    attr_accessor :loader_name
 
     # Finds the loader to use when loading originates from the source position of the given argument.
     #
-    # @param instance [Model::PopsObject] The model object
-    # @param scope [Puppet::Parser::Scope] The scope to use
+    # @param [Model::PopsObject] instance The model object
+    # @param [Puppet::Parser::Scope] scope The scope to use
+    # @param [String] file the file from where the model was parsed
     # @return [Loader,nil] the found loader or `nil` if it could not be found
     #
-    def self.loader_for_model_object(model, scope)
-      # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
-      adapter = Utils.find_adapter(model, self)
-      return adapter.loader unless adapter.nil?
-
+    def self.loader_for_model_object(model, scope, file = nil)
       if scope.nil?
         loaders = Puppet.lookup(:loaders) { nil }
         loaders.nil? ? nil : loaders.private_environment_loader
       else
-        # Use source location to determine calling module, or use the private_environment_loader (sees env + all modules)
-        # This is necessary since not all .pp files are loaded by a Loader (see PUP-1833)
-        adapter = adapt_by_source(scope, model)
-        adapter.nil? ? scope.compiler.loaders.private_environment_loader : adapter.loader
+        loaders = scope.compiler.loaders
+        loader_name = loader_name_by_source(scope.environment, model, file)
+        loader_name.nil? ? loaders.private_environment_loader : loaders[loader_name]
       end
     end
 
+    class PathsAndNameCacheAdapter < Puppet::Pops::Adaptable::Adapter
+      attr_accessor :cache, :paths
+    end
+
     # Attempts to find the module that `instance` originates from by looking at it's {SourcePosAdapter} and
     # compare the `locator.file` found there with the module paths given in the environment found in the
     # given `scope`. If the file is found to be relative to a path, then the first segment of the relative
@@ -157,25 +148,29 @@ module Adapters
     #
     # @param scope
     # @param instance
-    def self.adapt_by_source(scope, instance)
-      source_pos = Utils.find_adapter(instance, SourcePosAdapter)
-      unless source_pos.nil?
-        mod = find_module_for_file(scope.environment, source_pos.locator.file)
-        unless mod.nil?
-          adapter = LoaderAdapter.adapt(source_pos.adapted)
-          adapter.loader = scope.compiler.loaders.private_loader_for_module(mod.name)
-          return adapter
-        end
+    # @api private
+    def self.loader_name_by_source(environment, instance, file)
+      file = find_file(instance) if file.nil?
+      return nil if file.nil?
+      pn_adapter = PathsAndNameCacheAdapter.adapt(environment) do |a|
+        a.paths ||= environment.modulepath.map { |p| Pathname.new(p) }
+        a.cache ||= {}
+      end
+      dir = File.dirname(file)
+      pn_adapter.cache.fetch(dir) do |key|
+        mod = find_module_for_dir(environment, pn_adapter.paths, dir)
+        loader_name = mod.nil? ? nil : "#{mod.name} private"
+        pn_adapter.cache[key] = loader_name
       end
-      nil
     end
 
-    def self.find_module_for_file(environment, file)
-      return nil if file.nil?
-      file_path = Pathname.new(file)
-      environment.modulepath.each do |path|
+    # @api private
+    def self.find_module_for_dir(environment, paths, dir)
+      return nil if dir.nil?
+      file_path = Pathname.new(dir)
+      paths.each do |path|
         begin
-          relative_path = file_path.relative_path_from(Pathname.new(path)).to_s.split(File::SEPARATOR)
+          relative_path = file_path.relative_path_from(path).to_s.split(File::SEPARATOR)
         rescue ArgumentError
           # file_path was not relative to the module_path. That's OK.
           next
@@ -187,7 +182,12 @@ module Adapters
       end
       nil
     end
-    private_class_method :find_module_for_file
+
+    # @api private
+    def self.find_file(instance)
+      source_pos = Utils.find_closest_positioned(instance)
+      source_pos.nil? ? nil : source_pos.locator.file
+    end
   end
 end
 end

data/lib/puppet/pops/binder/scheme_handler/confdir_scheme.rb

@@ -6,7 +6,7 @@ require 'puppet/pops/binder/scheme_handler/symbolic_scheme'
 # URI
 # ---
 # The URI scheme is `confdir:/[<FQN>]['?' | [?optional]` where FQN is the fully qualified name of the bindings to load.
-# The referecence is made optional by using a URI query of `?` or `?optional`.
+# The reference is made optional by using a URI query of `?` or `?optional`.
 #
 # @todo
 #   If the file to load is outside of the file system rooted at $confdir (in a gem, or just on the Ruby path), it can not

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

@@ -9,8 +9,6 @@ class AccessOperator
   #
   include Runtime3Support
 
-  EMPTY_STRING = ''.freeze
-
   attr_reader :semantic
 
   # Initialize with AccessExpression to enable reporting issues
@@ -266,6 +264,19 @@ class AccessOperator
     end
   end
 
+  def access_PSensitiveType(o, scope, keys)
+    keys.flatten!
+    if keys.size == 1
+      type = keys[0]
+      unless type.is_a?(Types::PAnyType)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Sensitive-Type', :actual => type.class})
+      end
+      Types::PSensitiveType.new(type)
+    else
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Sensitive-Type', :min => 1, :actual => keys.size})
+    end
+  end
+
   def access_PObjectType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
@@ -275,6 +286,15 @@ class AccessOperator
     end
   end
 
+  def access_PTypeSetType(o, scope, keys)
+    keys.flatten!
+    if keys.size == 1
+      Types::TypeFactory.type_set(keys[0])
+    else
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'TypeSet-Type', :min => 1, :actual => keys.size})
+    end
+  end
+
   def access_PNotUndefType(o, scope, keys)
     keys.flatten!
     case keys.size
@@ -597,11 +617,13 @@ class AccessOperator
       #
       result = keys.each_with_index.map do |c, i|
         name = if c.is_a?(Types::PResourceType) && !c.type_name.nil? && c.title.nil?
+                 strict_check(c, i)
                  # type_name is already downcase. Don't waste time trying to downcase again
                  c.type_name
                elsif c.is_a?(String)
                  c.downcase
                elsif c.is_a?(Types::PTypeReferenceType)
+                 strict_check(c, i)
                  c.type_string.downcase
                else
                  fail(Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
@@ -634,6 +656,21 @@ class AccessOperator
     # returns single type as type, else an array of types
     return result_type_array ? result : result.pop
   end
+
+  # PUP-6083 - Using Class[Foo] is deprecated since an arbitrary foo will trigger a "resource not found"
+  # @api private
+  def strict_check(name, index)
+    if Puppet[:strict] != :off
+      msg = 'Upper cased class-name in a Class[<class-name>] is deprecated, class-name should be a lowercase string'
+      case Puppet[:strict]
+      when :error
+        fail(Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[index], {:name => name})
+      when :warning
+        Puppet.warn_once(:deprecation, 'ClassReferenceInUpperCase', msg)
+      end
+    end
+  end
+
 end
 end
 end

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

@@ -18,16 +18,15 @@ class Closure < CallableSignature
   attr_reader :model
   attr_reader :enclosing_scope
 
-  def initialize(evaluator, model, scope)
+  def initialize(evaluator, model)
     @evaluator = evaluator
     @model = model
-    @enclosing_scope = scope
   end
 
   # Evaluates a closure in its enclosing scope after having matched given arguments with parameters (from left to right)
   # @api public
   def call(*args)
-    call_with_scope(@enclosing_scope, args)
+    call_with_scope(enclosing_scope, args)
   end
 
   # This method makes a Closure compatible with a Dispatch. This is used when the closure is wrapped in a Function
@@ -35,7 +34,7 @@ class Closure < CallableSignature
   # checks of the argument type/arity validity).
   # @api private
   def invoke(instance, calling_scope, args, &block)
-    @enclosing_scope.with_global_scope do |global_scope|
+    enclosing_scope.with_global_scope do |global_scope|
       call_with_scope(global_scope, args, &block)
     end
   end
@@ -43,8 +42,9 @@ class Closure < CallableSignature
   # Call closure with argument assignment by name
   def call_by_name(args_hash, enforce_parameters)
     if enforce_parameters
+      closure_scope = enclosing_scope
       # Push a temporary parameter scope used while resolving the parameter defaults
-      @enclosing_scope.with_parameter_scope(closure_name, parameter_names) do |param_scope|
+      closure_scope.with_parameter_scope(closure_name, parameter_names) do |param_scope|
         # Assign all non-nil values, even those that represent non-existent paramaters.
         args_hash.each { |k, v| param_scope[k] = v unless v.nil? }
         parameters.each do |p|
@@ -56,7 +56,7 @@ class Closure < CallableSignature
               # No default. Assign nil if the args_hash included it
               param_scope[name] = nil if args_hash.include?(name)
             else
-              param_scope[name] = param_scope.evaluate(name, p.value, @enclosing_scope, @evaluator)
+              param_scope[name] = param_scope.evaluate(name, p.value, closure_scope, @evaluator)
             end
           end
         end
@@ -65,7 +65,7 @@ class Closure < CallableSignature
       Types::TypeMismatchDescriber.validate_parameters(closure_name, params_struct, args_hash)
     end
 
-    @evaluator.evaluate_block_with_bindings(@enclosing_scope, args_hash, @model.body)
+    @evaluator.evaluate_block_with_bindings(enclosing_scope, args_hash, @model.body)
   end
 
   def parameters
@@ -113,15 +113,38 @@ class Closure < CallableSignature
     CLOSURE_NAME
   end
 
+  class Dynamic < Closure
+    def initialize(evaluator, model, scope)
+      @enclosing_scope = scope
+      super(evaluator, model)
+    end
+
+    def enclosing_scope
+      @enclosing_scope
+    end
+  end
+
   class Named < Closure
-    def initialize(name, evaluator, model, scope)
+    def initialize(name, evaluator, model)
       @name = name
-      super(evaluator, model, scope)
+      super(evaluator, model)
     end
 
     def closure_name
       @name
     end
+
+    # The assigned enclosing scope, or global scope if enclosing scope was initialized to nil
+    #
+    def enclosing_scope
+      # Named closures are typically used for puppet functions and they cannot be defined
+      # in an enclosing scope as they are cashed and reused. They need to bind to the
+      # global scope at time of use rather at time of definition.
+      # Unnamed closures are always a runtime construct, they are never bound by a loader
+      # and are thus garbage collected at end of a compilation.
+      #
+      Puppet.lookup(:global_scope) { {} }
+    end
   end
 
   private
@@ -196,8 +219,10 @@ class Closure < CallableSignature
     types = []
     range = [0, 0]
     in_optional_parameters = false
+    closure_scope = enclosing_scope
+
     parameters.each do |param|
-      type, param_range = create_param_type(param)
+      type, param_range = create_param_type(param, closure_scope)
 
       types << type
 
@@ -221,9 +246,10 @@ class Closure < CallableSignature
   def create_params_struct
     type_factory = Types::TypeFactory
     members = {}
+    closure_scope = enclosing_scope
 
     parameters.each do |param|
-      arg_type, param_range = create_param_type(param)
+      arg_type, param_range = create_param_type(param, closure_scope)
       key_type = type_factory.string(nil, param.name.to_s)
       key_type = type_factory.optional(key_type) unless param.value.nil?
       members[key_type] = arg_type
@@ -231,9 +257,9 @@ class Closure < CallableSignature
     type_factory.struct(members)
   end
 
-  def create_param_type(param)
+  def create_param_type(param, closure_scope)
     type = if param.type_expr
-             @evaluator.evaluate(param.type_expr, @enclosing_scope)
+             @evaluator.evaluate(param.type_expr, closure_scope)
            else
              Types::PAnyType::DEFAULT
            end

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

@@ -19,7 +19,8 @@ class CollectorTransformer
       fail "Classes cannot be collected"
     end
 
-    resource_type = scope.find_resource_type(type)
+    resource_type = Runtime3ResourceSupport.find_resource_type(scope, type)
+
     fail "Resource type #{type} doesn't exist" unless resource_type
 
     adapter = Adapters::SourcePosAdapter.adapt(o)
@@ -155,6 +156,10 @@ protected
     @@evaluator.evaluate(o, scope)
   end
 
+  def query_LiteralUndef(o, scope)
+    nil
+  end
+
   def query_QualifiedName(o, scope)
     @@evaluator.evaluate(o, scope)
   end
@@ -205,6 +210,10 @@ protected
     @@evaluator.evaluate(o, scope)
   end
 
+  def match_LiteralUndef(o, scope)
+    nil
+  end
+
   def match_ConcatenatedString(o, scope)
     @@evaluator.evaluate(o, scope)
   end