puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

data/lib/puppet/pops/binder/scheme_handler/confdir_scheme.rb

@@ -1,34 +0,0 @@
-require 'puppet/pops/binder/scheme_handler/symbolic_scheme'
-
-# Similar to {Puppet::Pops::Binder::SchemeHandler::ModuleScheme ModuleScheme}, but relative to the config root.
-# Does not support wildcard expansion.
-#
-# URI
-# ---
-# The URI scheme is `confdir:/[<FQN>]['?' | [?optional]` where FQN is the fully qualified name of the bindings to load.
-# The reference is made optional by using a URI query of `?` or `?optional`.
-#
-# @todo
-#   If the file to load is outside of the file system rooted at $confdir (in a gem, or just on the Ruby path), it can not
-#   be marked as optional as it will always be ignored.
-#
-class Puppet::Pops::Binder::SchemeHandler::ConfdirScheme < Puppet::Pops::Binder::SchemeHandler::SymbolicScheme
-
-  def expand_included(uri, composer)
-    fqn = fqn_from_path(uri)[1]
-    if is_optional?(uri)
-      if Puppet::Pops::Binder::BindingsLoader.loadable?(composer.confdir, fqn)
-        [URI.parse('confdir:/' + fqn)]
-      else
-        []
-      end
-    else
-      # assume it exists (do not give error if not, since it may be excluded later)
-      [URI.parse('confdir:/' + fqn)]
-    end
-  end
-
-  def expand_excluded(uri, composer)
-    [URI.parse("confdir:/#{fqn_from_path(uri)[1]}")]
-  end
-end

data/lib/puppet/pops/binder/scheme_handler/module_scheme.rb

@@ -1,143 +0,0 @@
-require 'puppet/pops/binder/scheme_handler/symbolic_scheme'
-
-# The module scheme allows loading bindings using the Puppet autoloader.
-# Optional uris are handled by checking if the symbolic name can be resolved to a loadable file
-# from modules.
-# 
-# URI
-# ---
-# The uri is on the format: `module:/[fqn][? | ?optional]` where `fqn` is a fully qualified bindings name
-# starting with the module name or '*' to denote 'any module'. A URI query of `?` or `?optional` makes the
-# request optional; if no loadable file is found, it is simply skipped.
-#
-#
-# @todo
-#   Does currently only support checking of optionality against files under a module. If the result should be loaded
-#   from any other location it can not be marked as optional as it will be ignored.
-#
-module Puppet::Pops::Binder
-class SchemeHandler::ModuleScheme < SchemeHandler::SymbolicScheme
-
-  METADATA_DATA_PROVIDER = 'data_provider'.freeze
-
-  def contributed_bindings(uri, scope, composer)
-    split_name, fqn = fqn_from_path(uri)
-    bindings = Puppet::Bindings.resolve(scope, split_name[0]) || load_bindings(uri, scope, composer, split_name, fqn)
-
-    # Must clone as the rest mutates the model
-    BindingsFactory.contributed_bindings(fqn, Marshal.load(Marshal.dump(bindings)))
-  end
-
-  # Expands URIs with wildcards and checks optionality.
-  # @param uri [URI] the uri to possibly expand
-  # @return [Array<URI>] the URIs to include
-  # @api public
-  #
-  def expand_included(uri, composer)
-    result = []
-    split_name, fqn = fqn_from_path(uri)
-
-    # supports wild card in the module name
-    case split_name[0]
-    when '*'
-      # create new URIs, one per module name that has a corresponding data_provider entry in metadata.json
-      # or an .rb file relative to its '<root>/lib/puppet/bindings/'
-      #
-      composer.name_to_module.each_pair do | module_name, mod |
-        expanded_name_parts = [module_name] + split_name[1..-1]
-        expanded_name = expanded_name_parts.join('::')
-
-        if is_metadata?(split_name)
-          if mod.metadata && mod.metadata[METADATA_DATA_PROVIDER]
-            result << URI.parse('module:/' + expanded_name)
-          end
-        elsif BindingsLoader.loadable?(mod.path, expanded_name)
-          result << URI.parse('module:/' + expanded_name)
-        end
-      end
-    when nil
-      raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
-    else
-      joined_name = split_name.join('::')
-      module_name = split_name[0]
-      # skip optional uri if it does not exist
-      if is_optional?(uri)
-        mod = composer.name_to_module[module_name]
-        unless mod.nil?
-          if is_metadata?(split_name)
-            if mod.metadata && mod.metadata[METADATA_DATA_PROVIDER]
-              result << URI.parse('module:/' + joined_name)
-            end
-          elsif BindingsLoader.loadable?(mod.path, joined_name)
-            result << URI.parse('module:/' + joined_name)
-          end
-        end
-      else
-        # assume it exists (do not give error if not, since it may be excluded later)
-        result << URI.parse('module:/' + joined_name)
-      end
-    end
-    result
-  end
-
-  # Expands URIs with wildcards
-  # @param uri [URI] the uri to possibly expand
-  # @return [Array<URI>] the URIs to exclude
-  # @api public
-  #
-  def expand_excluded(uri, composer)
-    result = []
-    split_name, fqn = fqn_from_path(uri)
-
-    case split_name[ 0 ]
-    when '*'
-      # create new URIs, one per module name
-      composer.name_to_module.each_pair do | name, mod |
-        result << URI.parse('module:/' + ([name] + split_name).join('::'))
-      end
-
-    when nil
-      raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
-    else
-      # create a clean copy (get rid of optional, fragments etc. and any trailing stuff
-      result << URI.parse('module:/' + split_name.join('::'))
-    end
-    result
-  end
-
-  def load_bindings(uri, scope, composer, split_name, fqn)
-    module_name = split_name[0]
-    mod = composer.name_to_module[module_name]
-    # given module name must exist
-    raise ArgumentError, "Cannot load bindings '#{uri}' - module not found." if mod.nil?
-
-    if is_metadata?(split_name)
-      metadata = mod.metadata
-      data_provider = metadata.nil? ? nil : metadata[METADATA_DATA_PROVIDER]
-      unless data_provider.nil?
-        # bind the data provider in a binding named after the module
-        # loader.load('thallgren/sample_module_data', Puppet.lookup(:current_environment))
-        Puppet::Bindings.newbindings(module_name) do
-          bind {
-            name(module_name)
-            to(data_provider)
-            in_multibind(Puppet::Plugins::DataProviders::PER_MODULE_DATA_PROVIDER_KEY)
-          }
-        end
-        # pick up and return the just created and registered bindings
-        bindings = Puppet::Bindings.resolve(scope, module_name)
-      end
-    else
-      bindings = BindingsLoader.provide(scope, fqn)
-    end
-    raise ArgumentError, "Cannot load bindings '#{uri}' - no bindings found." unless bindings
-    bindings
-  end
-  private :load_bindings
-
-  def is_metadata?(split_name)
-    split_name.size > 1 && split_name[1] == 'metadata'
-  end
-  private :is_metadata?
-end
-end

