bolt 0.24.0 → 0.25.0

data/vendored/hiera/lib/hiera/noop_logger.rb

@@ -1,8 +0,0 @@
-class Hiera
-  module Noop_logger
-    class << self
-      def warn(msg);end
-      def debug(msg);end
-    end
-  end
-end

data/vendored/hiera/lib/hiera/puppet_logger.rb

@@ -1,17 +0,0 @@
-class Hiera
-  module Puppet_logger
-    class << self
-      def suitable?
-        defined?(::Puppet) == "constant"
-      end
-
-      def warn(msg)
-        Puppet.notice("hiera(): #{msg}")
-      end
-
-      def debug(msg)
-        Puppet.debug("hiera(): #{msg}")
-      end
-    end
-  end
-end

data/vendored/hiera/lib/hiera/recursive_guard.rb

@@ -1,20 +0,0 @@
-# Allow for safe recursive lookup of values during variable interpolation.
-#
-# @api private
-class Hiera::InterpolationLoop < StandardError; end
-
-class Hiera::RecursiveGuard
-  def initialize
-    @seen = []
-  end
-
-  def check(value, &block)
-    if @seen.include?(value)
-      raise Hiera::InterpolationLoop, "Lookup recursion detected in [#{@seen.join(', ')}]"
-    end
-    @seen.push(value)
-    ret = yield
-    @seen.pop
-    ret
-  end
-end

data/vendored/hiera/lib/hiera/util.rb

@@ -1,65 +0,0 @@
-class Hiera
-
-  # Matches a key that is quoted using a matching pair of either single or double quotes.
-  QUOTED_KEY = /^(?:"([^"]+)"|'([^']+)')$/
-  QUOTES = /[",]/
-
-  module Util
-    module_function
-
-    def posix?
-      require 'etc'
-      Etc.getpwuid(0) != nil
-    end
-
-    def microsoft_windows?
-      !!file_alt_separator
-    end
-
-    def config_dir
-      if microsoft_windows?
-         File.join(common_appdata, 'PuppetLabs', 'puppet', 'etc')
-      else
-        '/etc/puppetlabs/puppet'
-      end
-    end
-
-    def code_dir
-      if microsoft_windows?
-        File.join(common_appdata, 'PuppetLabs', 'code')
-      else
-        '/etc/puppetlabs/code'
-      end
-    end
-
-    def var_dir
-      File.join(code_dir, 'environments' , '%{environment}' , 'hieradata')
-    end
-
-    def file_alt_separator
-      File::ALT_SEPARATOR
-    end
-
-    def common_appdata
-      @common_appdata ||= Hiera::Util::Win32.get_common_appdata()
-    end
-
-    def split_key(key)
-      segments = key.split(/(?:"([^"]+)"|'([^']+)'|([^'".]+))/)
-      if segments.empty?
-        # Only happens if the original key was an empty string
-        ''
-      elsif segments.shift == ''
-        count = segments.size
-        raise yield('Syntax error') unless count > 0
-
-        segments.keep_if { |seg| seg != '.' }
-        raise yield('Syntax error') unless segments.size * 2 == count + 1
-        segments
-      else
-        raise yield('Syntax error')
-      end
-    end
-  end
-end
-

data/vendored/hiera/lib/hiera/util/win32.rb

