bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,60 @@
+# 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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,39 @@
+# 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

@@ -0,0 +1,45 @@
+# 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

@@ -0,0 +1,101 @@
+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