puppet-retrospec 0.12.2 → 1.0.0

data/vendor/gems/puppet-4.5.2/lib/puppet/pops/types/p_runtime_type.rb

@@ -0,0 +1,102 @@
+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])])
+
+  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 == 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/vendor/gems/puppet-4.5.2/lib/puppet/pops/types/p_sem_ver_range_type.rb

@@ -0,0 +1,164 @@
+module Puppet::Pops
+module Types
+
+# An unparameterized type that represents all VersionRange instances
+#
+# @api public
+class PSemVerRangeType < PScalarType
+  # Check if a version is included in a version range. The version can be a string or
+  # a `Semantic::SemVer`
+  #
+  # @param range [Semantic::VersionRange] the range to match against
+  # @param version [Semantic::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 Semantic::Version
+      range.include?(version)
+    when String
+      begin
+        range.include?(Semantic::Version.parse(version))
+      rescue Semantic::Version::ValidationFailure
+        false
+      end
+    else
+      false
+    end
+  end
+
+  # Checks if range _a_ is a sub-range of (i.e. completely covered by) range _b_
+  # @param a [Semantic::VersionRange] the first range
+  # @param b [Semantic::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 [Semantic::VersionRange] the first range
+  # @param b [Semantic::VersionRange] the second range
+  # @return [Semantic::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
+      Semantic::VersionRange.new([a.begin, b.begin].min, max, exclude_end)
+    elsif a.exclude_end? && a.end == b.begin
+      # Adjacent, a before b
+      Semantic::VersionRange.new(a.begin, b.end, b.exclude_end?)
+    elsif b.exclude_end? && b.end == a.begin
+      # Adjacent, b before a
+      Semantic::VersionRange.new(b.begin, a.end, a.exclude_end?)
+    else
+      # No overlap
+      nil
+    end
+  end
+
+  def instance?(o, guard = nil)
+    o.is_a?(Semantic::VersionRange)
+  end
+
+  def eql?(o)
+    self.class == o.class
+  end
+
+  def hash?
+    super ^ @version_range.hash
+  end
+
+  def self.new_function(_, loader)
+    range_expr = "\\A#{range_pattern}\\Z"
+    @@new_function ||= Puppet::Functions.create_loaded_function(:new_VersionRange, 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 {{Semantic::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)
+        Semantic::VersionRange.parse(str)
+      end
+
+      def from_versions(min, max = :default, exclude_max = false)
+        min = Semantic::Version::MIN if min == :default
+        max = Semantic::Version::MAX if max == :default
+        Semantic::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/vendor/gems/puppet-4.5.2/lib/puppet/pops/types/p_sem_ver_type.rb

@@ -0,0 +1,113 @@
+module Puppet::Pops
+module Types
+
+# A Puppet Language Type that exposes the {{Semantic::Version}} and {{Semantic::VersionRange}}.
+# The version type is parameterized with version ranges.
+#
+# @api public
+class PSemVerType < PScalarType
+  attr_reader :ranges
+
+  def initialize(*ranges)
+    ranges = ranges.map { |range| range.is_a?(Semantic::VersionRange) ? range : Semantic::VersionRange.parse(range) }
+    ranges = merge_ranges(ranges) if ranges.size > 1
+    @ranges = ranges
+  end
+
+  def instance?(o, guard = nil)
+    o.is_a?(Semantic::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
+
+  # @api private
+  def self.new_function(_, loader)
+    @@new_function ||= Puppet::Functions.create_loaded_function(:new_Version, loader) do
+      local_types do
+        type 'PositiveInteger = Integer[0,default]'
+        type 'SemVerQualifier = Pattern[/\A(?<part>[0-9A-Za-z-]+)(?:\.\g<part>)*\Z/]'
+        type 'SemVerString = String[1]'
+        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 'SemVerString', :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
+
+      def from_string(str)
+        Semantic::Version.parse(str)
+      end
+
+      def from_args(major, minor, patch, prerelease = nil, build = nil)
+        Semantic::Version.new(major, minor, patch, prerelease, build)
+      end
+
+      def from_hash(hash)
+        Semantic::Version.new(hash['major'], hash['minor'], hash['patch'], hash['prerelease'], hash['build'])
+      end
+    end
+  end
+
+  DEFAULT = PSemVerType.new
+
+  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/vendor/gems/puppet-4.5.2/lib/puppet/pops/types/puppet_object.rb

@@ -0,0 +1,21 @@
+module Puppet::Pops
+module Types
+
+# Marker module for implementations that are mapped to Object types
+# @api public
+module PuppetObject
+  # Returns all classes that includes this module
+  def self.descendants
+    ObjectSpace.each_object(Class).select { |klass| klass < self }
+  end
+
+  # Returns the Puppet Type for this instance. The implementing class must
+  # add the {#_ptype} as a class method.
+  #
+  # @return [PObjectType] the type
+  def _ptype
+    self.class._ptype
+  end
+end
+end
+end

data/vendor/gems/puppet-4.5.2/lib/puppet/pops/types/recursion_guard.rb

@@ -0,0 +1,92 @@
+module Puppet::Pops
+module Types
+# Keeps track of self recursion of conceptual 'this' and 'that' instances using two separate maps and
+# a state. The class is used when tracking self recursion in two objects ('this' and 'that') simultaneously.
+# A typical example of when this is needed is when testing if 'that' Puppet Type is assignable to 'this'
+# Puppet Type since both types may contain self references.
+#
+# All comparisons are made using the `object_id` of the instance rather than the instance itself.
+#
+# @api private
+class RecursionGuard
+  attr_reader :state
+
+  NO_SELF_RECURSION = 0
+  SELF_RECURSION_IN_THIS = 1
+  SELF_RECURSION_IN_THAT = 2
+  SELF_RECURSION_IN_BOTH = 3
+
+  def initialize
+    @state = NO_SELF_RECURSION
+  end
+
+  # Checks if recursion was detected for the given argument in the 'this' context
+  # @param instance [Object] the instance to check
+  # @return [Integer] the resulting state
+  def recursive_this?(instance)
+    this_map[instance.object_id] == true
+  end
+
+  # Checks if recursion was detected for the given argument in the 'that' context
+  # @param instance [Object] the instance to check
+  # @return [Integer] the resulting state
+  def recursive_that?(instance)
+    that_map[instance.object_id] == true
+  end
+
+  # Add the given argument as 'this' and return the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Integer] the resulting state
+  def add_this(instance)
+    if (@state & SELF_RECURSION_IN_THIS) == 0
+      @state = @state | SELF_RECURSION_IN_THIS if map_put(this_map, instance)
+    end
+    @state
+  end
+
+  # Add the given argument as 'that' and return the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Integer] the resulting state
+  def add_that(instance)
+    if (@state & SELF_RECURSION_IN_THAT) == 0
+      @state = @state | SELF_RECURSION_IN_THAT if map_put(that_map, instance)
+    end
+    @state
+  end
+
+  # @return the number of objects added to the `this` map
+  def this_count
+    this_map.size
+  end
+
+  # @return the number of objects added to the `that` map
+  def that_count
+    that_map.size
+  end
+
+  private
+
+  def map_put(map, o)
+    id = o.object_id
+    case map[id]
+    when true
+      true # Recursion already detected
+    when false
+      map[id] = true
+      true # Recursion occured. This was the second time this entry was added
+    else
+      map[id] = false
+      false # First time add. No recursion
+    end
+  end
+
+  def this_map
+    @this_map ||= {}
+  end
+
+  def that_map
+    @that_map ||= {}
+  end
+end
+end
+end