bolt 0.19.1 → 0.20.0

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

@@ -1,154 +0,0 @@
-require 'hiera/scope'
-require_relative 'sub_lookup'
-module Puppet::Pops
-module Lookup
-# Adds support for interpolation expressions. The expressions may contain keys that uses dot-notation
-# to further navigate into hashes and arrays
-#
-# @api public
-module Interpolation
-  include SubLookup
-
-  # @param value [Object] The value to interpolate
-  # @param context [Context] The current lookup context
-  # @param allow_methods [Boolean] `true` if interpolation expression that contains lookup methods are allowed
-  # @return [Object] the result of resolving all interpolations in the given value
-  # @api public
-  def interpolate(value, context, allow_methods)
-    case value
-    when String
-      value.index('%{').nil? ? value : interpolate_string(value, context, allow_methods)
-    when Array
-      value.map { |element| interpolate(element, context, allow_methods) }
-    when Hash
-      result = {}
-      value.each_pair { |k, v| result[interpolate(k, context, allow_methods)] = interpolate(v, context, allow_methods) }
-      result
-    else
-      value
-    end
-  end
-
-  private
-
-  EMPTY_INTERPOLATIONS = {
-    '' => true,
-    '::' => true,
-    '""' => true,
-    "''" => true,
-    '"::"' => true,
-    "'::'" => true
-  }.freeze
-
-  # Matches a key that is quoted using a matching pair of either single or double quotes.
-  QUOTED_KEY = /^(?:"([^"]+)"|'([^']+)')$/
-
-  def interpolate_string(subject, context, allow_methods)
-    lookup_invocation = context.is_a?(Invocation) ? context : context.invocation
-    lookup_invocation.with(:interpolate, subject) do
-      subject.gsub(/%\{([^\}]*)\}/) do |match|
-        expr = $1
-        # Leading and trailing spaces inside an interpolation expression are insignificant
-        expr.strip!
-        value = nil
-        unless EMPTY_INTERPOLATIONS[expr]
-          method_key, key = get_method_and_data(expr, allow_methods)
-          is_alias = method_key == :alias
-
-          # Alias is only permitted if the entire string is equal to the interpolate expression
-          fail(Issues::HIERA_INTERPOLATION_ALIAS_NOT_ENTIRE_STRING) if is_alias && subject != match
-          value = interpolate_method(method_key).call(key, lookup_invocation, subject)
-
-          # break gsub and return value immediately if this was an alias substitution. The value might be something other than a String
-          return value if is_alias
-
-          value = lookup_invocation.check(method_key == :scope ? "scope:#{key}" : key) { interpolate(value, lookup_invocation, allow_methods) }
-        end
-        value.nil? ? '' : value
-      end
-    end
-  end
-
-  def interpolate_method(method_key)
-    @@interpolate_methods ||= begin
-      global_lookup = lambda do |key, lookup_invocation, _|
-        scope = lookup_invocation.scope
-        if scope.is_a?(Hiera::Scope) && !lookup_invocation.global_only?
-          # "unwrap" the Hiera::Scope
-          scope = scope.real
-        end
-        lookup_invocation.with_scope(scope) do |sub_invocation|
-          sub_invocation.lookup(key) {  Lookup.lookup(key, nil, '', true, nil, sub_invocation) }
-        end
-      end
-      scope_lookup = lambda do |key, lookup_invocation, subject|
-        segments = split_key(key) { |problem| Puppet::DataBinding::LookupError.new("#{problem} in string: #{subject}") }
-        root_key = segments.shift
-        value = lookup_invocation.with(:scope, 'Global Scope') do
-          ovr = lookup_invocation.override_values
-          if ovr.include?(root_key)
-            lookup_invocation.report_found_in_overrides(root_key, ovr[root_key])
-          else
-            scope = lookup_invocation.scope
-            val = scope[root_key]
-            if val.nil? && !nil_in_scope?(scope, root_key)
-              defaults = lookup_invocation.default_values
-              if defaults.include?(root_key)
-                lookup_invocation.report_found_in_defaults(root_key, defaults[root_key])
-              else
-                nil
-              end
-            else
-              lookup_invocation.report_found(root_key, val)
-            end
-          end
-        end
-        unless value.nil? || segments.empty?
-          found = nil;
-          catch(:no_such_key) { found = sub_lookup(key, lookup_invocation, segments, value) }
-          value = found;
-        end
-        lookup_invocation.remember_scope_lookup(key, root_key, segments, value)
-        value
-      end
-
-      {
-        :lookup => global_lookup,
-        :hiera => global_lookup, # this is just an alias for 'lookup'
-        :alias => global_lookup, # same as 'lookup' but expression must be entire string and result is not subject to string substitution
-        :scope => scope_lookup,
-        :literal => lambda { |key, _, _| key }
-      }.freeze
-    end
-    interpolate_method = @@interpolate_methods[method_key]
-    fail(Issues::HIERA_INTERPOLATION_UNKNOWN_INTERPOLATION_METHOD, :name => method_key) unless interpolate_method
-    interpolate_method
-  end
-
-  # Because the semantics of Puppet::Parser::Scope#include? differs from Hash#include?
-  def nil_in_scope?(scope, key)
-    if scope.is_a?(Hash)
-      scope.include?(key)
-    else
-      scope.exist?(key)
-    end
-  end
-
-  def get_method_and_data(data, allow_methods)
-    if match = data.match(/^(\w+)\((?:["]([^"]+)["]|[']([^']+)['])\)$/)
-      fail(Issues::HIERA_INTERPOLATION_METHOD_SYNTAX_NOT_ALLOWED) unless allow_methods
-      key = match[1].to_sym
-      data = match[2] || match[3] # double or single qouted
-    else
-      key = :scope
-    end
-    [key, data]
-  end
-
-  def fail(issue, args = EMPTY_HASH)
-    raise Puppet::DataBinding::LookupError.new(
-      issue.format(args), nil, nil, nil, nil, issue.issue_code)
-  end
-end
-end
-end

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

@@ -1,261 +0,0 @@
-require_relative 'explainer'
-
-module Puppet::Pops
-module Lookup
-# @api private
-class Invocation
-  attr_reader :scope, :override_values, :default_values, :explainer, :module_name, :top_key, :adapter_class
-
-  def self.current
-    @current
-  end
-
-  # Creates a new instance with same settings as this instance but with a new given scope
-  # and yields with that scope.
-  #
-  # @param scope [Puppet::Parser::Scope] The new scope
-  # @return [Invocation] the new instance
-  def with_scope(scope)
-    yield(Invocation.new(scope, override_values, default_values, explainer))
-  end
-
-  # Creates a context object for a lookup invocation. The object contains the current scope, overrides, and default
-  # values and may optionally contain an {ExplanationAcceptor} instance that will receive book-keeping information
-  # about the progress of the lookup.
-  #
-  # If the _explain_ argument is a boolean, then _false_ means that no explanation is needed and _true_ means that
-  # the default explanation acceptor should be used. The _explain_ argument may also be an instance of the
-  # `ExplanationAcceptor` class.
-  #
-  # @param scope [Puppet::Parser::Scope] The scope to use for the lookup
-  # @param override_values [Hash<String,Object>|nil] A map to use as override. Values found here are returned immediately (no merge)
-  # @param default_values [Hash<String,Object>] A map to use as the last resort (but before default)
-  # @param explainer [boolean,Explanainer] An boolean true to use the default explanation acceptor or an explainer instance that will receive information about the lookup
-  def initialize(scope, override_values = EMPTY_HASH, default_values = EMPTY_HASH, explainer = nil, adapter_class = nil)
-    @scope = scope
-    @override_values = override_values
-    @default_values = default_values
-
-    parent_invocation = self.class.current
-    if parent_invocation && (adapter_class.nil? || adapter_class == parent_invocation.adapter_class)
-      # Inherit from parent invocation (track recursion)
-      @name_stack = parent_invocation.name_stack
-      @adapter_class = parent_invocation.adapter_class
-
-      # Inherit Hiera 3 legacy properties
-      set_hiera_xxx_call if parent_invocation.hiera_xxx_call?
-      set_hiera_v3_merge_behavior if parent_invocation.hiera_v3_merge_behavior?
-      set_global_only if parent_invocation.global_only?
-      povr = parent_invocation.hiera_v3_location_overrides
-      set_hiera_v3_location_overrides(povr) unless povr.empty?
-
-      # Inherit explainer unless a new explainer is given or disabled using false
-      explainer = explainer == false ? nil : parent_invocation.explainer
-    else
-      @name_stack = []
-      @adapter_class = adapter_class.nil? ? LookupAdapter : adapter_class
-      unless explainer.is_a?(Explainer)
-        explainer = explainer == true ? Explainer.new : nil
-      end
-      explainer = DebugExplainer.new(explainer) if Puppet[:debug] && !explainer.is_a?(DebugExplainer)
-    end
-    @explainer = explainer
-  end
-
-  def lookup(key, module_name = nil)
-    key = LookupKey.new(key) unless key.is_a?(LookupKey)
-    @top_key = key
-    @module_name = module_name.nil? ? key.module_name : module_name
-    save_current = self.class.current
-    if save_current.equal?(self)
-      yield
-    else
-      begin
-        self.class.instance_variable_set(:@current, self)
-        yield
-      ensure
-        self.class.instance_variable_set(:@current, save_current)
-      end
-    end
-  end
-
-  def check(name)
-    if @name_stack.include?(name)
-      raise Puppet::DataBinding::RecursiveLookupError, _("Recursive lookup detected in [%{name_stack}]") % { name_stack: @name_stack.join(', ') }
-    end
-    return unless block_given?
-
-    @name_stack.push(name)
-    begin
-      yield
-    rescue Puppet::DataBinding::LookupError
-      raise
-    rescue Puppet::Error => detail
-      raise Puppet::DataBinding::LookupError.new(detail.message, nil, nil, nil, detail)
-    ensure
-      @name_stack.pop
-    end
-  end
-
-  def emit_debug_info(preamble)
-    @explainer.emit_debug_info(preamble) if @explainer.is_a?(DebugExplainer)
-  end
-
-  def lookup_adapter
-    @adapter ||= @adapter_class.adapt(scope.compiler)
-  end
-
-  # This method is overridden by the special Invocation used while resolving interpolations in a
-  # Hiera configuration file (hiera.yaml) where it's used for collecting and remembering the current
-  # values that the configuration was based on
-  #
-  # @api private
-  def remember_scope_lookup(*lookup_result)
-    # Does nothing by default
-  end
-
-  # The qualifier_type can be one of:
-  # :global - qualifier is the data binding terminus name
-  # :data_provider - qualifier a DataProvider instance
-  # :path - qualifier is a ResolvedPath instance
-  # :merge - qualifier is a MergeStrategy instance
-  # :interpolation - qualifier is the unresolved interpolation expression
-  # :meta - qualifier is the module name
-  # :data - qualifier is the key
-  #
-  # @param qualifier [Object] A branch, a provider, or a path
-  def with(qualifier_type, qualifier)
-    if explainer.nil?
-      yield
-    else
-      @explainer.push(qualifier_type, qualifier)
-      begin
-        yield
-      ensure
-        @explainer.pop
-      end
-    end
-  end
-
-  def without_explain
-    if explainer.nil?
-      yield
-    else
-      save_explainer = @explainer
-      begin
-        @explainer = nil
-        yield
-      ensure
-        @explainer = save_explainer
-      end
-    end
-  end
-
-  def only_explain_options?
-    @explainer.nil? ? false : @explainer.only_explain_options?
-  end
-
-  def explain_options?
-    @explainer.nil? ? false : @explainer.explain_options?
-  end
-
-  def report_found_in_overrides(key, value)
-    @explainer.accept_found_in_overrides(key, value) unless @explainer.nil?
-    value
-  end
-
-  def report_found_in_defaults(key, value)
-    @explainer.accept_found_in_defaults(key, value) unless @explainer.nil?
-    value
-  end
-
-  def report_found(key, value)
-    @explainer.accept_found(key, value) unless @explainer.nil?
-    value
-  end
-
-  def report_merge_source(merge_source)
-    @explainer.accept_merge_source(merge_source) unless @explainer.nil?
-  end
-
-  # Report the result of a merge or fully resolved interpolated string
-  # @param value [Object] The result to report
-  # @return [Object] the given value
-  def report_result(value)
-    @explainer.accept_result(value) unless @explainer.nil?
-    value
-  end
-
-  def report_not_found(key)
-    @explainer.accept_not_found(key) unless @explainer.nil?
-  end
-
-  def report_location_not_found
-    @explainer.accept_location_not_found unless @explainer.nil?
-  end
-
-  def report_module_not_found(module_name)
-    @explainer.accept_module_not_found(module_name) unless @explainer.nil?
-  end
-
-  def report_module_provider_not_found(module_name)
-    @explainer.accept_module_provider_not_found(module_name) unless @explainer.nil?
-  end
-
-  def report_text(&block)
-    unless @explainer.nil?
-      @explainer.accept_text(block.call)
-    end
-  end
-
-  def global_only?
-    lookup_adapter.global_only? || (instance_variable_defined?(:@global_only) ? @global_only : false)
-  end
-
-  # Instructs the lookup framework to only perform lookups in the global layer
-  # @return [Invocation] self
-  def set_global_only
-    @global_only = true
-    self
-  end
-
-  # @return [Pathname] the full path of the hiera.yaml config file
-  def global_hiera_config_path
-    lookup_adapter.global_hiera_config_path
-  end
-
-  # @return [Boolean] `true` if the invocation stems from the hiera_xxx function family
-  def hiera_xxx_call?
-    instance_variable_defined?(:@hiera_xxx_call)
-  end
-
-  def set_hiera_xxx_call
-    @hiera_xxx_call = true
-  end
-
-  # @return [Boolean] `true` if the invocation stems from the hiera_xxx function family
-  def hiera_v3_merge_behavior?
-    instance_variable_defined?(:@hiera_v3_merge_behavior)
-  end
-
-  def set_hiera_v3_merge_behavior
-    @hiera_v3_merge_behavior = true
-  end
-
-  # Overrides passed from hiera_xxx functions down to V3DataHashFunctionProvider
-  def set_hiera_v3_location_overrides(overrides)
-    @hiera_v3_location_overrides = [overrides].flatten unless overrides.nil?
-  end
-
-  def hiera_v3_location_overrides
-    instance_variable_defined?(:@hiera_v3_location_overrides) ? @hiera_v3_location_overrides : EMPTY_ARRAY
-  end
-
-  protected
-
-  def name_stack
-    @name_stack.clone
-  end
-end
-end
-end

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

@@ -1,99 +0,0 @@
-require 'pathname'
-require_relative 'interpolation'
-
-module Puppet::Pops
-module Lookup
-  # Class that keeps track of the original location (as it appears in the declaration, before interpolation),
-  # and the fully resolved location, and whether or not the resolved location exists.
-  #
-  # @api private
-  class ResolvedLocation
-    attr_reader :original_location, :location
-
-    # @param original_location [String] location as found in declaration. May contain interpolation expressions
-    # @param location [Pathname,URI] the expanded location
-    # @param exist [Boolean] `true` if the location is assumed to exist
-    # @api public
-    def initialize(original_location, location, exist)
-      @original_location = original_location
-      @location = location
-      @exist = exist
-    end
-
-    # @return [Boolean] `true` if the location is assumed to exist
-    # @api public
-    def exist?
-      @exist
-    end
-
-    # @return the resolved location as a string
-    def to_s
-      @location.to_s
-    end
-  end
-
-  # Helper methods to resolve interpolated locations
-  #
-  # @api private
-  module LocationResolver
-    include Interpolation
-
-    def expand_globs(datadir, declared_globs, lookup_invocation)
-      declared_globs.map do |declared_glob|
-        glob = datadir + interpolate(declared_glob, lookup_invocation, false)
-        Pathname.glob(glob).reject { |path| path.directory? }.map { |path| ResolvedLocation.new(glob.to_s, path, true) }
-      end.flatten
-    end
-
-    # @param datadir [Pathname] The base when creating absolute paths
-    # @param declared_paths [Array<String>] paths as found in declaration. May contain interpolation expressions
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-    # @param is_default_config [Boolean] `true` if this is the default config and non-existent paths should be excluded
-    # @param extension [String] Required extension such as '.yaml' or '.json'. Use only if paths without extension can be expected
-    # @return [Array<ResolvedLocation>] Array of resolved paths
-    def resolve_paths(datadir, declared_paths, lookup_invocation, is_default_config, extension = nil)
-      result = []
-      declared_paths.each do |declared_path|
-        path = interpolate(declared_path, lookup_invocation, false)
-        path += extension unless extension.nil? || path.end_with?(extension)
-        path = datadir + path
-        path_exists = path.exist?
-        result << ResolvedLocation.new(declared_path, path, path_exists) unless is_default_config && !path_exists
-      end
-      result
-    end
-
-    # @param declared_uris [Array<String>] paths as found in declaration. May contain interpolation expressions
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-    # @return [Array<ResolvedLocation>] Array of resolved paths
-    def expand_uris(declared_uris, lookup_invocation)
-      declared_uris.map do |declared_uri|
-        uri = URI(interpolate(declared_uri, lookup_invocation, false))
-        ResolvedLocation.new(declared_uri, uri, true)
-      end
-    end
-
-    def expand_mapped_paths(datadir, mapped_path_triplet, lookup_invocation)
-      # The scope interpolation method is used directly to avoid unnecessary parsing of the string that otherwise
-      # would need to be generated
-      mapped_vars = interpolate_method(:scope).call(mapped_path_triplet[0], lookup_invocation, 'mapped_path[0]')
-
-      # No paths here unless the scope lookup returned something
-      return EMPTY_ARRAY if mapped_vars.nil? || mapped_vars.empty?
-
-      mapped_vars = [mapped_vars] if mapped_vars.is_a?(String)
-      var_key = mapped_path_triplet[1]
-      template = mapped_path_triplet[2]
-      scope = lookup_invocation.scope
-      lookup_invocation.with_local_memory_eluding(var_key) do
-        mapped_vars.map do |var|
-          # Need to use parent lookup invocation to avoid adding 'var' to the set of variables to track for changes. The
-          # variable that 'var' stems from is added above.
-          path = scope.with_local_scope(var_key => var) {  datadir + interpolate(template, lookup_invocation, false) }
-          ResolvedLocation.new(template, path, path.exist?)
-        end
-      end
-    end
-  end
-end
-end