puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

data/lib/puppet/functions/regsubst.rb

@@ -1,44 +1,33 @@
+# frozen_string_literal: true
+
 # Performs regexp replacement on a string or array of strings.
-#
-# @param target [String, Array[String]]
-#      The string or array of strings to operate on.  If an array, the replacement will be
-#      performed on each of the elements in the array, and the return value will be an array.
-# @param pattern [String, Regexp, Type[Regexp]]
-#      The regular expression matching the target string.  If you want it anchored at the start
-#      and or end of the string, you must do that with ^ and $ yourself.
-# @param replacement [String, Hash[String, String]]
-#      Replacement string. Can contain backreferences to what was matched using \\0 (whole match),
-#      \\1 (first set of parentheses), and so on.
-#      If the second argument is a Hash, and the matched text is one of its keys, the corresponding value is the replacement string.
-# @param flags [Optional[Pattern[/^[GEIM]*$/]], Pattern[/^G?$/]]
-#      Optional. String of single letter flags for how the regexp is interpreted (E, I, and M cannot be used
-#      if pattern is a precompiled regexp):
-#        - *E*         Extended regexps
-#        - *I*         Ignore case in regexps
-#        - *M*         Multiline regexps
-#        - *G*         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
-# @param encoding [Enum['N','E','S','U']]
-#      Optional. How to handle multibyte characters when compiling the regexp (must not be used when pattern is a
-#      precompiled regexp). A single-character string with the following values:
-#        - *N*         None
-#        - *E*         EUC
-#        - *S*         SJIS
-#        - *U*         UTF-8
-# @return [Array[String], String] The result of the substitution. Result type is the same as for the target parameter.
-#
-# @example Get the third octet from the node's IP address:
-#
-# ```puppet
-# $i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')
-# ```
-#
-# @example Put angle brackets around each octet in the node's IP address:
-#
-# ```puppet
-# $x = regsubst($ipaddress, /([0-9]+)/, '<\\1>', 'G')
-# ```
-#
 Puppet::Functions.create_function(:regsubst) do
+  # @param target [String]
+  #      The string or array of strings to operate on.  If an array, the replacement will be
+  #      performed on each of the elements in the array, and the return value will be an array.
+  # @param pattern [String, Regexp, Type[Regexp]]
+  #      The regular expression matching the target string.  If you want it anchored at the start
+  #      and or end of the string, you must do that with ^ and $ yourself.
+  # @param replacement [String, Hash[String, String]]
+  #      Replacement string. Can contain backreferences to what was matched using \\0 (whole match),
+  #      \\1 (first set of parentheses), and so on.
+  #      If the second argument is a Hash, and the matched text is one of its keys, the corresponding value is the replacement string.
+  # @param flags [Optional[Pattern[/^[GEIM]*$/]], Pattern[/^G?$/]]
+  #      Optional. String of single letter flags for how the regexp is interpreted (E, I, and M cannot be used
+  #      if pattern is a precompiled regexp):
+  #        - *E*         Extended regexps
+  #        - *I*         Ignore case in regexps
+  #        - *M*         Multiline regexps
+  #        - *G*         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
+  # @param encoding [Enum['N','E','S','U']]
+  #      Deprecated and ignored parameter, only here for compatibility.
+  # @return [Array[String], String] The result of the substitution. Result type is the same as for the target parameter.
+  # @deprecated
+  #   This method has the optional encoding parameter, which is ignored.
+  # @example Get the third octet from the node's IP address:
+  #   ```puppet
+  #   $i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')
+  #   ```
   dispatch :regsubst_string do
     param          'Variant[Array[String],String]',       :target
     param          'String',                              :pattern
@@ -47,6 +36,28 @@ Puppet::Functions.create_function(:regsubst) do
     optional_param "Enum['N','E','S','U']",               :encoding
   end
 
