puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/lib/puppet/application/resource_type.rb

@@ -1,7 +0,0 @@
-require 'puppet/application/indirection_base'
-
-# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
-#  compatibility with 2.7.x.  When the old naming convention is officially and publicly deprecated,
-#  this should be changed to camel-case.
-class Puppet::Application::Resource_type < Puppet::Application::IndirectionBase
-end

data/lib/puppet/data_providers.rb

@@ -1,34 +0,0 @@
-# TODO: API 5.0, remove this module
-# @api private
-# @deprecated
-module Puppet::DataProviders
-
-  def self.assert_loaded
-    unless @loaded
-      require 'puppet/pops'
-    end
-    @loaded = true
-  end
-
-  # @deprecated use `lookup_adapter(lookup_invocation).lookup` instead
-  def self.lookup_in_environment(name, lookup_invocation, merge)
-    Puppet.deprecation_warning('The method Puppet::DataProviders.lookup_in_environment is deprecated and will be removed in the next major release of Puppet.')
-    lookup_adapter(lookup_invocation).lookup_in_environment(name, lookup_invocation, Puppet::Pops::MergeStrategy.strategy(merge))
-  end
-
-  MODULE_NAME = 'module_name'.freeze
-
-  # @deprecated use `adapter(lookup_invocation).lookup` instead
-  def self.lookup_in_module(name, lookup_invocation, merge)
-    Puppet.deprecation_warning('The method Puppet::DataProviders.lookup_in_module is deprecated and will be removed in the next major release of Puppet.')
-    lookup_adapter(lookup_invocation).lookup_in_module(name, lookup_invocation, Puppet::Pops::MergeStrategy.strategy(merge))
-  end
-
-  def self.lookup_adapter(lookup_invocation)
-    unless Puppet[:strict] == :off
-      Puppet.deprecation_warning('The method Puppet::DataProviders.lookup_adapter is deprecated and will be removed in the next major release of Puppet.')
-    end
-    assert_loaded()
-    Puppet::Pops::Lookup::LookupAdapter.adapt(lookup_invocation.scope.compiler)
-  end
-end

data/lib/puppet/data_providers/data_adapter.rb

@@ -1,37 +0,0 @@
-# A DataAdapter adapts an object with a Hash of data
-#
-# TODO: API 5.0, remove this class
-# @api private
-# @deprecated
-class Puppet::DataProviders::DataAdapter < Puppet::Pops::Adaptable::Adapter
-  include Puppet::Plugins::DataProviders
-
-  attr_accessor :data
-
-  def self.create_adapter(o)
-    new
-  end
-
-  def initialize
-    unless Puppet[:strict] == :off
-      Puppet.warn_once(:deprecation, 'Puppet::DataProviders::DataAdapter',
-        'Puppet::DataProviders::DataAdapter is deprecated and will be removed in the next major version of Puppet')
-    end
-    @data = {}
-  end
-
-  def [](name)
-    @data[name]
-  end
-
-  def has_name?(name)
-    @data.has_key? name
-  end
-
-  def []=(name, value)
-    unless value.is_a?(Hash)
-      raise ArgumentError, "Given value must be a Hash, got: #{value.class}."
-    end
-    @data[name] = value
-  end
-end

data/lib/puppet/data_providers/data_function_support.rb

@@ -1,32 +0,0 @@
-# TODO: API 5.0, remove this module
-# @api private
-# @deprecated
-module Puppet::DataProviders::DataFunctionSupport
-  def initialize_data(data_key, lookup_invocation)
-    name = "#{data_key}::data"
-    scope = lookup_invocation.scope
-    Puppet::Util::Profiler.profile("Called #{name}", [ :functions, name ]) do
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::DataFunctionSupport',
-        'Puppet::DataProviders::DataFunctionSupport is deprecated and will be removed in the next major version of Puppet')
-      end
-
-      loader = loader(data_key, scope)
-      if loader && func = loader.load(:function, name)
-        # function found, call without arguments, must return a Hash
-        # TODO: Validate the function - to ensure it does not contain unwanted side effects
-        #       That can only be done if the function is a puppet function
-        #
-        result = func.call(scope)
-        unless result.is_a?(Hash)
-          raise Puppet::Error.new("Expected '#{name}' function to return a Hash, got #{result.class}")
-        end
-        # validate result if block given
-        result = yield(result) if block_given?
-      else
-        raise Puppet::Error.new("Cannot find the function '#{name}' - required when using 'function' data provider scheme")
-      end
-      result
-    end
-  end
-end

data/lib/puppet/data_providers/function_env_data_provider.rb

