bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/pops/loader/null_loader.rb

@@ -1,60 +0,0 @@
-# The null loader is empty and delegates everything to its parent if it has one.
-#
-class Puppet::Pops::Loader::NullLoader < Puppet::Pops::Loader::Loader
-  attr_reader :loader_name
-
-  # Construct a NullLoader, optionally with a parent loader
-  #
-  def initialize(parent_loader=nil, loader_name = "null-loader")
-    super(loader_name)
-    @parent = parent_loader
-  end
-
-  # Has parent if one was set when constructed
-  def parent
-    @parent
-  end
-
-  def find(typed_name)
-    if @parent.nil?
-      nil
-    else
-      @parent.find(typed_name)
-    end
-  end
-
-  def load_typed(typed_name)
-    if @parent.nil?
-      nil
-    else
-      @parent.load_typed(typed_name)
-    end
-  end
-
-  def loaded_entry(typed_name, check_dependencies = false)
-    if @parent.nil?
-      nil
-    else
-      @parent.loaded_entry(typed_name, check_dependencies)
-    end
-  end
-
-  # Has no entries on its own - always nil
-  def get_entry(typed_name)
-    nil
-  end
-
-  # Finds nothing, there are no entries
-  def find(name)
-    nil
-  end
-
-  # Cannot store anything
-  def set_entry(typed_name, value, origin = nil)
-    nil
-  end
-
-  def to_s()
-    "(NullLoader '#{loader_name}')"
-  end
-end

data/vendored/puppet/lib/puppet/pops/loader/predefined_loader.rb

@@ -1,24 +0,0 @@
-module Puppet::Pops::Loader
-
-# A PredefinedLoader is a loader that is manually populated with loaded elements
-# before being used. It never loads anything on its own.
-#
-class PredefinedLoader < BaseLoader
-  def find(typed_name)
-    nil
-  end
-
-  def to_s()
-    "(PredefinedLoader '#{loader_name}')"
-  end
-
-  # Allows shadowing since this loader is used internally for things like function local types
-  # And they should win as there is otherwise a risk that the local types clash with built in types
-  # that were added after the function was written, or by resource types loaded by the 3x auto loader.
-  #
-  def allow_shadowing?
-    true
-  end
-end
-
-end

data/vendored/puppet/lib/puppet/pops/loader/puppet_function_instantiator.rb

