puppet 3.8.7 → 4.0.0

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

@@ -5,7 +5,7 @@ require 'rgen/metamodel_builder'
 # This means it can load a class from a gem, or from puppet modules.
 #
 class Puppet::Pops::Types::ClassLoader
-  @autoloader = Puppet::Util::Autoload.new("ClassLoader", "", :wrap => false)
+  @autoloader = Puppet::Util::Autoload.new("ClassLoader", "")
 
   # Returns a Class given a fully qualified class name.
   # Lookup of class is never relative to the calling namespace.
@@ -89,7 +89,7 @@ class Puppet::Pops::Types::ClassLoader
     unless result.is_a?(Class)
       # Attempt to load it using the auto loader
       loaded_path = nil
-      if paths_for_name(name).find {|path| loaded_path = path; @autoloader.load(path) }
+      if paths_for_name(name_path).find {|path| loaded_path = path; @autoloader.load(path, Puppet.lookup(:current_environment)) }
         result = find_class(name_path)
         unless result.is_a?(Class)
           raise RuntimeError, "Loading of #{name} using relative path: '#{loaded_path}' did not create expected class"
@@ -110,12 +110,12 @@ class Puppet::Pops::Types::ClassLoader
     end
   end
 
-  def self.paths_for_name(fq_name)
-    [de_camel(fq_name), downcased_path(fq_name)]
-  end
-
-  def self.downcased_path(fq_name)
-    fq_name.to_s.gsub(/::/, '/').downcase
+  def self.paths_for_name(fq_named_parts)
+    # search two entries, one where all parts are decamelized, and one with names just downcased
+    # TODO:this is not perfect - it will not produce the correct mix if a mix of styles are used
+    # The alternative is to test many additional paths.
+    #
+    [fq_named_parts.map {|part| de_camel(part)}.join('/'), fq_named_parts.join('/').downcase ]
   end
 
   def self.de_camel(fq_name)

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

@@ -15,7 +15,7 @@ class Puppet::Pops::Types::Enumeration
     case o
     when String
       x = o.chars
-      # Ruby 1.8.7 returns Enumerable::Enumerator, Ruby 1.8.9 Enumerator, and 2.0.0 an Array
+      # Ruby 1.9.3 returns an Enumerator, and 2.0.0 an Array
       x.is_a?(Array) ? x.each : x
     when Integer
       o.times

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

@@ -0,0 +1,45 @@
+# Utility module for type assertion
+#
+module Puppet::Pops::Types::TypeAsserter
+  # Asserts that a type_to_check is assignable to required_type and raises
+  # a {Puppet::ParseError} if that's not the case
+  #
+  # @param subject [String] String to be prepended to the exception message
+  # @param expected_type [PAnyType] Expected type
+  # @param type_to_check [PAnyType] Type to check against the required type
+  # @return The type_to_check argument
+  #
+  def self.assert_assignable(subject, expected_type, type_to_check)
+    check_assignability(Puppet::Pops::Types::TypeCalculator.singleton, subject, expected_type, type_to_check)
+    type_to_check
+  end
+
+  # Asserts that a value is an instance of a given type and raises
+  # a {Puppet::ParseError} if that's not the case
+  #
+  # @param subject [String] String to be prepended to the exception message
+  # @param expected_type [PAnyType] Expected type for the value
+  # @param value [Object] Value to check
+  # @param nil_ok [Boolean] Can be true to allow nil value. Optional and defaults to false
+  # @return The value argument
+  #
+  def self.assert_instance_of(subject, expected_type, value, nil_ok = false)
+    if !(value.nil? && nil_ok)
+      tc = Puppet::Pops::Types::TypeCalculator.singleton
+      check_assignability(tc, subject, expected_type, tc.infer_set(value), true)
+    end
+    value
+  end
+
+  def self.check_assignability(tc, subject, expected_type, actual_type, inferred = false)
+    unless tc.assignable?(expected_type, actual_type)
+      # Do not give all the details for inferred types - i.e. format as Integer, instead of Integer[n, n] for exact
+      # value, which is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output).
+      #
+      actual_type = Puppet::Pops::Types::TypeCalculator.generalize!(actual_type) if inferred
+      raise Puppet::Pops::Types::TypeAssertionError.new(
+        "#{subject} value has wrong type, expected #{tc.string(expected_type)}, actual #{tc.string(actual_type)}", expected_type, actual_type)
+    end
+  end
+  private_class_method :check_assignability
+end

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

