puppet 5.3.7-universal-darwin → 5.4.0-universal-darwin

data/lib/puppet/parser/functions/realize.rb

@@ -7,6 +7,12 @@ Puppet::Parser::Functions::newfunction(:realize, :arity => -2, :doc => "Make a v
     and, of course, is a bit shorter.  You must pass the object using a
     reference; e.g.: `realize User[luke]`." ) do |vals|
 
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'realize'})
+    end
+
     vals = [vals] unless vals.is_a?(Array)
 
     coll = Puppet::Pops::Evaluator::Collectors::FixedSetCollector.new(self, vals.flatten)

data/lib/puppet/parser/functions/return.rb

@@ -4,8 +4,7 @@ Puppet::Parser::Functions::newfunction(
   :doc => <<-DOC
 Immediately returns the given optional value from a function, class body or user defined type body.
 If a value is not given, an `undef` value is returned. This function does not return to the immediate caller.
-If this function is called from within a lambda, the return action is from the scope of the
-function containing the lambda (top scope), not the function accepting the lambda (local scope).
+If called from within a lambda the return will return from the function evaluating the lambda.
 
 The signal produced to return a value bubbles up through
 the call stack until reaching a function, class definition or
@@ -64,26 +63,6 @@ The code would notice `'bar'` but not `'foo'`
 
 Note that the returned value is ignored if used in a class or user defined type.
 
-**Example:** Using `return` in a lambda
-
-```puppet
-# Concatenate three strings into a single string formatted as a list.
-function getFruit() {
-  with("apples", "oranges", "bananas") |$x, $y, $z| {
-    return("${x}, ${y}, and ${z}")
-  }
-  notice "not reached"
-}
-$fruit = getFruit()
-notice $fruit
-
-# The output contains "apples, oranges, and bananas".
-# "not reached" is not output because the function returns its value within the
-# calling function's scope, which stops processing the calling function before
-# the `notice "not reached"` statement.
-# Using `return()` outside of a calling function results in an error.
-```
-
 * Also see functions `return` and `break`
 * Since 4.8.0
 DOC

data/lib/puppet/parser/functions/reverse_each.rb

@@ -40,7 +40,7 @@ $reverse_data = reverse_each($data)
 When no second argument is present, Puppet returns an `Iterable` that represents the reverse
 order of its first argument. This allows methods on `Iterable` to be chained.
 
-When a lamdba is given as the second argument, Puppet iterates the first argument in reverse
+When a lambda is given as the second argument, Puppet iterates the first argument in reverse
 order and passes each value in turn to the lambda, then returns `undef`.
 
 **Example:** Using the `reverse_each` function with an array and a one-parameter lambda

data/lib/puppet/parser/functions/scanf.rb

@@ -34,5 +34,5 @@ DOC
 ) do |args|
   data = args[0]
   format = args[1]
-  result = data.scanf(format)
+  data.scanf(format)
 end

data/lib/puppet/parser/functions/sha256.rb

@@ -0,0 +1,5 @@
+require 'digest/sha2'
+
+Puppet::Parser::Functions::newfunction(:sha256, :type => :rvalue, :arity => 1, :doc => "Returns a SHA256 hash value from a provided string.") do |args|
+  Digest::SHA256.hexdigest(args[0])
+end

data/lib/puppet/parser/functions/tag.rb

@@ -2,5 +2,11 @@
 Puppet::Parser::Functions::newfunction(:tag, :arity => -2, :doc => "Add the specified tags to the containing class
   or definition.  All contained objects will then acquire that tag, also.
   ") do |vals|
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'tag'})
+    end
+
     self.resource.tag(*vals)
 end

data/lib/puppet/parser/functions/tagged.rb

@@ -3,6 +3,12 @@ Puppet::Parser::Functions::newfunction(:tagged, :type => :rvalue, :arity => -2,
   tells you whether the current container is tagged with the specified tags.
   The tags are ANDed, so that all of the specified tags must be included for
   the function to return true.") do |vals|
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'tagged'})
+    end
+
     configtags = compiler.catalog.tags
     resourcetags = resource.tags
 

data/lib/puppet/parser/functions/template.rb

@@ -12,6 +12,11 @@ Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2
   * An absolute path, which can load a template file from anywhere on disk.
   * Multiple arguments, which will evaluate all of the specified templates and
   return their outputs concatenated into a single string.") do |vals|
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::FEATURE_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:feature => 'ERB template'})
+    end
     vals.collect do |file|
       # Use a wrapper, so the template can't get access to the full
       # Scope object.

