bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/pops/types/p_object_type_extension.rb

@@ -1,218 +0,0 @@
-module Puppet::Pops
-module Types
-
-# Base class for Parameterized Object implementations. The wrapper impersonates the base
-# object and extends it with methods to filter assignable types and instances based on parameter
-# values.
-#
-# @api public
-class PObjectTypeExtension < PAnyType
-  include TypeWithMembers
-
-  def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'AnyType',
-      'base_type' => {
-        KEY_TYPE => PTypeType::DEFAULT
-      },
-      'init_parameters' => {
-        KEY_TYPE => PArrayType::DEFAULT
-      }
-    )
-  end
-
-  attr_reader :base_type, :parameters
-
-  # @api private
-  def self.create(base_type, init_parameters)
-    impl_class = Loaders.implementation_registry.module_for_type("#{base_type.name}TypeExtension") || self
-    impl_class.new(base_type, init_parameters)
-  end
-
-  # Creates an array of type parameters from the attributes of the given instance that matches the
-  # type parameters by name. Type parameters for which there is no matching attribute
-  # will have `nil` in their corresponding position on the array. The array is then passed
-  # as the `init_parameters` argument in a call to `create`
-  #
-  # @return [PObjectTypeExtension] the created extension
-  # @api private
-  def self.create_from_instance(base_type, instance)
-    type_parameters = base_type.type_parameters(true)
-    attrs = base_type.attributes(true)
-    params = type_parameters.keys.map do |pn|
-      attr = attrs[pn]
-      attr.nil? ? nil : instance.send(pn)
-    end
-    create(base_type, params)
-  end
-
-  def [](name)
-    @base_type[name]
-  end
-
-  # @api private
-  def initialize(base_type, init_parameters)
-    pts = base_type.type_parameters(true)
-    raise Puppet::ParseError, _('The %{label}-Type cannot be parameterized using []') % { label: base_type.label } if pts.empty?
-    @base_type = base_type
-
-    named_args = init_parameters.size == 1 && init_parameters[0].is_a?(Hash)
-    if named_args
-      # Catch case when first parameter is an assignable Hash
-      named_args = pts.size >= 1 && !pts.values[0].type.instance?(init_parameters[0])
-    end
-
-    by_name = {}
-    if named_args
-      hash = init_parameters[0]
-      hash.each_pair do |pn, pv|
-        tp = pts[pn]
-        if tp.nil?
-          raise Puppet::ParseError, _("'%{pn}' is not a known type parameter for %{label}-Type") % { pn: pn, label: base_type.label }
-        end
-        by_name[pn] = check_param(tp, pv) unless pv == :default
-      end
-    else
-      pts.values.each_with_index do |tp, idx|
-        if idx < init_parameters.size
-          pv = init_parameters[idx]
-          by_name[tp.name] = check_param(tp, pv) unless pv == :default
-        end
-      end
-    end
-    if by_name.empty?
-      raise Puppet::ParseError, _('The %{label}-Type cannot be parameterized using an empty parameter list') % { label: base_type.label }
-    end
-    @parameters = by_name
-  end
-
-  def check_param(type_param, v)
-    TypeAsserter.assert_instance_of(nil, type_param.type, v) { type_param.label }
-  end
-
-  # Return the parameter values as positional arguments with unset values as :default. The
-  # array is stripped from trailing :default values
-  # @return [Array] the parameter values
-  # @api private
-  def init_parameters
-    pts = @base_type.type_parameters(true)
-    if pts.size > 2
-      @parameters
-    else
-      result = pts.values.map do |tp|
-        pn = tp.name
-        @parameters.include?(pn) ? @parameters[pn] : :default
-      end
-      # Remove trailing defaults
-      result.pop while result.last == :default
-      result
-    end
-  end
-
-  # @api private
-  def eql?(o)
-    super(o) && @base_type.eql?(o.base_type) && @parameters.eql?(o.parameters)
-  end
-
-  # @api private
-  def generalize
-    @base_type
-  end
-
-  # @api private
-  def hash
-    @base_type.hash ^ @parameters.hash
-  end
-
-  # @api private
-  def loader
-    @base_type.loader
-  end
-
-  # @api private
-  def check_self_recursion(originator)
-    @base_type.check_self_recursion(originator)
-  end
-
-  # @api private
-  def create(*args)
-    @base_type.create(*args)
-  end
-
-  # @api private
-  def instance?(o, guard = nil)
-    @base_type.instance?(o, guard) && test_instance?(o, guard)
-  end
-
-  # @api private
-  def new_function
-    @base_type.new_function
-  end
-
-  # @api private
-  def simple_name
-    @base_type.simple_name
-  end
-
-  protected
-
-  # Checks that the given `param_values` hash contains all keys present in the `parameters` of
-  # this instance and that each keyed value is a match for the given parameter. The match is done
-  # using case expression semantics.
-  #
-  # This method is only called when a given type is found to be assignable to the base type of
-  # this extension.
-  #
-  # @param param_values[Hash] the parameter values of the assignable type
-  # @param guard[RecursionGuard] guard against endless recursion
-  # @return [Boolean] true or false to indicate assignability
-  # @api public
-  def test_assignable?(param_values, guard)
-    # Default implementation performs case expression style matching of all parameter values
-    # provided that the value exist (this should always be the case, since all defaults have
-    # been assigned at this point)
-    eval = Parser::EvaluatingParser.singleton.evaluator
-    @parameters.keys.all? do |pn|
-      if param_values.include?(pn)
-        a = param_values[pn]
-        b = @parameters[pn]
-        eval.match?(a, b) || a.is_a?(PAnyType) && b.is_a?(PAnyType) && b.assignable?(a)
-      else
-        false
-      end
-    end
-  end
-
-  # Checks that the given instance `o` has one attribute for each key present in the `parameters` of
-  # this instance and that each attribute value is a match for the given parameter. The match is done
-  # using case expression semantics.
-  #
-  # This method is only called when the given value is found to be an instance of the base type of
-  # this extension.
-  #
-  # @param o [Object] the instance to test
-  # @param guard[RecursionGuard] guard against endless recursion
-  # @return [Boolean] true or false to indicate if the value is an instance or not
-  # @api public
-  def test_instance?(o, guard)
-    eval = Parser::EvaluatingParser.singleton.evaluator
-    @parameters.keys.all? do |pn|
-      begin
-        m = o.public_method(pn)
-        m.arity == 0 ? eval.match?(m.call, @parameters[pn]) : false
-      rescue NameError
-        false
-      end
-    end
-  end
-
-  # @api private
-  def _assignable?(o, guard = nil)
-    if o.is_a?(PObjectTypeExtension)
-      @base_type.assignable?(o.base_type, guard) && test_assignable?(o.parameters, guard)
-    else
-      @base_type.assignable?(o, guard) && test_assignable?(EMPTY_HASH, guard)
-    end
-  end
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/types/p_runtime_type.rb