@@ -0,0 +1,26 @@
+module Puppet::Pops::Types
+  # Raised when an assertion of actual type against an expected type fails.
+  #
+  class TypeAssertionError < Puppet::Error
+
+    # Returns the expected type
+    # @return [PAnyType] expected type
+    attr_reader :expected_type
+
+    # Returns the actual type
+    # @return [PAnyType] actual type
+    attr_reader :actual_type
+
+    # Creates a new instance with a default message, expected, and actual types,
+    #
+    # @param message [String] The default message
+    # @param expected_type [PAnyType] The expected type
+    # @param actual_type [PAnyType] The actual type
+    #
+    def initialize(message, expected_type, actual_type)
+      super(message)
+      @expected_type = expected_type
+      @actual_type = actual_type
+    end
+  end
+end

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

@@ -99,7 +99,6 @@
 class Puppet::Pops::Types::TypeCalculator
 
   Types = Puppet::Pops::Types
-  TheInfinity = 1.0 / 0.0 # because the Infinity symbol is not defined
 
   # @api public
   def self.assignable?(t1, t2)
@@ -269,21 +268,14 @@ class Puppet::Pops::Types::TypeCalculator
     if t2.is_a?(Class)
       t2 = type(t2)
     end
-    t2_class = t2.class
-
     # Unit can be assigned to anything
-    return true if t2_class == Types::PUnitType
+    return true if t2.class == Types::PUnitType
 
-    if t2_class == Types::PVariantType
+    if t2.class == Types::PVariantType
       # Assignable if all contained types are assignable
       t2.types.all? { |vt| @@assignable_visitor.visit_this_1(self, t, vt) }
     else
-      # Turn NotUndef[T] into T when T is not assignable from Undef
-      if t2_class == Types::PNotUndefType && !(t2.type.nil? || assignable?(t2.type, @nil_t))
-        assignable?(t, t2.type)
-      else
-        @@assignable_visitor.visit_this_1(self, t, t2)
-      end
+      @@assignable_visitor.visit_this_1(self, t, t2)
     end
  end
 
@@ -361,23 +353,10 @@ class Puppet::Pops::Types::TypeCalculator
     # do nothing, there is nothing to change for most types
   end
 
-  # @return [Boolean] true if the given argument is contained in a struct element key
-  def is_struct_element_key?(o)
-    c = o.eContainer
-    if c.is_a?(Types::POptionalType)
-      o = c
-      c = c.eContainer
-    end
-    c.is_a?(Types::PStructElement) && c.key_type.equal?(o)
-  end
-  private :is_struct_element_key?
-
   def generalize_PStringType(o)
-    # Skip generalization if the string is contained in a PStructElement key.
-    unless is_struct_element_key?(o)
-      o.values = []
-      o.size_type = nil
-    end
+    o.values = []
+    o.size_type = nil
+    []
   end
 
   def generalize_PCollectionType(o)
@@ -454,13 +433,8 @@ class Puppet::Pops::Types::TypeCalculator
   def instance_of_PStringType(t, o)
     return false unless o.is_a?(String)
     # true if size compliant
-    size_t = t.size_type
-    if size_t.nil? || instance_of_PIntegerType(size_t, o.size)
-      values = t.values
-      values.empty? || values.include?(o)
-    else
-      false
-    end
+    size_t = t.size_type || @collection_default_size_t
+    instance_of_PIntegerType(size_t, o.size)
   end
 
   def instance_of_PTupleType(t, o)
@@ -477,18 +451,9 @@ class Puppet::Pops::Types::TypeCalculator
 
   def instance_of_PStructType(t, o)
     return false unless o.is_a?(Hash)
