bolt 0.24.0 → 0.25.0

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

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

@@ -1,20 +0,0 @@
-# SimpleEnvironmentLoader
-# ===
-# This loader does not load anything and it is populated by the bootstrapping logic that loads
-# the site.pp or equivalent for an environment. It does not restrict the names of what it may contain,
-# and what is loaded here overrides any child loaders (modules).
-#
-class Puppet::Pops::Loader::SimpleEnvironmentLoader < Puppet::Pops::Loader::BaseLoader
-
-  attr_accessor :private_loader
-
-  # Never finds anything, everything "loaded" is set externally
-  def find(typed_name)
-    nil
-  end
-
-  def to_s()
-    "(SimpleEnvironmentLoader '#{loader_name}')"
-  end
-
-end

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

@@ -1,127 +0,0 @@
-  # Static Loader contains constants, basic data types and other types required for the system
-  # to boot.
-  #
-module Puppet::Pops
-module Loader
-class StaticLoader < Loader
-
-  BUILTIN_TYPE_NAMES = %w{
-      Component
-      Exec
-      File
-      Filebucket
-      Group
-      Node
-      Notify
-      Package
-      Resources
-      Schedule
-      Service
-      Stage
-      Tidy
-      User
-      Whit
-    }.freeze
-
-  BUILTIN_TYPE_NAMES_LC = Set.new(BUILTIN_TYPE_NAMES.map { |n| n.downcase }).freeze
-
-  BUILTIN_ALIASES = {
-    'Data' => 'Variant[ScalarData,Undef,Hash[String,Data],Array[Data]]',
-    'RichDataKey' => 'Variant[String,Numeric]',
-    'RichData' => 'Variant[Scalar,SemVerRange,Binary,Sensitive,Type,TypeSet,URI,Object,Undef,Default,Hash[RichDataKey,RichData],Array[RichData]]',
-
-    # Backward compatible aliases.
-    'Puppet::LookupKey' => 'RichDataKey',
-    'Puppet::LookupValue' => 'RichData'
-  }.freeze
-
-  attr_reader :loaded
-  def initialize
-    @loaded = {}
-    @runtime_3_initialized = false
-    create_built_in_types
-  end
-
-  def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY)
-    # Static loader only contains runtime types
-    return EMPTY_ARRAY unless type == :type && name_authority == name_authority = Pcore::RUNTIME_NAME_AUTHORITY
-
-    typed_names = type == :type && name_authority == Pcore::RUNTIME_NAME_AUTHORITY ? @loaded.keys : EMPTY_ARRAY
-    block_given? ? typed_names.select { |tn| yield(tn) } : typed_names
-  end
-
-  def load_typed(typed_name)
-    load_constant(typed_name)
-  end
-
-  def get_entry(typed_name)
-    load_constant(typed_name)
-  end
-
-  def set_entry(typed_name, value, origin = nil)
-    @loaded[typed_name] = Loader::NamedEntry.new(typed_name, value, origin)
-  end
-
-  def find(name)
-    # There is nothing to search for, everything this loader knows about is already available
-    nil
-  end
-
-  def parent
-    nil # at top of the hierarchy
-  end
-
-  def to_s()
-    "(StaticLoader)"
-  end
-
-  def loaded_entry(typed_name, check_dependencies = false)
-    @loaded[typed_name]
-  end
-
-  def runtime_3_init
-    unless @runtime_3_initialized
-      @runtime_3_initialized = true
-      create_resource_type_references
-    end
-    nil
-  end
-
-  def register_aliases
-    aliases = BUILTIN_ALIASES.map { |name, string| add_type(name, Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(string), nil)) }
-    aliases.each { |type| type.resolve(self) }
-  end
-
-  private
-
-  def load_constant(typed_name)
-    @loaded[typed_name]
-  end
-
-  def create_built_in_types
-    origin_uri = URI("puppet:Puppet-Type-System/Static-Loader")
-    type_map = Puppet::Pops::Types::TypeParser.type_map
-    type_map.each do |name, type|
-      set_entry(TypedName.new(:type, name), type, origin_uri)
-    end
-  end
-
-  def create_resource_type_references()
-    # These needs to be done quickly and we do not want to scan the file system for these
-    # We are also not interested in their definition only that they exist.
-    # These types are in all environments.
-    #
-    BUILTIN_TYPE_NAMES.each { |name| create_resource_type_reference(name) }
-  end
-
-  def add_type(name, type)
-    set_entry(TypedName.new(:type, name), type)
-    type
-  end
-
-  def create_resource_type_reference(name)
-    add_type(name, Types::TypeFactory.resource(name))
-  end
-end
-end
-end

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