+  # @param target [String, Array[String]]
+  #      The string or array of strings to operate on.  If an array, the replacement will be
+  #      performed on each of the elements in the array, and the return value will be an array.
+  # @param pattern [Regexp, Type[Regexp]]
+  #      The regular expression matching the target string.  If you want it anchored at the start
+  #      and or end of the string, you must do that with ^ and $ yourself.
+  # @param replacement [String, Hash[String, String]]
+  #      Replacement string. Can contain backreferences to what was matched using \\0 (whole match),
+  #      \\1 (first set of parentheses), and so on.
+  #      If the second argument is a Hash, and the matched text is one of its keys, the corresponding value is the replacement string.
+  # @param flags [Optional[Pattern[/^[GEIM]*$/]], Pattern[/^G?$/]]
+  #      Optional. String of single letter flags for how the regexp is interpreted (E, I, and M cannot be used
+  #      if pattern is a precompiled regexp):
+  #        - *E*         Extended regexps
+  #        - *I*         Ignore case in regexps
+  #        - *M*         Multiline regexps
+  #        - *G*         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
+  # @return [Array[String], String] The result of the substitution. Result type is the same as for the target parameter.
+  # @example Put angle brackets around each octet in the node's IP address:
+  #   ```puppet
+  #   $x = regsubst($ipaddress, /([0-9]+)/, '<\\1>', 'G')
+  #   ```
   dispatch :regsubst_regexp do
     param          'Variant[Array[String],String]',       :target
     param          'Variant[Regexp,Type[Regexp]]',        :pattern
@@ -55,9 +66,16 @@ Puppet::Functions.create_function(:regsubst) do
   end
 
   def regsubst_string(target, pattern, replacement, flags = nil, encoding = nil)
+    if encoding
+      Puppet.warn_once(
+        'deprecations', 'regsubst_function_encoding',
+        _("The regsubst() function's encoding argument has been ignored since Ruby 1.9 and will be removed in a future release")
+      )
+    end
+
     re_flags = 0
     operation = :sub
-    if !flags.nil?
+    unless flags.nil?
       flags.split(//).each do |f|
         case f
         when 'G' then operation = :gsub
@@ -67,11 +85,11 @@ Puppet::Functions.create_function(:regsubst) do
         end
       end
     end
-    inner_regsubst(target, Regexp.compile(pattern, re_flags, encoding), replacement, operation)
+    inner_regsubst(target, Regexp.compile(pattern, re_flags), replacement, operation)
   end
 
   def regsubst_regexp(target, pattern, replacement, flags = nil)
-    pattern = (pattern.pattern || '') if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
+    pattern = pattern.pattern || '' if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
     inner_regsubst(target, pattern, replacement, flags == 'G' ? :gsub : :sub)
   end
 

data/lib/puppet/functions/require.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 # Requires the specified classes.
 # Evaluate one or more classes, adding the required class as a dependency.
 #
 # The relationship metaparameters work well for specifying relationships
 # between individual resources, but they can be clumsy for specifying
 # relationships between classes.  This function is a superset of the
-# 'include' function, adding a class relationship so that the requiring
+# `include` function, adding a class relationship so that the requiring
 # class depends on the required class.
 #
-# Warning: using require in place of include can lead to unwanted dependency cycles.
+# Warning: using `require` in place of `include` can lead to unwanted dependency cycles.
 #
-# For instance the following manifest, with 'require' instead of 'include' would produce a nasty
-# dependence cycle, because notify imposes a before between File[/foo] and Service[foo]:
+# For instance, the following manifest, with `require` instead of `include`, would produce a nasty
+# dependence cycle, because `notify` imposes a `before` between `File[/foo]` and `Service[foo]`:
 #
 # ```puppet
 # class myservice {
@@ -32,7 +34,7 @@
 # resource and relationship expressions.
 #
 # - Since 4.0.0 Class and Resource types, absolute names
-# - Since 4.7.0 Returns an Array[Type[Class]] with references to the required classes
+# - Since 4.7.0 Returns an `Array[Type[Class]]` with references to the required classes
 #
 Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction) do
   dispatch :require_impl do
