bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/functions/compare.rb

@@ -1,125 +0,0 @@
-# Compares two values and returns -1, 0 or 1 if first value is smaller, equal or larger than the second value.
-# The compare function accepts arguments of the data types `String`, `Numeric`, `Timespan`, `Timestamp`, and `Semver`,
-# such that:
-#
-# * two of the same data type can be compared
-# * `Timespan` and `Timestamp` can be compared with each other and with `Numeric`
-#
-# When comparing two `String` values the comparison can be made to consider case by passing a third (optional)
-# boolean `false` value - the default is `true` which ignores case as the comparison operators
-# in the Puppet Language.
-#
-Puppet::Functions.create_function(:compare) do
-  local_types do
-    type 'TimeComparable = Variant[Numeric, Timespan, Timestamp]'
-    type 'Comparable = Variant[String, Semver, TimeComparable]'
-  end
-
-  dispatch :on_numeric do
-    param 'Numeric', :a
-    param 'Numeric', :b
-  end
-
-  dispatch :on_string do
-    param 'String', :a
-    param 'String', :b
-    optional_param 'Boolean', :ignore_case
-  end
-
-  dispatch :on_version do
-    param 'Semver', :a
-    param 'Semver', :b
-  end
-
-  dispatch :on_time_num_first do
-    param 'Numeric', :a
-    param 'Variant[Timespan, Timestamp]', :b
-  end
-
-  dispatch :on_timestamp do
-    param 'Timestamp', :a
-    param 'Variant[Timestamp, Numeric]', :b
-  end
-
-  dispatch :on_timespan do
-    param 'Timespan', :a
-    param 'Variant[Timespan, Numeric]', :b
-  end
-
-  argument_mismatch :on_error do
-    param 'Comparable', :a
-    param 'Comparable', :b
-    repeated_param 'Any', :ignore_case
-  end
-
-  argument_mismatch :on_not_comparable do
-    param 'Any', :a
-    param 'Any', :b
-    repeated_param 'Any', :ignore_case
-  end
-
-  def on_numeric(a, b)
-    a <=> b
-  end
-
-  def on_string(a, b, ignore_case = true)
-    if ignore_case
-      a.casecmp(b)
-    else
-      a <=> b
-    end
-  end
-
-  def on_version(a, b)
-    a <=> b
-  end
-
-  def on_time_num_first(a, b)
-    # Time data types can compare against Numeric but not the other way around
-    # the comparison is therefore done in reverse and the answer is inverted.
-    -(b <=> a)
-  end
-
-  def on_timespan(a, b)
-    a <=> b
-  end
-
-  def on_timestamp(a, b)
-    a <=> b
-  end
-
-  def on_not_comparable(a, b, *ignore_case)
-    # TRANSLATORS 'compare' is a name
-    _("compare(): Non comparable type. Only values of the types Numeric, String, Semver, Timestamp and Timestamp can be compared. Got %{type_a} and %{type_b}") % {
-      type_a: type_label(a), type_b: type_label(b)
-    }
-  end
-
-  def on_error(a, b, *ignore_case)
-    if !ignore_case.empty?
-      unless a.is_a?(String) && b.is_a?(String)
-        # TRANSLATORS 'compare' is a name
-        return _("compare(): The third argument (ignore case) can only be used when comparing strings")
-      end
-      unless ignore_case.size == 1
-        # TRANSLATORS 'compare' is a name
-        return _("compare(): Accepts at most 3 arguments, got %{actual_number}") % {actual_number: 2 + ignore_case.size}
-      end
-      unless ignore_case[0].is_a?(Boolean)
-        # TRANSLATORS 'compare' is a name
-        return _("compare(): The third argument (ignore case) must be a Boolean. Got %{type}") % { type: type_label(ignore_case[0]) }
-      end
-    end
-
-    if a.class != b.class
-      # TRANSLATORS 'compare' is a name
-      return _("compare(): Can only compare values of the same type (or for Timestamp/Timespan also against Numeric). Got %{type_a} and %{type_b}") % {
-        type_a: type_label(a), type_b: type_label(b)
-      }
-    end
-  end
-
-  def type_label(x)
-    Puppet::Pops::Model::ModelLabelProvider.new.label(x)
-  end
-end

data/vendored/puppet/lib/puppet/functions/contain.rb