-    matched = 0
-    t.elements.all? do |e|
-      key = e.name
-      v = o[key]
-      if v.nil? && !o.include?(key)
-        # Entry is missing. Only OK when key is optional
-        assignable?(e.key_type, @nil_t)
-      else
-        matched += 1
-        instance_of(e.value_type, v)
-      end
-    end && matched == o.size
+    h = t.hashed_elements
+    # all keys must be present and have a value (even if nil/undef)
+    (o.keys - h.keys).empty? && h.all? { |k,v| instance_of(v, o[k]) }
   end
 
   def instance_of_PHashType(t, o)
@@ -505,10 +470,6 @@ class Puppet::Pops::Types::TypeCalculator
     instance_of(@data_variant_t, o)
   end
 
-  def instance_of_PNotUndefType(t, o)
-    !(o.nil? || o == :undef) && (t.type.nil? || instance_of(t.type, o))
-  end
-
   def instance_of_PUndefType(t, o)
     o.nil? || o == :undef
   end
@@ -617,8 +578,8 @@ class Puppet::Pops::Types::TypeCalculator
       t = Types::PIntegerType.new()
       from = [t1range[0], t2range[0]].min
       to = [t1range[1], t2range[1]].max
-      t.from = from unless from == TheInfinity
-      t.to = to unless to == TheInfinity
+      t.from = from unless from == Float::INFINITY
+      t.to = to unless to == Float::INFINITY
       return t
     end
 
@@ -629,15 +590,14 @@ class Puppet::Pops::Types::TypeCalculator
       t = Types::PFloatType.new()
       from = [t1range[0], t2range[0]].min
       to = [t1range[1], t2range[1]].max
-      t.from = from unless from == TheInfinity
-      t.to = to unless to == TheInfinity
+      t.from = from unless from == Float::INFINITY
+      t.to = to unless to == Float::INFINITY
       return t
     end
 
     if t1.is_a?(Types::PStringType) && t2.is_a?(Types::PStringType)
       t = Types::PStringType.new()
-      t.values = t1.values | t2.values unless t1.values.empty? || t2.values.empty?
-      t.size_type = common_type(t1.size_type, t2.size_type) unless t1.size_type.nil? || t2.size_type.nil?
+      t.values = t1.values | t2.values
       return t
     end
 
@@ -842,36 +802,19 @@ class Puppet::Pops::Types::TypeCalculator
   def infer_Proc(o)
     min = 0
     max = 0
-    if o.respond_to?(:parameters)
-      mapped_types = o.parameters.map do |p|
-        param_t = Types::PAnyType.new
-        case p[0]
-        when :rest
-          max = :default
-          break param_t
-        when :req
-          min += 1
-        end
-        max += 1
-      	param_t
-      end
-    else
-      # Cannot correctly compute the signature in Ruby 1.8.7 because arity for
-      # optional values is screwed up (there is no way to get the upper limit),
-      # an optional looks the same as a varargs.
-      arity = o.arity
-      if arity < 0
-        min = -arity - 1
-        max = :default # i.e. infinite (which is wrong when there are optional - flaw in 1.8.7)
-      else
-        min = max = arity
+    mapped_types = o.parameters.map do |p|
+      case p[0]
+      when :rest
+        max = :default
+        break @t
+      when :req
+        min += 1
       end
-      mapped_types = Array.new(min) { Types::PAnyType.new }
-    end
-    if min == 0 || min != max
-      mapped_types << min
-      mapped_types << max
+      max += 1
+      @t
     end
+    mapped_types << min
+    mapped_types << max
     Types::TypeFactory.callable(*mapped_types)
   end
 
@@ -886,8 +829,6 @@ class Puppet::Pops::Types::TypeCalculator
     case o
     when :default
       Types::PDefaultType.new()
-    when :undef
-      Types::PUndefType.new()
     else
       infer_Object(o)
     end
@@ -978,23 +919,27 @@ class Puppet::Pops::Types::TypeCalculator
       type.key_type = Types::PUndefType.new
       type.element_type = Types::PUndefType.new
       type.size_type = size_as_type(o)
-    elsif o.keys.all? {|k| instance_of_PStringType(@non_empty_string_t, k) }
-      type = Types::PStructType.new
-      type.elements = o.map do |k,v|
-        element = Types::PStructElement.new
-        element.key_type = infer_String(k)
-        element.value_type = infer_set(v)
-        element
-      end
     else