@@ -1,40 +0,0 @@
-class Hiera
-  module Util
-    module Win32
-      if !!File::ALT_SEPARATOR
-        require 'fiddle/import'
-        require 'fiddle/types'
-
-        # import, dlload, include and typealias must be ordered this way
-        extend Fiddle::Importer
-        dlload 'shell32'
-        include Fiddle::Win32Types # adds HWND, HANDLE, DWORD type aliases
-        typealias 'LPWSTR', 'wchar_t*'
-        typealias 'LONG', 'long'
-        typealias 'HRESULT','LONG'
-
-        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
-        # HRESULT SHGetFolderPath(
-        #   _In_  HWND   hwndOwner,
-        #   _In_  int    nFolder,
-        #   _In_  HANDLE hToken,
-        #   _In_  DWORD  dwFlags,
-        #   _Out_ LPTSTR pszPath
-        # );
-        extern 'HRESULT SHGetFolderPathW(HWND, int, HANDLE, DWORD, LPWSTR)'
-
-        COMMON_APPDATA = 0x0023
-        S_OK           = 0x0
-        MAX_PATH       = 260;
-
-        def self.get_common_appdata
-          # null terminated MAX_PATH string in wchar (i.e. 2 bytes per char)
-          buffer = 0.chr * ((MAX_PATH + 1) * 2)
-          result = SHGetFolderPathW(0, COMMON_APPDATA, 0, 0, buffer)
-          raise "Could not find COMMON_APPDATA path - HRESULT: #{result}" unless result == S_OK
-          buffer.force_encoding(Encoding::UTF_16LE).encode(Encoding::UTF_8).strip
-        end
-      end
-    end
-  end
-end

data/vendored/hiera/lib/hiera/version.rb

@@ -1,89 +0,0 @@
-# The version method and constant are isolated in hiera/version.rb so that a
-# simple `require 'hiera/version'` allows a rubygems gemspec or bundler
-# Gemfile to get the hiera version of the gem install.
-#
-# The version is programatically settable because we want to allow the
-# Raketasks and such to set the version based on the output of `git describe`
-
-
-class Hiera
-  VERSION = "3.4.3"
-
-  ##
-  # version is a public API method intended to always provide a fast and
-  # lightweight way to determine the version of hiera.
-  #
-  # The intent is that software external to hiera be able to determine the
-  # hiera version with no side-effects.  The expected use is:
-  #
-  #     require 'hiera/version'
-  #     version = Hiera.version
-  #
-  # This function has the following ordering precedence.  This precedence list
-  # is designed to facilitate automated packaging tasks by simply writing to
-  # the VERSION file in the same directory as this source file.
-  #
-  #  1. If a version has been explicitly assigned using the Hiera.version=
-  #     method, return that version.
-  #  2. If there is a VERSION file, read the contents, trim any
-  #     trailing whitespace, and return that version string.
-  #  3. Return the value of the Hiera::VERSION constant hard-coded into
-  #     the source code.
-  #
-  # If there is no VERSION file, the method must return the version string of
-  # the nearest parent version that is an officially released version.  That is
-  # to say, if a branch named 3.1.x contains 25 patches on top of the most
-  # recent official release of 3.1.1, then the version method must return the
-  # string "3.1.1" if no "VERSION" file is present.
-  #
-  # By design the version identifier is _not_ intended to vary during the life
-  # a process.  There is no guarantee provided that writing to the VERSION file
-  # while a Hiera process is running will cause the version string to be
-  # updated.  On the contrary, the contents of the VERSION are cached to reduce
-  # filesystem accesses.
-  #
-  # The VERSION file is intended to be used by package maintainers who may be
-  # applying patches or otherwise changing the software version in a manner
-  # that warrants a different software version identifier.  The VERSION file is
-  # intended to be managed and owned by the release process and packaging
-  # related tasks, and as such should not reside in version control.  The
-  # VERSION constant is intended to be version controlled in history.
-  #
-  # Ideally, this behavior will allow package maintainers to precisely specify
-  # the version of the software they're packaging as in the following example:
-  #
-  #     $ git describe --match "1.2.*" > lib/hiera/VERSION
-  #     $ ruby -r hiera/version -e 'puts Hiera.version'
-  #     1.2.1-9-g9fda440
-  #
-  # @api public
-  #
-  # @return [String] containing the hiera version, e.g. "1.2.1"
-  def self.version
-    version_file = File.join(File.dirname(__FILE__), 'VERSION')
-    return @hiera_version if @hiera_version
-    if version = read_version_file(version_file)
-      @hiera_version = version
-    end
-    @hiera_version ||= VERSION
-  end
-
-  def self.version=(version)
-    @hiera_version = version
-  end
-
-  ##
-  # read_version_file reads the content of the "VERSION" file that lives in the
-  # same directory as this source code file.
-  #
-  # @api private
-  #
-  # @return [String] for example: "1.6.14-6-gea42046" or nil if the VERSION
-  #   file does not exist.
-  def self.read_version_file(path)
-    if File.exists?(path)
-      File.read(path).chomp
-    end
-  end
-  private_class_method :read_version_file
-end

