bolt 0.19.1 → 0.20.0

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

@@ -1,149 +0,0 @@
-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, prerelease, build)
-      end
-
-      def from_hash(hash)
-        SemanticPuppet::Version.new(hash['major'], hash['minor'], hash['patch'], hash['prerelease'], hash['build'])
-      end
-
-      def on_error(str)
-        _("The string '%{str}' cannot be converted to a SemVer") % { str: str }
-      end
-    end
-  end
-
-  DEFAULT = PSemVerType.new(EMPTY_ARRAY)
-
-  protected
-
-  def _assignable?(o, guard)
-    return false unless o.class == 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

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

@@ -1,73 +0,0 @@
-module Puppet::Pops
-module Types
-
-# A Puppet Language type that wraps sensitive information. The sensitive type is parameterized by
-# the wrapped value type.
-#
-#
-# @api public
-class PSensitiveType < PTypeWithContainedType
-
-  class Sensitive
-    def initialize(value)
-      @value = value
-    end
-
-    def unwrap
-      @value
-    end
-
-    def to_s
-      "Sensitive [value redacted]"
-    end
-
-    def inspect
-      "#<#{to_s}>"
-    end
-  end
-
-  def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'AnyType')
-  end
-
-  def initialize(type = nil)
-    @type = type.nil? ? PAnyType.new : type.generalize
-  end
-
-  def instance?(o, guard = nil)
-    o.is_a?(Sensitive) && @type.instance?(o.unwrap, guard)
-  end
-
-  def self.new_function(type)
-    @new_function ||= Puppet::Functions.create_loaded_function(:new_Sensitive, type.loader) do
-
-      dispatch :from_sensitive do
-        param 'Sensitive', :value
-      end
-
-      dispatch :from_any do
-        param 'Any', :value
-      end
-
-      def from_any(value)
-        Sensitive.new(value)
-      end
-
-      # Since the Sensitive value is immutable we can reuse the existing instance instead of making a copy.
-      def from_sensitive(value)
-        value
-      end
-    end
-  end
-
-  private
-
-  def _assignable?(o, guard)
-    self.class == o.class && @type.assignable?(o.type, guard)
-  end
-
-  DEFAULT = PSensitiveType.new
-end
-
-end
-end

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

