puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/lib/puppet/functions/new.rb

@@ -991,17 +991,12 @@ Puppet::Functions.create_function(:new, Puppet::Functions::InternalFunction) do
 
   def new_instance(scope, t, *args)
     return args[0] if args.size == 1 && !t.is_a?(Puppet::Pops::Types::PInitType) && t.instance?(args[0])
-    result = assert_type(t, new_function_for_type(t).call(scope, *args))
+    result = assert_type(t, new_function_for_type(t, scope).call(scope, *args))
     return block_given? ? yield(result) : result
   end
 
-  def new_function_for_type(t)
-    @new_function_cache ||= {}
-
-    unless @new_function_cache.key?(t)
-      @new_function_cache[t] = t.new_function.new(nil, loader)
-    end
-
+  def new_function_for_type(t, scope)
+    @new_function_cache ||= Hash.new() {|hsh, key| hsh[key] = key.new_function.new(scope, loader) }
     @new_function_cache[t]
   end
 

data/lib/puppet/functions/reduce.rb

@@ -39,9 +39,11 @@
 # values to the lambda.
 #
 # Puppet calls the lambda for each of the data structure's remaining values. For each
-# call, it passes the result of the previous call as the first parameter (`$memo` in the
+# call, it passes the result of the previous call as the first parameter ($memo in the
 # above examples) and the next value from the data structure as the second parameter
-# (`$value`).
+# ($value).
+#
+# If the structure has one value, Puppet returns the value and does not call the lambda.
 #
 # @example Using the `reduce` function
 #

data/lib/puppet/functions/reverse_each.rb

@@ -84,7 +84,7 @@ Puppet::Functions.create_function(:reverse_each) do
 
   def reverse_each(iterable)
     # produces an Iterable
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable, true).reverse_each
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each
   end
 
   def reverse_each_block(iterable, &block)

data/lib/puppet/functions/round.rb

@@ -0,0 +1,24 @@
+# Returns an `Integer` value rounded to the nearest value.
+# Takes a single `Numeric` value as an argument.
+#
+# @example 'rounding a value'
+#
+# ```puppet
+# notice(round(2.9)) # would notice 3
+# notice(round(2.1)) # would notice 2
+# notice(round(-2.9)) # would notice -3
+# ```
+#
+Puppet::Functions.create_function(:round) do
+  dispatch :on_numeric do
+    param 'Numeric', :val
+  end
+
+  def on_numeric(x)
+    if x > 0
+      Integer(x + 0.5)
+    else
+      Integer(x - 0.5)
+    end
+  end
+end

data/lib/puppet/functions/rstrip.rb

@@ -0,0 +1,58 @@
+# Strips trailing spaces from a String
+#
+# This function is compatible with the stdlib function with the same name.
+#
+# The function does the following:
+# * For a `String` the conversion removes all trailing ASCII white space characters such as space, tab, newline, and return.
+#   It does not remove other space-like characters like hard space (Unicode U+00A0). (Tip, `/^[[:space:]]/` regular expression
+#   matches all space-like characters).
+# * For an `Iterable[Variant[String, Numeric]]` (for example an `Array`) each value is processed and the conversion is not recursive.
+# * If the value is `Numeric` it is simply returned (this is for backwards compatibility).
+# * An error is raised for all other data types.
+#
+# @example Removing trailing space from a String
+# ```puppet
+# "hello\n\t".lstrip()
+# camelcase("hello\n\t")
+# ```
+# Would both result in `"hello"`
+#
+# @example Removing trailing space from strings in an Array
+# ```puppet
+# ["hello\n\t", "hi\n\t"].lstrip()
+# lstrip(["hello\n\t", "hi\n\t"])
+# ```
+# Would both result in `['hello', 'hi']`
+#
+Puppet::Functions.create_function(:rstrip) do
+
+  dispatch :on_numeric do
+    param 'Numeric', :arg
+  end
+
+  dispatch :on_string do
+    param 'String', :arg
+  end
+
+  dispatch :on_iterable do
+    param 'Iterable[Variant[String, Numeric]]', :arg
+  end
+
+  # unit function - since the old implementation skipped Numeric values
+  def on_numeric(n)
+    n
+  end
+
+  def on_string(s)
+    s.rstrip
+  end
+
+  def on_iterable(a)
+    a.map {|x| do_rstrip(x) }
+  end
+
+  def do_rstrip(x)
+    # x can only be a String or Numeric because type constraints have been automatically applied
+    x.is_a?(String) ? x.rstrip : x
+  end
+end

data/lib/puppet/functions/size.rb