@@ -1,84 +0,0 @@
-module Puppet::Pops
-module Loader
-# The PuppetFunctionInstantiator instantiates a Puppet::Functions::PuppetFunction given a Puppet Programming language
-# source that when called evaluates the Puppet logic it contains.
-#
-class PuppetFunctionInstantiator
-  # Produces an instance of the Function class with the given typed_name, or fails with an error if the
-  # given puppet source does not produce this instance when evaluated.
-  #
-  # @param loader [Loader] The loader the function is associated with
-  # @param typed_name [TypedName] the type / name of the function to load
-  # @param source_ref [URI, String] a reference to the source / origin of the puppet code to evaluate
-  # @param pp_code_string [String] puppet code in a string
-  #
-  # @return [Functions::Function] - an instantiated function with global scope closure associated with the given loader
-  #
-  def self.create(loader, typed_name, source_ref, pp_code_string)
-    parser = Parser::EvaluatingParser.new()
-
-    # parse and validate
-    result = parser.parse_string(pp_code_string, source_ref)
-    # Only one function is allowed (and no other definitions)
-    case result.definitions.size
-    when 0
-      raise ArgumentError, _("The code loaded from %{source_ref} does not define the function '%{func_name}' - it is empty.") % { source_ref: source_ref, func_name: typed_name.name }
-    when 1
-      # ok
-    else
-      raise ArgumentError, _("The code loaded from %{source_ref} must contain only the function '%{type_name}' - it has additional definitions.") % { source_ref: source_ref, type_name: typed_name.name }
-    end
-    the_function_definition = result.definitions[0]
-
-    unless the_function_definition.is_a?(Model::FunctionDefinition)
-      raise ArgumentError, _("The code loaded from %{source_ref} does not define the function '%{type_name}' - no function found.") % { source_ref: source_ref, type_name: typed_name.name }
-    end
-    unless the_function_definition.name == typed_name.name
-      expected = typed_name.name
-      actual = the_function_definition.name
-      raise ArgumentError, _("The code loaded from %{source_ref} produced function with the wrong name, expected %{expected}, actual %{actual}") % { source_ref: source_ref, expected: expected, actual: actual }
-    end
-    unless result.body == the_function_definition
-      raise ArgumentError, _("The code loaded from %{source} contains additional logic - can only contain the function %{name}") % { source: source_ref, name: typed_name.name }
-    end
-
-    # Adapt the function definition with loader - this is used from logic contained in it body to find the
-    # loader to use when making calls to the new function API. Such logic have a hard time finding the closure (where
-    # the loader is known - hence this mechanism
-    private_loader = loader.private_loader
-    Adapters::LoaderAdapter.adapt(the_function_definition).loader_name = private_loader.loader_name
-
-    # Cannot bind loaded functions to global scope, that must be done without binding that scope as
-    # loaders survive a compilation.
-    closure_scope = nil # Puppet.lookup(:global_scope) { {} }
-
-    created = create_function_class(the_function_definition)
-    # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
-    # when calling functions etc.
-    # It should be bound to global scope
-
-    created.new(closure_scope, private_loader)
-  end
-
-  # Creates Function class and instantiates it based on a FunctionDefinition model
-  # @return [Array<TypedName, Functions.Function>] - array of
-  #   typed name, and an instantiated function with global scope closure associated with the given loader
-  #
-  def self.create_from_model(function_definition, loader)
-    created = create_function_class(function_definition)
-    typed_name = TypedName.new(:function, function_definition.name)
-    [typed_name, created.new(nil, loader)]
-  end
-
-  def self.create_function_class(function_definition)
-    # Create a 4x function wrapper around a named closure
-    Puppet::Functions.create_function(function_definition.name, Puppet::Functions::PuppetFunction) do
-      # TODO: should not create a new evaluator per function
-      init_dispatch(Evaluator::Closure::Named.new(
-        function_definition.name,
-        Evaluator::EvaluatorImpl.new(), function_definition))
-    end
-  end
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/loader/puppet_plan_instantiator.rb

