puppet 4.10.12 → 5.0.0

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

@@ -0,0 +1,31 @@
+module Puppet::Pops
+module Types
+  class RubyMethod < Annotation
+    # Register the Annotation type. This is the type that all custom Annotations will inherit from.
+    def self.register_ptype(loader, ir)
+      @type = Pcore::create_object_type(loader, ir, self, 'RubyMethod', 'Annotation',
+        'body' => PStringType::DEFAULT,
+        'parameters' => {
+          KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
+          KEY_VALUE => nil
+        }
+      )
+    end
+
+    def self.from_hash(i12n)
+      from_asserted_hash(Types::TypeAsserter.assert_instance_of('RubyMethod initializer', _pcore_type.i12n_type, i12n))
+    end
+
+    def self.from_asserted_hash(init_hash)
+      new(init_hash['body'], init_hash['parameters'])
+    end
+
+    attr_reader :body, :parameters
+
+    def initialize(body, parameters = nil)
+      @body = body
+      @parameters = parameters
+    end
+  end
+end
+end

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

@@ -163,6 +163,11 @@ class StringConverter
       unless lower && higher
         return lower || higher
       end
+
+      # drop all formats in lower than is more generic in higher. Lower must never
+      # override higher
+      lower = lower.reject { |lk, _| higher.keys.any? { |hk| hk != lk && hk.assignable?(lk) }}
+
       merged = (lower.keys + higher.keys).uniq.map do |k|
         [k, merge(lower[k], higher[k])]
       end
@@ -275,6 +280,7 @@ class StringConverter
   DEFAULT_ARRAY_DELIMITERS                      = ['[', ']'].freeze
 
   DEFAULT_STRING_FORMATS = {
+    PObjectType::DEFAULT   => Format.new('%p').freeze,    # call with initialization hash
     PFloatType::DEFAULT    => Format.new('%f').freeze,    # float
     PNumericType::DEFAULT  => Format.new('%d').freeze,    # decimal number
     PArrayType::DEFAULT    => DEFAULT_ARRAY_FORMAT.freeze,
@@ -283,6 +289,13 @@ class StringConverter
     PAnyType::DEFAULT      => Format.new('%s').freeze,    # unquoted string
   }.freeze
 
+  DEFAULT_PARAMETER_FORMAT = {
+    PCollectionType::DEFAULT => '%#p',
+    PObjectType::DEFAULT => '%#p',
+    PBinaryType::DEFAULT => '%p',
+    PStringType::DEFAULT => '%p',
+    PRuntimeType::DEFAULT => '%p'
+  }.freeze
 
   # Converts the given value to a String, under the direction of formatting rules per type.
   #
@@ -538,15 +551,47 @@ class StringConverter
   end
   private :validate_container_input
 
-  def string_PRuntimeType(val_type, val, format_map, _)
+  def string_PObjectType(val_type, val, format_map, indentation)
+    f = get_format(val_type, format_map)
+    case f.format
+    when :p
+      fmt = TypeFormatter.singleton
+      indentation = indentation.indenting(f.alt? || indentation.is_indenting?)
+      fmt = fmt.indented(indentation.level, 2) if indentation.is_indenting?
+      fmt.string(val)
+    when :s
+      val.to_s
+    when :q
+      val.inspect
+    else
+      raise FormatError.new('Object', f.format, 'spq')
+    end
+  end
+
+  def string_PRuntimeType(val_type, val, format_map, indent)
+    # Before giving up on this, and use a string representation of the unknown
+    # object, a check is made to see if the object can present itself as
+    # a hash or an array. If it can, then that representation is used instead.
+    if val.is_a?(Hash)
+      hash = val.to_hash
+      # Ensure that the returned value isn't derived from Hash
+      return string_PHashType(val_type, hash, format_map, indent) if hash.instance_of?(Hash)
+    elsif val.is_a?(Array)
+      array = val.to_a
+      # Ensure that the returned value isn't derived from Array
+      return string_PArrayType(val_type, array, format_map, indent) if array.instance_of?(Array)
+    end
+
     f = get_format(val_type, format_map)
     case f.format
     when :s
       val.to_s
