puppet 4.10.12 → 5.0.0

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

@@ -109,8 +109,8 @@ class BaseLoader < Loader
   private
 
   def fail_redefine(entry)
-    origin_info = entry.origin ? "Originally set #{origin_label(entry.origin)}." : "Set at unknown location"
-    raise ArgumentError, "Attempt to redefine entity '#{entry.typed_name}'. #{origin_info}"
+    origin_info = entry.origin ? _("Originally set %{original}.") % { original: origin_label(entry.origin) } : _("Set at unknown location")
+    raise ArgumentError, _("Attempt to redefine entity '%{name}'. %{origin_info}") % { name: entry.typed_name, origin_info: origin_info }
   end
 
   # TODO: Should not really be here?? - TODO: A Label provider ? semantics for the URI?

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

@@ -27,7 +27,7 @@ module Puppet::Pops::Loader::GemSupport
   #
   def gem_dir_from_uri(uri)
     unless spec = Gem::Specification.find_by_name(uri.hostname)
-      raise ArgumentError, "Gem not found #{uri}"
+      raise ArgumentError, _("Gem not found %{uri}") % { uri: uri }
     end
     # if path given append that, else append given subdir
     if uri.path.empty?
@@ -42,7 +42,7 @@ module Puppet::Pops::Loader::GemSupport
   #
   def gem_dir_from_name(gem_name)
     unless spec = Gem::Specification.find_by_name(gem_name)
-      raise ArgumentError, "Gem not found '#{gem_name}'"
+      raise ArgumentError, _("Gem not found '%{gem_name}'") % { gem_name: gem_name }
     end
     spec.full_gem_path
   end

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

@@ -136,6 +136,21 @@ module ModuleLoaders
         when :resource_type
         when :resource_type_pp
         when :type
+          if !global?
+            # Global name can only be the module typeset
+            return nil unless name_parts[0] == module_name
+
+            origin, smart_path = find_existing_path(init_typeset_name)
+            return nil unless smart_path
+
+            value = smart_path.instantiator.create(self, typed_name, origin, get_contents(origin))
+            if value.is_a?(Types::PTypeSetType)
+              # cache the entry and return it
+              return set_entry(typed_name, value, origin)
+            end
+
+            raise ArgumentError,"The code loaded from #{origin} does not define the TypeSet '#{module_name.capitalize}'"
+          end
         else
           # anything else cannot possibly be in this module
           # TODO: should not be allowed anyway... may have to revisit this decision
@@ -146,17 +161,31 @@ module ModuleLoaders
       # Get the paths that actually exist in this module (they are lazily processed once and cached).
       # The result is an array (that may be empty).
       # Find the file to instantiate, and instantiate the entity if file is found
-      origin = nil
-      if (smart_path = smart_paths.effective_paths(typed_name.type).find do |sp|
-          origin = sp.effective_path(typed_name, global? ? 0 : 1)
-          existing_path(origin)
-        end)
+      origin, smart_path = find_existing_path(typed_name)
+      if smart_path
         value = smart_path.instantiator.create(self, typed_name, origin, get_contents(origin))
         # cache the entry and return it
-        set_entry(typed_name, value, origin)
-      else
-        nil
+        return set_entry(typed_name, value, origin)
+      end
+
+      return nil unless typed_name.type == :type && typed_name.qualified?
+
+      # Search for TypeSet using parent name
+      ts_name = typed_name.parent
+      while ts_name
+        # Do not traverse parents here. This search must be confined to this loader
+        tse = get_entry(ts_name)
+        tse = find(ts_name) if tse.nil? || tse.value.nil?
+        if tse && (ts = tse.value).is_a?(Types::PTypeSetType)
+          # The TypeSet might be unresolved at this point. If so, it must be resolved using
+          # this loader. That in turn, adds all contained types to this loader.
+          ts.resolve(Types::TypeParser.singleton, self)
+          te = get_entry(typed_name)
+          return te unless te.nil?
+        end
+        ts_name = ts_name.parent
       end
+      nil
     end
 
     # Abstract method that subclasses override that checks if it is meaningful to search using a generic smart path.
