bolt 0.20.3 → 0.20.5

data/vendored/puppet/lib/puppet/pops/lookup/lookup_adapter.rb

@@ -16,6 +16,8 @@ class LookupAdapter < DataAdapter
 
   HASH = 'hash'.freeze
   MERGE = 'merge'.freeze
+  CONVERT_TO = 'convert_to'.freeze
+  NEW = 'new'.freeze
 
   def self.create_adapter(compiler)
     new(compiler)
@@ -52,18 +54,65 @@ class LookupAdapter < DataAdapter
         catch(:no_such_key) { do_lookup(LookupKey::LOOKUP_OPTIONS, lookup_invocation, HASH) }
         nil
       else
+        lookup_options = lookup_lookup_options(key, lookup_invocation) || {}
+
         if merge.nil?
           # Used cached lookup_options
-          merge = lookup_merge_options(key, lookup_invocation)
+          # merge = lookup_merge_options(key, lookup_invocation)
+          merge = lookup_options[MERGE]
           lookup_invocation.report_merge_source(LOOKUP_OPTIONS) unless merge.nil?
         end
-        lookup_invocation.with(:data, key.to_s) do
-          catch(:no_such_key) { return do_lookup(key, lookup_invocation, merge) }
-          throw :no_such_key if lookup_invocation.global_only?
-          key.dig(lookup_invocation, lookup_default_in_module(key, lookup_invocation))
-        end
+        convert_result(key.to_s, lookup_options, lookup_invocation, lambda do
+          lookup_invocation.with(:data, key.to_s) do
+            catch(:no_such_key) { return do_lookup(key, lookup_invocation, merge) }
+            throw :no_such_key if lookup_invocation.global_only?
+            key.dig(lookup_invocation, lookup_default_in_module(key, lookup_invocation))
+          end
+        end)
+      end
+    end
+  end
+
+  # Performs a possible conversion of the result of calling `the_lookup` lambda
+  # The conversion takes place if there is a 'convert_to' key in the lookup_options
+  # If there is no conversion, the result of calling `the_lookup` is returned
+  # otherwise the successfully converted value.
+  # Errors are raised if the convert_to is faulty (bad type string, or if a call to
+  # new(T, <args>) fails.
+  #
+  # @param key [String] The key to lookup
+  # @param lookup_options [Hash] a hash of options
+  # @param lookup_invocation [Invocation] the lookup invocation
+  # @param the_lookup [Lambda] zero arg lambda that performs the lookup of a value
+  # @return [Object] the looked up value, or converted value if there was conversion
+  # @throw :no_such_key when the object is not found (if thrown by `the_lookup`)
+  #
+  def convert_result(key, lookup_options, lookup_invocation, the_lookup)
+    result = the_lookup.call
+    convert_to = lookup_options[CONVERT_TO]
+    return result if convert_to.nil?
+
+    convert_to = convert_to.is_a?(Array) ? convert_to : [convert_to]
+    if convert_to[0].is_a?(String)
+      begin
+        convert_to[0] = Puppet::Pops::Types::TypeParser.singleton.parse(convert_to[0])
+      rescue StandardError => e
+        raise Puppet::DataBinding::LookupError,
+          _("Invalid data type in lookup_options for key '%{key}' could not parse '%{source}', error: '%{msg}") %
+            { key: key, source: convert_to[0], msg: e.message}
       end
     end
+    begin
+      result = lookup_invocation.scope.call_function(NEW, [convert_to[0], result, *convert_to[1..-1]])
+      # TRANSLATORS 'lookup_options', 'convert_to' and args_string variable should not be translated,
+      args_string = Puppet::Pops::Types::StringConverter.singleton.convert(convert_to)
+      lookup_invocation.report_text { _("Applying convert_to lookup_option with arguments %{args}") % { args: args_string } }
+    rescue StandardError => e
+      raise Puppet::DataBinding::LookupError,
+        _("The convert_to lookup_option for key '%{key}' raised error: %{msg}") %
+          { key: key, msg: e.message}
+    end
+    result
   end
 
   def lookup_global(key, lookup_invocation, merge_strategy)