-      type = Types::PHashType.new
-      ktype = Types::PVariantType.new
-      ktype.types = o.keys.map {|k| infer_set(k) }
-      etype = Types::PVariantType.new
-      etype.types = o.values.map {|e| infer_set(e) }
-      type.key_type = unwrap_single_variant(ktype)
-      type.element_type = unwrap_single_variant(etype)
-      type.size_type = size_as_type(o)
+      if o.keys.find {|k| !instance_of_PStringType(@non_empty_string_t, k) }
+        type = Types::PHashType.new
+        ktype = Types::PVariantType.new
+        ktype.types = o.keys.map {|k| infer_set(k) }
+        etype = Types::PVariantType.new
+        etype.types = o.values.map {|e| infer_set(e) }
+        type.key_type = unwrap_single_variant(ktype)
+        type.element_type = unwrap_single_variant(etype)
+        type.size_type = size_as_type(o)
+      else
+        elements = []
+        o.each_pair do |k,v|
+          element = Types::PStructElement.new
+          element.name = k
+          element.type = infer_set(v)
+          elements << element
+        end
+        type = Types::PStructType.new
+        type.elements = elements
+      end
     end
     type
   end
@@ -1018,11 +963,6 @@ class Puppet::Pops::Types::TypeCalculator
     t2.is_a?(Types::PAnyType)
   end
 
-  # @api private
-  def assignable_PNotUndefType(t, t2)
-    !assignable?(t2, @nil_t) && (t.type.nil? || assignable?(t.type, t2))
-  end
-
   # @api private
   def assignable_PUndefType(t, t2)
     # Only undef/nil is assignable to nil type
@@ -1070,14 +1010,18 @@ class Puppet::Pops::Types::TypeCalculator
     from = range.from
     to = range.to
     x = from.nil? ? 1 : from
-    y = to.nil? ? TheInfinity : to
-    [x, y]
+    y = to.nil? ? Float::INFINITY : to
+    if x < y
+      [x, y]
+    else
+      [y, x]
+    end
   end
 
   # @api private
   def from_to_ordered(from, to)
-    x = (from.nil? || from == :default) ? -TheInfinity : from
-    y = (to.nil? || to == :default) ? TheInfinity : to
+    x = (from.nil? || from == :default) ? -Float::INFINITY : from
+    y = (to.nil? || to == :default) ? Float::INFINITY : to
     if x < y
       [x, y]
     else
@@ -1116,22 +1060,33 @@ class Puppet::Pops::Types::TypeCalculator
     if args_tuple.size_type
       raise ArgumentError, "Callable tuple may not have a size constraint when used as args"
     end
-    # Assume no block was given - i.e. it is nil, and its type is PUndefType
-    block_t = @nil_t
-    if self.class.is_kind_of_callable?(args_tuple.types.last)
-      # a split is needed to make it possible to use required, optional, and varargs semantics
-      # of the tuple type.
-      #
-      args_tuple = args_tuple.copy
-      # to drop the callable, it must be removed explicitly since this is an rgen array
-      args_tuple.removeTypes(block_t = args_tuple.types.last())
-    else
-      # no block was given, if it is required, the below will fail
+
+    params_tuple = callable_t.param_types
+    param_block_t = callable_t.block_type
+    arg_types = args_tuple.types
+    arg_block_t = arg_types.last()
+    if self.class.is_kind_of_callable?(arg_block_t)
+      # Can't pass a block to a callable that doesn't accept one
+      return false if param_block_t.nil?
+
+      # Check that the block is of the right tyṕe
+      return false unless assignable?(param_block_t, arg_block_t)
+
+      # Check other arguments
+      arg_count = arg_types.size - 1
+      params_size_t = params_tuple.size_type || Types::TypeFactory.range(*params_tuple.size_range)
+      return false unless assignable?(params_size_t, Types::TypeFactory.range(arg_count, arg_count))
+
+      ctypes = params_tuple.types
+      args_assignable = false
+      arg_count.times do |index|
+        return false unless assignable?((ctypes[index] || ctypes[-1]), arg_types[index])
+      end
+      return true
     end
