puppet 4.3.2-x86-mingw32 → 4.4.0-x86-mingw32

data/lib/puppet/pops.rb

@@ -34,14 +34,6 @@ module Puppet
 
     # (the Types module initializes itself)
     require 'puppet/pops/types/types'
-    require 'puppet/pops/types/type_asserter'
-    require 'puppet/pops/types/type_assertion_error'
-    require 'puppet/pops/types/type_calculator'
-    require 'puppet/pops/types/type_factory'
-    require 'puppet/pops/types/type_parser'
-    require 'puppet/pops/types/class_loader'
-    require 'puppet/pops/types/enumeration'
-    require 'puppet/pops/types/type_mismatch_describer'
 
     require 'puppet/pops/merge_strategy'
 

data/lib/puppet/pops/adaptable.rb

@@ -15,7 +15,8 @@
 #   be exploited as the implementation of _being adaptable_ may change in the future.
 # @api private
 #
-module Puppet::Pops::Adaptable
+module Puppet::Pops
+module Adaptable
   # Base class for an Adapter.
   #
   # A typical adapter just defines some accessors.
@@ -199,3 +200,5 @@ module Puppet::Pops::Adaptable
     end
   end
 end
+end
+

data/lib/puppet/pops/adapters.rb

@@ -1,11 +1,12 @@
 # The Adapters module contains adapters for Documentation, Origin, SourcePosition, and Loader.
 #
-module Puppet::Pops::Adapters
+module Puppet::Pops
+module Adapters
   # A documentation adapter adapts an object with a documentation string.
   # (The intended use is for a source text parser to extract documentation and store this
   # in DocumentationAdapter instances).
   #
-  class DocumentationAdapter < Puppet::Pops::Adaptable::Adapter
+  class DocumentationAdapter < Adaptable::Adapter
     # @return [String] The documentation associated with an object
     attr_accessor :documentation
   end
@@ -19,9 +20,9 @@ module Puppet::Pops::Adapters
   # @note It is relatively expensive to compute line and position on line - it is not something that
   #   should be done for every token or model object.
   #
-  # @see Puppet::Pops::Utils#find_adapter, Puppet::Pops::Utils#find_closest_positioned
+  # @see Utils#find_adapter, Utils#find_closest_positioned
   #
-  class SourcePosAdapter < Puppet::Pops::Adaptable::Adapter
+  class SourcePosAdapter < Adaptable::Adapter
     attr_accessor :locator
     attr_reader :adapted
 
@@ -45,10 +46,10 @@ module Puppet::Pops::Adapters
         raise ArgumentError, "InternalError: SourcePosAdapter for something that has no locator among parents"
       end
       case
-      when o.is_a?(Puppet::Pops::Model::Program)
+      when o.is_a?(Model::Program)
         return o.locator
       # TODO_HEREDOC use case of SubLocator instead
-      when o.is_a?(Puppet::Pops::Model::SubLocatedExpression) && !(found_locator = o.locator).nil?
+      when o.is_a?(Model::SubLocatedExpression) && !(found_locator = o.locator).nil?
         return found_locator
       when adapter = self.class.get(o)
         return adapter.locator
@@ -83,7 +84,7 @@ module Puppet::Pops::Adapters
 
     # Extracts the text represented by this source position (the string is obtained from the locator)
     def extract_text
-      locator.string.slice(offset, length)
+      locator.extract_text(offset, length)
     end
 
     def extract_tree_text
@@ -91,11 +92,12 @@ module Puppet::Pops::Adapters
       last = first + @adapted.length
       @adapted.eAllContents.each do |m|
         m_offset = m.offset
+        next if m_offset.nil?
         first = m_offset if m_offset < first
         m_last = m_offset + m.length
         last = m_last if m_last > last
       end
-      locator.string.slice(first, last-first)
+      locator.extract_text(first, last-first)
     end
 
     # Produces an URI with path?line=n&pos=n. If origin is unknown the URI is string:?line=n&pos=n
@@ -106,19 +108,41 @@ module Puppet::Pops::Adapters
     end
   end
 