@@ -1,26 +0,0 @@
-# This file is loaded by the autoloader, and it does not find the data function support unless required relative
-#
-require_relative 'data_function_support'
-module Puppet::DataProviders; end
-
-# The FunctionEnvDataProvider provides data from a function called 'environment::data()' that resides in a
-# directory environment (seen as a module with the name environment).
-# The function is called on demand, and is associated with the compiler via an Adapter. This ensures that the data
-# is only produced once per compilation.
-#
-# TODO: API 5.0, remove this class
-# @api private
-# @deprecated
-class Puppet::DataProviders::FunctionEnvDataProvider < Puppet::Plugins::DataProviders::EnvironmentDataProvider
-  include Puppet::DataProviders::DataFunctionSupport
-
-  def loader(key, scope)
-    unless Puppet[:strict] == :off
-      Puppet.warn_once(:deprecation, 'Puppet::DataProviders::FunctionEnvDataProvider',
-        'Puppet::DataProviders::FunctionEnvDataProvider is deprecated and will be removed in the next major version of Puppet')
-    end
-
-    # This loader allows the data function to be private or public in the environment
-    scope.compiler.loaders.private_environment_loader
-  end
-end

data/lib/puppet/data_providers/function_module_data_provider.rb

@@ -1,24 +0,0 @@
-# This file is loaded by the autoloader, and it does not find the data function support unless required relative
-#
-require_relative 'data_function_support'
-module Puppet::DataProviders; end
-
-# The FunctionModuleDataProvider provides data from a function called 'environment::data()' that resides in a
-# directory environment (seen as a module with the name environment).
-# The function is called on demand, and is associated with the compiler via an Adapter. This ensures that the data
-# is only produced once per compilation.
-#
-# TODO: API 5.0, remove this class
-# @api private
-# @deprecated
-class Puppet::DataProviders::FunctionModuleDataProvider < Puppet::Plugins::DataProviders::ModuleDataProvider
-  include Puppet::DataProviders::DataFunctionSupport
-
-  def loader(key, scope)
-    unless Puppet[:strict] == :off
-      Puppet.warn_once(:deprecation, 'Puppet::DataProviders::FunctionModuleDataProvider',
-      'Puppet::DataProviders::FunctionModuleDataProvider is deprecated and will be removed in the next major version of Puppet')
-    end
-    scope.compiler.loaders.private_loader_for_module(key)
-  end
-end

data/lib/puppet/data_providers/hiera_config.rb