@@ -219,6 +248,28 @@ module ModuleLoaders
       # that can only by called by puppet runtime - if so, it acts as the private loader directly.
       @private_loader ||= (global? ? self : @loaders.private_loader_for_module(module_name))
     end
+
+    private
+
+    # @return [TypedName] the fake typed name that maps to the init_typeset path for this module
+    def init_typeset_name
+      @init_typeset_name ||= TypedName.new(:type, "#{module_name}::init_typeset")
+    end
+
+    # Find an existing path for the given `typed_name`. Return `nil` if no such path is found
+    # @param typed_name [TypedName] the `typed_name` to find a path for
+    # @return [Array,nil] `nil`or a two element array an effective path `String` and the `SmartPath` that produced the effective path.
+    def find_existing_path(typed_name)
+      is_global = global?
+      smart_paths.effective_paths(typed_name.type).each do |sp|
+        origin = sp.effective_path(typed_name, is_global ? 0 : 1)
+        unless origin.nil?
+          existing = existing_path(origin)
+          return [origin, sp] unless existing.nil?
+        end
+      end
+      nil
+    end
   end
 
   # @api private

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

@@ -2,15 +2,10 @@ 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.
-# When searching for a type, it must exist or an error is raised
 #
 class PredefinedLoader < BaseLoader
   def find(typed_name)
-    if typed_name.type == :type
-      raise Puppet::Pops::Loaders::LoaderError, "Cannot load undefined type '#{typed_name.name.capitalize}'"
-    else
-      nil
-    end
+    nil
   end
 
   def to_s()

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

@@ -20,26 +20,26 @@ class PuppetFunctionInstantiator
     # parse and validate
     result = parser.parse_string(pp_code_string, source_ref)
     # Only one function is allowed (and no other definitions)
-    case result.model.definitions.size
+    case result.definitions.size
     when 0
-      raise ArgumentError, "The code loaded from #{source_ref} does not define the function '#{typed_name.name}' - it is empty."
+      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 '#{typed_name.name}' - it has additional definitions."
+      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.model.definitions[0]
+    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 '#{typed_name.name}' - no function found."
+      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}"
+      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.model().body == the_function_definition
-      raise ArgumentError, "The code loaded from #{source_ref} contains additional logic - can only contain the function #{typed_name.name}"
+    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

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

@@ -18,8 +18,7 @@ class PuppetResourceTypeImplInstantiator
     parser = Parser::EvaluatingParser.new()
 
     # parse and validate
-    result = parser.parse_string(pp_code_string, source_ref)
-    model = result.model
+    model = parser.parse_string(pp_code_string, source_ref)
     statements = if model.is_a?(Model::Program)
       if model.body.is_a?(Model::BlockExpression)
         statements = model.body.statements
@@ -31,10 +30,10 @@ class PuppetResourceTypeImplInstantiator
     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 '#{typed_name.name}' - it is 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._ptype.name
+    rname = Resource::ResourceTypeImpl._pcore_type.name
     unless statements.find do |s|
       if s.is_a?(Model::CallMethodExpression)
         functor_expr = s.functor_expr
@@ -42,30 +41,30 @@ class PuppetResourceTypeImplInstantiator
           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'
+          functor_expr.right_expr.value == _('new')
       else
         false
       end
     end
-      raise ArgumentError, "The code loaded from #{source_ref} does not create the resource type '#{typed_name.name}' - no call to #{rname}.new found."
+      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 '#{typed_name.name}' - it has additional logic."
+      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, result)
+    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 '#{typed_name.name}' - got '#{got}'."
+      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}'"
+      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

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

@@ -14,17 +14,17 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
   #
   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."
+      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 '#{created.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 '#{typed_name.name}', got #{created.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.

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

@@ -6,7 +6,7 @@ module Loader
 class StaticLoader < Loader
 
   BUILTIN_TYPE_NAMES = %w{
-      Augeas
+      Auegas
       Component
       Computer
       Cron
@@ -36,6 +36,7 @@ class StaticLoader < Loader
       Nagios_serviceextinfo
       Nagios_servicegroup
       Nagios_timeperiod
+      Node
       Notify
       Package
       Resources
@@ -60,11 +61,22 @@ class StaticLoader < Loader
 
   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,Undef,Hash[RichDataKey,RichData],Array[RichData]]',