@@ -0,0 +1,15 @@
+# The same as length() - returns the size of an Array, Hash, String, or Binary value.
+#
+# @since 6.0.0 - also supporting Binary
+#
+Puppet::Functions.create_function(:size) do
+  dispatch :generic_size do
+    param 'Variant[Collection, String, Binary]', :arg
+  end
+
+
+  def generic_size(arg)
+    call_function('length', arg)
+  end
+
+end

data/lib/puppet/functions/sort.rb

@@ -0,0 +1,74 @@
+# Sorts an Array numerically or lexicographically or the characters of a String lexicographically.
+# Please note: This function is based on Ruby String comparison and as such may not be entirely UTF8 compatible.
+# To ensure compatibility please use this function with Ruby 2.4.0 or greater - https://bugs.ruby-lang.org/issues/10085.
+#
+# This function is compatible with the function sort() in stdlib.
+# * Comparison of characters in a string always uses a system locale and may not be what is expected for a particular locale
+# * Sorting is based on Ruby's <=> operator unless a lambda is given that performs the comparison.
+#   * comparison of strings is case dependent (use lambda with `compare($a,$b)` to ignore case)
+#   * comparison of mixed data types raises an error (if there is the need to sort mixed data types use a lambda)
+#
+# Also see the `compare()` function for information about comparable data types in general.
+#
+# @example Sorting a String
+#
+# ```puppet
+# notice(sort("xadb")) # notices 'abdx'
+# ```
+#
+# @example Sorting an Array
+#
+# ```puppet
+# notice(sort([3,6,2])) # notices [2, 3, 6]
+# ```
+#
+# @example Sorting with a lambda
+#
+# ```puppet
+# notice(sort([3,6,2]) |$a,$b| { compare($a, $b) }) # notices [2, 3, 6]
+# notice(sort([3,6,2]) |$a,$b| { compare($b, $a) }) # notices [6, 3, 2]
+# ```
+#
+# @example Case independent sorting with a lambda
+#
+# ```puppet
+# notice(sort(['A','b','C']))                                    # notices ['A', 'C', 'b']
+# notice(sort(['A','b','C']) |$a,$b| { compare($a, $b) })        # notices ['A', 'b', 'C']
+# notice(sort(['A','b','C']) |$a,$b| { compare($a, $b, true) })  # notices ['A', 'b', 'C']
+# notice(sort(['A','b','C']) |$a,$b| { compare($a, $b, false) }) # notices ['A','C', 'b']
+# ```
+#
+# @example Sorting Array with Numeric and String so that numbers are before strings
+#
+# ```puppet
+# notice(sort(['b', 3, 'a', 2]) |$a, $b| {
+#   case [$a, $b] {
+#     [String, Numeric] : { 1 }
+#     [Numeric, String] : { -1 }
+#     default:            { compare($a, $b) }
+#   }
+# })
+# ```
+# Would notice [2,3,'a','b']
+#
+# @since 6.0.0 - supporting a lambda to do compare
+#
+Puppet::Functions.create_function(:sort) do
+  dispatch :sort_string do
+    param 'String', :string_value
+    optional_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :sort_array do
+    param 'Array', :array_value
+    optional_block_param 'Callable[2,2]', :block
+  end
+
+  def sort_string(s, &block)
+    sort_array(s.split(''), &block).join('')
+  end
+
+  def sort_array(a, &block)
+    a.sort(&block)
+  end
+end

data/lib/puppet/functions/step.rb

@@ -88,7 +88,7 @@ Puppet::Functions.create_function(:step) do
 
   def step(iterable, step)
     # produces an Iterable
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable, true).step(step)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step)
   end
 
   def step_block(iterable, step, &block)

data/lib/puppet/functions/strip.rb

@@ -0,0 +1,58 @@
+# Strips leading and trailing spaces from a String
+#
+# This function is compatible with the stdlib function with the same name.
+#
+# The function does the following:
+# * For a `String` the conversion removes all leading and trailing ASCII white space characters such as space, tab, newline, and return.
+#   It does not remove other space-like characters like hard space (Unicode U+00A0). (Tip, `/^[[:space:]]/` regular expression
+#   matches all space-like characters).
+# * For an `Iterable[Variant[String, Numeric]]` (for example an `Array`) each value is processed and the conversion is not recursive.
+# * If the value is `Numeric` it is simply returned (this is for backwards compatibility).
+# * An error is raised for all other data types.
+#
+# @example Removing leading and trailing space from a String
+# ```puppet
+# " hello\n\t".lstrip()
+# camelcase(" hello\n\t")
+# ```
+# Would both result in `"hello"`
+#
+# @example Removing trailing space from strings in an Array
+# ```puppet
+# [" hello\n\t", " hi\n\t"].lstrip()
+# lstrip([" hello\n\t", " hi\n\t"])
+# ```
+# Would both result in `['hello', 'hi']`
+#
+Puppet::Functions.create_function(:strip) do
+
+  dispatch :on_numeric do
+    param 'Numeric', :arg
+  end
+
+  dispatch :on_string do
+    param 'String', :arg
+  end
+
+  dispatch :on_iterable do
+    param 'Iterable[Variant[String, Numeric]]', :arg
+  end
+
+  # unit function - since the old implementation skipped Numeric values
+  def on_numeric(n)
+    n
+  end
+
+  def on_string(s)
+    s.strip
+  end
+
+  def on_iterable(a)
+    a.map {|x| do_strip(x) }
+  end
+
+  def do_strip(x)
+    # x can only be a String or Numeric because type constraints have been automatically applied
+    x.is_a?(String) ? x.strip : x
+  end
+end