@@ -48,14 +50,15 @@ Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction)
     if Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
-        {:operation => 'require'})
+        { :operation => 'require' }
+      )
     end
 
     # Make call patterns uniform and protected against nested arrays, also make
     # names absolute if so desired.
     classes = scope.transform_and_assert_classnames(classes.flatten)
 
-    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
+    result = classes.map { |name| Puppet::Pops::Types::TypeFactory.host_class(name) }
 
     # This is the same as calling the include function (but faster) since it again
     # would otherwise need to perform the optional absolute name transformation
@@ -67,7 +70,8 @@ Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction)
     classes.each do |klass|
       # lookup the class in the scopes
       klass = (classobj = krt.find_hostclass(klass)) ? classobj.name : nil
-      raise Puppet::ParseError.new(_("Could not find class %{klass}") % { klass: klass }) unless klass
+      raise Puppet::ParseError, _("Could not find class %{klass}") % { klass: klass } unless klass
+
       ref = Puppet::Resource.new(:class, klass)
       resource = scope.resource
       resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)

data/lib/puppet/functions/return.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Makes iteration continue with the next value, optionally with a given value for this iteration.
 # If a value is not given it defaults to `undef`
 #

data/lib/puppet/functions/reverse_each.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Reverses the order of the elements of something that is iterable and optionally runs a
 # [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) for each
 # element.
@@ -84,7 +86,7 @@ Puppet::Functions.create_function(:reverse_each) do
 
   def reverse_each(iterable)
     # produces an Iterable
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable, true).reverse_each
   end
 
   def reverse_each_block(iterable, &block)

data/lib/puppet/functions/round.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Returns an `Integer` value rounded to the nearest value.
 # Takes a single `Numeric` value as an argument.
 #

data/lib/puppet/functions/rstrip.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Strips trailing spaces from a String
 #
 # This function is compatible with the stdlib function with the same name.
@@ -12,20 +14,19 @@
 #
 # @example Removing trailing space from a String
 # ```puppet
-# "hello\n\t".lstrip()
-# camelcase("hello\n\t")
+# " hello\n\t".rstrip()
+# rstrip(" 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"])
+# [" hello\n\t", " hi\n\t"].rstrip()
+# rstrip([" 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
@@ -48,7 +49,7 @@ Puppet::Functions.create_function(:rstrip) do
   end
 
   def on_iterable(a)
-    a.map {|x| do_rstrip(x) }
+    a.map { |x| do_rstrip(x) }
   end
 
   def do_rstrip(x)

data/lib/puppet/functions/scanf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Scans a string and returns an array of one or more converted values based on the given format string.
 # See the documentation of Ruby's String#scanf method for details about the supported formats (which
 # are similar but not identical to the formats used in Puppet's `sprintf` function.)

data/lib/puppet/functions/size.rb

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

data/lib/puppet/functions/slice.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Slices an array or hash into pieces of a given size.
 #
 # This function takes two mandatory arguments: the first should be an array or hash, and the second specifies
@@ -115,9 +117,10 @@ Puppet::Functions.create_function(:slice) do
     if serving_size == 0
       raise ArgumentError, _("slice(): block must define at least one parameter. Block has 0.")
     end
+
     unless serving_size == 1 || serving_size == slice_size
       raise ArgumentError, _("slice(): block must define one parameter, or the same number of parameters as the given size of the slice (%{slice_size}). Block has %{serving_size}; %{parameter_names}") %
-          { slice_size: slice_size, serving_size: serving_size, parameter_names: pblock.parameter_names.join(', ') }
+                           { slice_size: slice_size, serving_size: serving_size, parameter_names: pblock.parameter_names.join(', ') }
     end
     serving_size
   end

data/lib/puppet/functions/sort.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 # 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.
+# 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.
+# * 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)
 #
