openvox 8.19.0

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

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+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
+
+  # @api private
+  def implementation_class(create = true)
+    @base_type.implementation_class(create)
+  end
+
+  # @api private
+  def parameter_info(impl_class)
+    @base_type.parameter_info(impl_class)
+  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|
+      m = o.public_method(pn)
+      m.arity == 0 ? eval.match?(m.call, @parameters[pn]) : false
+    rescue NameError
+      false
+    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/lib/puppet/pops/types/p_runtime_type.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+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/lib/puppet/pops/types/p_sem_ver_range_type.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+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

data/lib/puppet/pops/types/p_sem_ver_type.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Types
+# A Puppet Language Type that exposes the {{SemanticPuppet::Version}} and {{SemanticPuppet::VersionRange}}.
+# The version type is parameterized with version ranges.
+#
+# @api public
+class PSemVerType < PScalarType
+  def self.register_ptype(loader, ir)
+    create_ptype(loader, ir, 'ScalarType',
+                 'ranges' => {
+                   KEY_TYPE => PArrayType.new(PVariantType.new([PSemVerRangeType::DEFAULT, PStringType::NON_EMPTY])),
+                   KEY_VALUE => []
+                 })
+  end
+
+  attr_reader :ranges
+
+  def initialize(ranges)
+    ranges = ranges.map { |range| range.is_a?(SemanticPuppet::VersionRange) ? range : SemanticPuppet::VersionRange.parse(range) }
+    ranges = merge_ranges(ranges) if ranges.size > 1
+    @ranges = ranges
+  end
+
+  def instance?(o, guard = nil)
+    o.is_a?(SemanticPuppet::Version) && (@ranges.empty? || @ranges.any? { |range| range.include?(o) })
+  end
+
+  def eql?(o)
+    self.class == o.class && @ranges == o.ranges
+  end
+
+  def hash?
+    super ^ @ranges.hash
+  end
+
+  # Creates a SemVer version from the given _version_ argument. If the argument is `nil` or
+  # a {SemanticPuppet::Version}, it is returned. If it is a {String}, it will be parsed into a
+  # {SemanticPuppet::Version}. Any other class will raise an {ArgumentError}.
+  #
+  # @param version [SemanticPuppet::Version,String,nil] the version to convert
+  # @return [SemanticPuppet::Version] the converted version
+  # @raise [ArgumentError] when the argument cannot be converted into a version
+  #
+  def self.convert(version)
+    case version
+    when nil, SemanticPuppet::Version
+      version
+    when String
+      SemanticPuppet::Version.parse(version)
+    else
+      raise ArgumentError, "Unable to convert a #{version.class.name} to a SemVer"
+    end
+  end
+
+  # @api private
+  def self.new_function(type)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_Version, type.loader) do
+      local_types do
+        type 'PositiveInteger = Integer[0,default]'
+        type 'SemVerQualifier = Pattern[/\A(?<part>[0-9A-Za-z-]+)(?:\.\g<part>)*\Z/]'
+        type "SemVerPattern = Pattern[/\\A#{SemanticPuppet::Version::REGEX_FULL}\\Z/]"
+        type 'SemVerHash = Struct[{major=>PositiveInteger,minor=>PositiveInteger,patch=>PositiveInteger,Optional[prerelease]=>SemVerQualifier,Optional[build]=>SemVerQualifier}]'
+      end
+
+      # Creates a SemVer from a string as specified by http://semver.org/
+      #
+      dispatch :from_string do
+        param 'SemVerPattern', :str
+      end
+
+      # Creates a SemVer from integers, prerelease, and build arguments
+      #
+      dispatch :from_args do
+        param 'PositiveInteger', :major
+        param 'PositiveInteger', :minor
+        param 'PositiveInteger', :patch
+        optional_param 'SemVerQualifier', :prerelease
+        optional_param 'SemVerQualifier', :build
+      end
+
+      # Same as #from_args but each argument is instead given in a Hash
+      #
+      dispatch :from_hash do
+        param 'SemVerHash', :hash_args
+      end
+
+      argument_mismatch :on_error do
+        param 'String', :str
+      end
+
+      def from_string(str)
+        SemanticPuppet::Version.parse(str)
+      end
+
+      def from_args(major, minor, patch, prerelease = nil, build = nil)
+        SemanticPuppet::Version.new(major, minor, patch, to_array(prerelease), to_array(build))
+      end
+
+      def from_hash(hash)
+        SemanticPuppet::Version.new(hash['major'], hash['minor'], hash['patch'], to_array(hash['prerelease']), to_array(hash['build']))
+      end
+
+      def on_error(str)
+        _("The string '%{str}' cannot be converted to a SemVer") % { str: str }
+      end
+
+      private
+
+      def to_array(component)
+        component ? [component] : nil
+      end
+    end
+  end
+
+  DEFAULT = PSemVerType.new(EMPTY_ARRAY)
+
+  protected
+
+  def _assignable?(o, guard)
+    return false unless o.instance_of?(self.class)
+    return true if @ranges.empty?
+    return false if o.ranges.empty?
+
+    # All ranges in o must be covered by at least one range in self
+    o.ranges.all? do |o_range|
+      @ranges.any? do |range|
+        PSemVerRangeType.covered_by?(o_range, range)
+      end
+    end
+  end
+
+  # @api private
+  def merge_ranges(ranges)
+    result = []
+    until ranges.empty?
+      unmerged = []
+      x = ranges.pop
+      result << ranges.inject(x) do |memo, y|
+        merged = PSemVerRangeType.merge(memo, y)
+        if merged.nil?
+          unmerged << y
+        else
+          memo = merged
+        end
+        memo
+      end
+      ranges = unmerged
+    end
+    result.reverse!
+  end
+end
+end
+end