data/lib/puppet/functions/upcase.rb

@@ -0,0 +1,89 @@
+# Converts a String, Array or Hash (recursively) into upper case.
+#
+# This function is compatible with the stdlib function with the same name.
+#
+# The function does the following:
+# * For a `String`, its upper case version is returned. This is done using Ruby system locale which handles some, but not all
+#   special international up-casing rules (for example German double-s ß is upcased to "SS", whereas upper case double-s
+#   is downcased to ß).
+# * For `Array` and `Hash` the conversion to upper case is recursive and each key and value must be convertible by
+#   this function.
+# * When a `Hash` is converted, some keys could result in the same key - in those cases, the
+#   latest key-value wins. For example if keys "aBC", and "abC" where both present, after upcase there would only be one
+#   key "ABC".
+# * If the value is `Numeric` it is simply returned (this is for backwards compatibility).
+# * An error is raised for all other data types.
+#
+# Please note: This function relies directly on Ruby's String implementation and as such may not be entirely UTF8 compatible.
+# To ensure best compatibility please use this function with Ruby 2.4.0 or greater - https://bugs.ruby-lang.org/issues/10085.
+#
+# @example Converting a String to upper case
+# ```puppet
+# 'hello'.upcase()
+# upcase('hello')
+# ```
+# Would both result in "HELLO"
+#
+# @example Converting an Array to upper case
+# ```puppet
+# ['a', 'b'].upcase()
+# upcase(['a', 'b'])
+# ```
+# Would both result in ['A', 'B']
+#
+# @example Converting a Hash to upper case
+# ```puppet
+# {'a' => 'hello', 'b' => 'goodbye'}.upcase()
+# ```
+# Would result in `{'A' => 'HELLO', 'B' => 'GOODBYE'}`
+#
+# @example Converting a recursive structure
+# ```puppet
+# ['a', 'b', ['c', ['d']], {'x' => 'y'}].upcase
+# ```
+# Would result in `['A', 'B', ['C', ['D']], {'X' => 'Y'}]`
+#
+Puppet::Functions.create_function(:upcase) do
+  local_types do
+    type 'StringData = Variant[String, Numeric, Array[StringData], Hash[StringData, StringData]]'
+  end
+
+  dispatch :on_numeric do
+    param 'Numeric', :arg
+  end
+
+  dispatch :on_string do
+    param 'String', :arg
+  end
+
+  dispatch :on_array do
+    param 'Array[StringData]', :arg
+  end
+
+  dispatch :on_hash do
+    param 'Hash[StringData, StringData]', :arg
+  end
+
+  # unit function - since the old implementation skipped Numeric values
+  def on_numeric(n)
+    n
+  end
+
+  def on_string(s)
+    s.upcase
+  end
+
+  def on_array(a)
+    a.map {|x| do_upcase(x) }
+  end
+
+  def on_hash(h)
+    result = {}
+    h.each_pair {|k,v| result[do_upcase(k)] = do_upcase(v) }
+    result
+  end
+
+  def do_upcase(x)
+    x.is_a?(String) ? x.upcase : call_function('upcase', x)
+  end
+end

data/lib/puppet/functions/yaml_data.rb

@@ -21,7 +21,7 @@ Puppet::Functions.create_function(:yaml_data) do
     path = options['path']
     context.cached_file_data(path) do |content|
       begin
-        data = YAML.load(content, path)
+        data = Puppet::Util::Yaml.safe_load(content, [Symbol], path)
         if data.is_a?(Hash)
           Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data)
         else
@@ -30,10 +30,9 @@ Puppet::Functions.create_function(:yaml_data) do
           Puppet.warning(msg)
           {}
         end