@@ -49,7 +51,7 @@
 #   }
 # })
 # ```
-# Would notice [2,3,'a','b']
+# Would notice `[2,3,'a','b']`
 #
 # @since 6.0.0 - supporting a lambda to do compare
 #

data/lib/puppet/functions/split.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Splits a string into an array using a given pattern.
 # The pattern can be a string, regexp or regexp type.
 #
@@ -35,6 +37,21 @@ Puppet::Functions.create_function(:split) do
     param 'Type[Regexp]', :pattern
   end
 
+  dispatch :split_String_sensitive do
+    param 'Sensitive[String]', :sensitive
+    param 'String', :pattern
+  end
+
+  dispatch :split_Regexp_sensitive do
+    param 'Sensitive[String]', :sensitive
+    param 'Regexp', :pattern
+  end
+
+  dispatch :split_RegexpType_sensitive do
+    param 'Sensitive[String]', :sensitive
+    param 'Type[Regexp]', :pattern
+  end
+
   def split_String(str, pattern)
     str.split(Regexp.compile(pattern))
   end
@@ -46,4 +63,16 @@ Puppet::Functions.create_function(:split) do
   def split_RegexpType(str, pattern)
     str.split(pattern.regexp)
   end
-end
+
+  def split_String_sensitive(sensitive, pattern)
+    Puppet::Pops::Types::PSensitiveType::Sensitive.new(split_String(sensitive.unwrap, pattern))
+  end
+
+  def split_Regexp_sensitive(sensitive, pattern)
+    Puppet::Pops::Types::PSensitiveType::Sensitive.new(split_Regexp(sensitive.unwrap, pattern))
+  end
+
+  def split_RegexpType_sensitive(sensitive, pattern)
+    Puppet::Pops::Types::PSensitiveType::Sensitive.new(split_RegexpType(sensitive.unwrap, pattern))
+  end
+end

data/lib/puppet/functions/step.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Provides stepping with given interval over elements in an iterable and optionally runs a
 # [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html) for each
 # element.
@@ -88,7 +90,7 @@ Puppet::Functions.create_function(:step) do
 
   def step(iterable, step)
     # produces an Iterable
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable, true).step(step)
   end
 
   def step_block(iterable, step, &block)

data/lib/puppet/functions/strftime.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Formats timestamp or timespan according to the directives in the given format string. The directives begins with a percent (%) character.
 # Any text not listed as a directive will be passed through to the output string.
 #
@@ -105,6 +107,7 @@
 # **Seconds since the Epoch:**
 #
 # | Format | Meaning |
+# | ------ | ------- |
 # | s | Number of seconds since 1970-01-01 00:00:00 UTC. |
 #
 # **Literal string:**
@@ -175,7 +178,7 @@
 # ```
 #
 # - Since 4.8.0
-# 
+#
 Puppet::Functions.create_function(:strftime) do
   dispatch :format_timespan do
     param 'Timespan', :time_object
@@ -204,8 +207,8 @@ Puppet::Functions.create_function(:strftime) do
   def legacy_strftime(format, timezone = nil)
     file, line = Puppet::Pops::PuppetStack.top_of_stack
     Puppet.warn_once('deprecations', 'legacy#strftime',
-      _('The argument signature (String format, [String timezone]) is deprecated for #strftime. See #strftime documentation and Timespan type for more info'),
-      file, line)
+                     _('The argument signature (String format, [String timezone]) is deprecated for #strftime. See #strftime documentation and Timespan type for more info'),
+                     file, line)
     Puppet::Pops::Time::Timestamp.format_time(format, Time.now.utc, timezone)
   end
 end

data/lib/puppet/functions/strip.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Strips leading and trailing spaces from a String
 #
 # This function is compatible with the stdlib function with the same name.
@@ -12,20 +14,19 @@
 #
 # @example Removing leading and trailing space from a String
 # ```puppet