@@ -1,151 +0,0 @@
-require 'puppet/plugins/data_providers'
-
-# @api private
-module Puppet::DataProviders
-  # TODO: API 5.0, remove this class
-  # @api private
-  # @deprecated
-  class HieraConfig
-    include Puppet::Plugins::DataProviders
-    include Puppet::Pops::Lookup::LocationResolver
-
-    DEFAULT_CONFIG = {
-      'version' => 4,
-      'datadir' => 'data',
-      'hierarchy' => [
-        {
-          'name' => 'common',
-          'backend' => 'yaml'
-        }
-      ]
-    }.freeze
-
-    def self.config_type
-      @@CONFIG_TYPE ||= create_config_type
-    end
-
-    def self.symkeys_to_string(struct)
-      case(struct)
-      when Hash
-        Hash[struct.map { |k,v| [k.to_s, symkeys_to_string(v)] }]
-      when Array
-        struct.map { |v| symkeys_to_string(v) }
-      else
-        struct
-      end
-    end
-
-    def self.config_exist?(config_root)
-      config_path = config_root + 'hiera.yaml'
-      config_path.exist?
-    end
-
-    def self.create_config_type
-      hierarchy_elem_type_base = 'Struct[{'\
-        'backend=>String[1],'\
-        'name=>String[1],'\
-        'datadir=>Optional[String[1]]'
-
-      hierarchy_elem_type_v1 = hierarchy_elem_type_base + ',path=>String[1]}]'
-      hierarchy_elem_type_v2 = hierarchy_elem_type_base + ',paths=>Array[String[1]]}]'
-      hierarchy_elem_type_v3 = hierarchy_elem_type_base + '}]'
-
-      Puppet::Pops::Types::TypeParser.singleton.parse('Struct[{'\
-        'version=>Integer[4],'\
-        "hierarchy=>Optional[Array[Variant[#{hierarchy_elem_type_v1},#{hierarchy_elem_type_v2},#{hierarchy_elem_type_v3}]]],"\
-        'datadir=>Optional[String[1]]}]')
-    end
-    private_class_method :create_config_type
-
-    attr_reader :config_path, :version
-
-    # Creates a new HieraConfig from the given _config_root_. This is where the 'hiera.yaml' is expected to be found
-    # and is also the base location used when resolving relative paths.
-    #
-    # @param config_root [Pathname] Absolute path to the configuration root
-    # @api public
-    def initialize(config_root)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::HieraConfig',
-          "Use of class Puppet::DataProviders::HieraConfig' is deprecated. Puppet::Pops::Lookup::HieraConfig should be used instead", config_path.to_s)
-      end
-      @config_root = config_root
-      @config_path = config_root + 'hiera.yaml'
-      if @config_path.exist?
-        @config = validate_config(HieraConfig.symkeys_to_string(YAML.load_file(@config_path)))
-        @config['hierarchy'] ||= DEFAULT_CONFIG['hierarchy']
-        @config['datadir'] ||= DEFAULT_CONFIG['datadir']
-      else
-        @config = DEFAULT_CONFIG
-      end
-      @version = @config['version']
-    end
-
-    def create_data_providers(lookup_invocation)
-      Puppet.deprecation_warning('Method HieraConfig#create_data_providers is deprecated. Use create_configured_data_providers instead')
-      create_configured_data_providers(lookup_invocation, nil)
-    end
-
-    # Creates the data providers for this config
-    #
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] Invocation data containing scope, overrides, and defaults
-    # @param parent_data_provider [Puppet::Plugins::DataProviders::DataProvider] The data provider that loaded this configuration
-    # @return [Array[DataProvider]] the created providers
-    #
-    # @api private
-    def create_configured_data_providers(lookup_invocation, parent_data_provider)
-      injector = Puppet.lookup(:injector)
-      service_type = Registry.hash_of_path_based_data_provider_factories
-      default_datadir = @config['datadir']
-
-      # Hashes enumerate their values in the order that the corresponding keys were inserted so it's safe to use
-      # a hash for the data_providers.
-      data_providers = {}
-      @config['hierarchy'].each do |he|
-        name = he['name']
-        raise Puppet::DataBinding::LookupError, "#{@config_path}: Name '#{name}' defined more than once" if data_providers.include?(name)
-        original_paths = he['paths']
-        if original_paths.nil?
-          single_path = he['path']
-          single_path = name if single_path.nil?
-          original_paths = [single_path]
-        end
-        paths = original_paths.map { |path| interpolate(path, lookup_invocation, false)}
-        datadir = @config_root + (he['datadir'] || default_datadir)
-        provider_name = he['backend']
-        data_providers[name] = case provider_name
-        when 'json', 'yaml'
-          Puppet::Pops::Lookup::DataHashFunctionProvider.new(name, parent_data_provider, "#{provider_name}_data", {},
-            resolve_paths(datadir, original_paths, lookup_invocation, ".#{provider_name}"))
-        else
-          # TODO: Remove support for injected provider factories
-          paths = original_paths.map { |path| interpolate(path, lookup_invocation, false)}
-          provider_factory = injector.lookup(nil, service_type, PATH_BASED_DATA_PROVIDER_FACTORIES_KEY)[provider_name]
-          raise Puppet::DataBinding::LookupError, "#{@config_path}: No data provider is registered for backend '#{provider_name}' " unless provider_factory
-          create_data_provider(parent_data_provider, provider_factory, name, provider_factory.resolve_paths(datadir, original_paths, paths, lookup_invocation))
-        end
-      end
-      data_providers.values
-    end
-
-    def name
-      "hiera version #{version}"
-    end
-
-    def create_data_provider(parent_data_provider, provider_factory, name, resolved_paths)
-      provider_factory_version = provider_factory.respond_to?(:version) ? provider_factory.version : 1
-      if provider_factory_version == 1
-        # Version 1 is not aware of the parent provider
-        provider_factory.create(name, resolved_paths)
-      else
-        provider_factory.create(name, resolved_paths, parent_data_provider)
-      end
-    end
-    private :create_data_provider
-
-    def validate_config(hiera_config)
-      Puppet::Pops::Types::TypeAsserter.assert_instance_of(["The Hiera Configuration at '%s'", @config_path], self.class.config_type, hiera_config)
-    end
-    private :validate_config
-  end
-end

data/lib/puppet/data_providers/hiera_env_data_provider.rb

@@ -1,25 +0,0 @@
-# This file is loaded by the autoloader, and it does not find the hiera support unless required relative
-require_relative 'hiera_support'
-
-module Puppet::DataProviders
-  # TODO: API 5.0, remove this class
-  # @api private
-  # @deprecated
-  class HieraEnvDataProvider < Puppet::Plugins::DataProviders::EnvironmentDataProvider
-    include HieraSupport
-
-    # Return the root of the environment found in the given _scope_
-    #
-    # @param data_key [String] not used
-    # @param scope [Puppet::Parser::Scope] the parser scope where the environment is found
-    # @return [Pathname] Path to root of the environment
-    def provider_root(_, scope)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::HieraEnvDataProvider',
-        'Puppet::DataProviders::HieraEnvDataProvider is deprecated and will be removed in the next major version of Puppet')
-      end
-      Pathname.new(scope.environment.configuration.path_to_env)
-    end
-    protected :provider_root
-  end
-end

