puppet 4.4.2-x64-mingw32 → 4.5.0-x64-mingw32

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

@@ -42,14 +42,36 @@ class TypeDefinitionInstantiator
     # the loader is known - hence this mechanism
     private_loader = loader.private_loader
     Adapters::LoaderAdapter.adapt(type_definition).loader = private_loader
-
-    Types::PTypeAliasType.new(name, type_definition.type_expr)
+    create_type(type_definition, loader)
   end
 
   def self.create_from_model(type_definition, loader)
+    typed_name = Loader::TypedName.new(:type, type_definition.name.downcase)
+    type = create_type(type_definition, loader)
+    loader.set_entry(
+      typed_name,
+      type,
+      Adapters::SourcePosAdapter.adapt(type_definition).to_uri)
+    type
+  end
+
+  def self.create_type(type_definition, loader)
+    type_expr = type_definition.type_expr
     name = type_definition.name
-    [Loader::TypedName.new(:type, name.downcase), Types::PTypeAliasType.new(name, type_definition.type_expr)]
+    if object_definition?(type_expr)
+      # No need for an alias. The Object type itself will receive the name instead
+      i12n_hash_expr = type_expr.keys.empty? ? nil : type_expr.keys[0]
+      Types::PObjectType.new(name, i12n_hash_expr)
+    else
+      Types::PTypeAliasType.new(name, type_expr)
+    end
+  end
+  private_class_method :create_type
+
+  def self.object_definition?(te)
+    te.is_a?(Model::AccessExpression) && (left = te.left_expr).is_a?(Model::QualifiedReference) && left.cased_value == 'Object'
   end
+  private_class_method :object_definition?
 end
 end
 end

data/lib/puppet/pops/loaders.rb

@@ -6,10 +6,9 @@ class Loaders
   attr_reader :puppet_system_loader
   attr_reader :public_environment_loader
   attr_reader :private_environment_loader
+  attr_reader :implementation_registry
 
   def initialize(environment)
-    # The static loader can only be changed after a reboot
-    @@static_loader ||= Loader::StaticLoader.new()
 
     # Create the set of loaders
     # 1. Puppet, loads from the "running" puppet - i.e. bundled functions, types, extension points and extensions
@@ -26,28 +25,81 @@ class Loaders
     #
     @private_environment_loader = create_environment_loader(environment)
 
-    # 3. module loaders are set up from the create_environment_loader, they register themselves
+    # 3. The implementation registry maintains mappings between Puppet types and Runtime types for
+    #    the current environment
+    @implementation_registry = Types::ImplementationRegistry.new(@private_environment_loader)
+    Pcore.init(@puppet_system_loader, @implementation_registry)
+
+    # 4. module loaders are set up from the create_environment_loader, they register themselves
   end
 
   # Clears the cached static and puppet_system loaders (to enable testing)
   #
   def self.clear
     @@static_loader = nil
-    @puppet_system_loader = nil
   end
 
-  # Finds the `Loaders` instance by looking up the :loaders in the global Puppet context and then uses it to
-  # find the appropriate loader for the given `module_name`, or for the environment in case `module_name`
-  # is `nil` or empty.
+  # Calls {#loaders} to obtain the {{Loaders}} instance and then uses it to find the appropriate loader
+  # for the given `module_name`, or for the environment in case `module_name` is `nil` or empty.
   #
   # @param module_name [String,nil] the name of the module
   # @return [Loader::Loader] the found loader
   # @raise [Puppet::ParseError] if no loader can be found
   # @api private
   def self.find_loader(module_name)