data/lib/puppet/parser/scope.rb

@@ -375,7 +375,7 @@ class Puppet::Parser::Scope
 
   # Initialize our new scope.  Defaults to having no parent.
   def initialize(compiler, options = EMPTY_HASH)
-    if compiler.is_a? Puppet::Parser::Compiler
+    if compiler.is_a? Puppet::Parser::AbstractCompiler
       @compiler = compiler
     else
       raise Puppet::DevError, _("you must pass a compiler instance to a new scope object")
@@ -708,7 +708,8 @@ class Puppet::Parser::Scope
 
   # Merge all settings for the given _env_name_ into this scope
   # @param env_name [Symbol] the name of the environment
-  def merge_settings(env_name)
+  # @param set_in_this_scope [Boolean] if the settings variables should also be set in this instance of scope
+  def merge_settings(env_name, set_in_this_scope=true)
     settings = Puppet.settings
     table = effective_symtable(false)
     global_table = compiler.qualified_variables
@@ -717,7 +718,9 @@ class Puppet::Parser::Scope
       next if :name == name
       key = name.to_s
       value = transform_setting(settings.value_sym(name, env_name))
-      table[key] = value
+      if set_in_this_scope
+        table[key] = value
+      end
       all_local[key] = value
       # also write the fqn into global table for direct lookup
       global_table["settings::#{key}"] = value
@@ -868,7 +871,25 @@ class Puppet::Parser::Scope
 
   # Used mainly for logging
   def to_s
-    "Scope(#{@resource})"
+    # As this is used for logging, this should really not be done in this class at all...
+    return "Scope(#{@resource})" unless @resource.nil?
+
+    # For logging of function-scope - it is now showing the file and line.
+    detail = Puppet::Pops::PuppetStack.stacktrace[0]
+    return "Scope()" unless detail.is_a?(Array)
+
+    # shorten the path if possible
+    path = detail[0]
+    env_path = nil
+    env_path = environment.configuration.path_to_env unless (environment.nil? || environment.configuration.nil?)
+    # check module paths first since they may be in the environment (i.e. they are longer)
+    if module_path = environment.full_modulepath.detect {|m_path| path.start_with?(m_path) }
+      path = "<module>" + path[module_path.length..-1]
+    elsif env_path && path && path.start_with?(env_path)
+      path = "<env>" + path[env_path.length..-1]
+    end
+    # Make the output appear as "Scope(path, line)"
+    "Scope(#{[path, detail[1]].join(', ')})" 
   end
 
   alias_method :inspect, :to_s
@@ -1045,7 +1066,10 @@ class Puppet::Parser::Scope
   def transform_and_assert_classnames(names)
     names.map do |name|
       case name
+      when NilClass
+        raise ArgumentError, _("Cannot use undef as a class name")
       when String
+        raise ArgumentError, _("Cannot use empty string as a class name") if name.empty?
         name.sub(/^([^:]{1,2})/, '::\1')
 
       when Puppet::Resource

data/lib/puppet/parser/script_compiler.rb