@@ -1,84 +0,0 @@
-module Puppet::Pops
-module Loader
-# The PuppetPlanInstantiator instantiates a Puppet::Functions::PuppetFunction given a Puppet Programming language
-# source that when called evaluates the Puppet logic it contains.
-#
-class PuppetPlanInstantiator
-  # Produces an instance of the Function class with the given typed_name, or fails with an error if the
-  # given puppet source does not produce this instance when evaluated.
-  #
-  # @param loader [Loader] The loader the function is associated with
-  # @param typed_name [TypedName] the type / name of the function to load
-  # @param source_ref [URI, String] a reference to the source / origin of the puppet code to evaluate
-  # @param pp_code_string [String] puppet code in a string
-  #
-  # @return [Functions::Function] - an instantiated function with global scope closure associated with the given loader
-  #
-  def self.create(loader, typed_name, source_ref, pp_code_string)
-    parser = Parser::EvaluatingParser.new()
-
-    # parse and validate
-    result = parser.parse_string(pp_code_string, source_ref)
-    # Only one function is allowed (and no other definitions)
-    case result.definitions.size
-    when 0
-      raise ArgumentError, _("The code loaded from %{source_ref} does not define the plan '%{plan_name}' - it is empty.") % { source_ref: source_ref, plan_name: typed_name.name }
-    when 1
-      # ok
-    else
-      raise ArgumentError, _("The code loaded from %{source_ref} must contain only the plan '%{plan_name}' - it has additional definitions.") % { source_ref: source_ref, plan_name: typed_name.name }
-    end
-    the_plan_definition = result.definitions[0]
-
-    unless the_plan_definition.is_a?(Model::PlanDefinition)
-      raise ArgumentError, _("The code loaded from %{source_ref} does not define the plan '%{plan_name}' - no plan found.") % { source_ref: source_ref, plan_name: typed_name.name }
-    end
-    unless the_plan_definition.name == typed_name.name
-      expected = typed_name.name
-      actual = the_plan_definition.name
-      raise ArgumentError, _("The code loaded from %{source_ref} produced plan with the wrong name, expected %{expected}, actual %{actual}") % { source_ref: source_ref, expected: expected, actual: actual }
-    end
-    unless result.body == the_plan_definition
-      raise ArgumentError, _("The code loaded from %{source} contains additional logic - can only contain the plan %{plan_name}") % { source: source_ref, plan_name: typed_name.name }
-    end
-
-    # Adapt the function definition with loader - this is used from logic contained in it body to find the
-    # loader to use when making calls to the new function API. Such logic have a hard time finding the closure (where
-    # the loader is known - hence this mechanism
-    private_loader = loader.private_loader
-    Adapters::LoaderAdapter.adapt(the_plan_definition).loader_name = private_loader.loader_name
-
-    # Cannot bind loaded functions to global scope, that must be done without binding that scope as
-    # loaders survive a compilation.
-    closure_scope = nil
-
-    created = create_function_class(the_plan_definition)
-    # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
-    # when calling functions etc.
-    # It should be bound to global scope
-
-    created.new(closure_scope, private_loader)
-  end
-
-  # Creates Function class and instantiates it based on a FunctionDefinition model
-  # @return [Array<TypedName, Functions.Function>] - array of
-  #   typed name, and an instantiated function with global scope closure associated with the given loader
-  #
-  def self.create_from_model(plan_definition, loader)
-    created = create_function_class(plan_definition)
-    typed_name = TypedName.new(:plan, plan_definition.name)
-    [typed_name, created.new(nil, loader)]
-  end
-
-  def self.create_function_class(plan_definition)
-    # Create a 4x function wrapper around a named closure
-    Puppet::Functions.create_function(plan_definition.name, Puppet::Functions::PuppetFunction) do
-      # TODO: should not create a new evaluator per function
-      init_dispatch(Evaluator::Closure::Named.new(
-        plan_definition.name,
-        Evaluator::EvaluatorImpl.new(), plan_definition))
-    end
-  end
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/loader/puppet_resource_type_impl_instantiator.rb

@@ -1,79 +0,0 @@
-module Puppet::Pops
-module Loader
-# The PuppetResourceTypeImplInstantiator instantiates a Puppet::Pops::ResourceTypeImpl object.
-# given a Puppet Programming language source that when called evaluates the Puppet logic it contains.
-#
-class PuppetResourceTypeImplInstantiator
-  # Produces an instance of Puppet::Pops::ResourceTypeImpl, or fails with an error if the
-  # given puppet source does not produce such an instance when evaluated.
-  #
-  # @param loader [Loader] The loader the function is associated with
-  # @param typed_name [TypedName] the type / name of the resource type impl to load
-  # @param source_ref [URI, String] a reference to the source / origin of the puppet code to evaluate
-  # @param pp_code_string [String] puppet code in a string
-  #
-  # @return [Puppet::Pops::ResourceTypeImpl] - an instantiated ResourceTypeImpl
-  #
-  def self.create(loader, typed_name, source_ref, pp_code_string)
-    parser = Parser::EvaluatingParser.new()
-
-    # parse and validate
-    model = parser.parse_string(pp_code_string, source_ref)
-    statements = if model.is_a?(Model::Program)
-                   if model.body.is_a?(Model::BlockExpression)
-                     model.body.statements
-                   else
-                     [model.body]
-                   end
-                 else
-                   EMPTY_ARRAY
-                 end
-    statements = statements.reject { |s| s.is_a?(Model::Nop) }
-    if statements.empty?
-      raise ArgumentError, _("The code loaded from %{source_ref} does not create the resource type '%{type_name}' - it is empty") % { source_ref: source_ref, type_name: typed_name.name }
-    end
-
-    rname = Resource::ResourceTypeImpl._pcore_type.name
-    unless statements.find do |s|
-      if s.is_a?(Model::CallMethodExpression)
-        functor_expr = s.functor_expr
-        functor_expr.is_a?(Model::NamedAccessExpression) &&
-          functor_expr.left_expr.is_a?(Model::QualifiedReference) &&
-          functor_expr.left_expr.cased_value == rname &&
-          functor_expr.right_expr.is_a?(Model::QualifiedName) &&
-          functor_expr.right_expr.value == 'new'
-      else
-        false
-      end
-    end
-      raise ArgumentError, _("The code loaded from %{source_ref} does not create the resource type '%{type_name}' - no call to %{rname}.new found.") % { source_ref: source_ref, type_name: typed_name.name, rname: rname }
-    end
-
-    unless statements.size == 1
-      raise ArgumentError, _("The code loaded from %{source_ref} must contain only the creation of resource type '%{type_name}' - it has additional logic.") % { source_ref: source_ref, type_name: typed_name.name }
-    end
-
-    closure_scope = Puppet.lookup(:global_scope) { {} }
-    resource_type_impl = parser.evaluate(closure_scope, model)
-
-    unless resource_type_impl.is_a?(Puppet::Pops::Resource::ResourceTypeImpl)
-      got = resource_type.class
-      raise ArgumentError, _("The code loaded from %{source_ref} does not define the resource type '%{type_name}' - got '%{got}'.") % { source_ref: source_ref, type_name: typed_name.name, got: got }
-    end
-
-    unless resource_type_impl.name == typed_name.name
-      expected = typed_name.name
-      actual = resource_type_impl.name
-      raise ArgumentError, _("The code loaded from %{source_ref} produced resource type with the wrong name, expected '%{expected}', actual '%{actual}'") % { source_ref: source_ref, expected: expected, actual: actual }
-    end
-
-    # Adapt the resource type definition with loader - this is used from logic contained in it body to find the
-    # loader to use when making calls to the new function API. Such logic have a hard time finding the closure (where
-    # the loader is known - hence this mechanism
-    Adapters::LoaderAdapter.adapt(resource_type_impl).loader_name = loader.loader_name
-    resource_type_impl
-  end
-
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/loader/ruby_data_type_instantiator.rb