+    loaders.find_loader(module_name)
+  end
+
+  def self.static_loader
+    # The static loader can only be changed after a reboot
+    @@static_loader ||= Loader::StaticLoader.new()
+  end
+
+  def self.implementation_registry
+    loaders = Puppet.lookup(:loaders) { nil }
+    loaders.nil? ? nil : loaders.implementation_registry
+  end
+
+  def register_implementations(*obj_classes)
+    loader = @private_environment_loader
+    types = obj_classes.map do |obj_class|
+      type = obj_class._ptype
+      typed_name = Loader::Loader::TypedName.new(:type, type.name.downcase)
+      entry = loader.loaded_entry(typed_name)
+      loader.set_entry(typed_name, type, obj_class._plocation) if entry.nil? || entry.value.nil?
+      type
+    end
+    # Resolve lazy so that all types can cross reference eachother
+    parser = Types::TypeParser.new
+    types.each { |type| type.resolve(parser, loader) }
+  end
+
+  # Register the given type with the Runtime3TypeLoader. The registration will not happen unless
+  # the type system has been initialized.
+  #
+  # @param name [String,Symbol] the name of the entity being set
+  # @param origin [URI] the origin or the source where the type is defined
+  # @api private
+  def self.register_runtime3_type(name, origin)
+    loaders = Puppet.lookup(:loaders) { nil }
+    unless loaders.nil?
+      name = name.to_s
+      caps_name = Types::TypeFormatter.singleton.capitalize_segments(name)
+      typed_name = Loader::Loader::TypedName.new(:type, name.downcase)
+      loaders.runtime3_type_loader.set_entry(typed_name, Types::PResourceType.new(caps_name), origin)
+    end
+    nil
+  end
+
+  # Finds the `Loaders` instance by looking up the :loaders in the global Puppet context
+  #
+  # @return [Loaders] the loaders instance
+  # @raise [Puppet::ParseError] if loader has been bound to the global context
+  # @api private
+  def self.loaders
     loaders = Puppet.lookup(:loaders) { nil }
     raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing" if loaders.nil?
-    loaders.find_loader(module_name)
+    loaders
   end
 
   # Finds the appropriate loader for the given `module_name`, or for the environment in case `module_name`
@@ -77,13 +129,17 @@ class Loaders
   end
 
   def static_loader
-    @@static_loader
+    self.class.static_loader
   end
 
   def puppet_system_loader
     @puppet_system_loader
   end
 
+  def runtime3_type_loader
+    @runtime3_type_loader
+  end
+
   def public_loader_for_module(module_name)
     md = @module_resolver[module_name] || (return nil)
     # Note, this loader is not resolved until there is interest in the visibility of entities from the
@@ -130,12 +186,16 @@ class Loaders
     module_name = nil
     loader_name = "environment:#{environment.name}"
     env_conf = Puppet.lookup(:environments).get_conf(environment.name)
+
+    # Create the 3.x resource type loader
+    @runtime3_type_loader = Loader::Runtime3TypeLoader.new(puppet_system_loader, environment)
+
     if env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf)
       # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?
-      loader = Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
+      loader = Loader::SimpleEnvironmentLoader.new(@runtime3_type_loader, loader_name)
     else
       # View the environment as a module to allow loading from it - this module is always called 'environment'
-      loader = Loader::ModuleLoaders.module_loader_from(puppet_system_loader, self, 'environment', env_conf.path_to_env)
+      loader = Loader::ModuleLoaders.module_loader_from(@runtime3_type_loader, self, 'environment', env_conf.path_to_env)
     end
 
     # An environment has a module path even if it has a null loader
@@ -270,9 +330,19 @@ class Loaders
 
     def create_loader_with_only_dependencies_visible(from_module_data)
       if from_module_data.unmet_dependencies?
-        Puppet.warning("ModuleLoader: module '#{from_module_data.name}' has unresolved dependencies"+
-          " - it will only see those that are resolved."+
-          " Use 'puppet module list --tree' to see information about modules")
+        if Puppet[:strict] != :off
+          msg = "ModuleLoader: module '#{from_module_data.name}' has unresolved dependencies" \
+              " - it will only see those that are resolved." \
+              " Use 'puppet module list --tree' to see information about modules"
+          case Puppet[:strict]
+          when :error
+              raise LoaderError.new(msg)
+          when :warning
+            Puppet.warn_once(:unresolved_module_dependencies,
+                             "unresolved_dependencies_for_module_#{from_module_data.name}",
+                             msg)
+          end
+        end
       end
       dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
       Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)

data/lib/puppet/pops/lookup/explainer.rb

@@ -367,13 +367,46 @@ module Puppet::Pops::Lookup
     end
   end
 
+  class ExplainSubLookup < ExplainTreeNode
+    def initialize(parent, sub_key)
+      super(parent)
+      @sub_key = sub_key
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << indent << 'Sub key: "' << @sub_key.join('.') << "\"\n"
+      indent = increase_indent(indent)
+      branches.each {|b| b.dump_on(io, indent, indent)}
+      dump_outcome(io, indent)
+    end
+
+    def type
+      :sub_key
+    end
+  end
+
+  class ExplainKeySegment < ExplainTreeNode
+    def initialize(parent, segment)
+      super(parent)
+      @segment = segment
+    end
+
+    def dump_on(io, indent, first_indent)
+      dump_outcome(io, indent)
+    end
+
+    def type
+      :segment
+    end
+  end
+
   class ExplainScope < ExplainTreeNode
     def initialize(parent)
       super(parent)
     end
 
     def dump_on(io, indent, first_indent)