@@ -1,115 +0,0 @@
-module Puppet::Pops
-module Types
-
-# @api public
-class PRuntimeType < PAnyType
-  TYPE_NAME_OR_PATTERN = PVariantType.new([PStringType::NON_EMPTY, PTupleType.new([PRegexpType::DEFAULT, PStringType::NON_EMPTY])])
-
-  def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'AnyType',
-      'runtime' => {
-        KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
-        KEY_VALUE => nil
-      },
-      'name_or_pattern' => {
-        KEY_TYPE => POptionalType.new(TYPE_NAME_OR_PATTERN),
-        KEY_VALUE => nil
-      }
-    )
-  end
-
-  attr_reader :runtime, :name_or_pattern
-
-  # Creates a new instance of a Runtime type
-  #
-  # @param runtime [String] the name of the runtime, e.g. 'ruby'
-  # @param name_or_pattern [String,Array(Regexp,String)] name of runtime or two patterns, mapping Puppet name => runtime name
-  # @api public
-  def initialize(runtime, name_or_pattern)
-    unless runtime.nil? || runtime.is_a?(Symbol)
-      runtime = TypeAsserter.assert_instance_of("Runtime 'runtime'", PStringType::NON_EMPTY, runtime).to_sym
-    end
-    @runtime = runtime
-    @name_or_pattern = TypeAsserter.assert_instance_of("Runtime 'name_or_pattern'", TYPE_NAME_OR_PATTERN, name_or_pattern, true)
-  end
-
-  def hash
-    @runtime.hash ^ @name_or_pattern.hash
-  end
-
-  def eql?(o)
-    self.class == o.class && @runtime == o.runtime && @name_or_pattern == o.name_or_pattern
-  end
-
-  def instance?(o, guard = nil)
-    assignable?(TypeCalculator.infer(o), guard)
-  end
-
-  def iterable?(guard = nil)
-    if @runtime == :ruby && !runtime_type_name.nil?
-      begin
-        c = ClassLoader.provide(self)
-        return c < Iterable unless c.nil?
-      rescue ArgumentError
-      end
-    end
-    false
-  end
-
-  def iterable_type(guard = nil)
-    iterable?(guard) ? PIterableType.new(self) : nil
-  end
-
-  # @api private
-  def runtime_type_name
-    @name_or_pattern.is_a?(String) ? @name_or_pattern : nil
-  end
-
-  # @api private
-  def class_or_module
-    raise "Only ruby classes or modules can be produced by this runtime, got '#{runtime}" unless runtime == :ruby
-    raise 'A pattern based Runtime type cannot produce a class or module' if @name_or_pattern.is_a?(Array)
-    com = ClassLoader.provide(self)
-    raise "The name #{@name_or_pattern} does not represent a ruby class or module" if com.nil?
-    com
-  end
-
-  # @api private
-  def from_puppet_name(puppet_name)
-    if @name_or_pattern.is_a?(Array)
-      substituted = puppet_name.sub(*@name_or_pattern)
-      substituted == puppet_name ? nil : PRuntimeType.new(@runtime, substituted)
-    else
-      nil
-    end
-  end
-
-  DEFAULT = PRuntimeType.new(nil, nil)
-  RUBY = PRuntimeType.new(:ruby, nil)
-
-  protected
-
-  # Assignable if o's has the same runtime and the runtime name resolves to
-  # a class that is the same or subclass of t1's resolved runtime type name
-  # @api private
-  def _assignable?(o, guard)
-    return false unless o.is_a?(PRuntimeType)
-    return false unless @runtime.nil? || @runtime == o.runtime
-    return true if @name_or_pattern.nil? # t1 is wider
-
-    onp = o.name_or_pattern
-    return true if @name_or_pattern == onp
-    return false unless @name_or_pattern.is_a?(String) && onp.is_a?(String)
-
-    # NOTE: This only supports Ruby, must change when/if the set of runtimes is expanded
-    begin
-      c1 = ClassLoader.provide(self)
-      c2 = ClassLoader.provide(o)
-      c1.is_a?(Module) && c2.is_a?(Module) && !!(c2 <= c1)
-    rescue ArgumentError
-      false
-    end
-  end
-end
-end
-end