@@ -0,0 +1,118 @@
+require 'puppet/loaders'
+require 'puppet/pops'
+
+# A Script "compiler" that does not support catalog operations
+#
+# The Script compiler is "one shot" - it does not support rechecking if underlying source has changed or
+# deal with possible errors in a cached environment.
+#
+class Puppet::Parser::ScriptCompiler
+  # Allows the ScriptCompiler to use the 3.x Scope class without being an actual "Compiler"
+  #
+  include Puppet::Parser::AbstractCompiler
+
+  # @api private
+  attr_reader :topscope
+
+  # @api private
+  attr_reader :qualified_variables
+
+  # Access to the configured loaders for 4x
+  # @return [Puppet::Pops::Loader::Loaders] the configured loaders
+  # @api private
+  attr_reader :loaders
+
+  # @api private
+  attr_reader :environment
+
+  # @api private
+  attr_reader :node_name
+
+  def with_context_overrides(description = '', &block)
+    Puppet.override( @context_overrides , description, &block)
+  end
+
+  # Evaluates the configured setup for a script + code in an environment with modules
+  #
+  def compile
+    Puppet[:strict_variables] = true
+    Puppet[:strict] = :error
+
+    # TRANSLATORS, "For running script" is not user facing
+    Puppet.override( @context_overrides , "For running script") do
+
+      #TRANSLATORS "main" is a function name and should not be translated
+      result = Puppet::Util::Profiler.profile(_("Script: Evaluated main"), [:script, :evaluate_main]) { evaluate_main }
+      if block_given?
+        yield self
+      else
+        result
+      end
+    end
+
+  rescue Puppet::ParseErrorWithIssue => detail
+    detail.node = node_name
+    Puppet.log_exception(detail)
+    raise
+  rescue => detail
+    message = "#{detail} on node #{node_name}"
+    Puppet.log_exception(detail, message)
+    raise Puppet::Error, message, detail.backtrace
+  end
+
+  # Constructs the overrides for the context
+  def context_overrides()
+    {
+      :current_environment => environment,
+      :global_scope => @topscope,             # 4x placeholder for new global scope
+      :loaders  => @loaders,                  # 4x loaders
+    }
+  end
+
+  # Create a script compiler for the given environment where errors are logged as coming
+  # from the given node_name
+  #
+  def initialize(environment, node_name)
+    @environment = environment
+    @node_name = node_name
+
+    # Create the initial scope, it is needed early
+    @topscope = Puppet::Parser::Scope.new(self)
+
+    # Initialize loaders and Pcore
+    @loaders = Puppet::Pops::Loaders.new(environment)
+
+    # Need to compute overrides here, and remember them, because we are about to
+    # Expensive entries in the context are bound lazily.
+    @context_overrides = context_overrides()
+
+    # Resolutions of fully qualified variable names
+    @qualified_variables = {}
+  end
+
+  # Having multiple named scopes hanging from top scope is not supported when scripting
+  # in the regular compiler this is used to create one named scope per class.
+  # When scripting, the "main class" is just a container of the top level code to evaluate
+  # and it is not evaluated as a class added to a catalog. Since classes are not supported
+  # there is no need to support the concept of "named scopes" as all variables are local
+  # or in the top scope itself (notably, the $settings:: namespace is initialized
+  # as just a set of variables in that namespace - there is no named scope for 'settings'
+  # when scripting.
+  # 
+  # Keeping this method here to get specific error as being unsure if there are functions/logic
+  # that will call this. The AbstractCompiler defines this method, but maybe it does not
+  # have to (TODO).
+  #
+  def newscope(parent, options = {})
+     raise _('having multiple named scopes is not supported when scripting')
+  end
+
+  private
+
+  # Find and evaluate the top level code.
+  def evaluate_main
+    @loaders.pre_load
+    program = @loaders.load_main_manifest
+    return program.nil? ? nil : Puppet::Pops::Parser::EvaluatingParser.singleton.evaluator.evaluate(program, @topscope)
+  end
+end

data/lib/puppet/parser/type_loader.rb

@@ -70,7 +70,7 @@ class Puppet::Parser::TypeLoader
           Puppet.debug {"Automatically imported #{fqname} from #{filename} into #{environment}"}
           return result
         end
-      rescue TypeLoaderError => detail
+      rescue TypeLoaderError
         # I'm not convinced we should just drop these errors, but this
         # preserves existing behaviours.
       end

data/lib/puppet/pops.rb

@@ -113,8 +113,8 @@ module Puppet
   end
 
   require 'puppet/parser/ast/pops_bridge'
-  require 'puppet/bindings'
   require 'puppet/functions'
+  require 'puppet/datatypes'
 
   Puppet::Pops::Model.register_pcore_types
 end

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

@@ -27,6 +27,11 @@ class AccessOperator
   protected
 
   def access_Object(o, scope, keys)
+    type = Puppet::Pops::Types::TypeCalculator.infer(o)
+    if type.is_a?(Puppet::Pops::Types::TypeWithMembers)
+      access_func = type['[]']
+      return access_func.invoke(o, scope, keys) unless access_func.nil?
+    end
     fail(Issues::OPERATOR_NOT_APPLICABLE, @semantic.left_expr, :operator=>'[]', :left_value => o)
   end
 
@@ -144,10 +149,22 @@ class AccessOperator
     end
   end
 
+  def access_PBooleanType(o, scope, keys)
+    keys.flatten!
+    assert_keys(keys, o, 1, 1, TrueClass, FalseClass)
+    Types::TypeFactory.boolean(keys[0])
+  end
+
   def access_PEnumType(o, scope, keys)
     keys.flatten!