+
+    # Backward compatible aliases.
+    'Puppet::LookupKey' => 'RichDataKey',
+    'Puppet::LookupValue' => 'RichData'
+  }.freeze
+
   attr_reader :loaded
   def initialize
     @loaded = {}
-    create_built_in_types()
-    create_resource_type_references()
+    create_built_in_types
+    create_resource_type_references
+    register_aliases
   end
 
   def load_typed(typed_name)
@@ -75,6 +87,10 @@ class StaticLoader < Loader
     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
@@ -88,7 +104,7 @@ class StaticLoader < Loader
     "(StaticLoader)"
   end
 
-  def loaded_entry(typed_name, _)
+  def loaded_entry(typed_name, check_dependencies = false)
     @loaded[typed_name]
   end
 
@@ -102,8 +118,7 @@ class StaticLoader < Loader
     origin_uri = URI("puppet:Puppet-Type-System/Static-Loader")
     type_map = Puppet::Pops::Types::TypeParser.type_map
     type_map.each do |name, type|
-      typed_name = TypedName.new(:type, name)
-      @loaded[ typed_name ] = NamedEntry.new(typed_name, type, origin_uri)#__FILE__)
+      set_entry(TypedName.new(:type, name), type, origin_uri)
     end
   end
 
@@ -112,68 +127,22 @@ class StaticLoader < Loader
     # We are also not interested in their definition only that they exist.
     # These types are in all environments.
     #
-    %w{
-      Augeas
-      Component
-      Computer
-      Cron
-      Exec
-      File
-      Filebucket
-      Group
-      Host
-      Interface
-      K5login
-      Macauthorization
-      Mailalias
-      Maillist
-      Mcx
-      Mount
-      Nagios_command
-      Nagios_contact
-      Nagios_contactgroup
-      Nagios_host
-      Nagios_hostdependency
-      Nagios_hostescalation
-      Nagios_hostgroup
-      Nagios_hostextinfo
-      Nagios_service
-      Nagios_servicedependency
-      Nagios_serviceescalation
-      Nagios_serviceextinfo
-      Nagios_servicegroup
-      Nagios_timeperiod
-      Notify
-      Package
-      Resources
-      Router
-      Schedule
-      Scheduled_task
-      Selboolean
-      Selmodule
-      Service
-      Ssh_authorized_key
-      Sshkey
-      Stage
-      Tidy
-      User
-      Vlan
-      Whit
-      Yumrepo
-      Zfs
-      Zone
-      Zpool
-    }.each { |name| create_resource_type_reference(name) }
+    BUILTIN_TYPE_NAMES.each { |name| create_resource_type_reference(name) }
+  end
 
-    if Puppet[:app_management]
-      create_resource_type_reference('Node')
-    end
+  def add_type(name, type)
+    set_entry(TypedName.new(:type, name), type)
+    type
   end
 
   def create_resource_type_reference(name)
-    typed_name = TypedName.new(:type, name)
-    type = Puppet::Pops::Types::TypeFactory.resource(name)
-    @loaded[ typed_name ] = NamedEntry.new(typed_name, type, __FILE__)
+    add_type(name, Types::TypeFactory.resource(name))
+  end
+
+  def register_aliases
+    aliases = BUILTIN_ALIASES.map { |name, string| add_type(name, Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(string), nil)) }
+    parser = Types::TypeParser.singleton
+    aliases.each { |type| type.resolve(parser, self) }
   end
 end
 end

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

@@ -6,35 +6,35 @@ 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).model
+    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."
+      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."
+        _("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."
+        _("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}'"
+        _("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}'"
+        _("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
@@ -51,7 +51,7 @@ class TypeDefinitionInstantiator
     loader.set_entry(
       typed_name,
       type,
-      Adapters::SourcePosAdapter.adapt(type_definition).to_uri)
+      type_definition.locator.to_uri(type_definition))
     type
   end