-  # A LoaderAdapter adapts an object with a {Puppet::Pops::Loader}. This is used to make further loading from the
+  # A LoaderAdapter adapts an object with a {Loader}. This is used to make further loading from the
   # perspective of the adapted object take place in the perspective of this Loader.
   #
   # It is typically enough to adapt the root of a model as a search is made towards the root of the model
   # until a loader is found, but there is no harm in duplicating this information provided a contained
   # object is adapted with the correct loader.
   #
-  # @see Puppet::Pops::Utils#find_adapter
+  # @see Utils#find_adapter
   #
-  class LoaderAdapter < Puppet::Pops::Adaptable::Adapter
-    # @return [Puppet::Pops::Loader::Loader] the loader
+  class LoaderAdapter < Adaptable::Adapter
+    # @return [Loader::Loader] the loader
     attr_accessor :loader
 
+    # Finds the loader to use when loading originates from the source position of the given argument.
+    #
+    # @param instance [Model::PopsObject] The model object
+    # @param scope [Puppet::Parser::Scope] The scope to use
+    # @return [Loader,nil] the found loader or `nil` if it could not be found
+    #
+    def self.loader_for_model_object(model, scope)
+      # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
+      adapter = Utils.find_adapter(model, self)
+      return adapter.loader unless adapter.nil?
+
+      if scope.nil?
+        loaders = Puppet.lookup(:loaders) { nil }
+        loaders.nil? ? nil : loaders.private_environment_loader
+      else
+        # Use source location to determine calling module, or use the private_environment_loader (sees env + all modules)
+        # This is necessary since not all .pp files are loaded by a Loader (see PUP-1833)
+        adapter = adapt_by_source(scope, model)
+        adapter.nil? ? scope.compiler.loaders.private_environment_loader : adapter.loader
+      end
+    end
+
     # Attempts to find the module that `instance` originates from by looking at it's {SourcePosAdapter} and
     # compare the `locator.file` found there with the module paths given in the environment found in the
     # given `scope`. If the file is found to be relative to a path, then the first segment of the relative
@@ -130,7 +154,7 @@ module Puppet::Pops::Adapters
     # @param scope
     # @param instance
     def self.adapt_by_source(scope, instance)
-      source_pos = Puppet::Pops::Utils.find_adapter(instance, SourcePosAdapter)
+      source_pos = Utils.find_adapter(instance, SourcePosAdapter)
       unless source_pos.nil?
         mod = find_module_for_file(scope.environment, source_pos.locator.file)
         unless mod.nil?
@@ -162,3 +186,4 @@ module Puppet::Pops::Adapters
     private_class_method :find_module_for_file
   end
 end
+end

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

@@ -3,11 +3,13 @@
 # An instance should be created and a call to {#define_layers} should be made which will process the layered bindings
 # (handle overrides, abstract entries etc.).
 # The constructed hash with `key => InjectorEntry` mappings is obtained as {#injector_entries}, and is used to initialize an
-# {Puppet::Pops::Binder::Injector Injector}.
+# {Injector Injector}.
 #
 # @api public
 #
-class Puppet::Pops::Binder::Binder
+module Puppet::Pops
+module Binder
+class Binder
 
   # @api private
   attr_reader :injector_entries
@@ -35,7 +37,7 @@ class Puppet::Pops::Binder::Binder
     @parent = parent_binder
     @id_index = Hash.new() { |k, v| [] }
 
-    @key_factory = Puppet::Pops::Binder::KeyFactory.new()
+    @key_factory = KeyFactory.new()
 
     # Resulting hash of all key -> binding
     @injector_entries = {}
@@ -58,11 +60,11 @@ class Puppet::Pops::Binder::Binder
   #   validated to get better error messages if the model is invalid. This implementation expects the model
   #   to be valid, and any errors raised will be more technical runtime errors.
   #
-  # @param layered_bindings [Puppet::Pops::Binder::Bindings::LayeredBindings] the named and ordered layers
+  # @param layered_bindings [Bindings::LayeredBindings] the named and ordered layers
   # @raise ArgumentError if this binder is already configured
   # @raise ArgumentError if bindings with unresolved 'override' surfaces as an effective binding
   # @raise ArgumentError if the given argument has the wrong type, or if model is invalid in some way
-  # @return [Puppet::Pops::Binder::Binder] self
+  # @return [Binder] self
   # @api public
   #
   def define_layers(layered_bindings)