data/vendored/puppet/lib/puppet/pops/model/model_label_provider.rb

@@ -104,6 +104,8 @@ class ModelLabelProvider
   def label_Sensitive o                   ; "Sensitive"                         end
   def label_Timestamp o                   ; "Timestamp"                         end
   def label_Timespan o                    ; "Timespan"                          end
+  def label_Version o                     ; "Semver"                            end
+  def label_VersionRange o                ; "SemverRange"                       end
 
   def label_PResourceType o
     if o.title

data/vendored/puppet/lib/puppet/pops/parser/epp_parser.rb

@@ -6,7 +6,7 @@ class Puppet::Pops::Parser::EppParser < Puppet::Pops::Parser::Parser
   # @return [void]
   #
   def initvars
-    self.lexer = Puppet::Pops::Parser::Lexer2.new()# {:mode => :epp})
+    self.lexer = Puppet::Pops::Parser::Lexer2.new()
   end
 
   # Parses a file expected to contain epp text/DSL logic.

data/vendored/puppet/lib/puppet/pops/parser/epp_support.rb

@@ -229,6 +229,7 @@ module EppSupport
 
         when "#"
           # template comment
+
           # drop the scanned <%, and skip past -%>, or %>, but also skip %%>
           s.slice!(-2..-1)
 
@@ -240,8 +241,11 @@ module EppSupport
             @mode = :error
             return s
           end
-          # Always trim leading whitespace on the same line when there is a comment
-          s.sub!(/[ \t]*\z/, '')
+          # Trim leading whitespace on the same line when start was <%#-
+          if part[1] == '-'
+            s.sub!(/[ \t]*\z/, '')
+          end
+
           @skip_leading = true if part.end_with?("-%>")
           # Continue scanning for more text
 

data/vendored/puppet/lib/puppet/pops/parser/lexer2.rb

@@ -647,7 +647,7 @@ class Lexer2
   #
   def lex_file(file)
     initvars
-    contents = Puppet::FileSystem.exist?(file) ? Puppet::FileSystem.read(file, :encoding => 'utf-8') : ''
+    contents = Puppet::FileSystem.exist?(file) ? Puppet::FileSystem.read(file, :mode => 'rb', :encoding => 'utf-8') : ''
     assert_not_bom(contents)
     @scanner = StringScanner.new(contents.freeze)
     @locator = Locator.locator(contents, file)

data/vendored/puppet/lib/puppet/pops/pcore.rb

