puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

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

@@ -1,4 +1,5 @@
-module Puppet::Pops::Types
+module Puppet::Pops
+module Types
   EMPTY_ARRAY = [].freeze
 
   class TypePathElement
@@ -19,6 +20,12 @@ module Puppet::Pops::Types
     alias :eql? :==
   end
 
+  class SubjectPathElement < TypePathElement
+    def to_s
+      key
+    end
+  end
+
   class MemberPathElement < TypePathElement
     def to_s
       "struct member #{key}"
@@ -65,7 +72,42 @@ module Puppet::Pops::Types
     end
   end
 
+  # Module to handle present/past tense.
+  #
+  # All method names prefixed with "it_" to avoid conflict with Mocha expectations. Adding a method
+  # named 'expects' just doesn't work.
+  #
+  module TenseVariants
+    def it_expects(tense)
+      case tense
+      when :present
+        'expects'
+      else
+        'expected'
+      end
+    end
+
+    def it_does_not_expect(tense)
+      case tense
+      when :present
+        'does not expect'
+      else
+        'did not expect'
+      end
+    end
+
+    def it_has_no(tense)
+      case tense
+      when :present
+        'has no'
+      else
+        'did not have a'
+      end
+    end
+  end
+
   class Mismatch
+    include TenseVariants
     attr_reader :path
 
     def initialize(path)
@@ -76,7 +118,7 @@ module Puppet::Pops::Types
       @canonical_path ||= @path.reject { |e| e.is_a?(VariantPathElement) }
     end
 
-    def message(variant, position)
+    def message(variant, position, tense = :present)
       "#{variant}unknown mismatch#{position}"
     end
 
@@ -108,6 +150,10 @@ module Puppet::Pops::Types
     end
 
     def to_s
+      format(:present)
+    end
+
+    def format(tense)
       p = @path
       variant = ''
       position = ''
@@ -119,7 +165,7 @@ module Puppet::Pops::Types
         end
         position = " #{p.join(' ')}" unless p.empty?
       end
-      message(variant, position)
+      message(variant, position, tense)
     end
   end
 
@@ -142,38 +188,38 @@ module Puppet::Pops::Types
   end
 
   class MissingKey < KeyMismatch
-    def message(variant, position)
-      "#{variant}#{position} expects a value for key '#{key}'"
+    def message(variant, position, tense = :present)
+      "#{variant}#{position} #{it_expects(tense)} a value for key '#{key}'"
     end
   end
 
   class MissingParameter < KeyMismatch
-    def message(variant, position)
-      "#{variant}#{position} expects a value for parameter '#{key}'"
+    def message(variant, position, tense = :present)
+      "#{variant}#{position} #{it_expects(tense)} a value for parameter '#{key}'"
     end
   end
 
   class ExtraneousKey < KeyMismatch
-    def message(variant, position)
-      "#{variant}#{position} has no '#{@key}' key"
+    def message(variant, position, tense = :present)
+      "#{variant}#{position} #{it_has_no(tense)} '#{@key}' key"
     end
   end
 
   class InvalidParameter < ExtraneousKey
-    def message(variant, position)
-      "#{variant}#{position} has no parameter named '#{@key}'"
+    def message(variant, position, tense = :present)
+      "#{variant}#{position} #{it_has_no(tense)} parameter named '#{@key}'"
     end
   end
 
   class UnexpectedBlock < Mismatch
-    def message(variant, position)
-      "#{variant}#{position} does not expect a block"
+    def message(variant, position, tense = :present)
+      "#{variant}#{position} #{it_does_not_expect(tense)} a block"
     end
   end
 
   class MissingRequiredBlock < Mismatch
-    def message(variant, position)
-      "#{variant}#{position} expects a block"
+    def message(variant, position, tense = :present)
+      "#{variant}#{position} #{it_expects(tense)} a block"
     end
   end
 
@@ -182,8 +228,8 @@ module Puppet::Pops::Types
 
     def initialize(path, expected, actual)
       super(path)
-      @expected = expected
-      @actual = actual
+      @expected = (expected.is_a?(Array) ? PVariantType.new(expected) : expected).normalize
+      @actual = actual.normalize
     end
 
     def ==(o)
@@ -195,30 +241,34 @@ module Puppet::Pops::Types
       hash = hash * 31 + expected.hash
       hash * 31 + actual.hash
     end
+
+    def swap_expected(expected)
+      copy = self.clone
+      copy.instance_variable_set(:@expected, expected)
+      copy
+    end
   end
 
   class TypeMismatch < ExpectedActualMismatch
-    include Puppet::Pops::LabelProvider
+    include LabelProvider
 
     # @return A new instance with the least restrictive respective boundaries
     def merge(path, o)
       self.class.new(path, [expected, o.expected].flatten.uniq, actual)
     end
 