@@ -1,40 +0,0 @@
-# The TypeDefinitionInstantiator instantiates a type alias or a type definition
-#
-require 'puppet/module/task'
-module Puppet::Pops
-module Loader
-class TaskInstantiator
-  def self.create(loader, typed_name, source_refs)
-    name = typed_name.name
-    basename = typed_name.name_parts[1] || 'init'
-    dirname = File.dirname(source_refs[0])
-    metadata_files, executables = source_refs.partition { |source_ref| source_ref.end_with?('.json') }
-    metadata_file = metadata_files.find { |source_ref| File.basename(source_ref, '.json') == basename }
-
-    metadata = Puppet::Module::Task.read_metadata(metadata_file) || {}
-
-    files = Puppet::Module::Task.find_files(name, dirname, metadata, executables)
-
-    task = { 'name' => name, 'metadata' => metadata, 'files' => files }
-
-    begin
-      task['parameters'] = convert_types(metadata['parameters'])
-
-      Types::TypeFactory.task.from_hash(task)
-    rescue Types::TypeAssertionError => ex
-      # Not strictly a parser error but from the users perspective, the file content didn't parse properly. The
-      # ParserError also conveys file info (even though line is unknown)
-      msg = _('Failed to load metadata for task %{name}: %{reason}') % { name: name, reason: ex.message }
-      raise Puppet::ParseError.new(msg, metadata_file)
-    end
-  end
-
-  def self.convert_types(args)
-    args.each_with_object({}) do |(k, v), hsh|
-      hsh[k] = v['type'].nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(v['type'])
-    end if args
-  end
-  private_class_method :convert_types
-end
-end
-end

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