-# " hello\n\t".lstrip()
-# camelcase(" hello\n\t")
+# " hello\n\t".strip()
+# strip(" 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"])
+# [" hello\n\t", " hi\n\t"].strip()
+# strip([" 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
@@ -48,7 +49,7 @@ Puppet::Functions.create_function(:strip) do
   end
 
   def on_iterable(a)
-    a.map {|x| do_strip(x) }
+    a.map { |x| do_strip(x) }
   end
 
   def do_strip(x)

data/lib/puppet/functions/then.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Calls a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 # with the given argument unless the argument is `undef`.
 # Returns `undef` if the argument is `undef`, and otherwise the result of giving the
@@ -72,6 +74,7 @@ Puppet::Functions.create_function(:then) do
 
   def then(arg)
     return nil if arg.nil?
+
     yield(arg)
   end
 end

data/lib/puppet/functions/tree_each.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Runs a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 # recursively and repeatedly using values from a data structure, then returns the unchanged data structure, or if
 # a lambda is not given, returns an `Iterator` for the tree.
@@ -6,13 +8,13 @@
 #
 # 1. An `Array`, `Hash`, `Iterator`, or `Object` that the function will iterate over.
 # 2. An optional hash with the options:
-#    * `include_containers` => `Optional[Boolean]` # default true - if containers should be given to the lambda
-#    * `include_values` => `Optional[Boolean]` # default true - if non containers should be given to the lambda
-#    * `include_root` => `Optional[Boolean]` # default true - if the root container should be given to the lambda
+#    * `include_containers` => `Optional[Boolean]` # default `true` - if containers should be given to the lambda
+#    * `include_values` => `Optional[Boolean]` # default `true` - if non containers should be given to the lambda
+#    * `include_root` => `Optional[Boolean]` # default `true` - if the root container should be given to the lambda
 #    * `container_type` => `Optional[Type[Variant[Array, Hash, Object]]]` # a type that determines what a container is - can only
 #       be set to a type that matches the default `Variant[Array, Hash, Object]`.
 #    * `order` => `Enum[depth_first, breadth_first]` # default ´depth_first`, the order in which elements are visited
-#    * `include_refs` => Optional[Boolean] # default `false`, if attributes in objects marked as bing of `reference` kind
+#    * `include_refs` => `Optional[Boolean]` # default `false`, if attributes in objects marked as bing of `reference` kind
 #       should be included.
 # 3. An optional lambda, which the function calls for each element in the first argument. It must
 #    accept one or two arguments; either `$path`, and `$value`, or just `$value`.
@@ -46,14 +48,12 @@
 # [1, [2, 3], 4]
 # ```
 #
-# Results in:
-#
-# If containers are skipped:
+# If containers are skipped, results in:
 #
 # * `depth_first` order `1`, `2`, `3`, `4`
 # * `breadth_first` order `1`, `4`,`2`, `3`
 #
-# If containers and root, are included:
+# If containers and root are included, results in:
 #
 # * `depth_first` order `[1, [2, 3], 4]`, `1`, `[2, 3]`, `2`, `3`, `4`
 # * `breadth_first` order `[1, [2, 3], 4]`, `1`, `[2, 3]`, `4`, `2`, `3`
@@ -96,7 +96,7 @@
 #
 # Any Puppet Type system data type can be used to filter what is
 # considered to be a container, but it must be a narrower type than one of
-# the default Array, Hash, Object types - for example it is not possible to make a
+# the default `Array`, `Hash`, `Object` types - for example it is not possible to make a
 # `String` be a container type.
 #
 # @example Only `Array` as container type
@@ -114,7 +114,6 @@
 # * `reverse_each` - get "leaves before root"
 # * `filter` - prune the tree
 # * `map` - transform each element
-# * `reduce` - produce something else
 #
 # Note than when chaining, the value passed on is a `Tuple` with `[path, value]`.
 #
@@ -143,7 +142,6 @@
 # @since 5.0.0
 #
 Puppet::Functions.create_function(:tree_each) do