-    def message(variant, position)
+    def message(variant, position, tense = :present)
       e = expected
       a = actual
       multi = false
-      if e.is_a?(Array)
-        # Use simple names when classes differ, or in other words, only include details
-        # when the classes are equal.
-        #
-        if e.find { |t| t.class == a.class }
-          e = e.map { |t| t.to_s }
-          a = a.to_s
+      if e.is_a?(PVariantType)
+        e = e.types
+        if report_detailed?(e, a)
+          a = detailed_actual_to_s(e, a)
+          e = e.map { |t| t.to_alias_expanded_s }
         else
-          sns = e.map { |t| t.simple_name }
-          e = e.map { |t| s = t.simple_name; sns.count {|x| x == s } == 1 ? s : t.to_s }
+          sns = e.map { |t| t.simple_name }.uniq
+          e = e.map { |t| s = t.simple_name; sns.count {|x| x == s } == 1 ? s : t.to_s }.uniq
           a = a.simple_name
         end
         case e.size
@@ -232,25 +282,105 @@ module Puppet::Pops::Types
           multi = true
         end
       else
-        if e.class != a.class
+        if report_detailed?(e, a)
+          a = detailed_actual_to_s(e, a)
+          e = e.to_alias_expanded_s
+        else
           e = e.simple_name
           a = a.simple_name
-        else
-          e = e.to_s
-          a = a.to_s
         end
       end
-      multi ? "#{variant}#{position} expects a value of type #{e}, got #{label(a)}" :  "#{variant}#{position} expects #{a_an(e)} value, got #{label(a)}"
+      if multi
+        "#{variant}#{position} #{it_expects(tense)} a value of type #{e}, got #{label(a)}"
+      else
+        "#{variant}#{position} #{it_expects(tense)} #{a_an(e)} value, got #{label(a)}"
+      end
     end
 
     def label(o)
       o.to_s
     end
+
+    private
+
+    # Decides whether or not the report must be fully detailed, or if generalization can be permitted
+    # in the mismatch report. All comparisons are made using resolved aliases rather than the alias
+    # itself.
+    #
+    # @param e [PAnyType,Array[PAnyType]] the expected type or array of expected types
+    # @param a [PAnyType] the actual type
+    # @return [Boolean] `true` when the class of _a_ equals the class _e_ or,
+    #   in case _e_ is an `Array`, the class of at least one element of _e_
+    def always_fully_detailed?(e, a)
+      if e.is_a?(Array)
+        e.any? { |t| always_fully_detailed?(t, a) }
+      else
+        e.class == a.class || e.is_a?(PTypeAliasType) || a.is_a?(PTypeAliasType)
+      end
+    end
+
+    # @param e [PAnyType,Array[PAnyType]] the expected type or array of expected types
+    # @param a [PAnyType] the actual type
+    # @return [Boolean] `true` when _a_ is assignable to _e_ or, in case _e_ is an `Array`,
+    #   to at least one element of _e_
+    def any_assignable?(e, a)
+      e.is_a?(Array) ? e.any? { |t| t.assignable?(a) } : e.assignable?(a)
+    end
+
+    # @param e [PAnyType,Array[PAnyType]] the expected type or array of expected types
+    # @param a [PAnyType] the actual type
+    # @return [Boolean] `true` when _a_ is assignable to the default generalization of _e_ or,
+    #   in case _e_ is an `Array`, to the default generalization of at least one element of _e_
+    def assignable_to_default?(e, a)
+      if e.is_a?(Array)
+        e.any? { |t| assignable_to_default?(t, a) }
+      else
+        e = e.resolved_type if e.is_a?(PTypeAliasType)
+        e.class::DEFAULT.assignable?(a)
+      end
+    end
+
+    # @param e [PAnyType,Array[PAnyType]] the expected type or array of expected types
+    # @param a [PAnyType] the actual type
+    # @return [Boolean] `true` when either #always_fully_detailed or #assignable_to_default returns `true`
+    def report_detailed?(e, a)
+      always_fully_detailed?(e, a) || assignable_to_default?(e, a)
+    end
+
+    # Returns its argument with all type aliases resolved
+    # @param e [PAnyType,Array[PAnyType]] the expected type or array of expected types
+    # @return [PAnyType,Array[PAnyType]] the resolved result
+    def all_resolved(e)
+      if e.is_a?(Array)
+        e.map { |t| all_resolved(t) }
+      else
+        e.is_a?(PTypeAliasType) ? e.resolved_type : e
+      end
+    end
+
+    # Returns a string that either represents the generalized type _a_ or the type _a_ verbatim. The latter
+    # form is used when at least one of the following conditions are met:
+    #
+    # - #always_fully_detailed returns `true` for the resolved type of _e_ and _a_
+    # - #any_assignable? returns `true` for the resolved type of _e_ and the generalized type of _a_.
+    #
+    # @param e [PAnyType,Array[PAnyType]] the expected type or array of expected types
+    # @param a [PAnyType] the actual type
+    # @return [String] The string representation of the type _a_ or generalized type _a_
+    def detailed_actual_to_s(e, a)
+      e = all_resolved(e)
+      if always_fully_detailed?(e, a)
+        a.to_alias_expanded_s
+      else
+        g = a.generalize
+        any_assignable?(e, g) ? a.to_alias_expanded_s : g.to_s
+      end
+    end
   end
 
   class PatternMismatch < TypeMismatch