@@ -1,39 +0,0 @@
-# The RubyTypeInstantiator instantiates a data type from the ruby source
-# that calls Puppet::DataTypes.create_type.
-#
-class Puppet::Pops::Loader::RubyDataTypeInstantiator
-  # Produces an instance of class derived from PAnyType class with the given typed_name, or fails with an error if the
-  # given ruby source does not produce this instance when evaluated.
-  #
-  # @param loader [Puppet::Pops::Loader::Loader] The loader the type is associated with
-  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the type to load
-  # @param source_ref [URI, String] a reference to the source / origin of the ruby code to evaluate
-  # @param ruby_code_string [String] ruby code in a string
-  #
-  # @return [Puppet::Pops::Types::PAnyType] - an instantiated data type associated with the given loader
-  #
-  def self.create(loader, typed_name, source_ref, ruby_code_string)
-    unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:DataTypes\.create_type/
-      raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 5x API data type - no create_type call.") % { source_ref: source_ref }
-    end
-    # make the private loader available in a binding to allow it to be passed on
-    loader_for_type = loader.private_loader
-    here = get_binding(loader_for_type)
-    created = eval(ruby_code_string, here, source_ref, 1)
-    unless created.is_a?(Puppet::Pops::Types::PAnyType)
-      raise ArgumentError, _("The code loaded from %{source_ref} did not produce a data type when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
-    end
-    unless created.name.casecmp(typed_name.name) == 0
-      raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected '%{type_name}', got %{created_name}") % { source_ref: source_ref, type_name: typed_name.name, created_name: created.name }
-    end
-    created
-  end
-
-  # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
-  # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
-  #
-  def self.get_binding(loader_injected_arg)
-    binding
-  end
-  private_class_method :get_binding
-end

data/vendored/puppet/lib/puppet/pops/loader/ruby_function_instantiator.rb

@@ -1,45 +0,0 @@
-# The RubyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
-# that calls Puppet::Functions.create_function.
-#
-class Puppet::Pops::Loader::RubyFunctionInstantiator
-  # Produces an instance of the Function class with the given typed_name, or fails with an error if the
-  # given ruby source does not produce this instance when evaluated.
-  #
-  # @param loader [Puppet::Pops::Loader::Loader] The loader the function is associated with
-  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the function to load
-  # @param source_ref [URI, String] a reference to the source / origin of the ruby code to evaluate
-  # @param ruby_code_string [String] ruby code in a string
-  #
-  # @return [Puppet::Pops::Functions.Function] - an instantiated function with global scope closure associated with the given loader
-  #
-  def self.create(loader, typed_name, source_ref, ruby_code_string)
-    unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Functions\.create_function/
-      raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 4x API function - no create_function call.") % { source_ref: source_ref }
-    end
-    # make the private loader available in a binding to allow it to be passed on
-    loader_for_function = loader.private_loader
-    here = get_binding(loader_for_function)
-    created = eval(ruby_code_string, here, source_ref, 1)
-    unless created.is_a?(Class)
-      raise ArgumentError, _("The code loaded from %{source_ref} did not produce a Function class when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
-    end
-    unless created.name.to_s == typed_name.name()
-      raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected '%{type_name}', got %{created_name}") % { source_ref: source_ref, type_name: typed_name.name, created_name: created.name }
-    end
-    # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
-    # when calling functions etc.
-    # It should be bound to global scope
-
-    # Sets closure scope to nil, to let it be picked up at runtime from Puppet.lookup(:global_scope)
-    # If function definition used the loader from the binding to create a new loader, that loader wins
-    created.new(nil, loader_for_function)
-  end
-
-  # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
-  # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
-  #
-  def self.get_binding(loader_injected_arg)
-    binding
-  end
-  private_class_method :get_binding
-end

data/vendored/puppet/lib/puppet/pops/loader/ruby_legacy_function_instantiator.rb

@@ -1,62 +0,0 @@
-# The RubyLegacyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
-# that calls Puppet::Functions.create_function.
-#
-class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
-  # Produces an instance of the Function class with the given typed_name, or fails with an error if the
-  # given ruby source does not produce this instance when evaluated.
-  #
-  # @param loader [Puppet::Pops::Loader::Loader] The loader the function is associated with
-  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the function to load
-  # @param source_ref [URI, String] a reference to the source / origin of the ruby code to evaluate
-  # @param ruby_code_string [String] ruby code in a string
-  #
-  # @return [Puppet::Pops::Functions.Function] - an instantiated function with global scope closure associated with the given loader
-  #
-  def self.create(loader, typed_name, source_ref, ruby_code_string)
-    unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Parser\:\:Functions.*newfunction/m
-      raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 3x API function - no 'newfunction' call.") % { source_ref: source_ref }
-    end
-    # make the private loader available in a binding to allow it to be passed on
-    loader_for_function = loader.private_loader
-    here = get_binding(loader_for_function)
-
-    # Avoid reloading the function if already loaded via one of the APIs that trigger 3x function loading
-    # Check if function is already loaded the 3x way (and obviously not the 4x way since we would not be here in the
-    # first place.
-    environment = Puppet.lookup(:current_environment)
-    func_info = Puppet::Parser::Functions.environment_module(environment).get_function_info(typed_name.name.to_sym)
-    if func_info.nil?
-      # This will to do the 3x loading and define the "function_<name>" and "real_function_<name>" methods
-      # in the anonymous module used to hold function definitions.
-      #
-      func_info = eval(ruby_code_string, here, source_ref, 1)
-
-      # Validate what was loaded
-      unless func_info.is_a?(Hash)
-        raise ArgumentError, _("The code loaded from %{source_ref} did not produce the expected 3x function info Hash when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
-      end
-      unless func_info[:name] == "function_#{typed_name.name()}"
-        raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected 'function_%{type_name}', got %{created_name}") % { 
-          source_ref: source_ref, type_name: typed_name.name, created_name: func_info[:name] }
-      end
-    end
-
-    created = Puppet::Functions::Function3x.create_function(typed_name.name(), func_info, loader_for_function)
-
-    # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
-    # when calling functions etc.
-    # It should be bound to global scope
-
-    # Sets closure scope to nil, to let it be picked up at runtime from Puppet.lookup(:global_scope)
-    # If function definition used the loader from the binding to create a new loader, that loader wins
-    created.new(nil, loader_for_function)
-  end
-
-  # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
-  # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
-  #
-  def self.get_binding(loader_injected_arg)
-    binding
-  end
-  private_class_method :get_binding
-end