bolt 0.19.1 → 0.20.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/runtime3_type_loader.rb

@@ -1,101 +0,0 @@
-module Puppet::Pops
-module Loader
-
-# Runtime3TypeLoader
-# ===
-# Loads a resource type using the 3.x type loader
-#
-# @api private
-class Runtime3TypeLoader < BaseLoader
-  def initialize(parent_loader, loaders, environment, env_path)
-    super(parent_loader, environment.name)
-    @environment = environment
-    @resource_3x_loader = env_path.nil? ? nil : ModuleLoaders.pcore_resource_type_loader_from(parent_loader, loaders, env_path)
-  end
-
-  def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY, &block)
-    # TODO: Use generated index of all known types (requires separate utility).
-    parent.discover(type, error_collector, name_authority, &block)
-  end
-
-  def to_s()
-    "(Runtime3TypeLoader '#{loader_name()}')"
-  end
-
-  # Finds typed/named entity in this module
-  # @param typed_name [TypedName] the type/name to find
-  # @return [Loader::NamedEntry, nil found/created entry, or nil if not found
-  #
-  def find(typed_name)
-    return nil unless typed_name.name_authority == Pcore::RUNTIME_NAME_AUTHORITY
-    case typed_name.type
-    when :type
-      value = nil
-      name = typed_name.name
-      if @resource_3x_loader.nil?
-        value = Puppet::Type.type(name) unless typed_name.qualified?
-        if value.nil?
-          # Look for a user defined type
-          value = @environment.known_resource_types.find_definition(name)
-        end
-      else
-        impl_te = find_impl(TypedName.new(:resource_type_pp, name, typed_name.name_authority))
-        value = impl_te.value unless impl_te.nil?
-      end
-
-      if value.nil?
-        # Cache the fact that it wasn't found
-        set_entry(typed_name, nil)
-        return nil
-      end
-
-      # Loaded types doesn't have the same life cycle as this loader, so we must start by
-      # checking if the type was created. If it was, an entry will already be stored in
-      # this loader. If not, then it was created before this loader was instantiated and
-      # we must therefore add it.
-      te = get_entry(typed_name)
-      te = set_entry(typed_name, Types::TypeFactory.resource(value.name.to_s)) if te.nil? || te.value.nil?
-      te
-    when :resource_type_pp
-      @resource_3x_loader.nil? ? nil : find_impl(typed_name)
-    else
-      nil
-    end
-  end
-
-  # Find the implementation for the resource type by first consulting the internal loader for pp defined 'Puppet::Resource::ResourceType3'
-  # instances, then check for a Puppet::Type and lastly check for a defined type.
-  #
-  def find_impl(typed_name)
-    name = typed_name.name
-    te = StaticLoader::BUILTIN_TYPE_NAMES_LC.include?(name) ? nil : @resource_3x_loader.load_typed(typed_name)
-    if te.nil? || te.value.nil?
-      # Look for Puppet::Type
-      value = Puppet::Type.type(name) unless typed_name.qualified?
-      if value.nil?
-        # Look for a user defined type
-        value = @environment.known_resource_types.find_definition(name)
-        if value.nil?
-          # Cache the fact that it wasn't found
-          @resource_3x_loader.set_entry(typed_name, nil)
-          return nil
-        end
-      end
-      te = @resource_3x_loader.get_entry(typed_name)
-      te = @resource_3x_loader.set_entry(typed_name, value) if te.nil? || te.value.nil?
-    end
-    te
-  end
-  private :find_impl
-
-  # Allows shadowing since this loader is populated with all loaded resource types at time
-  # of loading. This loading will, for built in types override the aliases configured in the static
-  # loader.
-  #
-  def allow_shadowing?
-    true
-  end
-
-end
-end
-end