-    def message(variant, position)
-      "#{variant}#{position} expects a match for #{expected}, got #{actual_string}"
+    def message(variant, position, tense = :present)
+      "#{variant}#{position} #{it_expects(tense)} a match for #{expected.to_alias_expanded_s}, got #{actual_string}"
     end
 
     def actual_string
@@ -274,8 +404,8 @@ module Puppet::Pops::Types
       self.class.new(path, range, @actual)
     end
 
-    def message(variant, position)
-      "#{variant}#{position} expects size to be #{range_to_s(expected, '0')}, got #{range_to_s(actual, '0')}"
+    def message(variant, position, tense = :present)
+      "#{variant}#{position} #{it_expects(tense)} size to be #{range_to_s(expected, '0')}, got #{range_to_s(actual, '0')}"
     end
 
     def range_to_s(range, zero_string)
@@ -298,15 +428,17 @@ module Puppet::Pops::Types
       super(path, expected, actual)
     end
 
-    def message(variant, position)
+    def message(variant, position, tense = :present)
       min = expected.from || 0
       max = expected.to || Float::INFINITY
       suffix = min == 1 && (max == 1 || max == Float::INFINITY) || min == 0 && max == 1 ? '' : 's'
-      "#{variant}#{position} expects #{range_to_s(expected, 'no')} argument#{suffix}, got #{range_to_s(actual, 'none')}"
+      "#{variant}#{position} #{it_expects(tense)} #{range_to_s(expected, 'no')} argument#{suffix}, got #{range_to_s(actual, 'none')}"
     end
   end
 
   class TypeMismatchDescriber
+    include TenseVariants
+
     def self.validate_parameters(subject, params_struct, given_hash, missing_ok = false)
       singleton.validate_parameters(subject, params_struct, given_hash, missing_ok)
     end
@@ -330,15 +462,36 @@ module Puppet::Pops::Types
     # @param params_struct [PStructType] Struct to use for validation
     # @param given_hash [Hash<String,Object>] the parameters to validate
     # @param missing_ok [Boolean] Do not generate errors on missing parameters
+    # @param tense [Symbol] the symbol :present or :past
     #
-    def validate_parameters(subject, params_struct, given_hash, missing_ok = false)
+    def validate_parameters(subject, params_struct, given_hash, missing_ok = false, tense = :present)
       errors = describe_struct_signature(params_struct, given_hash, missing_ok).flatten
       case errors.size
       when 0
       when 1
-        raise Puppet::ParseError.new("#{subject}:#{errors[0]}")
+        raise Puppet::ParseError.new("#{subject}:#{errors[0].format(tense)}")
       else
-        raise Puppet::ParseError.new("#{subject}:\n #{errors.join("\n ")}")
+        errors_str = errors.map { |error| error.format(tense) }.join("\n ")
+        raise Puppet::ParseError.new("#{subject}:\n #{errors_str}")
+      end
+    end
+
+    # Describe a confirmed mismatch using present tense
+    #
+    # @param name [String] name of mismatch
+    # @param expected [PAnyType] expected type
+    # @param actual [PAnyType] actual type
+    # @param tense [Symbol] the symbol :present or :past
+    #
+    def describe_mismatch(name, expected, actual, tense = :past)
+      errors = describe(expected, actual, [SubjectPathElement.new(name)])
+      case errors.size
+      when 0
+        ''
+      when 1
+        errors[0].format(tense).strip
+      else
+        errors.map { |error| error.format(tense) }.join("\n ")
       end
     end
 
@@ -346,16 +499,18 @@ module Puppet::Pops::Types
     # @param param_name [String] parameter name
     # @param param_type [PAnyType] parameter type
     # @param value [Object] value to be validated against the given type
+    # @param tense [Symbol] the symbol :present or :past
     #
-    def validate_default_parameter(subject, param_name, param_type, value)
+    def validate_default_parameter(subject, param_name, param_type, value, tense = :present)
       unless param_type.instance?(value)
         errors = describe(param_type, TypeCalculator.singleton.infer_set(value).generalize, [ParameterPathElement.new(param_name)])
         case errors.size
         when 0
         when 1