data/vendored/puppet/lib/hiera/puppet_function.rb

@@ -1,84 +0,0 @@
-require 'hiera_puppet'
-
-# Provides the base class for the puppet functions hiera, hiera_array, hiera_hash, and hiera_include.
-# The actual function definitions will call init_dispatch and override the merge_type and post_lookup methods.
-#
-# @see hiera_array.rb, hiera_include.rb under lib/puppet/functions for sample usage
-#
-class Hiera::PuppetFunction < Puppet::Functions::InternalFunction
-  def self.init_dispatch
-    dispatch :hiera_splat do
-      scope_param
-      param 'Tuple[String, Any, Any, 1, 3]', :args
-    end
-
-    dispatch :hiera_no_default do
-      scope_param
-      param 'String',:key
-    end
-
-    dispatch :hiera_with_default do
-      scope_param
-      param 'String',:key
-      param 'Any',   :default
-      optional_param 'Any',   :override
-    end
-
-    dispatch :hiera_block1 do
-      scope_param
-      param 'String',              :key
-      block_param 'Callable[1,1]', :default_block
-    end
-
-    dispatch :hiera_block2 do
-      scope_param
-      param 'String',              :key
-      param 'Any',                 :override
-      block_param 'Callable[1,1]', :default_block
-    end
-  end
-
-  def hiera_splat(scope, args)
-    hiera(scope, *args)
-  end
-
-  def hiera_no_default(scope, key)
-    post_lookup(scope, key, lookup(scope, key, nil, false, nil))
-  end
-
-  def hiera_with_default(scope, key, default, override = nil)
-    post_lookup(scope, key, lookup(scope, key, default, true, override))
-  end
-
-  def hiera_block1(scope, key, &default_block)
-    post_lookup(scope, key, lookup(scope, key, nil, false, nil, &default_block))
-  end
-
-  def hiera_block2(scope, key, override, &default_block)
-    post_lookup(scope, key, lookup(scope, key, nil, false, override, &default_block))
-  end
-
-  def lookup(scope, key, default, has_default, override, &default_block)
-    unless Puppet[:strict] == :off
-      #TRANSLATORS 'lookup' is a puppet function and should not be translated
-      message = _("The function '%{class_name}' is deprecated in favor of using 'lookup'.") % { class_name: self.class.name }
-      message += ' '+ _("See https://puppet.com/docs/puppet/%{minor_version}/deprecated_language.html") %
-          { minor_version: Puppet.minor_version }
-      Puppet.warn_once('deprecations', self.class.name, message)
-    end
-    lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {})
-    adapter = lookup_invocation.lookup_adapter
-    lookup_invocation.set_hiera_xxx_call
-    lookup_invocation.set_global_only unless adapter.global_only? || adapter.has_environment_data_provider?(lookup_invocation)
-    lookup_invocation.set_hiera_v3_location_overrides(override) unless override.nil? || override.is_a?(Array) && override.empty?
-    Puppet::Pops::Lookup.lookup(key, nil, default, has_default, merge_type, lookup_invocation, &default_block)
-  end
-
-  def merge_type
-    :first
-  end
-
-  def post_lookup(scope, key, result)
-    result
-  end
-end

data/vendored/puppet/lib/hiera/scope.rb