data/vendored/puppet/lib/puppet/pops/types/p_sem_ver_range_type.rb

@@ -1,190 +0,0 @@
-module Puppet::Pops
-module Types
-
-# An unparameterized type that represents all VersionRange instances
-#
-# @api public
-class PSemVerRangeType < PAnyType
-  def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'AnyType')
-  end
-
-  # Check if a version is included in a version range. The version can be a string or
-  # a `SemanticPuppet::SemVer`
-  #
-  # @param range [SemanticPuppet::VersionRange] the range to match against
-  # @param version [SemanticPuppet::Version,String] the version to match
-  # @return [Boolean] `true` if the range includes the given version
-  #
-  # @api public
-  def self.include?(range, version)
-    case version
-    when SemanticPuppet::Version
-      range.include?(version)
-    when String
-      begin
-        range.include?(SemanticPuppet::Version.parse(version))
-      rescue SemanticPuppet::Version::ValidationFailure
-        false
-      end
-    else
-      false
-    end
-  end
-
-  # Creates a {SemanticPuppet::VersionRange} from the given _version_range_ argument. If the argument is `nil` or
-  # a {SemanticPuppet::VersionRange}, it is returned. If it is a {String}, it will be parsed into a
-  # {SemanticPuppet::VersionRange}. Any other class will raise an {ArgumentError}.
-  #
-  # @param version_range [SemanticPuppet::VersionRange,String,nil] the version range to convert
-  # @return [SemanticPuppet::VersionRange] the converted version range
-  # @raise [ArgumentError] when the argument cannot be converted into a version range
-  #
-  def self.convert(version_range)
-    case version_range
-    when nil, SemanticPuppet::VersionRange
-      version_range
-    when String
-      SemanticPuppet::VersionRange.parse(version_range)
-    else
-      raise ArgumentError, "Unable to convert a #{version_range.class.name} to a SemVerRange"
-    end
-  end
-
-  # Checks if range _a_ is a sub-range of (i.e. completely covered by) range _b_
-  # @param a [SemanticPuppet::VersionRange] the first range
-  # @param b [SemanticPuppet::VersionRange] the second range
-  #
-  # @return [Boolean] `true` if _a_ is completely covered by _b_
-  def self.covered_by?(a, b)
-    b.begin <= a.begin && (b.end > a.end || b.end == a.end && (!b.exclude_end? || a.exclude_end?))
-  end
-
-  # Merge two ranges so that the result matches all versions matched by both. A merge
-  # is only possible when the ranges are either adjacent or have an overlap.
-  #
-  # @param a [SemanticPuppet::VersionRange] the first range
-  # @param b [SemanticPuppet::VersionRange] the second range
-  # @return [SemanticPuppet::VersionRange,nil] the result of the merge
-  #
-  # @api public
-  def self.merge(a, b)
-    if a.include?(b.begin) || b.include?(a.begin)
-      max = [a.end, b.end].max
-      exclude_end = false
-      if a.exclude_end?
-        exclude_end = max == a.end && (max > b.end || b.exclude_end?)
-      elsif b.exclude_end?
-        exclude_end = max == b.end && (max > a.end || a.exclude_end?)
-      end
-      SemanticPuppet::VersionRange.new([a.begin, b.begin].min, max, exclude_end)
-    elsif a.exclude_end? && a.end == b.begin
-      # Adjacent, a before b
-      SemanticPuppet::VersionRange.new(a.begin, b.end, b.exclude_end?)
-    elsif b.exclude_end? && b.end == a.begin
-      # Adjacent, b before a
-      SemanticPuppet::VersionRange.new(b.begin, a.end, a.exclude_end?)
-    else
-      # No overlap
-      nil
-    end
-  end
-
-  def roundtrip_with_string?
-    true
-  end
-
-  def instance?(o, guard = nil)
-    o.is_a?(SemanticPuppet::VersionRange)
-  end
-
-  def eql?(o)
-    self.class == o.class
-  end
-
-  def hash?
-    super ^ @version_range.hash
-  end
-
-  def self.new_function(type)
-    @new_function ||= Puppet::Functions.create_loaded_function(:new_VersionRange, type.loader) do
-      local_types do
-        type 'SemVerRangeString = String[1]'
-        type 'SemVerRangeHash = Struct[{min=>Variant[Default,SemVer],Optional[max]=>Variant[Default,SemVer],Optional[exclude_max]=>Boolean}]'
-      end
-
-      # Constructs a VersionRange from a String with a format specified by
-      #
-      # https://github.com/npm/node-semver#range-grammar
-      #
-      # The logical or || operator is not implemented since it effectively builds
-      # an array of ranges that may be disparate. The {{SemanticPuppet::VersionRange}} inherits
-      # from the standard ruby range. It must be possible to describe that range in terms
-      # of min, max, and exclude max.
-      #
-      # The Puppet Version type is parameterized and accepts multiple ranges so creating such
-      # constraints is still possible. It will just require several parameters rather than one
-      # parameter containing the '||' operator.
-      #
-      dispatch :from_string do
-        param 'SemVerRangeString', :str
-      end
-
-      # Constructs a VersionRange from a min, and a max version. The Boolean argument denotes
-      # whether or not the max version is excluded or included in the range. It is included by
-      # default.
-      #
-      dispatch :from_versions do
-        param 'Variant[Default,SemVer]', :min
-        param 'Variant[Default,SemVer]', :max
-        optional_param 'Boolean', :exclude_max
-      end
-
-      # Same as #from_versions but each argument is instead given in a Hash
-      #
-      dispatch :from_hash do
-        param 'SemVerRangeHash', :hash_args
-      end
-
-      def from_string(str)
-        SemanticPuppet::VersionRange.parse(str)
-      end
-
-      def from_versions(min, max = :default, exclude_max = false)
-        min = SemanticPuppet::Version::MIN if min == :default
-        max = SemanticPuppet::Version::MAX if max == :default
-        SemanticPuppet::VersionRange.new(min, max, exclude_max)
-      end
-
-      def from_hash(hash)
-        from_versions(hash['min'], hash.fetch('max') { :default }, hash.fetch('exclude_max') { false })
-      end
-    end
-  end
-
-  DEFAULT = PSemVerRangeType.new
-
-  protected
-
-  def _assignable?(o, guard)
-    self == o
-  end
-
-  def self.range_pattern
-    part = '(?<part>[0-9A-Za-z-]+)'
-    parts = "(?<parts>#{part}(?:\\.\\g<part>)*)"
-
-    qualifier = "(?:-#{parts})?(?:\\+\\g<parts>)?"
-
-    xr = '(?<xr>[xX*]|0|[1-9][0-9]*)'
-    partial = "(?<partial>#{xr}(?:\\.\\g<xr>(?:\\.\\g<xr>#{qualifier})?)?)"
-
-    hyphen = "(?:#{partial}\\s+-\\s+\\g<partial>)"
-    simple = "(?<simple>(?:<|>|>=|<=|~|\\^)?\\g<partial>)"
-
-    "#{hyphen}|#{simple}(?:\\s+\\g<simple>)*"
-  end
-  private_class_method :range_pattern
-end
-end
-end