data/lib/puppet/pops/binder/scheme_handler/symbolic_scheme.rb

@@ -1,53 +0,0 @@
-# Abstract base class for schemes based on symbolic names of bindings.
-# This class helps resolve symbolic names by computing a path from a fully qualified name (fqn).
-# There are also helper methods do determine if the symbolic name contains a wild-card ('*') in the first
-# portion of the fqn (with the convention that '*' means 'any module').
-#
-# @abstract
-# @api public
-#
-class Puppet::Pops::Binder::SchemeHandler::SymbolicScheme < Puppet::Plugins::BindingSchemes::BindingsSchemeHandler
-
-  # Shared implementation for module: and confdir: since the distinction is only in checks if a symbolic name
-  # exists as a loadable file or not. Once this method is called it is assumed that the name is relative
-  # and that it should exist relative to some loadable ruby location.
-  #
-  # TODO: this needs to be changed once ARM-8 Puppet DSL concrete syntax is also supported.
-  # @api public
-  #
-  def contributed_bindings(uri, scope, composer)
-    fqn = fqn_from_path(uri)[1]
-    bindings = Puppet::Pops::Binder::BindingsLoader.provide(scope, fqn)
-    raise ArgumentError, "Cannot load bindings '#{uri}' - no bindings found." unless bindings
-    # Must clone as the rest mutates the model
-    cloned_bindings = Marshal.load(Marshal.dump(bindings))
-    Puppet::Pops::Binder::BindingsFactory.contributed_bindings(fqn, cloned_bindings)
-  end
-
-  # @api private
-  def fqn_from_path(uri)
-    split_path = uri.path.split('/')
-    if split_path.size > 1 && split_path[-1].empty?
-      split_path.delete_at(-1)
-    end
-
-    fqn = split_path[ 1 ]
-    raise ArgumentError, "Module scheme binding reference has no name." unless fqn
-    split_name = fqn.split('::')
-    # drop leading '::'
-    split_name.shift if split_name[0] && split_name[0].empty?
-    [split_name, split_name.join('::')]
-  end
-
-  # True if super thinks it is optional or if it contains a wildcard.
-  # @return [Boolean] true if the uri represents an optional set of bindings.
-  # @api public
-  def is_optional?(uri)
-    super(uri) || has_wildcard?(uri)
-  end
-
-  # @api private
-  def has_wildcard?(uri)
-    (path = uri.path) && path.split('/')[1].start_with?('*::')
-  end
-end