@@ -107,7 +109,7 @@ class Puppet::Pops::Binder::Binder
   end
 
   def add_id_to_index(binding)
-    return unless binding.is_a?(Puppet::Pops::Binder::Bindings::Multibinding) && !(id = binding.id).nil?
+    return unless binding.is_a?(Bindings::Multibinding) && !(id = binding.id).nil?
     @id_index[id] = @id_index[id] << binding
   end
 
@@ -118,7 +120,7 @@ class Puppet::Pops::Binder::Binder
       entry = lookup(key)
       unless entry.precedence == @binder_precedence
         # it is from a lower layer it must be promoted
-        injector_entries[ key ] = Puppet::Pops::Binder::InjectorEntry.new(binding, binder_precedence)
+        injector_entries[ key ] = InjectorEntry.new(binding, binder_precedence)
       end
     end
     # recursive "up the parent chain" to promote all
@@ -138,7 +140,7 @@ class Puppet::Pops::Binder::Binder
 
   # @api private
   def self.format_binding(b)
-    type_name = Puppet::Pops::Types::TypeCalculator.singleton.string(b.type)
+    type_name = b.type.to_s
     layer_name, bindings_name = get_named_binding_layer_and_name(b)
     "binding: '#{type_name}/#{b.name}' in: '#{bindings_name}' in layer: '#{layer_name}'"
   end
@@ -152,14 +154,14 @@ class Puppet::Pops::Binder::Binder
   # @api private
   def self.get_named_binding_layer_and_name(b)
     return ['<unknown>', '<unknown>'] if b.nil?
-    return [get_named_layer(b), b.name] if b.is_a?(Puppet::Pops::Binder::Bindings::NamedBindings)
+    return [get_named_layer(b), b.name] if b.is_a?(Bindings::NamedBindings)
     get_named_binding_layer_and_name(b.eContainer)
   end
 
   # @api private
   def self.get_named_layer(b)
     return '<unknown>' if b.nil?
-    return b.name if b.is_a?(Puppet::Pops::Binder::Bindings::NamedLayer)
+    return b.name if b.is_a?(Bindings::NamedLayer)
     get_named_layer(b.eContainer)
   end
 
@@ -181,21 +183,21 @@ class Puppet::Pops::Binder::Binder
       @key_factory = key_factory
       @bindings = []
       @contributions = []
-      @@bind_visitor ||= Puppet::Pops::Visitor.new(nil,"bind",0,0)
+      @@bind_visitor ||= Visitor.new(nil,"bind",0,0)
     end
 
     # Add the binding to the list of potentially effective bindings from this layer
     # @api private
     #
     def add(b)
-      bindings << Puppet::Pops::Binder::InjectorEntry.new(b, binder_precedence)
+      bindings << InjectorEntry.new(b, binder_precedence)
     end
 
     # Add a multibind contribution
     # @api private
     #
     def add_contribution(b)
-      contributions << Puppet::Pops::Binder::InjectorEntry.new(b, binder_precedence)
+      contributions << InjectorEntry.new(b, binder_precedence)
     end
 
     # Bind given abstract binding
@@ -205,7 +207,7 @@ class Puppet::Pops::Binder::Binder
       @@bind_visitor.visit_this_0(self, binding)
     end
 
-    # @return [Puppet::Pops::Binder::InjectorEntry] the entry with the highest precedence
+    # @return [InjectorEntry] the entry with the highest precedence
     # @api private
     def highest(b1, b2)
       if b1.is_abstract? != b2.is_abstract?
@@ -268,7 +270,7 @@ class Puppet::Pops::Binder::Binder
 
 
     # Produces the key for the given Binding.
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding] the binding to get a key for
+    # @param binding [Bindings::Binding] the binding to get a key for
     # @return [Object] an opaque key
     # @api private
     #
@@ -318,8 +320,8 @@ class Puppet::Pops::Binder::Binder
           entry = binder.injector_entries[k]
           unless key_factory.is_contributions_key?(k)
             if v.is_abstract?()
