puppet 5.0.1 → 5.1.0

data/lib/puppet/module.rb

@@ -95,6 +95,17 @@ class Puppet::Module
     load_metadata
 
     @absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(manifests)
+
+    # i18n initialization for modules
+    if Puppet::GETTEXT_AVAILABLE
+      begin
+        initialize_i18n
+      rescue Exception => e
+        Puppet.warning _("GettextSetup initialization for %{module_name} failed with: %{error_message}") % { module_name: name, error_message: e.message }
+      end
+    else
+      Puppet.warning _("GettextSetup is not available, skipping GettextSetup initialization for %{module_name}.") % { module_name: name }
+    end
   end
 
   # @deprecated The puppetversion module metadata field is no longer used.
@@ -385,8 +396,27 @@ class Puppet::Module
     @strict_semver
   end
 
+  def initialize_i18n
+    module_name = @forge_name.gsub("/","-") if @forge_name
+    return if module_name.nil? || i18n_initialized?(module_name)
+
+    locales_path = File.absolute_path('locales', path)
+
+    begin
+      GettextSetup.initialize(locales_path)
+      Puppet.debug "#{module_name} initialized for i18n: #{GettextSetup.translation_repositories[module_name]}"
+    rescue
+      config_path = File.absolute_path('config.yaml', locales_path)
+      Puppet.debug "Could not find locales configuration file for #{module_name} at #{config_path}. Skipping i18n initialization."
+    end
+  end
+
   private
 
+  def i18n_initialized?(module_name)
+    GettextSetup.translation_repositories.has_key? module_name
+  end
+
   def wanted_manifests_from(pattern)
     begin
       extended = File.extname(pattern).empty? ? "#{pattern}.pp" : pattern

data/lib/puppet/parser/functions/new.rb