data/lib/puppet/pops/binder/system_bindings.rb

@@ -1,60 +0,0 @@
-class Puppet::Pops::Binder::SystemBindings
-  # Constant with name used for bindings used during initialization of injector
-  ENVIRONMENT_BOOT_BINDINGS_NAME = 'puppet::env::injector::boot'
-
-  Factory = Puppet::Pops::Binder::BindingsFactory
-  @extension_bindings = Factory.named_bindings("puppet::extensions")
-  @default_bindings   = Factory.named_bindings("puppet::default")
-  # Bindings in effect when real injector is created
-  @injector_boot_bindings   = Factory.named_bindings("puppet::injector_boot")
-
-  def self.extensions()
-    @extension_bindings
-  end
-
-  def self.default_bindings()
-    @default_bindings
-  end
-
-  def self.injector_boot_bindings()
-    @injector_boot_bindings
-  end
-
-  def self.final_contribution
-    Factory.contributed_bindings("puppet-final", [deep_clone(@extension_bindings.model)])
-  end
-
-  def self.default_contribution
-    Factory.contributed_bindings("puppet-default", [deep_clone(@default_bindings.model)])
-  end
-
-  def self.injector_boot_contribution(env_boot_bindings)
-    # Compose the injector_boot_bindings contributed from the puppet runtime book (i.e. defaults for
-    # extensions that should be active in the boot injector - see Puppetx initialization.
-    #
-    bindings = [deep_clone(@injector_boot_bindings.model), deep_clone(@injector_default_bindings)]
-
-    # Add the bindings that come from the bindings_composer as it may define custom extensions added in the bindings
-    # configuration. (i.e. bindings required to be able to lookup using bindings schemes and backends when
-    # configuring the real injector).
-    #
-    bindings << env_boot_bindings unless env_boot_bindings.nil?
-
-    # return the composition
-    Factory.contributed_bindings("puppet-injector-boot", bindings)
-  end
-
-  def self.factory()
-    Puppet::Pops::Binder::BindingsFactory
-  end
-
-  def self.type_factory()
-    Puppet::Pops::Types::TypeFactory
-  end
-
-  private
-
-  def self.deep_clone(o)
-    Marshal.load(Marshal.dump(o))
-  end
-end

data/lib/puppet/pops/containment.rb

@@ -1,104 +0,0 @@
-# FIXME: This module should be updated when a newer version of RGen (>0.6.2) adds required meta model "e-method" supports.
-#
-require 'rgen/ecore/ecore'
-module Puppet::Pops::Containment
-  # Returns Enumerable, thus allowing
-  # some_element.eAllContents each {|contained| }
-  # This is a depth first enumeration where parent appears before children.
-  # @note the top-most object itself is not included in the enumeration, only what it contains.
-  def eAllContents
-    EAllContentsEnumerator.new(self)
-  end
-
-  def eAllContainers
-    EAllContainersEnumerator.new(self)
-  end
-
-  class EAllContainersEnumerator
-    include Enumerable
-
-    def initialize o
-      @element = o
-    end
-
-    def each &block
-      if block_given?
-        eAllContainers(@element, &block)
-      else
-        self
-      end
-    end
-
-    def eAllContainers(element, &block)
-      x = element.eContainer
-      while !x.nil? do
-        yield x
-        x = x.eContainer
-      end
-    end
-
-  end
-
-  class EAllContentsEnumerator
-    include Enumerable
-    def initialize o
-      @element = o
-      @@cache ||= {}
-    end
-
-    def each &block
-      if block_given?
-        eAllContents(@element, &block)
-        @element
-      else
-        self
-      end
-    end
-
-    def eAllContents(element, &block)
-      # This method is performance critical and code has been manually in-lined.
-      # Resist the urge to make this pretty.
-      # The slow way is element.eAllContainments.each {|c| element.getGenericsAsArray(c.name) }
-      #
-      (@@cache[element.class] || all_containment_getters(element)).each do |r|
-        children = element.send(r)
-        if children.is_a?(Array)
-          children.each do |c|
-            yield c
-            eAllContents(c, &block)
-          end
-        elsif !children.nil?
-          yield children
-          eAllContents(children, &block)
-        end
-      end
-    end
-
-    private
-
-    def all_containment_getters(element)
-      elem_class = element.class
-      containments = []
-      collect_getters(elem_class.ecore, containments)
-      @@cache[elem_class] = containments
-    end
-
-    def collect_getters(eclass, containments)
-        eclass.eStructuralFeatures.select {|r| r.is_a?(RGen::ECore::EReference) && r.containment}.each do |r|
-          n = r.name
-          containments << :"get#{n[0..0].upcase + ( n[1..-1] || "" )}"
-        end
-        eclass.eSuperTypes.each do |t|
-          if cached = @@cache[ t.instanceClass ]
-            containments.concat(cached)
-          else
-            super_containments = []
-            collect_getters(t, super_containments)
-            @@cache[ t.instanceClass ] = super_containments
-            containments.concat(super_containments)
-          end
-      end
-    end
-
-  end
-end