@@ -35,20 +35,20 @@ module Pcore
     if Puppet[:tasks]
       add_object_type('Task', <<-PUPPET, loader)
         {
-          attributes => {   
+          attributes => {
             # Fully qualified name of the task
             name => { type => Pattern[/\\A[a-z][a-z0-9_]*(?:::[a-z][a-z0-9_]*)*\\z/] },
 
-            # Full path to executable
-            executable => { type => String },
+            # List of implementations with requirements
+            implementations => { type => Array[Struct[name => String, path => String, Optional[requirements] => Array[String]], 1] },
 
             # Task description
             description => { type => Optional[String], value => undef },
 
             # Puppet Task version
             puppet_task_version => { type => Integer, value => 1 },
-  
-            # Type, description, and sensitive property of each parameter 
+
+            # Type, description, and sensitive property of each parameter
             parameters => {
               type => Optional[Hash[
                 Pattern[/\\A[a-z][a-z0-9_]*\\z/],
@@ -59,7 +59,7 @@ module Pcore
               value => undef
             },
 
-             # Type, description, and sensitive property of each output 
+             # Type, description, and sensitive property of each output
             output => {
               type => Optional[Hash[
                 Pattern[/\\A[a-z][a-z0-9_]*\\z/],
@@ -69,7 +69,7 @@ module Pcore
                   type => Type]]],
               value => undef
             },
- 
+
             supports_noop => { type => Boolean, value => false },
             input_method => { type => String, value => 'both' },
           }

data/vendored/puppet/lib/puppet/pops/puppet_stack.rb

@@ -17,6 +17,9 @@ module Puppet::Pops
 # will be represented with the text `unknown` and `0´ respectively.
 #
 module PuppetStack
+  # Pattern matching an entry in the ruby stack that is a puppet entry
+  PP_ENTRY_PATTERN = /^(.*\.pp)?:([0-9]+):in (`stack'|`block in call_function')/
+
   # Sends a message to an obj such that it appears to come from
   # file, line when calling stacktrace.
   #
@@ -33,11 +36,22 @@ module PuppetStack
 
   def self.stacktrace
     caller().reduce([]) do |memo, loc|
-      if loc =~ /^(.*\.pp)?:([0-9]+):in (`stack'|`block in call_function')/
+      if loc =~ PP_ENTRY_PATTERN
         memo << [$1.nil? ? 'unknown' : $1, $2.to_i]
       end
       memo
     end
   end
+
+  # Returns an Array with the top of the puppet stack, or an empty Array if there was no such entry.
+  #
+  def self.top_of_stack
+    caller.each do |loc|
+      if loc =~ PP_ENTRY_PATTERN
+        return [$1.nil? ? 'unknown' : $1, $2.to_i]
+      end
+    end
+    []
+  end
 end
 end

data/vendored/puppet/lib/puppet/pops/serialization.rb

@@ -7,12 +7,12 @@ module Serialization
   class SerializationError < Puppet::Error
   end
 
-  PCORE_TYPE_KEY = '__pcore_type__'.freeze
+  PCORE_TYPE_KEY = '__ptype'.freeze
 
   # Key used when the value can be represented as, and recreated from, a single string that can
   # be passed to a `from_string` method or an array of values that can be passed to the default
   # initializer method.
-  PCORE_VALUE_KEY = '__pcore_value__'.freeze
+  PCORE_VALUE_KEY = '__pvalue'.freeze
 
   # Type key used for hashes that contain keys that are not of type String
   PCORE_TYPE_HASH = 'Hash'.freeze

data/vendored/puppet/lib/puppet/pops/serialization/from_data_converter.rb

@@ -64,7 +64,7 @@ module Serialization
     # @option options [Loaders::Loader] :loader the loader to use. Can be `nil` in which case the default is
     #    determined by the {Types::TypeParser}.
     # @option options [Boolean] :allow_unresolved `true` to allow that rich_data hashes are kept "as is" if the
-    #    designated '__pcore_type__' cannot be resolved. Defaults to `false`.
+    #    designated '__ptype' cannot be resolved. Defaults to `false`.
     # @return [RichData] the processed result.
     #
     # @api public
@@ -78,7 +78,7 @@ module Serialization
     # @option options [Loaders::Loader] :loader the loader to use. Can be `nil` in which case the default is
     #    determined by the {Types::TypeParser}.
     # @option options [Boolean] :allow_unresolved `true` to allow that rich_data hashes are kept "as is" if the
-    #    designated '__pcore_type__' cannot be resolved. Defaults to `false`.
+    #    designated '__ptype' cannot be resolved. Defaults to `false`.
     #
     # @api public
     def initialize(options = EMPTY_HASH)

data/vendored/puppet/lib/puppet/pops/serialization/json.rb

@@ -1,4 +1,4 @@
-require 'json'
+require 'puppet/util/json'
 
 module Puppet::Pops
 module Serialization
@@ -146,12 +146,12 @@ module JSON
     end
 
     def to_a
-      ::JSON.parse(io_string)
+      ::Puppet::Util::Json.load(io_string)
     end
 
     def to_json
       if @indent > 0
-        ::JSON.pretty_unparse(to_a, { :indent => ' ' * @indent })
+        ::Puppet::Util::Json.dump(to_a, { :pretty => true, :indent => ' ' * @indent })
       else
         io_string
       end
@@ -159,7 +159,7 @@ module JSON
 
     # Write a payload object. Not subject to extensions
     def write_pl(obj)
-      @io << obj.to_json << ','
+      @io << Puppet::Util::Json.dump(obj) << ','
     end
 
     def io_string
@@ -198,7 +198,7 @@ module JSON
       if ext.nil?
         case obj
         when Numeric, String, true, false, nil
-          @io << obj.to_json
+          @io << Puppet::Util::Json.dump(obj)
           write_delim
         else
           raise SerializationError, _("Unable to serialize a %{obj}") % { obj: obj.class.name }
@@ -284,9 +284,9 @@ module JSON
     def parse_io(io)
       case io
       when IO, StringIO
-        ::JSON.parse(io.read)
+        ::Puppet::Util::Json.load(io.read)
       when String
-        ::JSON.parse(io)
+        ::Puppet::Util::Json.load(io)
       else
         io
       end

data/vendored/puppet/lib/puppet/pops/serialization/to_data_converter.rb

@@ -290,12 +290,12 @@ module Serialization
     def serialization_issue(issue, options = EMPTY_HASH)
       semantic = @semantic
       if semantic.nil?
-        stacktrace = Puppet::Pops::PuppetStack.stacktrace()
-        if stacktrace.size > 0
-          file, line = stacktrace[0]
-          semantic = Puppet::Pops::SemanticError.new(issue, nil, {:file => file, :line => line})
-        else
+        tos = Puppet::Pops::PuppetStack.top_of_stack
+        if tos.empty?
           semantic = Puppet::Pops::SemanticError.new(issue, nil, EMPTY_HASH)
+        else
+          file, line = stacktrace
+          semantic = Puppet::Pops::SemanticError.new(issue, nil, {:file => file, :line => line})
         end
       end
       optionally_fail(issue,  semantic, options)

data/vendored/puppet/lib/puppet/pops/types/types.rb

@@ -906,11 +906,15 @@ class PNumericType < PScalarDataType
           0
         else
           begin
-            if from[0] == '0' && (from[1].downcase == 'b' || from[1].downcase == 'x')
-              Integer(from)
-            else
-              Puppet::Pops::Utils.to_n(from)
+            if from[0] == '0'
+              second_char = (from[1] || '').downcase
+              if second_char == 'b' || second_char == 'x'
+                # use built in conversion
+                return Integer(from)
+              end
             end
+
+            Puppet::Pops::Utils.to_n(from)
           rescue TypeError => e
             raise TypeConversionError.new(e.message)
           rescue ArgumentError => e

data/vendored/puppet/lib/puppet/pops/validation/checker4_0.rb

@@ -35,6 +35,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
     @check_visitor = self.class.check_visitor
     @acceptor = diagnostics_producer
+    @file_to_namespace = {}
 
     # Use null migration checker unless given in context
     @migration_checker = (Puppet.lookup(:migration_checker) { Migration::MigrationChecker.new() })
@@ -395,6 +396,8 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     if o.name !~ Patterns::CLASSREF_DECL
       acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, {:name=>o.name})
     end
+
+    internal_check_file_namespace(o, o.name, o.locator.file)
     internal_check_reserved_type_name(o, o.name)
     internal_check_future_reserved_word(o, o.name)
   end
@@ -530,6 +533,76 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     end
   end
 
+  def internal_check_file_namespace(o, name, file)
+    return if file.nil?
+
+    lc_file = file.downcase
+
+    file_namespace = @file_to_namespace[lc_file]
+    if file_namespace.nil?
+      return if @file_to_namespace.key?(lc_file)
+      file_namespace = @file_to_namespace[lc_file] = namespace_for_file(lc_file)
+      return if file_namespace.nil?
+    end
+
+    if !name.downcase.start_with?(file_namespace)
+      acceptor.accept(Issues::ILLEGAL_DEFINITION_LOCATION, o, {:name => name, :file => file})
+    end
+  end
+
+  NEVER_MATCH = '\b'.freeze
+
+  def namespace_for_file(file)
+    path = Pathname.new(file)
+
+    return nil if path.extname != ".pp"
+
+    return nil if initial_manifest?(path)
+
+    path = path.each_filename.to_a
+
+    # Example definition dir: manifests in this path:
+    # <modules dir>/<module name>/manifests/<module subdir>/<classfile>.pp
+    definition_dir_index = find_module_definition_dir(path)
+
+    # How can we get this result?
+    # If it is not an initial manifest, it must come from a module,
+    # and from the manifests dir there.  This may never get used...
+    return NEVER_MATCH if definition_dir_index.nil? || definition_dir_index == 0
+
+    before_definition_dir = definition_dir_index - 1
+    after_definition_dir = definition_dir_index + 1
+    names = path[after_definition_dir .. -2] # Directories inside module
+    names.unshift(path[before_definition_dir]) # Name of the module itself
+    # Do not include name of module init file at top level of module
+    filename = path[-1]
+    if !(path.length == (after_definition_dir+1) && filename == 'init.pp')
+      names.push(filename[0 .. -4]) # Remove .pp from filename
+    end
+
+    names.join("::").freeze
+  end
+
+  def initial_manifest?(path)
+    manifest_setting = Puppet[:manifest]
+
+    # Does this ever happen outside of tests?
+    if manifest_setting.nil?
+      return path.basename.to_s == 'site.pp'
+    end
+
+    full_path = path.expand_path.to_s
+    full_path == manifest_setting || full_path.start_with?(manifest_setting)
+  end
+
+  # Returns module root directory index in path for files under 'manifests',
+  # 'functions', 'types' and 'plans'
+  def find_module_definition_dir(path)
+    reverse_index = path.reverse_each.find_index do |dir|
+      dir == 'manifests' || dir == 'functions' || dir == 'types' || dir == 'plans'
+    end
+    return reverse_index.nil? ? nil : (path.length - 1) - reverse_index
+  end
 
   RESERVED_PARAMETERS = {
     'name' => true,

data/vendored/puppet/lib/puppet/pops/validation/validator_factory_4_0.rb

@@ -27,15 +27,16 @@ class ValidatorFactory_4_0 < Factory
     # Configure each issue that should **not** be an error
     #
     # Validate as per the current runtime configuration
-    p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
-    p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
+    p[Issues::RT_NO_STORECONFIGS_EXPORT]     = Puppet[:storeconfigs] ? :ignore : :warning
+    p[Issues::RT_NO_STORECONFIGS]            = Puppet[:storeconfigs] ? :ignore : :warning
 
     p[Issues::FUTURE_RESERVED_WORD]          = :deprecation
 
     p[Issues::DUPLICATE_KEY]                 = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
     p[Issues::NAME_WITH_HYPHEN]              = :error
     p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
-    p[Issues::CLASS_NOT_VIRTUALIZABLE]      = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+    p[Issues::CLASS_NOT_VIRTUALIZABLE]       = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+    p[Issues::ILLEGAL_DEFINITION_LOCATION]   = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
     p
   end
 end

data/vendored/puppet/lib/puppet/provider/augeas/augeas.rb

@@ -122,6 +122,13 @@ Puppet::Type.type(:augeas).provide(:augeas) do
           if delim == "'" || delim == "\""
             sc.getch
             argline << sc.scan(/([^\\#{delim}]|(\\.))*/)
+            # Unescape the delimiter so it's actually possible to have a
+            # literal delim inside the string. We only unescape the
+            # delimeter and not every backslash-escaped character so that
+            # things like escaped spaces '\ ' get passed through because
+            # Augeas needs to see them. If we unescaped them, too, users
+            # would be forced to double-escape them
+            argline.last.gsub!(/\\(#{delim})/, '\1')
             sc.getch
           else
             argline << sc.scan(/[^\s]+/)