@@ -475,6 +475,16 @@ $ts = Timestamp('2016-08-24T12:13:14', default, 'PST')   # 2016-08-24 20:13:14.0
 
 ```
 
+Conversion to Type
+------------------
+A new `Type` can be create from its `String` representation.
+
+**Example:** Creating a type from a string
+
+```puppet
+$t = Type.new('Integer[10]')
+```
+
 Conversion to String
 --------------------
 
@@ -772,6 +782,32 @@ Accepts a single value as argument:
 * An `Iterable` is turned into an `Array` and then converted to hash as per the array rules
 * A `Hash` is simply returned
 
+Alternatively, a tree can be constructed by giving two values; an array of tuples on the form `[path, value]`
+(where the `path` is the path from the root of a tree, and `value` the value at that position in the tree), and
+either the option `'tree'` (do not convert arrays to hashes except the top level), or
+`'hash_tree'` (convert all arrays to hashes).
+
+The tree/hash_tree forms of Hash creation are suited for transforming the result of an iteration
+using `tree_each` and subsequent filtering or mapping.
+
+**Example:** Mapping a hash tree
+
+Mapping an arbitrary structure in a way that keeps the structure, but where some values are replaced
+can be done by using the `tree_each` function, mapping, and then constructing a new Hash from the result:
+
+```puppet
+# A hash tree with 'water' at different locations
+$h = { a => { b => { x => 'water'}}, b => { y => 'water'} }
+# a helper function that turns water into wine
+function make_wine($x) { if $x == 'water' { 'wine' } else { $x } }
+# create a flattened tree with water turned into wine
+$flat_tree = $h.tree_each.map |$entry| { [$entry[0], make_wine($entry[1])] }
+# create a new Hash and log it
+notice Hash($flat_tree, 'hash_tree')
+```
+
+Would notice the hash `{a => {b => {x => wine}}, b => {y => wine}}`
+
 Conversion to a `Struct` works exactly as conversion to a `Hash`, only that the constructed hash is
 asserted against the given struct type.
 
@@ -932,6 +968,37 @@ $b = binary_file('mymodule/mypicture.jpg')
 * Since 4.5.0
 * Binary type since 4.8.0
 
+Creating an instance of a `Type` using the `Init` type.
+-------
+
+The type `Init[T]` describes a value that can be used when instantiating a type. When used as the first argument in a call to `new`, it
+will dispatch the call to its contained type and optionally augment the parameter list with additional arguments.
+
+**Example:** Creating an instance of Integer using Init[Integer]
+
+```puppet
+# The following declaration
+$x = Init[Integer].new('128')
+# is exactly the same as
+$x = Integer.new('128')
+```
+
+or, with base 16 and using implicit new
+
+```puppet
+# The following declaration
+$x = Init[Integer,16]('80')
+# is exactly the same as
+$x = Integer('80', 16)
+```
+
+**Example:** Creating an instance of String using a predefined format
+
+```puppet
+$fmt = Init[String,'%#x']
+notice($fmt(256)) # will notice '0x100'
+```
+
 DOC
 ) do |args|
   Puppet::Parser::Functions::Error.is4x('new')

data/lib/puppet/parser/functions/reduce.rb

@@ -99,6 +99,37 @@ $combine = $data.reduce( [d, 4] ) |$memo, $value| {
 # $combine contains [dabc, 10]
 ~~~
 
+**Example**: Using the `reduce` function to reduce a hash of hashes
+
+~~~ puppet
+# Reduce a hash of hashes $data, merging defaults into the inner hashes.
+$data = {
+  'connection1' => {
+    'username' => 'user1',
+    'password' => 'pass1',
+  },
+  'connection_name2' => {
+    'username' => 'user2',
+    'password' => 'pass2',
+  },
+}
+
+$defaults = {
+  'maxActive' => '20',
+  'maxWait'   => '10000',
+  'username'  => 'defaultuser',
+  'password'  => 'defaultpass',
+}
+
+$merged = $data.reduce( {} ) |$memo, $x| {
+  $memo + { $x[0] => $defaults + $data[$x[0]] }
+}
+# At the start of the lambda's first iteration, $memo is set to {}, and $x is set to
+# the first [key, value] tuple. The key in $data is, therefore, given by $x[0]. In
+# subsequent rounds, $memo retains the value returned by the expression, i.e.
+# $memo + { $x[0] => $defaults + $data[$x[0]] }.
+~~~
+
 - Since 4.0.0
 DOC
 ) do |args|

data/lib/puppet/parser/relationship.rb

@@ -67,14 +67,14 @@ class Puppet::Parser::Relationship
     end
   end
 
-  # Turns a PResourceType or PHostClassType into an array [type, title] and all other references to [ref, nil]
+  # Turns a PResourceType or PClassType into an array [type, title] and all other references to [ref, nil]
   # This is needed since it is not possible to find resources in the catalog based on the type system types :-(
   # (note, the catalog is also used on the agent side)
   def canonical_ref(ref)
     case ref
     when Puppet::Pops::Types::PResourceType
       [ref.type_name, ref.title]
-    when Puppet::Pops::Types::PHostClassType
+    when Puppet::Pops::Types::PClassType
       ['class', ref.class_name]
     else
       [ref.to_s, nil]

data/lib/puppet/parser/resource.rb

@@ -167,6 +167,18 @@ class Puppet::Parser::Resource < Puppet::Resource
     unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
       raise Puppet::ParseError.new(_("Only subclasses can override parameters"), resource.file, resource.line)
     end
+
+    if evaluated?
+      strict = Puppet[:strict]
+      unless strict == :off
+        msg = _('Attempt to override an already evaluated resource%{location} with new values') %
+          { resource: ref, location: append_location(file, line, _(', defined'), ',') }
+        raise Puppet::ParseError.new(msg, resource.file, resource.line) if strict == :error
+        msg << append_location(resource.file, resource.line)
+        Puppet.warning(msg)
+      end
+    end
+
     # Some of these might fail, but they'll fail in the way we want.
     resource.parameters.each do |name, param|
       override_parameter(param)
@@ -258,7 +270,7 @@ class Puppet::Parser::Resource < Puppet::Resource
       t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
       cap = catalog.resource(t, ref.title)
       if cap.nil?
-        raise _("Resource %{ref} could not be found; it might not have been produced yet") % { ref: ref }
+        raise Puppet::Error, _("Resource %{ref} could not be found; it might not have been produced yet") % { ref: ref }
       end
 
       # Ensure that the found resource is a capability resource
@@ -310,6 +322,28 @@ class Puppet::Parser::Resource < Puppet::Resource
 
   private
 
+  # Append location to the message if location is present. If it is not, an empty string
+  # is returned instead.
+  #
+  # @param file [String] path to the file
+  # @param line [Integer] the line in the file
+  # @param prefix [String] string prefix
+  # @param suffix [String] string suffix
+  # @return [String] the formatted location or an empty string
+  def append_location(file, line, prefix = '', suffix = '')
+    if file && file != ''
+      if line
+        _('%{prefix} at %{file}:%{line}%{suffix}') % { prefix: prefix, suffix: suffix, file: file, line: line }
+      else
+        _('%{prefix} in %{file}%{suffix}') % { prefix: prefix, suffix: suffix, file: file }
+      end
+    elsif line
+      _('%{prefix} at line %{line}%{suffix}') % { prefix: prefix, suffix: suffix, line: line }
+    else
+      ''
+    end
+  end
+
   def add_scope_tags
     scope_resource = scope.resource
     unless scope_resource.nil? || scope_resource.equal?(self)
@@ -337,15 +371,10 @@ class Puppet::Parser::Resource < Puppet::Resource
 
     # The parameter is already set.  Fail if they're not allowed to override it.
     unless param.source.child_of?(current.source) || param.source.equal?(current.source) && scope.is_default?(type, param.name, current.value)
-      msg = "Parameter '#{param.name}' is already set on #{self}"
-      msg += " by #{current.source}" if current.source.to_s != ""
-      if current.file or current.line
-        fields = []
-        fields << current.file if current.file
-        fields << current.line.to_s if current.line
-        msg += " at #{fields.join(":")}"
-      end
-      msg += "; cannot redefine"
+      msg = _("Parameter '%{name}' is already set on %{resource}") % { name: param.name, resource: ref }
+      msg << _(' by %{source}') % { source: current.source.to_s } unless current.source.to_s == ''
+      msg << append_location(current.file, current.line)
+      msg << _('; cannot redefine')
       raise Puppet::ParseError.new(msg, param.file, param.line)
     end
 

data/lib/puppet/parser/scope.rb

@@ -1043,7 +1043,7 @@ class Puppet::Parser::Scope
         assert_class_and_title(name.type, name.title)
         name.title.sub(/^([^:]{1,2})/, '::\1')
 
-      when Puppet::Pops::Types::PHostClassType
+      when Puppet::Pops::Types::PClassType
         #TRANSLATORS "Class" and "Type" are Puppet keywords and should not be translated
         raise ArgumentError, _("Cannot use an unspecific Class[] Type") unless name.class_name
         name.class_name.sub(/^([^:]{1,2})/, '::\1')

data/lib/puppet/pops/evaluator/access_operator.rb

@@ -347,18 +347,25 @@ class AccessOperator
     end
   end
 
-  def access_PType(o, scope, keys)
+  def access_PTypeType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
       unless keys[0].is_a?(Types::PAnyType)
         fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
       end
-      Types::PType.new(keys[0])
+      Types::PTypeType.new(keys[0])
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
     end
   end
 
+  def access_PInitType(o, scope, keys)
+    unless keys[0].is_a?(Types::PAnyType)
+      fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Init-Type', :actual => keys[0].class})
+    end
+    Types::TypeFactory.init(*keys)
+  end
+
   def access_PIterableType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
@@ -618,7 +625,7 @@ class AccessOperator
 
   NS = '::'.freeze
 
-  def access_PHostClassType(o, scope, keys)
+  def access_PClassType(o, scope, keys)
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
     keys_orig_size = keys.size
 
@@ -651,7 +658,7 @@ class AccessOperator
         name = name[2..-1] if name[0,2] == NS
 
         fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c}) unless name =~ Patterns::NAME
-        Types::PHostClassType.new(name)
+        Types::PClassType.new(name)
       end
     else
       # lookup class resource and return one or more parameter values

data/lib/puppet/pops/evaluator/collector_transformer.rb

@@ -27,7 +27,7 @@ class CollectorTransformer
       overrides = {
         :parameters => o.operations.map{ |x| @@evaluator.evaluate(x, scope)}.flatten,
         :file       => o.file,
-        :line       => [o.line, o.pos],
+        :line       => o.line,
         :source     => scope.source,
         :scope      => scope
       }

data/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -231,7 +231,7 @@ class EvaluatorImpl
           values.fetch(lval) {|k| fail(Issues::MISSING_MULTI_ASSIGNMENT_KEY, o, :key =>k)},
           o, scope)
       end
-    elsif values.is_a?(Puppet::Pops::Types::PHostClassType)
+    elsif values.is_a?(Puppet::Pops::Types::PClassType)
       # assign variables from class variables
       # lookup class resource and return one or more parameter values
       # TODO: behavior when class_name is nil
@@ -305,7 +305,7 @@ class EvaluatorImpl
     nil
   end
 
-  # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
+  # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PTypeType
   #
   def eval_QualifiedReference(o, scope)
     type = Types::TypeParser.singleton.interpret(o)
@@ -479,7 +479,7 @@ class EvaluatorImpl
   def eval_AccessExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     keys = o.keys || []
-    if left.is_a?(Types::PHostClassType)
+    if left.is_a?(Types::PClassType)
       # Evaluate qualified references without errors no undefined types
       keys = keys.map {|key| key.is_a?(Model::QualifiedReference) ? Types::TypeParser.singleton.interpret(key) : evaluate(key, scope) }
     else
@@ -755,7 +755,7 @@ class EvaluatorImpl
 
       # must be a CatalogEntry subtype
       case evaluated_name
-      when Types::PHostClassType
+      when Types::PClassType
         unless evaluated_name.class_name.nil?
           fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end

data/lib/puppet/pops/evaluator/relationship_operator.rb

@@ -91,7 +91,7 @@ class RelationshipOperator
   end
 
   # Asserts (and returns) the type if it is a PCatalogEntryType
-  # (A PCatalogEntryType is the base class of PHostClassType, and PResourceType).
+  # (A PCatalogEntryType is the base class of PClassType, and PResourceType).
   #
   def assert_catalog_type(o, scope)
     unless @type_calculator.assignable?(@catalog_type, o)

data/lib/puppet/pops/evaluator/runtime3_converter.rb

@@ -127,9 +127,9 @@ class Runtime3Converter
   # Ensures that resources are *not* absolute.
   #
   def catalog_type_to_split_type_title(catalog_type)
-    split_type = catalog_type.is_a?(Puppet::Pops::Types::PType) ? catalog_type.type : catalog_type
+    split_type = catalog_type.is_a?(Puppet::Pops::Types::PTypeType) ? catalog_type.type : catalog_type
     case split_type
-      when Puppet::Pops::Types::PHostClassType
+      when Puppet::Pops::Types::PClassType
         class_name = split_type.class_name
         ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
       when Puppet::Pops::Types::PResourceType
@@ -143,7 +143,7 @@ class Runtime3Converter
           [type_name.nil? ? nil : type_name.sub(/^::/, '').downcase, title.nil? ? '' : title]
         end
       else
-        raise ArgumentError, "Cannot split the type #{catalog_type.class}, it represents neither a PHostClassType, nor a PResourceType."
+        raise ArgumentError, "Cannot split the type #{catalog_type.class}, it represents neither a PClassType, nor a PResourceType."
     end
   end
 

data/lib/puppet/pops/evaluator/runtime3_resource_support.rb

@@ -60,7 +60,7 @@ module Runtime3ResourceSupport
         # Classes are evaluated immediately
         scope.compiler.evaluate_classes([resource_title], scope, false) if resolved_type == CLASS_STRING
 
-        # Turn the resource into a PType (a reference to a resource type)
+        # Turn the resource into a PTypeType (a reference to a resource type)
         # weed out nil's
         resource_to_ptype(resource)
     end

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

@@ -179,7 +179,7 @@ module ModuleLoaders
         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)
+          ts.resolve(self)
           te = get_entry(typed_name)
           return te unless te.nil?
         end

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

@@ -141,8 +141,7 @@ class StaticLoader < Loader
 
   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) }
+    aliases.each { |type| type.resolve(self) }
   end
 end
 end

data/lib/puppet/pops/loaders.rb

@@ -110,8 +110,7 @@ class Loaders
       type
     end
     # Resolve lazy so that all types can cross reference each other
-    parser = Types::TypeParser.singleton
-    types.each { |type| type.resolve(parser, loader) }
+    types.each { |type| type.resolve(loader) }
   end
 
   # Register the given type with the Runtime3TypeLoader. The registration will not happen unless

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

@@ -157,7 +157,7 @@ class Context
           tf.callable([0, 0], tf.iterable(tf.tuple([key_type, tf.any])))),
         'cached_file_data' => tf.callable(tf.string, tf.optional(tf.callable([1, 1])))
       }
-    ).resolve(Types::TypeParser.singleton, loader)
+    ).resolve(loader)
   end
 
   # Mainly for test purposes. Makes it possible to create a {Context} in Puppet code provided that a current {Invocation} exists.