-      rescue YAML::SyntaxError => ex
-        # Psych errors includes the absolute path to the file, so no need to add that
-        # to the message
-        raise Puppet::DataBinding::LookupError, "Unable to parse #{ex.message}"
+      rescue Puppet::Util::Yaml::YamlLoadError => ex
+        # YamlLoadErrors include the absolute path to the file, so no need to add that
+        raise Puppet::DataBinding::LookupError, _("Unable to parse %{message}") % { message: ex.message }
       end
     end
   end

data/lib/puppet/gettext/config.rb

@@ -4,7 +4,7 @@ require 'puppet/file_system'
 module Puppet::GettextConfig
   LOCAL_PATH = File.absolute_path('../../../locales', File.dirname(__FILE__))
   POSIX_PATH = File.absolute_path('../../../../../share/locale', File.dirname(__FILE__))
-  WINDOWS_PATH = File.absolute_path('../../../../../../../puppet/share/locale', File.dirname(__FILE__))
+  WINDOWS_PATH = File.absolute_path('../../../../../../puppet/share/locale', File.dirname(__FILE__))
 
   # This is the only domain name that won't be a symbol, making it unique from environments.
   DEFAULT_TEXT_DOMAIN = 'default-text-domain'

data/lib/puppet/gettext/module_translations.rb

@@ -11,7 +11,7 @@ module Puppet::ModuleTranslations
     modules.each do |mod|
       next unless mod.forge_name && mod.has_translations?(Puppet::GettextConfig.current_locale)
 
-      module_name = mod.forge_name.tr('/', '-')
+      module_name = mod.forge_name.gsub('/', '-')
       if Puppet::GettextConfig.load_translations(module_name, mod.locale_directory, :po)
         Puppet.debug "Loaded translations for #{module_name}."
       elsif Puppet::GettextConfig.gettext_loaded?

data/lib/puppet/graph.rb

@@ -1,8 +1,6 @@
 module Puppet::Graph
   require 'puppet/graph/prioritizer'
   require 'puppet/graph/sequential_prioritizer'
-  require 'puppet/graph/title_hash_prioritizer'
-  require 'puppet/graph/random_prioritizer'
 
   require 'puppet/graph/simple_graph'
   require 'puppet/graph/rb_tree_map'

data/lib/puppet/graph/rb_tree_map.rb

@@ -213,8 +213,8 @@ class Puppet::Graph::RbTreeMap
           :color => @color,
         }
       }
-      h[:left] = left.to_hash if @left
-      h[:right] = right.to_hash if @right
+      h.merge!(:left => left.to_hash) if @left
+      h.merge!(:right => right.to_hash) if @right
       h
     end
 

data/lib/puppet/graph/simple_graph.rb

@@ -133,12 +133,11 @@ class Puppet::Graph::SimpleGraph
         else
           if s[:lowlink][vertex] == s[:index][vertex] then
             this_scc = []
-            loop do
+            begin
               top = s[:stack].pop
               s[:seen][top] = false
               this_scc << top
-              break if top == vertex
-            end
+            end until top == vertex
             s[:scc] << this_scc
           end
           recur.pop               # done with this node, finally.
@@ -438,13 +437,13 @@ class Puppet::Graph::SimpleGraph
   # rdot.rb. If an edge or vertex label is a kind of Hash then the keys
   # which match +dot+ properties will be used as well.
   def to_dot_graph(params = {})
-    params['name'] ||= self.class.name.tr(':','_')
+    params['name'] ||= self.class.name.gsub(/:/,'_')
     fontsize   = params['fontsize'] ? params['fontsize'] : '8'
     graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
     edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
     vertices.each do |v|
       name = v.ref
-      params = {'name'     => '"'+name+'"',
+      params = {'name'     => stringify(name),
         'fontsize' => fontsize,
         'label'    => name}
       v_label = v.ref
@@ -452,8 +451,8 @@ class Puppet::Graph::SimpleGraph
       graph << DOT::DOTNode.new(params)
     end
     edges.each do |e|
-      params = {'from'     => '"'+ e.source.ref + '"',
-        'to'       => '"'+ e.target.ref + '"',
+      params = {'from'     => stringify(e.source.ref),
+        'to'       => stringify(e.target.ref),
         'fontsize' => fontsize }
       e_label = e.ref
       params.merge!(e_label) if e_label and e_label.kind_of? Hash
@@ -462,6 +461,10 @@ class Puppet::Graph::SimpleGraph
     graph
   end
 
+  def stringify(s)
+    %("#{s.gsub('"', '\\"')}")
+  end
+
   # Output the dot format as a string
   def to_dot(params={}) to_dot_graph(params).to_s; end