-    # unless argument types match parameter types
-    return false unless assignable?(callable_t.param_types, args_tuple)
-    # can the given block be *called* with a signature requirement specified by callable_t?
-    assignable?(callable_t.block_type || @nil_t, block_t)
+
+    # Check that tuple is assignable and that the block (if declared) is optional
+    assignable?(params_tuple, args_tuple) &&  (param_block_t.nil? || assignable?(param_block_t, @nil_t))
   end
 
   # @api private
@@ -1148,17 +1103,6 @@ class Puppet::Pops::Types::TypeCalculator
     end
   end
 
-  # @api private
-  def self.is_kind_of_optional?(t, optional = true)
-    case t
-    when Types::POptionalType
-      true
-    when Types::PVariantType
-      t.types.all? {|t2| is_kind_of_optional?(t2, optional) }
-    else
-      false
-    end
-  end
 
   def callable_PArrayType(args_array, callable_t)
     return false unless assignable?(callable_t.param_types, args_array)
@@ -1242,34 +1186,22 @@ class Puppet::Pops::Types::TypeCalculator
   #
   def assignable_PStructType(t, t2)
     if t2.is_a?(Types::PStructType)
+      h = t.hashed_elements
       h2 = t2.hashed_elements
-      matched = 0
-      t.elements.all? do |e1|
-        e2 = h2[e1.name]
-        if e2.nil?
-          assignable?(e1.key_type, @nil_t)
-        else
-          matched += 1
-          assignable?(e1.key_type, e2.key_type) && assignable?(e1.value_type, e2.value_type)
-        end
-      end && matched == h2.size
+      (h2.keys - h.keys).empty? && h.all? {|k, v| v2 = h2[k]; assignable?(v, v2.nil? ? @nil_t : v2) }
     elsif t2.is_a?(Types::PHashType)
-      required = 0
-      required_elements_assignable = t.elements.all? do |e|
-        if assignable?(e.key_type, @nil_t)
-          true
-        else
-          required += 1
-          assignable?(e.value_type, t2.element_type)
-        end
-      end
-      if required_elements_assignable
-        size_t2 = t2.size_type || @collection_default_size_t
-        size_t = Types::PIntegerType.new
-        size_t.from = required
-        size_t.to = t.elements.size
-        assignable_PIntegerType(size_t, size_t2)
-      end
+      size_t2 = t2.size_type || @collection_default_size_t
+      size_t = Types::PIntegerType.new
+      elements = t.elements
+      size_t.from = elements.count {|e| !assignable?(e.type, @nil_t) }
+      size_t.to = elements.size
+      # compatible size
+      # hash key type must be string of min 1 size
+      # hash value t must be assignable to each key
+      element_type = t2.element_type
+      assignable_PIntegerType(size_t, size_t2) &&
+        (size_t2.to == 0 || assignable?(@non_empty_string_t, t2.key_type)) &&
+          elements.all? {|e| assignable?(e.type, element_type) }
     else
       false
     end
@@ -1278,9 +1210,8 @@ class Puppet::Pops::Types::TypeCalculator
   # @api private
   def assignable_POptionalType(t, t2)
     return true if t2.is_a?(Types::PUndefType)
-    return true if t.optional_type.nil?
     if t2.is_a?(Types::POptionalType)
-      assignable?(t.optional_type, t2.optional_type || @t)
+      assignable?(t.optional_type, t2.optional_type)
     else
       assignable?(t.optional_type, t2)
     end
@@ -1447,15 +1378,14 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   # Array is assignable if t2 is an Array and t2's element type is assignable, or if t2 is a Tuple
-  # where 
   # @api private
   def assignable_PArrayType(t, t2)
     if t2.is_a?(Types::PArrayType)
-      return false unless t.element_type.nil? || assignable?(t.element_type, t2.element_type || @t)
+      return false unless assignable?(t.element_type, t2.element_type)
       assignable_PCollectionType(t, t2)
 
     elsif t2.is_a?(Types::PTupleType)
-      return false unless t.element_type.nil? || t2.types.all? {|t2_element| assignable?(t.element_type, t2_element) }
+      return false unless t2.types.all? {|t2_element| assignable?(t.element_type, t2_element) }
       t2_regular = t2.types[0..-2]
       t2_ranged = t2.types[-1]
       t2_from, t2_to = size_range(t2.size_type)