@@ -1,55 +0,0 @@
-# Makes one or more classes be contained inside the current class.
-# If any of these classes are undeclared, they will be declared as if
-# there were declared with the `include` function.
-# Accepts a class name, an array of class names, or a comma-separated
-# list of class names.
-#
-# A contained class will not be applied before the containing class is
-# begun, and will be finished before the containing class is finished.
-#
-# You must use the class's full name;
-# relative names are not allowed. In addition to names in string form,
-# you may also directly use `Class` and `Resource` `Type`-values that are produced by
-# evaluating resource and relationship expressions.
-#
-# The function returns an array of references to the classes that were contained thus
-# allowing the function call to `contain` to directly continue.
-#
-# - Since 4.0.0 support for `Class` and `Resource` `Type`-values, absolute names
-# - Since 4.7.0 a value of type `Array[Type[Class[n]]]` is returned with all the contained classes
-#
-Puppet::Functions.create_function(:contain, Puppet::Functions::InternalFunction) do
-  dispatch :contain do
-    scope_param
-    # The function supports what the type system sees as Ruby runtime objects, and
-    # they cannot be parameterized to find what is actually valid instances.
-    # The validation is instead done in the function body itself via a call to
-    # `transform_and_assert_classnames` on the calling scope.
-    required_repeated_param 'Any', :names
-  end
-
-  def contain(scope, *classes)
-    if Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
-        {:operation => 'contain'})
-    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) }
-    containing_resource = scope.resource
-
-    # This is the same as calling the include function but faster and does not rely on the include
-    # function.
-    (scope.compiler.evaluate_classes(classes, scope, false) || []).each do |resource|
-      if ! scope.catalog.edge?(containing_resource, resource)
-        scope.catalog.add_edge(containing_resource, resource)
-      end
-    end
-    # Result is an Array[Class, 1, n] which allows chaining other operations
-    result
-  end
-end

data/vendored/puppet/lib/puppet/functions/convert_to.rb

@@ -1,34 +0,0 @@
-# The `convert_to(value, type)` is a convenience function that does the same as `new(type, value)`.
-# The difference in the argument ordering allows it to be used in chained style for
-# improved readability "left to right".
-#
-# When the function is given a lambda, it is called with the converted value, and the function
-# returns what the lambda returns, otherwise the converted value.
-#
-# @example 'convert_to' instead of 'new'
-#
-# ```puppet
-#   # The harder to read variant:
-#   # Using new operator - that is "calling the type" with operator ()
-#   Hash(Array("abc").map |$i,$v| { [$i, $v] })
-#
-#   # The easier to read variant:
-#   # using 'convert_to'
-#   "abc".convert_to(Array).map |$i,$v| { [$i, $v] }.convert_to(Hash)
-# ```
-#
-# @since 5.4.0
-#
-Puppet::Functions.create_function(:convert_to) do
-  dispatch :convert_to do
-    param 'Any', :value
-    param 'Type', :type
-    optional_repeated_param 'Any', :args
-    optional_block_param 'Callable[1,1]', :block
-  end
-
-  def convert_to(value, type, *args, &block)
-    result = call_function('new', type, value, *args)
-    block_given? ? yield(result) : result
-  end
-end

data/vendored/puppet/lib/puppet/functions/crit.rb

@@ -1,14 +0,0 @@
-# Logs a message on the server at level `crit`.
-Puppet::Functions.create_function(:crit, Puppet::Functions::InternalFunction) do
-  # @param values The values to log.
-  # @return [Undef]
-  dispatch :crit do
-    scope_param
-    repeated_param 'Any', :values
-    return_type 'Undef'
-  end
-
-  def crit(scope, *values)
-    Puppet::Util::Log.log_func(scope, :crit, values)
-  end
-end

data/vendored/puppet/lib/puppet/functions/debug.rb

@@ -1,14 +0,0 @@
-# Logs a message on the server at level `debug`.
-Puppet::Functions.create_function(:debug, Puppet::Functions::InternalFunction) do
-  # @param values The values to log.
-  # @return [Undef]
-  dispatch :debug do
-    scope_param
-    repeated_param 'Any', :values
-    return_type 'Undef'
-  end
-
-  def debug(scope, *values)
-    Puppet::Util::Log.log_func(scope, :debug, values)
-  end
-end