@@ -1,192 +0,0 @@
-module Puppet::Pops
-module Types
-  class PAbstractTimeDataType < PScalarType
-    # @param from [AbstractTime] lower bound for this type. Nil or :default means unbounded
-    # @param to [AbstractTime] upper bound for this type. Nil or :default means unbounded
-    def initialize(from, to = nil)
-      @from = convert_arg(from, true)
-      @to = convert_arg(to, false)
-      raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{@from}, #{@to}" unless @from <= @to
-    end
-
-    # Checks if this numeric range intersects with another
-    #
-    # @param o [PNumericType] the range to compare with
-    # @return [Boolean] `true` if this range intersects with the other range
-    # @api public
-    def intersect?(o)
-      self.class == o.class && !(@to < o.numeric_from || o.numeric_to < @from)
-    end
-
-    # Returns the lower bound of the numeric range or `nil` if no lower bound is set.
-    # @return [Float,Integer]
-    def from
-      @from == -Float::INFINITY ? nil : @from
-    end
-
-    # Returns the upper bound of the numeric range or `nil` if no upper bound is set.
-    # @return [Float,Integer]
-    def to
-      @to == Float::INFINITY ? nil : @to
-    end
-
-    # Same as #from but will return `-Float::Infinity` instead of `nil` if no lower bound is set.
-    # @return [Float,Integer]
-    def numeric_from
-      @from
-    end
-
-    # Same as #to but will return `Float::Infinity` instead of `nil` if no lower bound is set.
-    # @return [Float,Integer]
-    def numeric_to
-      @to
-    end
-
-    def hash
-      @from.hash ^ @to.hash
-    end
-
-    def eql?(o)
-      self.class == o.class && @from == o.numeric_from && @to == o.numeric_to
-    end
-
-    def unbounded?
-      @from == -Float::INFINITY && @to == Float::INFINITY
-    end
-
-    def convert_arg(arg, min)
-      case arg
-      when impl_class
-        arg
-      when Hash
-        impl_class.from_hash(arg)
-      when nil, :default
-        min ? -Float::INFINITY : Float::INFINITY
-      when String
-        impl_class.parse(arg)
-      when Integer
-        arg == impl_class.new(arg * Time::NSECS_PER_SEC)
-      when Float
-        arg == (min ? -Float::INFINITY : Float::INFINITY) ? arg : impl_class.new(arg * Time::NSECS_PER_SEC)
-      else
-        raise ArgumentError, "Unable to create a #{impl_class.name} from a #{arg.class.name}" unless arg.nil? || arg == :default
-        nil
-      end
-    end
-
-    # Concatenates this range with another range provided that the ranges intersect or
-    # are adjacent. When that's not the case, this method will return `nil`
-    #
-    # @param o [PAbstractTimeDataType] the range to concatenate with this range
-    # @return [PAbstractTimeDataType,nil] the concatenated range or `nil` when the ranges were apart
-    # @api public
-    def merge(o)
-      if intersect?(o) || adjacent?(o)
-        new_min = numeric_from <= o.numeric_from ? numeric_from : o.numeric_from
-        new_max = numeric_to >= o.numeric_to ? numeric_to : o.numeric_to
-        self.class.new(new_min, new_max)
-      else
-        nil
-      end
-    end
-
-    def _assignable?(o, guard)
-      self.class == o.class && numeric_from <= o.numeric_from && numeric_to >= o.numeric_to
-    end
-  end
-
-  class PTimespanType < PAbstractTimeDataType
-    def self.register_ptype(loader, ir)
-      create_ptype(loader, ir, 'ScalarType',
-        'from' => { KEY_TYPE => POptionalType.new(PTimespanType::DEFAULT), KEY_VALUE => nil },
-        'to' => { KEY_TYPE => POptionalType.new(PTimespanType::DEFAULT), KEY_VALUE => nil }
-      )
-    end
-
-    def self.new_function(type)
-      @new_function ||= Puppet::Functions.create_loaded_function(:new_timespan, type.loader) do
-        local_types do
-          type 'Formats = Variant[String[2],Array[String[2], 1]]'
-        end
-
-        dispatch :from_seconds do
-          param           'Variant[Integer,Float]', :seconds
-        end
-
-        dispatch :from_string do
-          param           'String[1]', :string
-          optional_param  'Formats', :format
-        end
-
-        dispatch :from_fields do
-          param          'Integer', :days
-          param          'Integer', :hours
-          param          'Integer', :minutes
-          param          'Integer', :seconds
-          optional_param 'Integer', :milliseconds
-          optional_param 'Integer', :microseconds
-          optional_param 'Integer', :nanoseconds
-        end
-
-        dispatch :from_string_hash do
-          param <<-TYPE, :hash_arg
-            Struct[{
-              string => String[1],
-              Optional[format] => Formats
-            }]
-          TYPE
-        end
-
-        dispatch :from_fields_hash do
-          param <<-TYPE, :hash_arg
-            Struct[{
-              Optional[negative] => Boolean,
-              Optional[days] => Integer,
-              Optional[hours] => Integer,
-              Optional[minutes] => Integer,
-              Optional[seconds] => Integer,
-              Optional[milliseconds] => Integer,
-              Optional[microseconds] => Integer,
-              Optional[nanoseconds] => Integer
-            }]
-          TYPE
-        end
-
-        def from_seconds(seconds)
-          Time::Timespan.new((seconds * Time::NSECS_PER_SEC).to_i)
-        end
-
-        def from_string(string, format = Time::Timespan::Format::DEFAULTS)
-          Time::Timespan.parse(string, format)
-        end
-
-        def from_fields(days, hours, minutes, seconds, milliseconds = 0, microseconds = 0, nanoseconds = 0)
-          Time::Timespan.from_fields(false, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds)
-        end
-
-        def from_string_hash(args_hash)
-          Time::Timespan.from_string_hash(args_hash)
-        end
-
-        def from_fields_hash(args_hash)
-          Time::Timespan.from_fields_hash(args_hash)
-        end
-      end
-    end
-
-    def generalize
-      DEFAULT
-    end
-
-    def impl_class
-      Time::Timespan
-    end
-
-    def instance?(o, guard = nil)
-      o.is_a?(Time::Timespan) && o >= @from && o <= @to
-    end
-
-    DEFAULT = PTimespanType.new(nil, nil)
-  end
-end
-end

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

@@ -1,73 +0,0 @@
-module Puppet::Pops
-module Types
-  class PTimestampType < PAbstractTimeDataType
-    def self.register_ptype(loader, ir)
-      create_ptype(loader, ir, 'ScalarType',
-        'from' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil },
-        'to' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil }
-      )
-    end
-
-    def self.new_function(type)
-      @new_function ||= Puppet::Functions.create_loaded_function(:new_timestamp, type.loader) do
-        local_types do
-          type 'Formats = Variant[String[2],Array[String[2], 1]]'
-        end
-
-        dispatch :now do
-        end
-
-        dispatch :from_seconds do
-          param 'Variant[Integer,Float]', :seconds
-        end
-
-        dispatch :from_string do
-          param           'String[1]', :string
-          optional_param  'Formats',   :format
-          optional_param  'String[1]', :timezone
-        end
-
-        dispatch :from_string_hash do
-          param <<-TYPE, :hash_arg
-            Struct[{
-              string => String[1],
-              Optional[format] => Formats,
-              Optional[timezone] => String[1]
-            }]
-          TYPE
-        end
-
-        def now
-          Time::Timestamp.now
-        end
-
-        def from_string(string, format = :default, timezone = nil)
-          Time::Timestamp.parse(string, format, timezone)
-        end
-
-        def from_string_hash(args_hash)
-          Time::Timestamp.from_hash(args_hash)
-        end
-
-        def from_seconds(seconds)
-          Time::Timestamp.new((seconds * Time::NSECS_PER_SEC).to_i)
-        end
-      end
-    end
-
-    def generalize
-      DEFAULT
-    end
-
-    def impl_class
-      Time::Timestamp
-    end
-
-    def instance?(o, guard = nil)
-      o.is_a?(Time::Timestamp) && o >= @from && o <= @to
-    end
-
-    DEFAULT = PTimestampType.new(nil, nil)
-  end
-end
-end