-          raise Puppet::ParseError.new("#{subject}:#{errors[0]}")
+          raise Puppet::ParseError.new("#{subject}:#{errors[0].format(tense)}")
         else
-          raise Puppet::ParseError.new("#{subject}:\n #{errors.join("\n ")}")
+          errors_str = errors.map { |error| error.format(tense) }.join("\n ")
+          raise Puppet::ParseError.new("#{subject}:\n #{errors_str}")
         end
       end
     end
@@ -385,7 +540,7 @@ module Puppet::Pops::Types
       result
     end
 
-    def describe_signatures(closure, signatures, args_tuple)
+    def describe_signatures(closure, signatures, args_tuple, tense = :present)
       error_arrays = []
       signatures.each_with_index do |signature, index|
         error_arrays << describe_signature_arguments(signature, args_tuple, [SignaturePathElement.new(index)])
@@ -411,17 +566,17 @@ module Puppet::Pops::Types
       label = closure == 'lambda' ? 'block' : "'#{closure}'"
       errors = merge_descriptions(0, CountMismatch, error_arrays)
       if errors.size == 1
-        "#{label}#{errors[0]}"
+        "#{label}#{errors[0].format(tense)}"
       else
         if signatures.size == 1
           sig = signatures[0]
-          result = ["#{label} expected (#{signature_string(sig)})"]
-          result.concat(error_arrays[0].map { |e| "  rejected:#{e.chop_path(0)}" })
+          result = ["#{label} #{it_expects(tense)} (#{signature_string(sig)})"]
+          result.concat(error_arrays[0].map { |e| "  rejected:#{e.chop_path(0).format(tense)}" })
         else
-          result = ["#{label} expected one of:"]
+          result = ["#{label} #{it_expects(tense)} one of:"]
           signatures.each_with_index do |sg, index|
             result << "  (#{signature_string(sg)})"
-            result.concat(error_arrays[index].map { |e| "    rejected:#{e.chop_path(0)}" })
+            result.concat(error_arrays[index].map { |e| "    rejected:#{e.chop_path(0).format(tense)}" })
           end
         end
         result.join("\n")
@@ -531,6 +686,17 @@ module Puppet::Pops::Types
       [PatternMismatch.new(path, expected, actual)]
     end
 
+    def describe_PTypeAliasType(expected, actual, path)
+      resolved_type = expected.resolved_type.normalize
+      describe(resolved_type, actual, path).map do |description|
+        if description.is_a?(ExpectedActualMismatch) && description.expected.equal?(resolved_type)
+          description.swap_expected(expected)
+        else
+          description
+        end
+      end
+    end
+
     def describe_PStructType(expected, actual, path)
       elements = expected.elements
       descriptions = []
@@ -667,6 +833,8 @@ module Puppet::Pops::Types
         describe_PPatternType(expected, actual, path)
       when PEnumType
         describe_PEnumType(expected, actual, path)
+      when PTypeAliasType
+        describe_PTypeAliasType(expected, actual, path)
       else
         describe_PAnyType(expected, actual, path)
       end
@@ -688,12 +856,11 @@ module Puppet::Pops::Types
       required_count = from
       types =
         case param_types
-        when Puppet::Pops::Types::PTupleType
+        when PTupleType
           param_types.types
-        when Puppet::Pops::Types::PArrayType
+        when PArrayType
           [param_types.element_type]
         end
-      tc = Puppet::Pops::Types::TypeCalculator.singleton
 
       # join type with names (types are always present, names are optional)
       # separate entries with comma
@@ -708,17 +875,17 @@ module Puppet::Pops::Types
           indicator = from == param_names.size ? '+' : '*'
         elsif optional(index, required_count)
           indicator = '?'
-          type = type.optional_type if type.is_a?(Puppet::Pops::Types::POptionalType)
+          type = type.optional_type if type.is_a?(POptionalType)
         end
-        "#{tc.string(type)} #{name}#{indicator}"
+        "#{type} #{name}#{indicator}"
       end.join(', ')
 
       # If there is a block, include it
       case signature.type.block_type
-      when Puppet::Pops::Types::POptionalType
+      when POptionalType
         result << ', ' unless result == ''
         result << "#{signature.type.block_type.optional_type} #{signature.block_name}?"
-      when Puppet::Pops::Types::PCallableType
+      when PCallableType
         result << ', ' unless result == ''
         result << "#{signature.type.block_type} #{signature.block_name}"
       when NilClass
@@ -740,4 +907,4 @@ module Puppet::Pops::Types
     end
   end
 end
-
+end