@@ -1,83 +0,0 @@
-class Hiera
-  class Scope
-    CALLING_CLASS = 'calling_class'.freeze
-    CALLING_CLASS_PATH = 'calling_class_path'.freeze
-    CALLING_MODULE = 'calling_module'.freeze
-    MODULE_NAME = 'module_name'.freeze
-
-    CALLING_KEYS = [CALLING_CLASS, CALLING_CLASS_PATH, CALLING_MODULE].freeze
-    EMPTY_STRING = ''.freeze
-
-    attr_reader :real
-
-    def initialize(real)
-      @real = real
-    end
-
-    def [](key)
-      if key == CALLING_CLASS
-        ans = find_hostclass(@real)
-      elsif key == CALLING_CLASS_PATH
-        ans = find_hostclass(@real).gsub(/::/, '/')
-      elsif key == CALLING_MODULE
-        ans = safe_lookupvar(MODULE_NAME)
-      else
-        ans = safe_lookupvar(key)
-      end
-      ans == EMPTY_STRING ? nil : ans
-    end
-
-    # This method is used to handle the throw of :undefined_variable since when
-    # strict variables is not in effect, missing handling of the throw leads to
-    # a more expensive code path.
-    #
-    def safe_lookupvar(key)
-      reason = catch :undefined_variable do
-        return @real.lookupvar(key)
-      end
-
-      case Puppet[:strict]
-      when :off
-        # do nothing
-      when :warning
-        Puppet.warn_once(Puppet::Parser::Scope::UNDEFINED_VARIABLES_KIND, _("Variable: %{name}") % { name: key },
-        _("Undefined variable '%{name}'; %{reason}") % { name: key, reason: reason } )
-      when :error
-        raise ArgumentError, _("Undefined variable '%{name}'; %{reason}") % { name: key, reason: reason }
-      end
-      nil
-    end
-    private :safe_lookupvar
-
-    def exist?(key)
-      CALLING_KEYS.include?(key) || @real.exist?(key)
-    end
-
-    def include?(key)
-      CALLING_KEYS.include?(key) || @real.include?(key)
-    end
-
-    def catalog
-      @real.catalog
-    end
-
-    def resource
-      @real.resource
-    end
-
-    def compiler
-      @real.compiler
-    end
-
-    def find_hostclass(scope)
-      if scope.source and scope.source.type == :hostclass
-        return scope.source.name.downcase
-      elsif scope.parent
-        return find_hostclass(scope.parent)
-      else
-        return nil
-      end
-    end
-    private :find_hostclass
-  end
-end

data/vendored/puppet/lib/hiera_puppet.rb

@@ -1,79 +0,0 @@
-require 'hiera'
-require 'hiera/scope'
-require 'puppet'
-
-module HieraPuppet
-  module_function
-
-  def lookup(key, default, scope, override, resolution_type)
-    scope = Hiera::Scope.new(scope)
-
-    answer = hiera.lookup(key, default, scope, override, resolution_type)
-
-    if answer.nil?
-      raise Puppet::ParseError, _("Could not find data item %{key} in any Hiera data file and no default supplied") % { key: key }
-    end
-
-    answer
-  end
-
-  def parse_args(args)
-    # Functions called from Puppet manifests like this:
-    #
-    #   hiera("foo", "bar")
-    #
-    # Are invoked internally after combining the positional arguments into a
-    # single array:
-    #
-    #   func = function_hiera
-    #   func(["foo", "bar"])
-    #
-    # Functions called from templates preserve the positional arguments:
-    #
-    #   scope.function_hiera("foo", "bar")
-    #
-    # Deal with Puppet's special calling mechanism here.
-    if args[0].is_a?(Array)
-      args = args[0]
-    end
-
-    if args.empty?
-      raise Puppet::ParseError, _("Please supply a parameter to perform a Hiera lookup")
-    end
-
-    key      = args[0]
-    default  = args[1]
-    override = args[2]
-
-    return [key, default, override]
-  end
-
-  private
-  module_function
-
-  def hiera
-    @hiera ||= Hiera.new(:config => hiera_config)
-  end
-
-  def hiera_config
-    config = {}
-
-    if config_file = hiera_config_file
-      config = Hiera::Config.load(config_file)
-    end
-
-    config[:logger] = 'puppet'
-    config
-  end
-
-  def hiera_config_file
-    hiera_config = Puppet.settings[:hiera_config]
-    if Puppet::FileSystem.exist?(hiera_config)
-      hiera_config
-    else
-      Puppet.warning _("Config file %{hiera_config} not found, using Hiera defaults") % { hiera_config: hiera_config }
-      nil
-    end
-  end
-end
-