+    when :p
+      puppet_quote(val.to_s)
     when :q
       val.inspect
     else
-      raise FormatError.new('Runtime', f.format, 'sq')
+      raise FormatError.new('Runtime', f.format, 'spq')
     end
   end
 
@@ -790,35 +835,65 @@ class StringConverter
   #
   # @api public
   def puppet_quote(str)
-    if str.ascii_only? && (str =~ /(?:'|\$|\p{Cntrl}|\\)/).nil?
-      "'#{str}'"
-    else
-      bld = '"'
-      str.codepoints do |codepoint|
-        case codepoint
-        when 0x09
-          bld << '\\t'
-        when 0x0a
-          bld << '\\n'
-        when 0x0d
-          bld << '\\r'
-        when 0x22
-          bld << '\\"'
-        when 0x24
-          bld << '\\$'
-        when 0x5c
-          bld << '\\\\'
+    # Assume that the string can be single quoted
+    bld = '\''
+    bld.force_encoding(str.encoding)
+    escaped = false
+    str.each_codepoint do |codepoint|
+      # Control characters and non-ascii characters cannot be present in a single quoted string
+      return puppet_double_quote(str) if codepoint < 0x20
+
+      if escaped
+        bld << 0x5c << codepoint
+        escaped = false
+      else
+        if codepoint == 0x27
+          bld << 0x5c << codepoint
+        elsif codepoint == 0x5c
+          escaped = true
+        elsif codepoint <= 0x7f
+          bld << codepoint
         else
-          if codepoint < 0x20 || codepoint > 0x7f
-            bld << sprintf('\\u{%X}', codepoint)
-          else
-            bld.concat(codepoint)
-          end
+          bld << [codepoint].pack('U')
+        end
+      end
+    end
+
+    # If string ended with a backslash, then that backslash must be escaped
+    bld << 0x5c if escaped
+
+    bld << '\''
+    bld
+  end
+
+  def puppet_double_quote(str)
+    bld = '"'
+    str.each_codepoint do |codepoint|
+      case codepoint
+      when 0x09
+        bld << '\\t'
+      when 0x0a
+        bld << '\\n'
+      when 0x0d
+        bld << '\\r'
+      when 0x22
+        bld << '\\"'
+      when 0x24
+        bld << '\\$'
+      when 0x5c
+        bld << '\\\\'
+      else
+        if codepoint < 0x20
+          bld << sprintf('\\u{%X}', codepoint)
+        elsif codepoint <= 0x7f
+          bld << codepoint
+        else
+          bld << [codepoint].pack('U')
         end
       end
-      bld << '"'
-      bld
     end
+    bld << '"'
+    bld
   end
 
   # @api private
@@ -826,10 +901,12 @@ class StringConverter
     f = get_format(val_type, format_map)
     case f.format
     when :p
-      str_regexp = PRegexpType.regexp_to_s_with_delimiters(val)
+      rx_s = val.options == 0 ? val.source : val.to_s
+      rx_s = rx_s.gsub(/\//, '\/') unless Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.0.0')
+      str_regexp = "/#{rx_s}/"
       f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.gsub('p', 's'), str_regexp)
     when :s
-      str_regexp = PRegexpType.regexp_to_s(val)
+      str_regexp = val.options == 0 ? val.source : val.to_s
       str_regexp = puppet_quote(str_regexp) if f.alt?
       f.orig_fmt == '%s' ? str_regexp : Kernel.format(f.orig_fmt, str_regexp)
     else
@@ -920,7 +997,7 @@ class StringConverter
 
   def is_container?(t)
     case t
-    when PArrayType, PHashType, PStructType, PTupleType
+    when PArrayType, PHashType, PStructType, PTupleType, PObjectType
       true
     else
       false

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

@@ -115,17 +115,6 @@ class TypeCalculator
     singleton.callable?(callable, args)
   end
 
-  # Produces a String representation of the given type.
-  # @param t [PAnyType] the type to produce a string form
-  # @return [String] the type in string form
-  #
-  # @api public
-  #
-  def self.string(t)
-    Puppet.deprecation_warning('TypeCalculator.string is deprecated. Use TypeFormatter')
-    TypeFormatter.string(t)
-  end
-
   # @api public
   def self.infer(o)
     singleton.infer(o)
@@ -141,18 +130,6 @@ class TypeCalculator
     singleton.infer_set(o)
   end
 
-  # @api public
-  def self.debug_string(t)
-    Puppet.deprecation_warning('TypeCalculator.debug_string is deprecated. Use TypeFormatter')
-    TypeFormatter.debug_string(t)
-  end
-
-  # @api public
-  def self.enumerable(t)
-    Puppet.deprecation_warning('TypeCalculator.enumerable is deprecated. Use iterable')
-    singleton.iterable(t)
-  end
-
   # @api public
   def self.iterable(t)
     singleton.iterable(t)
@@ -172,29 +149,6 @@ class TypeCalculator
     @@extract_visitor ||= Visitor.new(nil, 'extract',0,0)
   end
 
-  # Answers the question 'is it possible to inject an instance of the given class'
-  # A class is injectable if it has a special *assisted inject* class method called `inject` taking
-  # an injector and a scope as argument, or if it has a zero args `initialize` method.
-  #
-  # @param klazz [Class, PRuntimeType] the class/type to check if it is injectable
-  # @return [Class, nil] the injectable Class, or nil if not injectable
-  # @api public
-  #
-  def injectable_class(klazz)
-    # Handle case when we get a PType instead of a class
-    if klazz.is_a?(PRuntimeType)
-      klazz = ClassLoader.provide(klazz)
-    end
-
-    # data types can not be injected (check again, it is not safe to assume that given RubyRuntime klazz arg was ok)
-    return false unless type(klazz).is_a?(PRuntimeType)
-    if (klazz.respond_to?(:inject) && klazz.method(:inject).arity == -4) || klazz.instance_method(:initialize).arity == 0
-      klazz
-    else
-      nil
-    end
-  end
-
   # Answers 'can an instance of type t2 be assigned to a variable of type t'.
   # Does not accept nil/undef unless the type accepts it.
   #
@@ -260,11 +214,11 @@ class TypeCalculator
     when c == Class
       type = PType::DEFAULT
     when c == Array
-      # Assume array of data values
-      type = PArrayType::DATA
+      # Assume array of any
+      type = PArrayType::DEFAULT
     when c == Hash
-      # Assume hash with scalar keys and data values
-      type = PHashType::DATA
+      # Assume hash of any
+      type = PHashType::DEFAULT
    else
       type = PRuntimeType.new(:ruby, c.name)
     end
@@ -283,16 +237,16 @@ class TypeCalculator
   #
   def infer(o)
     # Optimize the most common cases into direct calls.
-    case o
-    when String
+    # Explicit if/elsif/else is faster than case
+    if o.is_a?(String)
       infer_String(o)
-    when Integer
+    elsif o.is_a?(Integer) # need subclasses for Ruby < 2.4
       infer_Integer(o)
-    when Array
+    elsif o.is_a?(Array)
       infer_Array(o)
-    when Hash
+    elsif o.is_a?(Hash)
       infer_Hash(o)
-    when Evaluator::PuppetProc
+    elsif o.is_a?(Evaluator::PuppetProc)
       infer_PuppetProc(o)
     else
       @@infer_visitor.visit_this_0(self, o)
@@ -307,15 +261,14 @@ class TypeCalculator
   # @api public
   #
   def infer_set(o)
-    case o
-      when Array
-        infer_set_Array(o)
-      when Hash
-        infer_set_Hash(o)
-      when SemanticPuppet::Version
-        infer_set_Version(o)
-      else
-        infer_set_Object(o)
+    if o.instance_of?(Array)
+      infer_set_Array(o)
+    elsif o.instance_of?(Hash)
+      infer_set_Hash(o)
+    elsif o.instance_of?(SemanticPuppet::Version)
+      infer_set_Version(o)
+    else
+      infer(o)
     end
   end
 
@@ -461,12 +414,16 @@ class TypeCalculator
       return PNumericType::DEFAULT
     end
 
+    if common_scalar_data?(t1, t2)
+      return PScalarDataType::DEFAULT
+    end
+
     if common_scalar?(t1, t2)
       return PScalarType::DEFAULT
     end
 
     if common_data?(t1,t2)
-      return PDataType::DEFAULT
+      return TypeFactory.data
     end
 
     # Meta types Type[Integer] + Type[String] => Type[Data]
@@ -474,6 +431,10 @@ class TypeCalculator
       return PType.new(common_type(t1.type, t2.type))
     end
 
+    if common_rich_data?(t1,t2)
+      return TypeFactory.rich_data
+    end
+
     # If both are Runtime types
     if t1.is_a?(PRuntimeType) && t2.is_a?(PRuntimeType)
       if t1.runtime == t2.runtime && t1.runtime_type_name == t2.runtime_type_name
@@ -509,23 +470,6 @@ class TypeCalculator
     result
   end
 
-  # Produces a string representing the type
-  # @api public
-  #
-  def string(t)
-    Puppet.deprecation_warning('TypeCalculator.string is deprecated. Use TypeFormatter')
-    TypeFormatter.singleton.string(t)
-  end
-
-  # Produces a debug string representing the type (possibly with more information that the regular string format)
-  # @api public
-  #
-  def debug_string(t)
-    Puppet.deprecation_warning('TypeCalculator.debug_string is deprecated. Use TypeFormatter')
-    TypeFormatter.singleton.debug_string(t)
-  end
-
-
   # Reduces an enumerable of types to a single common type.
   # @api public
   #
@@ -565,7 +509,7 @@ class TypeCalculator
   # @api private
   def infer_Object(o)
     if o.is_a?(PuppetObject)
-      o._ptype
+      o._pcore_type
     else
       name = o.class.name
       ir = Loaders.implementation_registry
@@ -606,7 +550,7 @@ class TypeCalculator
 
   # @api private
   def infer_Regexp(o)
-    PRegexpType.new(o)
+    PRegexpType.new(o.source)
   end
 
   # @api private
@@ -690,10 +634,14 @@ class TypeCalculator
 
   # @api private
   def infer_Array(o)
-    if o.empty?
-      PArrayType::EMPTY
+    if o.instance_of?(Array)
+      if o.empty?
+        PArrayType::EMPTY
+      else
+        PArrayType.new(infer_and_reduce_type(o), size_as_type(o))
+      end
     else
-      PArrayType.new(infer_and_reduce_type(o), size_as_type(o))
+      infer_Object(o)
     end
   end
 
@@ -714,12 +662,16 @@ class TypeCalculator
 
   # @api private
   def infer_Hash(o)
-    if o.empty?
-      PHashType::EMPTY
+    if o.instance_of?(Hash)
+      if o.empty?
+        PHashType::EMPTY
+      else
+        ktype = infer_and_reduce_type(o.keys)
+        etype = infer_and_reduce_type(o.values)
+        PHashType.new(ktype, etype, size_as_type(o))
+      end
     else
-      ktype = infer_and_reduce_type(o.keys)
-      etype = infer_and_reduce_type(o.values)
-      PHashType.new(ktype, etype, size_as_type(o))
+      infer_Object(o)
     end
   end
 
@@ -819,8 +771,18 @@ class TypeCalculator
 
   private
 
+  def common_rich_data?(t1, t2)
+    d = TypeFactory.rich_data
+    d.assignable?(t1) && d.assignable?(t2)
+  end
+
   def common_data?(t1, t2)
-    PDataType::DEFAULT.assignable?(t1) && PDataType::DEFAULT.assignable?(t2)
+    d = TypeFactory.data
+    d.assignable?(t1) && d.assignable?(t2)
+  end
+
+  def common_scalar_data?(t1, t2)
+    PScalarDataType::DEFAULT.assignable?(t1) && PScalarDataType::DEFAULT.assignable?(t2)
   end
 
   def common_scalar?(t1, t2)