@@ -1493,8 +1423,7 @@ class Puppet::Pops::Types::TypeCalculator
     case t2
     when Types::PHashType
       return true if (t.size_type.nil? || t.size_type.from == 0) && t2.is_the_empty_hash?
-      return false unless t.key_type.nil? || assignable?(t.key_type, t2.key_type || @t)
-      return false unless t.element_type.nil? || assignable?(t.element_type, t2.element_type || @t)
+      return false unless assignable?(t.key_type, t2.key_type) && assignable?(t.element_type, t2.element_type)
       assignable_PCollectionType(t, t2)
     when Types::PStructType
       # hash must accept String as key type
@@ -1506,7 +1435,7 @@ class Puppet::Pops::Types::TypeCalculator
       key_type = t.key_type
       element_type = t.element_type
       ( struct_size >= min && struct_size <= max &&
-        t2.elements.all? {|e| (key_type.nil? || instance_of(key_type, e.name)) && (element_type.nil? || assignable?(element_type, e.value_type)) })
+        t2.elements.all? {|e| instance_of(key_type, e.name) && assignable?(element_type, e.type) })
     else
       false
     end
@@ -1538,15 +1467,7 @@ class Puppet::Pops::Types::TypeCalculator
   # Data is assignable by other Data and by Array[Data] and Hash[Scalar, Data]
   # @api private
   def assignable_PDataType(t, t2)
-    # We cannot put the NotUndefType[Data] in the @data_variant_t since that causes an endless recursion
-    case t2
-    when Types::PDataType
-      true
-    when Types::PNotUndefType
-      assignable?(t, t2.type || @t)
-    else
-      assignable?(@data_variant_t, t2)
-    end
+    t2.is_a?(Types::PDataType) || assignable?(@data_variant_t, t2)
   end
 
   # Assignable if t2's has the same runtime and the runtime name resolves to
@@ -1717,16 +1638,7 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   def string_PStructElement(t)
-    k = t.key_type
-    value_optional = assignable?(t.value_type, @nil_t)
-    key_string =
-      if k.is_a?(Types::POptionalType)
-        # Output as literal String
-        value_optional ? "'#{t.name}'" : string(k)
-      else
-        value_optional ? "NotUndef['#{t.name}']" : "'#{t.name}'"
-      end
-    "#{key_string}=>#{string(t.value_type)}"
+    "'#{t.name}'=>#{string(t.type)}"
   end
 
   # @api private
@@ -1792,30 +1704,11 @@ class Puppet::Pops::Types::TypeCalculator
     end
   end
 
-  # @api private
-  def string_PNotUndefType(t)
-    contained_type = t.type
-    if contained_type.nil? || contained_type.class == Puppet::Pops::Types::PAnyType
-      'NotUndef'
-    else
-      if contained_type.is_a?(Puppet::Pops::Types::PStringType) && contained_type.values.size == 1
-        "NotUndef['#{contained_type.values[0]}']"
-      else
-        "NotUndef[#{string(contained_type)}]"
-      end
-    end
-  end
-
   def string_POptionalType(t)
-    optional_type = t.optional_type
-    if optional_type.nil?
+    if t.optional_type.nil?
       "Optional"
     else
-      if optional_type.is_a?(Puppet::Pops::Types::PStringType) && optional_type.values.size == 1
-        "Optional['#{optional_type.values[0]}']"
-      else
-        "Optional[#{string(optional_type)}]"
-      end
+      "Optional[#{string(t.optional_type)}]"
     end
   end
 
@@ -1828,7 +1721,7 @@ class Puppet::Pops::Types::TypeCalculator
   # @api private
   def enumerable_PIntegerType(t)
     # Not enumerable if representing an infinite range
-    return nil if t.size == TheInfinity
+    return nil if t.size == Float::INFINITY
     t
   end
 
@@ -1847,6 +1740,11 @@ class Puppet::Pops::Types::TypeCalculator
     end
   end
 
+  # Debugging to_s to reduce the amount of output
+  def to_s
+    '[a TypeCalculator]'
+  end
+
   private
 
   NAME_SEGMENT_SEPARATOR = '::'.freeze