-      io << indent << 'Global Scope' << "\"\n"
+      io << indent << 'Global Scope' << "\n"
       indent = increase_indent(indent)
       dump_outcome(io, indent)
     end
@@ -406,6 +439,10 @@ module Puppet::Pops::Lookup
           ExplainMerge.new(@current, qualifier)
         when :scope
           ExplainScope.new(@current)
+        when :sub_lookup
+          ExplainSubLookup.new(@current, qualifier)
+        when :segment
+          ExplainKeySegment.new(@current, qualifier)
         when :meta, :data
           ExplainTop.new(@current, qualifier_type, qualifier)
         when :invalid_key

data/lib/puppet/pops/lookup/interpolation.rb

@@ -0,0 +1,115 @@
+require_relative 'sub_lookup'
+
+# Add support for Hiera-like interpolation expressions. The expressions may contain keys that uses dot-notation
+# to further navigate into hashes and arrays
+#
+module Puppet::Pops
+module Lookup
+module Interpolation
+  include SubLookup
+
+  def interpolate(subject, lookup_invocation, allow_methods)
+    case subject
+    when String
+      subject.index('%{').nil? ? subject : interpolate_string(subject, lookup_invocation, allow_methods)
+    when Array
+      subject.map { |element| interpolate(element, lookup_invocation, allow_methods) }
+    when Hash
+      Hash[subject.map { |k, v| [k, interpolate(v, lookup_invocation, allow_methods)] }]
+    else
+      subject
+    end
+  end
+
+  private
+
+  EMPTY_INTERPOLATIONS = {
+    '' => true,
+    '::' => true,
+    '""' => true,
+    "''" => true,
+    '"::"' => true,
+    "'::'" => true
+  }.freeze
+
+  # Matches a key that is quoted using a matching pair of either single or double quotes.
+  QUOTED_KEY = /^(?:"([^"]+)"|'([^']+)')$/
+
+  def interpolate_string(subject, lookup_invocation, allow_methods)
+    lookup_invocation.with(:interpolate, subject) do
+      subject.gsub(/%\{([^\}]*)\}/) do |match|
+        expr = $1
+        # Leading and trailing spaces inside an interpolation expression are insignificant
+        expr.strip!
+        value = nil
+        unless EMPTY_INTERPOLATIONS[expr]
+          method_key, key = get_method_and_data(expr, allow_methods)
+          is_alias = method_key == 'alias'
+
+          # Alias is only permitted if the entire string is equal to the interpolate expression
+          raise Puppet::DataBinding::LookupError, "'alias' interpolation is only permitted if the expression is equal to the entire string" if is_alias && subject != match
+
+          segments = split_key(key) { |problem| Puppet::DataBinding::LookupError.new("#{problem} in string: #{subject}") }
+          root_key = segments.shift
+          value = interpolate_method(method_key).call(root_key, lookup_invocation)
+          value = sub_lookup(key, lookup_invocation, segments, value) unless segments.empty?
+          value = lookup_invocation.check(key) { interpolate(value, lookup_invocation, allow_methods) }
+
+          # break gsub and return value immediately if this was an alias substitution. The value might be something other than a String
+          return value if is_alias
+        end
+        value || ''
+      end
+    end
+  end
+
+  def interpolate_method(method_key)
+    @@interpolate_methods ||= begin
+      global_lookup = lambda { |key, lookup_invocation| Lookup.lookup(key, nil, '', true, nil, lookup_invocation) }
+      scope_lookup = lambda do |key, lookup_invocation|
+        lookup_invocation.with(:scope, nil) do
+          ovr = lookup_invocation.override_values
+          if ovr.include?(key)
+            lookup_invocation.report_found_in_overrides(key, ovr[key])
+          else
+            scope = lookup_invocation.scope
+            if scope.include?(key)
+              lookup_invocation.report_found(key, scope[key])
+            else
+              defaults = lookup_invocation.default_values
+              if defaults.include?(key)
+                lookup_invocation.report_found_in_defaults(key, defaults[key])
+              else
+                nil
+              end
+            end
+          end
+        end
+      end
+
+      {
+        'lookup' => global_lookup,
+        'hiera' => global_lookup, # this is just an alias for 'lookup'
+        'alias' => global_lookup, # same as 'lookup' but expression must be entire string and result is not subject to string substitution
+        'scope' => scope_lookup,
+        'literal' => lambda { |key, _| key }
+      }.freeze
+    end
+    interpolate_method = @@interpolate_methods[method_key]
+    raise Puppet::DataBinding::LookupError, "Unknown interpolation method '#{method_key}'" unless interpolate_method
+    interpolate_method
+  end
+
+  def get_method_and_data(data, allow_methods)
+    if match = data.match(/^(\w+)\((?:["]([^"]+)["]|[']([^']+)['])\)$/)
+      raise Puppet::DataBinding::LookupError, 'Interpolation using method syntax is not allowed in this context' unless allow_methods
+      key = match[1]
+      data = match[2] || match[3] # double or single qouted
+    else
+      key = 'scope'
+    end
+    [key, data]
+  end
+end
+end
+end

data/lib/puppet/pops/lookup/sub_lookup.rb

@@ -0,0 +1,86 @@
+module Puppet::Pops
+module Lookup
+module SubLookup
+  # Split key into segments. A segment may be a quoted string (both single and double quotes can
+  # be used) and the segment separator is the '.' character. Whitespace will be trimmed off on
+  # both sides of each segment. Whitespace within quotes are not trimmed.
+  #
+  # If the key cannot be parsed, this method will yield a string describing the problem to a one
+  # parameter block. The block must return an exception instance.
+  #
+  # @param key [String] the string to split
+  # @return Array<String> the array of segments
+  # @yieldparam problem [String] the problem, i.e. 'Syntax error'
+  # @yieldreturn [Exception] the exception to raise
+  #
+  # @api public
+  def split_key(key)
+    segments = key.split(/(\s*"[^"]+"\s*|\s*'[^']+'\s*|[^'".]+)/)
+    if segments.empty?
+      # Only happens if the original key was an empty string
+      ''
+    elsif segments.shift == ''
+      count = segments.size
+      raise yield('Syntax error') unless count > 0
+
+      segments.keep_if { |seg| seg != '.' }
+      raise yield('Syntax error') unless segments.size * 2 == count + 1
+      segments.map! do |segment|
+        segment.strip!
+        segment.start_with?('"') || segment.start_with?("'") ? segment[1..-2] : segment
+      end
+    else
+      raise yield('Syntax error')
+    end
+  end
+
+  # Perform a sub-lookup using the given _segments_ to access the given _value_. Each segment must be a string. A string
+  # consisting entirely of digits will be treated as an indexed lookup which means that the value that it is applied to
+  # must be an array. Other types of segments will expect that the given value is something other than a String that
+  # implements the '#[]' method.
+  #
+  # @param key [String] the original key (only used for error messages)
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param segments [Array<String>] the segments to use for lookup
+  # @param value [Object] the value to access using the segments
+  # @return [Object] the value obtained when accessing the value
+  #
+  # @api public
+  def sub_lookup(key, lookup_invocation, segments, value)
+    lookup_invocation.with(:sub_lookup, segments) do
+      segments.each do |segment|
+        lookup_invocation.with(:segment, segment) do
+          if value.nil?
+            lookup_invocation.report_not_found(segment)
+            throw :no_such_key
+          end
+          if segment =~ /^[0-9]+$/
+            segment = segment.to_i
+            unless value.instance_of?(Array)
+              raise Puppet::DataBinding::LookupError,
+                "Data Provider type mismatch: Got #{value.class.name} when Array was expected to access value using '#{segment}' from key '#{key}'"
+            end
+            unless segment < value.size
+              lookup_invocation.report_not_found(segment)
+              throw :no_such_key
+            end
+          else
+            unless value.respond_to?(:'[]') && !(value.instance_of?(Array) || value.instance_of?(String))
+              raise Puppet::DataBinding::LookupError,
+                "Data Provider type mismatch: Got #{value.class.name} when a hash-like object was expected to access value using '#{segment}' from key '#{key}'"
+            end
+            unless value.include?(segment)
+              lookup_invocation.report_not_found(segment)
+              throw :no_such_key
+            end
+          end
+          value = value[segment]
+          lookup_invocation.report_found(segment, value)
+        end
+      end
+      value
+    end
+  end
+end
+end
+end