data/lib/puppet/pops/model/model.rb

@@ -1,131 +0,0 @@
-#
-# The Puppet Pops Metamodel Implementation
-#
-# The Puppet Pops Metamodel consists of two parts; the metamodel expressed with RGen in model_meta.rb,
-# and this file which mixes in implementation details.
-#
-
-require 'rgen/metamodel_builder'
-require 'rgen/ecore/ecore'
-require 'rgen/ecore/ecore_ext'
-require 'rgen/ecore/ecore_to_ruby'
-
-module Puppet::Pops
-  require 'puppet/pops/model/model_meta'
-
-  # TODO: See PUP-2978 for possible performance optimization
-
-  # Mix in implementation into the generated code
-  module Model
-
-    class PopsObject
-      include Visitable
-      include Adaptable
-      include Containment
-    end
-
-    class Positioned
-      module ClassModule
-        def set_loc(offset, length)
-          @offset = offset
-          @length = length
-        end
-      end
-    end
-
-    class LocatableExpression
-      module ClassModule
-        # Go through the gymnastics of making either value or pattern settable
-        # with synchronization to the other form. A derived value cannot be serialized
-        # and we want to serialize the pattern. When recreating the object we need to
-        # recreate it from the pattern string.
-        # The below sets both values if one is changed.
-        #
-        def locator
-          unless result = getLocator
-            setLocator(result = Parser::Locator.locator(source_text, source_ref(), line_offsets))
-          end
-          result
-        end
-      end
-    end
-
-    class SubLocatedExpression
-      module ClassModule
-        def locator
-          unless result = getLocator
-            # Adapt myself to get the Locator for me
-            adapter = Adapters::SourcePosAdapter.adapt(self)
-            # Get the program (root), and deal with case when not contained in a program
-            program = eAllContainers.find {|c| c.is_a?(Program) }
-            source_ref = program.nil? ? '' : program.source_ref
-
-            # An outer locator is needed since SubLocator only deals with offsets. This outer locator
-            # has 0,0 as origin.
-            outer_locator = Parser::Locator.locator(adpater.extract_text, source_ref, line_offsets)
-
-            # Create a sublocator that describes an offset from the outer
-            # NOTE: the offset of self is the same as the sublocator's leading_offset
-            result = Parser::Locator::SubLocator.new(outer_locator,
-              leading_line_count, offset, leading_line_offset)
-            setLocator(result)
-          end
-          result
-        end
-      end
-    end
-
-    class LiteralRegularExpression
-      module ClassModule
-        # Go through the gymnastics of making either value or pattern settable
-        # with synchronization to the other form. A derived value cannot be serialized
-        # and we want to serialize the pattern. When recreating the object we need to
-        # recreate it from the pattern string.
-        # The below sets both values if one is changed.
-        #
-        def value= regexp
-          setValue regexp
-          setPattern regexp.to_s
-        end
-
-        def pattern= regexp_string
-          setPattern regexp_string
-          setValue Regexp.new(regexp_string)
-        end
-      end
-    end
-
-    class AbstractResource
-      module ClassModule
-        def virtual_derived
-          form == :virtual || form == :exported
-        end
-
-        def exported_derived
-          form == :exported
-        end
-      end
-    end
-
-    class QualifiedReference
-      module ClassModule
-        def value
-          @value ||= cased_value.downcase
-        end
-      end
-    end
-
-    class Program < PopsObject
-      module ClassModule
-        def locator
-          unless result = getLocator
-            setLocator(result = Parser::Locator.locator(source_text, source_ref(), line_offsets, char_offsets))
-          end
-          result
-        end
-      end
-    end
-
-  end
-
-end