+    last = keys.last
+    case_insensitive = false
+    if last == true || last == false
+      keys = keys[0...-1]
+      case_insensitive = last
+    end
     assert_keys(keys, o, 1, Float::INFINITY, String)
-    Types::TypeFactory.enum(*keys)
+    Types::PEnumType.new(keys, case_insensitive)
   end
 
   def access_PVariantType(o, scope, keys)
@@ -278,6 +295,19 @@ class AccessOperator
     Types::TypeFactory.pattern(*keys)
   end
 
+  def access_PURIType(o, scope, keys)
+    keys.flatten!
+    if keys.size == 1
+      param = keys[0]
+      unless Types::PURIType::TYPE_URI_PARAM_TYPE.instance?(param)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'URI-Type', :actual => param.class})
+      end
+      Types::PURIType.new(param)
+    else
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'URI-Type', :min => 1, :actual => keys.size})
+    end
+  end
+
   def access_POptionalType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
@@ -310,10 +340,14 @@ class AccessOperator
 
   def access_PObjectType(o, scope, keys)
     keys.flatten!
-    if keys.size == 1
-      Types::TypeFactory.object(keys[0])
+    if o.resolved? && !o.name.nil?
+      Types::PObjectTypeExtension.create(o, keys)
     else
-      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Object-Type', :min => 1, :actual => keys.size})
+      if keys.size == 1
+        Types::TypeFactory.object(keys[0])
+      else
+        fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Object-Type', :min => 1, :actual => keys.size})
+      end
     end
   end
 

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

@@ -78,13 +78,20 @@ class Closure < CallableSignature
     end
   end
 
-  # Call closure with argument assignment by name
+  def call_by_name_with_scope(scope, args_hash, enforce_parameters)
+    call_by_name_internal(scope, args_hash, enforce_parameters)
+   end
+
   def call_by_name(args_hash, enforce_parameters)
-    closure_scope = enclosing_scope
+    call_by_name_internal(enclosing_scope, args_hash, enforce_parameters)
+  end
+
+  # Call closure with argument assignment by name
+  def call_by_name_internal(closure_scope, args_hash, enforce_parameters)
     if enforce_parameters
       # Push a temporary parameter scope used while resolving the parameter defaults
       closure_scope.with_parameter_scope(closure_name, parameter_names) do |param_scope|
-        # Assign all non-nil values, even those that represent non-existent paramaters.
+        # Assign all non-nil values, even those that represent non-existent parameters.
         args_hash.each { |k, v| param_scope[k] = v unless v.nil? }
         parameters.each do |p|
           name = p.name
@@ -112,6 +119,7 @@ class Closure < CallableSignature
       @evaluator.evaluate_block_with_bindings(closure_scope, args_hash, @model.body)
     end
   end
+  private :call_by_name_internal
 
   def parameters
     @model.parameters
@@ -310,7 +318,7 @@ class Closure < CallableSignature
     closure_scope = enclosing_scope
 
     parameters.each do |param|
-      arg_type, param_range = create_param_type(param, closure_scope)
+      arg_type, _ = create_param_type(param, closure_scope)
       key_type = type_factory.string(param.name.to_s)
       key_type = type_factory.optional(key_type) unless param.value.nil?
       members[key_type] = arg_type

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

@@ -34,7 +34,7 @@ class CompareOperator
   end
 
   # Performs a match of a and b, and returns true if b matches a
-  def match(a, b, scope)
+  def match(a, b, scope = nil)
     @@match_visitor.visit_this_2(self, b, a, scope)
   end
 
@@ -133,7 +133,7 @@ class CompareOperator
   def include_String(a, b, scope)
     case b
     when String
-      # subsstring search downcased
+      # substring search downcased
       a.downcase.include?(b.downcase)
     when Regexp
       matched = a.match(b)           # nil, or MatchData
@@ -200,7 +200,7 @@ class CompareOperator
   def match_Regexp(regexp, left, scope)
     return false unless left.is_a? String
     matched = regexp.match(left)
-    set_match_data(matched, scope) # creates or clears ephemeral
+    set_match_data(matched, scope) unless scope.nil? # creates or clears ephemeral
     !!matched # convert to boolean
   end
 
@@ -245,7 +245,7 @@ class CompareOperator
 
   def match_Symbol(symbol, left, scope)
     return true if symbol == :default
-    equals(left, default, scope)
+    equals(left, default)
   end
 end
 end