data/vendored/puppet/lib/puppet/functions/defined.rb

@@ -1,159 +0,0 @@
-# Determines whether a given class or resource type is defined and returns a Boolean
-# value. You can also use `defined` to determine whether a specific resource is defined,
-# or whether a variable has a value (including `undef`, as opposed to the variable never
-# being declared or assigned).
-#
-# This function takes at least one string argument, which can be a class name, type name,
-# resource reference, or variable reference of the form `'$name'`. (Note that the `$` sign
-# is included in the string which must be in single quotes to prevent the `$` character
-# to be interpreted as interpolation.
-#
-# The `defined` function checks both native and defined types, including types
-# provided by modules. Types and classes are matched by their names. The function matches
-# resource declarations by using resource references.
-#
-# @example Different types of `defined` function matches
-#
-# ```puppet
-# # Matching resource types
-# defined("file")
-# defined("customtype")
-#
-# # Matching defines and classes
-# defined("foo")
-# defined("foo::bar")
-#
-# # Matching variables (note the single quotes)
-# defined('$name')
-#
-# # Matching declared resources
-# defined(File['/tmp/file'])
-# ```
-#
-# Puppet depends on the configuration's evaluation order when checking whether a resource
-# is declared.
-#
-# @example Importance of evaluation order when using `defined`
-#
-# ```puppet
-# # Assign values to $is_defined_before and $is_defined_after using identical `defined`
-# # functions.
-#
-# $is_defined_before = defined(File['/tmp/file'])
-#
-# file { "/tmp/file":
-#   ensure => present,
-# }
-#
-# $is_defined_after = defined(File['/tmp/file'])
-#
-# # $is_defined_before returns false, but $is_defined_after returns true.
-# ```
-#
-# This order requirement only refers to evaluation order. The order of resources in the
-# configuration graph (e.g. with `before` or `require`) does not affect the `defined`
-# function's behavior.
-#
-# > **Warning:** Avoid relying on the result of the `defined` function in modules, as you
-# > might not be able to guarantee the evaluation order well enough to produce consistent
-# > results. This can cause other code that relies on the function's result to behave
-# > inconsistently or fail.
-#
-# If you pass more than one argument to `defined`, the function returns `true` if _any_
-# of the arguments are defined. You can also match resources by type, allowing you to
-# match conditions of different levels of specificity, such as whether a specific resource
-# is of a specific data type.
-#
-# @example Matching multiple resources and resources by different types with `defined`
-#
-# ```puppet
-# file { "/tmp/file1":
-#   ensure => file,
-# }
-#
-# $tmp_file = file { "/tmp/file2":
-#   ensure => file,
-# }
-#
-# # Each of these statements return `true` ...
-# defined(File['/tmp/file1'])
-# defined(File['/tmp/file1'],File['/tmp/file2'])
-# defined(File['/tmp/file1'],File['/tmp/file2'],File['/tmp/file3'])
-# # ... but this returns `false`.
-# defined(File['/tmp/file3'])
-#
-# # Each of these statements returns `true` ...
-# defined(Type[Resource['file','/tmp/file2']])
-# defined(Resource['file','/tmp/file2'])
-# defined(File['/tmp/file2'])
-# defined('$tmp_file')
-# # ... but each of these returns `false`.
-# defined(Type[Resource['exec','/tmp/file2']])
-# defined(Resource['exec','/tmp/file2'])
-# defined(File['/tmp/file3'])
-# defined('$tmp_file2')
-# ```
-#
-# @since 2.7.0
-# @since 3.6.0 variable reference and future parser types
-# @since 3.8.1 type specific requests with future parser
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunction) do
-
-  dispatch :is_defined do
-    scope_param
-    required_repeated_param 'Variant[String, Type[CatalogEntry], Type[Type[CatalogEntry]]]', :vals
-  end
-
-  def is_defined(scope, *vals)
-    vals.any? do |val|
-      case val
-      when String
-        if val =~ /^\$(.+)$/
-          scope.exist?($1)
-        else
-          case val
-          when ''
-            next nil
-          when 'main'
-            # Find the main class (known as ''), it does not have to be in the catalog
-            Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_main_class(scope)
-          else
-            # Find a resource type, definition or class definition
-            Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type_or_class(scope, val)
-          end
-        end
-      when Puppet::Resource
-        # Find instance of given resource type and title that is in the catalog
-        scope.compiler.findresource(val.resource_type, val.title)
-
-      when Puppet::Pops::Types::PResourceType
-        raise ArgumentError, _('The given resource type is a reference to all kind of types') if val.type_name.nil?
-        type = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, val.type_name)
-        val.title.nil? ? type : scope.compiler.findresource(type, val.title)
-
-      when Puppet::Pops::Types::PClassType
-        raise  ArgumentError, _('The given class type is a reference to all classes') if val.class_name.nil?
-        scope.compiler.findresource(:class, val.class_name)
-
-      when Puppet::Pops::Types::PTypeType
-        case val.type
-        when Puppet::Pops::Types::PResourceType
-          # It is most reasonable to take Type[File] and Type[File[foo]] to mean the same as if not wrapped in a Type
-          # Since the difference between File and File[foo] already captures the distinction of type vs instance.
-          is_defined(scope, val.type)
-
-        when Puppet::Pops::Types::PClassType
-          # Interpreted as asking if a class (and nothing else) is defined without having to be included in the catalog
-          # (this is the same as asking for just the class' name, but with the added certainty that it cannot be a defined type.
-          #
-          raise  ArgumentError, _('The given class type is a reference to all classes') if val.type.class_name.nil?
-          Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_hostclass(scope, val.type.class_name)
-        end
-      else
-        raise ArgumentError, _("Invalid argument of type '%{value_class}' to 'defined'") % { value_class: val.class }
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/functions/dig.rb