data/lib/puppet/data_providers/hiera_interpolate.rb

@@ -1,21 +0,0 @@
-# TODO: API 5.0, remove this module
-# @deprecated Moved to Puppet::Pops::Lookup::Interpolation
-module Puppet::DataProviders::HieraInterpolate
-  include Puppet::Pops::Lookup::Interpolation
-
-  # For backward compatibility
-  # @api private
-  # @deprecated
-  def qualified_lookup(segments, value)
-    if Puppet[:strict] != :off
-      msg = 'Puppet::DataProviders::HieraInterpolate#qualified_lookup is deprecated, use Puppet::Pops::Lookup::SubLookup#sub_lookup'
-      case Puppet[:strict]
-      when :error
-        raise Puppet::DataBinding::LookupError.new(msg)
-      when :warning
-        Puppet.warn_once(:deprecation, 'HieraInterpolate#qualified_lookup', msg)
-      end
-    end
-    sub_lookup('<unknown key>', Puppet::Pops::Lookup::Invocation.current, segments, value)
-  end
-end

data/lib/puppet/data_providers/hiera_module_data_provider.rb

@@ -1,30 +0,0 @@
-# This file is loaded by the autoloader, and it does not find the hiera support unless required relative
-require_relative 'hiera_support'
-
-module Puppet::DataProviders
-  # TODO: API 5.0, remove this class
-  # @api private
-  # @deprecated
-  class HieraModuleDataProvider < Puppet::Plugins::DataProviders::ModuleDataProvider
-    include HieraSupport
-
-    # Return the root of the module with the name equal to _data_key_ found in the environment of the given _scope_
-    #
-    # @param data_key [String] the name of the module
-    # @param scope [Puppet::Parser::Scope] the parser scope where the environment is found
-    # @return [Pathname] Path to root of the environment
-    # @raise [Puppet::DataBinder::LookupError] if the given module is can not be found
-    #
-    def provider_root(module_name, scope)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::HieraModuleDataProvider',
-        'Puppet::DataProviders::HieraModuleDataProvider is deprecated and will be removed in the next major version of Puppet')
-      end
-      env = scope.environment
-      mod = env.modules.find { |m| m.name == module_name }
-      raise Puppet::DataBinder::LookupError, "Environment '#{env.name}', cannot find module '#{module_name}'" unless mod
-      Pathname.new(mod.path)
-    end
-    protected :provider_root
-  end
-end

data/lib/puppet/data_providers/hiera_support.rb

@@ -1,42 +0,0 @@
-require_relative 'hiera_config'
-
-# TODO: API 5.0, remove this module
-# @api private
-# @deprecated
-module Puppet::DataProviders::HieraSupport
-  def config_path
-    @hiera_config.nil? ? 'not yet configured' : @hiera_config.config_path
-  end
-
-  def name
-    'Hiera Data Provider' + (@hiera_config.nil? ? '' : ", version #{@hiera_config.version}")
-  end
-
-  # Performs a lookup by searching all given paths for the given _key_. A merge will be performed if
-  # the value is found in more than one location and _merge_ is not nil.
-  #
-  # @param key [String] The key to lookup
-  # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-  # @param merge [Puppet::Pops::MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
-  def unchecked_lookup(key, lookup_invocation, merge)
-    unless Puppet[:strict] == :off
-      Puppet.warn_once(:deprecation, 'Puppet::DataProviders::HieraSupport',
-      'Puppet::DataProviders::HieraSupport is deprecated and will be removed in the next major version of Puppet')
-    end
-    lookup_invocation.with(:data_provider, self) do
-      merge_strategy = Puppet::Pops::MergeStrategy.strategy(merge)
-      lookup_invocation.with(:merge, merge_strategy) do
-        merged_result = merge_strategy.merge_lookup(data_providers(data_key(key, lookup_invocation), lookup_invocation)) do |data_provider|
-          data_provider.unchecked_lookup(key, lookup_invocation, merge_strategy)
-        end
-        lookup_invocation.report_result(merged_result)
-      end
-    end
-  end
-
-  def data_providers(data_key, lookup_invocation)
-    @hiera_config ||= Puppet::DataProviders::HieraConfig.new(provider_root(data_key, lookup_invocation.scope))
-    @data_providers ||= @hiera_config.create_configured_data_providers(lookup_invocation, self)
-  end
-  private :data_providers
-end