-              layer_name, bindings_name = Puppet::Pops::Binder::Binder.get_named_binding_layer_and_name(v.binding)
-              type_name = Puppet::Pops::Types::TypeCalculator.singleton.string(v.binding.type)
+              layer_name, bindings_name = Binder.get_named_binding_layer_and_name(v.binding)
+              type_name = v.binding.type.to_s
               raise ArgumentError, "The abstract binding '#{type_name}/#{v.binding.name}' in '#{bindings_name}' in layer '#{layer_name}' was not overridden"
             end
             raise ArgumentError, "Internal Error - redefinition of key: #{k}, (should never happen)" if entry
@@ -392,3 +394,5 @@ class Puppet::Pops::Binder::Binder
     end
   end
 end
+end
+end

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

@@ -1,8 +1,9 @@
+module Puppet::Pops
 # @api public
-module Puppet::Pops::Binder::BinderIssues
+module Binder::BinderIssues
 
   # NOTE: The methods #issue and #hard_issue are done in a somewhat funny way
-  # since the Puppet::Pops::Issues is a module with these methods defined on the module-class
+  # since the Issues is a module with these methods defined on the module-class
   # This makes it hard to inherit them in this module. (Likewise if Issues was a class, and they
   # need to be defined for the class, and such methods are also not inherited, it becomes more
   # difficult to reuse these. It did not seem as a good idea to refactor Issues at this point
@@ -10,14 +11,14 @@ module Puppet::Pops::Binder::BinderIssues
   # Meanwhile, they delegate to Issues.
 
 
-  # (see Puppet::Pops::Issues#issue)
+  # (see Issues#issue)
   def self.issue (issue_code, *args, &block)
-    Puppet::Pops::Issues.issue(issue_code, *args, &block)
+    Issues.issue(issue_code, *args, &block)
   end
 
-  # (see Puppet::Pops::Issues#hard_issue)
+  # (see Issues#hard_issue)
   def self.hard_issue(issue_code, *args, &block)
-    Puppet::Pops::Issues.hard_issue(issue_code, *args, &block)
+    Issues.hard_issue(issue_code, *args, &block)
   end
 
   # Producer issues (binding identified using :binding argument)
@@ -120,3 +121,4 @@ module Puppet::Pops::Binder::BinderIssues
   end
 
 end
+end

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

@@ -1,19 +1,21 @@
+module Puppet::Pops
+module Binder
 # A validator/checker of a bindings model
 # @api public
 #
-class Puppet::Pops::Binder::BindingsChecker
-  Bindings = Puppet::Pops::Binder::Bindings
-  Issues = Puppet::Pops::Binder::BinderIssues
-  Types = Puppet::Pops::Types
+class BindingsChecker
+  Bindings = Bindings
+  Issues = BinderIssues
+  Types = Types
 
   attr_reader :type_calculator
   attr_reader :acceptor
 
   # @api public
   def initialize(diagnostics_producer)
-    @@check_visitor     ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
-    @type_calculator      = Puppet::Pops::Types::TypeCalculator.singleton
-    @expression_validator = Puppet::Pops::Validation::ValidatorFactory_4_0.new().checker(diagnostics_producer)
+    @@check_visitor     ||= Visitor.new(nil, "check", 0, 0)
+    @type_calculator      = Types::TypeCalculator.singleton
+    @expression_validator = Validation::ValidatorFactory_4_0.new().checker(diagnostics_producer)
     @acceptor             = diagnostics_producer
   end
 
@@ -109,7 +111,7 @@ class Puppet::Pops::Binder::BindingsChecker
   # Checks that an expression has been declared in the producer
   # @api private
   def check_EvaluatingProducerDescriptor(p)
-    unless p.expression.is_a?(Puppet::Pops::Model::Expression)
+    unless p.expression.is_a?(Model::Expression)
       acceptor.accept(Issues::MISSING_EXPRESSION, p, {:binding => binding_parent(p)})
     end
   end
@@ -195,3 +197,5 @@ class Puppet::Pops::Binder::BindingsChecker
     p
   end
 end
+end
+end

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

@@ -1,5 +1,7 @@
+module Puppet::Pops
+module Binder
 # The BindingsComposer handles composition of multiple bindings sources