-
   local_types do
     type "OptionsType  = Struct[{\
       container_type => Optional[Type],\
@@ -173,12 +171,12 @@ Puppet::Functions.create_function(:tree_each) do
   end
 
   def tree_Enumerable1(enum, options = {}, &block)
-    iterator(enum, options).each {|_, v| yield(v) }
+    iterator(enum, options).each { |_, v| yield(v) }
     enum
   end
 
   def tree_Enumerable2(enum, options = {}, &block)
-    iterator(enum, options).each {|path, v| yield(path, v) }
+    iterator(enum, options).each { |path, v| yield(path, v) }
     enum
   end
 

data/lib/puppet/functions/type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Returns the data type of a given value with a given degree of generality.
 #
 # ```puppet
@@ -35,10 +37,10 @@
 #
 # Would notice the four values:
 #
-# 1. 'Array[Numeric]'
-# 2. 'Array[Numeric, 2, 2]'
-# 3. 'Tuple[Float[3.14], Integer[42,42]]]'
-# 4. 'Tuple[Float[3.14], Integer[42,42]]]'
+# 1. `Array[Numeric]`
+# 2. `Array[Numeric, 2, 2]`
+# 3. `Tuple[Float[3.14], Integer[42,42]]]`
+# 4. `Tuple[Float[3.14], Integer[42,42]]]`
 #
 # @since 4.4.0
 #

data/lib/puppet/functions/unique.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Produces a unique set of values from an `Iterable` argument.
 #
 # * If the argument is a `String`, the unique set of characters are returned as a new `String`.
@@ -56,7 +58,7 @@
 # ['aBc', 'AbC', 'bbb'].unique |$x| { String($x,'%d') }
 #
 # # will produce {[a] => [10], [b, c, d, e] => [11, 12, 100]}
-# {a => 10, b => 11, c => 12, d => 100, e => 11}.unique |$v| { if $v > 10 { big } else { $v } } 
+# {a => 10, b => 11, c => 12, d => 100, e => 11}.unique |$v| { if $v > 10 { big } else { $v } }
 # ```
 #
 # Note that for `Hash` the result is slightly different than for the other data types. For those the result contains the
@@ -64,7 +66,7 @@
 # equality lambda (or the default value equality if no lambda was given). This makes the `unique` function more versatile for hashes
 # in general, while requiring that the simple computation of "hash's unique set of values" is performed as `$hsh.map |$k, $v| { $v }.unique`.
 # (A unique set of hash keys is in general meaningless (since they are unique by definition) - although if processed with a different
-# lambda for equality that would be different. First map the hash to an array of its keys if such a unique computation is wanted). 
+# lambda for equality that would be different. First map the hash to an array of its keys if such a unique computation is wanted).
 # If the more advanced clustering is wanted for one of the other data types, simply transform it into a `Hash` as shown in the
 # following example.
 #
@@ -109,20 +111,20 @@ Puppet::Functions.create_function(:unique) do
   end
 
   def unique_hash(hash, &block)
-    block = lambda {|v| v } unless block_given?
-    result = Hash.new {|h, k| h[k] = {:keys =>[], :values =>[]} }
-    hash.each_pair do |k,v|
-      rc = result[ block.call(v) ]
+    block = ->(v) { v } unless block_given?
+    result = Hash.new { |h, k| h[k] = { :keys => [], :values => [] } }
+    hash.each_pair do |k, v|
+      rc = result[block.call(v)]
       rc[:keys] << k
       rc[:values] << v
     end
     # reduce the set of possibly duplicated value entries
     inverted = {}
-    result.each_pair {|k,v| inverted[v[:keys]] = v[:values].uniq }
+    result.each_pair { |_k, v| inverted[v[:keys]] = v[:values].uniq }
     inverted
   end
 
-  def unique_array(array,&block)
+  def unique_array(array, &block)
     array.uniq(&block)
   end