@@ -1,100 +0,0 @@
-# The TypeDefinitionInstantiator instantiates a type alias or a type definition
-#
-module Puppet::Pops
-module Loader
-class TypeDefinitionInstantiator
-  def self.create(loader, typed_name, source_ref, pp_code_string)
-    # parse and validate
-    parser = Parser::EvaluatingParser.new()
-    model = parser.parse_string(pp_code_string, source_ref)
-    # Only one type is allowed (and no other definitions)
-
-    name = typed_name.name
-    case model.definitions.size
-    when 0
-      raise ArgumentError, _("The code loaded from %{source_ref} does not define the type '%{name}' - it is empty.") % { source_ref: source_ref, name: name }
-    when 1
-      # ok
-    else
-      raise ArgumentError,
-        _("The code loaded from %{source_ref} must contain only the type '%{name}' - it has additional definitions.") % { source_ref: source_ref, name: name }
-    end
-    type_definition = model.definitions[0]
-
-    unless type_definition.is_a?(Model::TypeAlias) || type_definition.is_a?(Model::TypeDefinition)
-      raise ArgumentError,
-        _("The code loaded from %{source_ref} does not define the type '%{name}' - no type alias or type definition found.") % { source_ref: source_ref, name: name }
-    end
-
-    actual_name = type_definition.name
-    unless name == actual_name.downcase
-      raise ArgumentError,
-        _("The code loaded from %{source_ref} produced type with the wrong name, expected '%{name}', actual '%{actual_name}'") % { source_ref: source_ref, name: name, actual_name: actual_name }
-    end
-
-    unless model.body == type_definition
-      raise ArgumentError,
-        _("The code loaded from %{source_ref} contains additional logic - can only contain the type '%{name}'") % { source_ref: source_ref, name: name }
-    end
-
-    # Adapt the type definition with loader - this is used from logic contained in its body to find the
-    # loader to use when resolving contained aliases 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(type_definition).loader_name = private_loader.loader_name
-    create_runtime_type(type_definition)
-  end
-
-  def self.create_from_model(type_definition, loader)
-    typed_name = TypedName.new(:type, type_definition.name)
-    type = create_runtime_type(type_definition)
-    loader.set_entry(
-      typed_name,
-      type,
-      type_definition.locator.to_uri(type_definition))
-    type
-  end
-
-  # @api private
-  def self.create_runtime_type(type_definition)
-    # Using the RUNTIME_NAME_AUTHORITY as the name_authority is motivated by the fact that the type
-    # alias name (managed by the runtime) becomes the name of the created type
-    #
-    create_type(type_definition.name, type_definition.type_expr, Pcore::RUNTIME_NAME_AUTHORITY)
-  end
-
-  # @api private
-  def self.create_type(name, type_expr, name_authority)
-    create_named_type(name, named_definition(type_expr), type_expr, name_authority)
-  end
-
-  # @api private
-  def self.create_named_type(name, type_name, type_expr, name_authority)
-    case type_name
-    when 'Object'
-      # No need for an alias. The Object type itself will receive the name instead
-      unless type_expr.is_a?(Model::LiteralHash)
-        type_expr = type_expr.keys.empty? ? nil : type_expr.keys[0] unless type_expr.is_a?(Hash)
-      end
-      Types::PObjectType.new(name, type_expr)
-    when 'TypeSet'
-      # No need for an alias. The Object type itself will receive the name instead
-      type_expr = type_expr.keys.empty? ? nil : type_expr.keys[0] unless type_expr.is_a?(Hash)
-      Types::PTypeSetType.new(name, type_expr, name_authority)
-    else
-      Types::PTypeAliasType.new(name, type_expr)
-    end
-  end
-
-  # @api private
-  def self.named_definition(te)
-    return 'Object' if te.is_a?(Model::LiteralHash)
-    te.is_a?(Model::AccessExpression) && (left = te.left_expr).is_a?(Model::QualifiedReference) ? left.cased_value : nil
-  end
-
-  def several_paths?
-    false
-  end
-end
-end
-end

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

@@ -1,54 +0,0 @@
-module Puppet::Pops
-module Loader
-# A namespace/name/type combination that can be used as a compound hash key
-#
-# @api public
-class TypedName
-  attr_reader :hash
-  attr_reader :type
-  attr_reader :name_authority
-  attr_reader :name
-  attr_reader :name_parts
-  attr_reader :compound_name
-
-  def initialize(type, name, name_authority = Pcore::RUNTIME_NAME_AUTHORITY)
-    name = name.downcase
-    @type = type
-    @name_authority = name_authority
-    # relativize the name (get rid of leading ::), and make the split string available
-    parts = name.to_s.split(DOUBLE_COLON)
-    if parts[0].empty?
-      parts.shift
-      @name = name[2..-1]
-    else
-      @name = name
-    end
-    @name_parts = parts.freeze
-
-    # Use a frozen compound key for the hash and comparison. Most varying part first
-    @compound_name = "#{@name}/#{@type}/#{@name_authority}".freeze
-    @hash = @compound_name.hash
-    freeze
-  end
-
-  def ==(o)
-    o.class == self.class && o.compound_name == @compound_name
-  end
-
-  alias eql? ==
-
-  # @return the parent of this instance, or nil if this instance is not qualified
-  def parent
-    @name_parts.size > 1 ? self.class.new(@type, @name_parts[0...-1].join(DOUBLE_COLON), @name_authority) : nil
-  end
-
-  def qualified?
-    @name_parts.size > 1
-  end
-
-  def to_s
-    "#{@name_authority}/#{@type}/#{@name}"
-  end
-end
-end
-end