-# It is directed by a {Puppet::Pops::Binder::Config::BinderConfig BinderConfig} that indicates how
+# It is directed by a {Config::BinderConfig BinderConfig} that indicates how
 # the final composition should be layered, and what should be included/excluded in each layer
 #
 # The bindings composer is intended to be used once per environment as the compiler starts its work.
@@ -11,7 +13,7 @@
 #
 require 'puppet/plugins/binding_schemes'
 
-class Puppet::Pops::Binder::BindingsComposer
+class BindingsComposer
 
   # The BindingsConfig instance holding the read and parsed, but not evaluated configuration
   # @api public
@@ -39,11 +41,11 @@ class Puppet::Pops::Binder::BindingsComposer
 
   # @api public
   def initialize()
-    @acceptor = Puppet::Pops::Validation::Acceptor.new()
-    @diagnostics = Puppet::Pops::Binder::Config::DiagnosticProducer.new(acceptor)
-    @config = Puppet::Pops::Binder::Config::BinderConfig.new(@diagnostics)
+    @acceptor = Validation::Acceptor.new()
+    @diagnostics = Config::DiagnosticProducer.new(acceptor)
+    @config = Config::BinderConfig.new(@diagnostics)
     if acceptor.errors?
-      Puppet::Pops::IssueReporter.assert_and_report(acceptor, :message => 'Binding Composer: error while reading config.')
+      IssueReporter.assert_and_report(acceptor, :message => 'Binding Composer: error while reading config.')
       raise Puppet::DevError.new("Internal Error: IssueReporter did not raise exception for errors in bindings config.")
     end
   end
@@ -66,7 +68,7 @@ class Puppet::Pops::Binder::BindingsComposer
     scheme_extensions = @config.scheme_extensions
 
     # Define a named bindings that are known by the SystemBindings
-    boot_bindings = Puppet::Pops::Binder::BindingsFactory.named_bindings(Puppet::Pops::Binder::SystemBindings::ENVIRONMENT_BOOT_BINDINGS_NAME) do
+    boot_bindings = BindingsFactory.named_bindings(SystemBindings::ENVIRONMENT_BOOT_BINDINGS_NAME) do
       scheme_extensions.each_pair do |scheme, class_name|
         # turn each scheme => class_name into a binding (contribute to the buildings-schemes multibind).
         # do this in category 'extensions' to allow them to override the 'default'
@@ -82,7 +84,7 @@ class Puppet::Pops::Binder::BindingsComposer
     @injector = scope.compiler.create_boot_injector(boot_bindings.model)
   end
 
-  # @return [Puppet::Pops::Binder::Bindings::LayeredBindings]
+  # @return [Bindings::LayeredBindings]
   def compose(scope)
     # The boot injector is used to lookup scheme-handlers
     configure_and_create_injector(scope)
@@ -94,7 +96,7 @@ class Puppet::Pops::Binder::BindingsComposer
     # setup the confdir
     @confdir = Puppet.settings[:confdir]
 
-    factory = Puppet::Pops::Binder::BindingsFactory
+    factory = BindingsFactory
     contributions = []
     configured_layers = @config.layering_config.collect do |  layer_config |
       # get contributions
@@ -108,8 +110,8 @@ class Puppet::Pops::Binder::BindingsComposer
     # Add the two system layers; the final - highest ("can not be overridden" layer), and the lowest
     # Everything here can be overridden 'default' layer.
     #
-    configured_layers.insert(0, Puppet::Pops::Binder::SystemBindings.final_contribution)
-    configured_layers.insert(-1, Puppet::Pops::Binder::SystemBindings.default_contribution)
+    configured_layers.insert(0, SystemBindings.final_contribution)
+    configured_layers.insert(-1, SystemBindings.default_contribution)
 
     # and finally... create the resulting structure
     factory.layered_bindings(*configured_layers)
@@ -158,7 +160,7 @@ class Puppet::Pops::Binder::BindingsComposer
   end
 
   class SchemeHandlerHelper
-    T = Puppet::Pops::Types::TypeFactory
+    T = Types::TypeFactory
     HASH_OF_HANDLER = T.hash_of(T.type_of(Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_TYPE))
     def initialize(scope)
       @scope = scope
@@ -175,3 +177,5 @@ class Puppet::Pops::Binder::BindingsComposer
   end
 
 end
+end
+end