@@ -1,67 +0,0 @@
-# Returns a value for a sequence of given keys/indexes into a structure, such as
-# an array or hash.
-#
-# This function is used to "dig into" a complex data structure by
-# using a sequence of keys / indexes to access a value from which
-# the next key/index is accessed recursively.
-#
-# The first encountered `undef` value or key stops the "dig" and `undef` is returned.
-#
-# An error is raised if an attempt is made to "dig" into
-# something other than an `undef` (which immediately returns `undef`), an `Array` or a `Hash`.
-#
-# @example Using `dig`
-#
-# ```puppet
-# $data = {a => { b => [{x => 10, y => 20}, {x => 100, y => 200}]}}
-# notice $data.dig('a', 'b', 1, 'x')
-# ```
-#
-# Would notice the value 100.
-#
-# This is roughly equivalent to `$data['a']['b'][1]['x']`. However, a standard
-# index will return an error and cause catalog compilation failure if any parent
-# of the final key (`'x'`) is `undef`. The `dig` function will return `undef`,
-# rather than failing catalog compilation. This allows you to check if data
-# exists in a structure without mandating that it always exists.
-#
-# @since 4.5.0
-#
-Puppet::Functions.create_function(:dig) do
-  dispatch :dig do
-    param 'Optional[Collection]', :data
-    repeated_param 'Any', :arg
-  end
-
-  def dig(data, *args)
-    walked_path = []
-    args.reduce(data) do | d, k |
-      return nil if d.nil? || k.nil?
-      if !(d.is_a?(Array) || d.is_a?(Hash))
-        t = Puppet::Pops::Types::TypeCalculator.infer(d)
-        msg = _("The given data does not contain a Collection at %{walked_path}, got '%{type}'") % { walked_path: walked_path, type: t }
-        error_data = Puppet::DataTypes::Error.new(
-            msg,
-            'SLICE_ERROR',
-            {'walked_path' => walked_path, 'value_type' => t},
-            'EXPECTED_COLLECTION'
-        )
-        raise Puppet::ErrorWithData.new(error_data, msg)
-      end
-
-      walked_path << k
-      if d.is_a?(Array) && !k.is_a?(Integer)
-        t = Puppet::Pops::Types::TypeCalculator.infer(k)
-        msg = _("The given data requires an Integer index at %{walked_path}, got '%{type}'") % { walked_path: walked_path, type: t }
-        error_data = Puppet::DataTypes::Error.new(
-            msg,
-            'SLICE_ERROR',
-            {'walked_path' => walked_path, 'index_type' => t},
-            'EXPECTED_INTEGER_INDEX'
-        )
-        raise Puppet::ErrorWithData.new(error_data, msg)
-      end
-      d[k]
-    end
-  end
-end