puppet 3.7.4-x64-mingw32 → 3.7.5-x64-mingw32

data/lib/puppet/pops/parser/heredoc_support.rb

@@ -64,7 +64,7 @@ module Puppet::Pops::Parser::HeredocSupport
     # and it should start scanning after the first found \n (or if not found == error).
 
     if ctx[:newline_jump]
-      scn.pos = lexing_context[:newline_jump]
+      scn.pos = ctx[:newline_jump]
     else
       scn.scan_until(/\n/) || lex_error("Heredoc without any following lines of text")
     end

data/lib/puppet/pops/parser/lexer2.rb

@@ -160,9 +160,9 @@ class Puppet::Pops::Parser::Lexer2
   # a letter a-z and may not contain dashes (\w includes letters, digits and _).
   #
   PATTERN_CLASSREF       = %r{((::){0,1}[A-Z][\w]*)+}
-  PATTERN_NAME           = %r{((::)?[a-z][\w]*)(::[a-z][\w]*)*}
+  PATTERN_NAME           = %r{^((::)?[a-z][\w]*)(::[a-z][\w]*)*$}
 
-  PATTERN_BARE_WORD      = %r{[a-z_](?:[\w-]*[\w])?}
+  PATTERN_BARE_WORD     = %r{((?:::){0,1}(?:[a-z_](?:[\w-]*[\w])?))+}
 
   PATTERN_DOLLAR_VAR     = %r{\$(::)?(\w+::)*\w+}
   PATTERN_NUMBER         = %r{\b(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b}
@@ -536,10 +536,13 @@ class Puppet::Pops::Parser::Lexer2
             lex_error("Illegal fully qualified class reference")
           end
         else
-          # NAME or error
-          value = scn.scan(PATTERN_NAME)
+          value = scn.scan(PATTERN_BARE_WORD)
           if value
-            emit_completed([:NAME, value.freeze, scn.pos-before], before)
+            if value =~ PATTERN_NAME
+              emit_completed([:NAME, value.freeze, scn.pos-before], before)
+            else
+              emit_completed([:WORD, value.freeze, scn.pos - before], before)
+            end
           else
             # move to faulty position ('::' was ok)
             scn.pos = scn.pos + 2
@@ -580,25 +583,20 @@ class Puppet::Pops::Parser::Lexer2
 
     when 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
     'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '_'
-      value = scn.scan(PATTERN_NAME)
-      # NAME or false start because followed by hyphen(s), underscore or word
-      if value && !scn.match?(/^-+\w/)
+
+      value = scn.scan(PATTERN_BARE_WORD)
+      if value && value =~ PATTERN_NAME
         emit_completed(KEYWORDS[value] || [:NAME, value.freeze, scn.pos - before], before)
+      elsif value
+        emit_completed([:WORD, value.freeze, scn.pos - before], before)
       else
-        # Restart and check entire pattern (for ease of detecting non allowed trailing hyphen)
-        scn.pos = before
-        value = scn.scan(PATTERN_BARE_WORD)
-        # If the WORD continues with :: it must be a correct fully qualified name
-        if value && !(fully_qualified = scn.match?(/::/))
-          emit_completed([:WORD, value.freeze, scn.pos - before], before)
+        # move to faulty position ([a-z_] was ok)
+        scn.pos = scn.pos + 1
+        fully_qualified = scn.match?(/::/)
+        if fully_qualified
+          lex_error("Illegal fully qualified name")
         else
-          # move to faulty position ([a-z_] was ok)
-          scn.pos = scn.pos + 1
-          if fully_qualified
-            lex_error("Illegal fully qualified name")
-          else
-            lex_error("Illegal name or bare word")
-          end
+          lex_error("Illegal name or bare word")
         end
       end
 
@@ -685,7 +683,7 @@ class Puppet::Pops::Parser::Lexer2
       true
 
     # Operands (that can be followed by DIV (even if illegal in grammar)
-    when :NAME, :CLASSREF, :NUMBER, :STRING, :BOOLEAN, :DQPRE, :DQMID, :DQPOST, :HEREDOC, :REGEX
+    when :NAME, :CLASSREF, :NUMBER, :STRING, :BOOLEAN, :DQPRE, :DQMID, :DQPOST, :HEREDOC, :REGEX, :VARIABLE, :WORD
       false
 
     else

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

@@ -66,7 +66,7 @@ class Puppet::Pops::Types::ClassLoader
     when Puppet::Pops::Types::PPatternType  ; String
     when Puppet::Pops::Types::PEnumType     ; String
     when Puppet::Pops::Types::PFloatType    ; Float
-    when Puppet::Pops::Types::PNilType      ; NilClass
+    when Puppet::Pops::Types::PUndefType      ; NilClass
     when Puppet::Pops::Types::PCallableType ; Proc
     else
       nil

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

@@ -197,7 +197,7 @@ class Puppet::Pops::Types::TypeCalculator
     data_variant.addTypes(@data_hash.copy)
     data_variant.addTypes(@data_array.copy)
     data_variant.addTypes(Types::PScalarType.new)
-    data_variant.addTypes(Types::PNilType.new)
+    data_variant.addTypes(Types::PUndefType.new)
     data_variant.addTypes(@data_tuple_t.copy)
     @data_variant_t = data_variant
 
@@ -212,7 +212,7 @@ class Puppet::Pops::Types::TypeCalculator
     non_empty_string.size_type.to = nil # infinity
     @non_empty_string_t = non_empty_string
 
-    @nil_t = Types::PNilType.new
+    @nil_t = Types::PUndefType.new
   end
 
   # Convenience method to get a data type for comparisons
@@ -322,7 +322,7 @@ class Puppet::Pops::Types::TypeCalculator
     when c == Regexp
       type = Types::PRegexpType.new()
     when c == NilClass
-      type = Types::PNilType.new()
+      type = Types::PUndefType.new()
     when c == FalseClass, c == TrueClass
       type = Types::PBooleanType.new()
     when c == Class
@@ -430,6 +430,14 @@ class Puppet::Pops::Types::TypeCalculator
     return x < y ? x <= o && y >= o : y <= o && x >= o
   end
 
+  # @api private
+  def instance_of_PStringType(t, o)
+    return false unless o.is_a?(String)
+    # true if size compliant
+    size_t = t.size_type || @collection_default_size_t
+    instance_of_PIntegerType(size_t, o.size)
+  end
+
   def instance_of_PTupleType(t, o)
     return false unless o.is_a?(Array)
     # compute the tuple's min/max size, and check if that size matches
@@ -463,12 +471,12 @@ class Puppet::Pops::Types::TypeCalculator
     instance_of(@data_variant_t, o)
   end
 
-  def instance_of_PNilType(t, o)
+  def instance_of_PUndefType(t, o)
     o.nil? || o == :undef
   end
 
   def instance_of_POptionalType(t, o)
-    instance_of_PNilType(t, o) || instance_of(t.optional_type, o)
+    instance_of_PUndefType(t, o) || instance_of(t.optional_type, o)
   end
 
   def instance_of_PVariantType(t, o)
@@ -497,11 +505,11 @@ class Puppet::Pops::Types::TypeCalculator
     return t.is_a?(Types::PAnyType)
   end
 
-  # Answers if t represents the puppet type PNilType
+  # Answers if t represents the puppet type PUndefType
   # @api public
   #
   def is_pnil?(t)
-    return t.nil? || t.is_a?(Types::PNilType)
+    return t.nil? || t.is_a?(Types::PUndefType)
   end
 
   # Answers, 'What is the common type of t1 and t2?'
@@ -787,7 +795,50 @@ class Puppet::Pops::Types::TypeCalculator
 
   # @api private
   def infer_NilClass(o)
-    Types::PNilType.new()
+    Types::PUndefType.new()
+  end
+
+  # @api private
+  # @param o [Proc]
+  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
+      end
+      mapped_types = Array.new(min) { Types::PAnyType.new }
+    end
+    if min == 0 || min != max
+      mapped_types << min
+      mapped_types << max
+    end
+    Types::TypeFactory.callable(*mapped_types)
+  end
+
+  # @api private
+  def infer_PuppetProc(o)
+    infer_Closure(o.closure)
   end
 
   # Inference of :default as PDefaultType, and all other are Ruby[Symbol]
@@ -831,7 +882,7 @@ class Puppet::Pops::Types::TypeCalculator
     type = Types::PArrayType.new()
     type.element_type =
     if o.empty?
-      Types::PNilType.new()
+      Types::PUndefType.new()
     else
       infer_and_reduce_type(o)
     end
@@ -843,8 +894,8 @@ class Puppet::Pops::Types::TypeCalculator
   def infer_Hash(o)
     type = Types::PHashType.new()
     if o.empty?
-      ktype = Types::PNilType.new()
-      etype = Types::PNilType.new()
+      ktype = Types::PUndefType.new()
+      etype = Types::PUndefType.new()
     else
       ktype = infer_and_reduce_type(o.keys())
       etype = infer_and_reduce_type(o.values())
@@ -871,7 +922,7 @@ class Puppet::Pops::Types::TypeCalculator
   def infer_set_Array(o)
     if o.empty?
       type = Types::PArrayType.new()
-      type.element_type = Types::PNilType.new()
+      type.element_type = Types::PUndefType.new()
       type.size_type = size_as_type(o)
     else
       type = Types::PTupleType.new()
@@ -881,19 +932,33 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   def infer_set_Hash(o)
-    type = Types::PHashType.new()
     if o.empty?
-      ktype = Types::PNilType.new()
-      vtype = Types::PNilType.new()
+      type = Types::PHashType.new
+      type.key_type = Types::PUndefType.new
+      type.element_type = Types::PUndefType.new
+      type.size_type = size_as_type(o)
     else
-      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) }
+      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.key_type = unwrap_single_variant(ktype)
-    type.element_type = unwrap_single_variant(etype)
-    type.size_type = size_as_type(o)
     type
   end
 
@@ -917,9 +982,9 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   # @api private
-  def assignable_PNilType(t, t2)
+  def assignable_PUndefType(t, t2)
     # Only undef/nil is assignable to nil type
-    t2.is_a?(Types::PNilType)
+    t2.is_a?(Types::PUndefType)
   end
 
   # Anything is assignable to a Unit type
@@ -1013,7 +1078,7 @@ 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 PNilType
+    # 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
@@ -1052,8 +1117,8 @@ class Puppet::Pops::Types::TypeCalculator
     assignable?(callable_t.block_type || @nil_t, @nil_t)
   end
 
-  def callable_PNilType(nil_t, callable_t)
-    # if callable_t is Optional (or indeed PNilType), this means that 'missing callable' is accepted
+  def callable_PUndefType(nil_t, callable_t)
+    # if callable_t is Optional (or indeed PUndefType), this means that 'missing callable' is accepted
     assignable?(callable_t, nil_t)
   end
 
@@ -1127,22 +1192,23 @@ class Puppet::Pops::Types::TypeCalculator
   # @api private
   #
   def assignable_PStructType(t, t2)
-    return true if t == t2 || t.elements.empty? && (t2.is_a?(Types::PHashType))
-    h = t.hashed_elements
     if t2.is_a?(Types::PStructType)
+      h = t.hashed_elements
       h2 = t2.hashed_elements
-      h.size == h2.size && h.all? {|k, v| assignable?(v, h2[k]) }
+      (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)
       size_t2 = t2.size_type || @collection_default_size_t
       size_t = Types::PIntegerType.new
-      size_t.from = size_t.to = h.size
+      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) &&
-        assignable?(@non_empty_string_t, t2.key_type) &&
-        h.all? {|k,v| assignable?(v, element_type) }
+        (size_t2.to == 0 || assignable?(@non_empty_string_t, t2.key_type)) &&
+          elements.all? {|e| assignable?(e.type, element_type) }
     else
       false
     end
@@ -1150,7 +1216,7 @@ class Puppet::Pops::Types::TypeCalculator
 
   # @api private
   def assignable_POptionalType(t, t2)
-    return true if t2.is_a?(Types::PNilType)
+    return true if t2.is_a?(Types::PUndefType)
     if t2.is_a?(Types::POptionalType)
       assignable?(t.optional_type, t2.optional_type)
     else
@@ -1364,6 +1430,7 @@ class Puppet::Pops::Types::TypeCalculator
   def assignable_PHashType(t, t2)
     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 assignable?(t.key_type, t2.key_type) && assignable?(t.element_type, t2.element_type)
       assignable_PCollectionType(t, t2)
     when Types::PStructType
@@ -1373,10 +1440,10 @@ class Puppet::Pops::Types::TypeCalculator
       size_t = t.size_type || @collection_default_size_t
       min, max = size_t.range
       struct_size = t2.elements.size
+      key_type = t.key_type
       element_type = t.element_type
       ( struct_size >= min && struct_size <= max &&
-        assignable?(t.key_type, @non_empty_string_t)  &&
-        t2.hashed_elements.all? {|k,v| assignable?(element_type, v) })
+        t2.elements.all? {|e| instance_of(key_type, e.name) && assignable?(element_type, e.type) })
     else
       false
     end
@@ -1453,7 +1520,7 @@ class Puppet::Pops::Types::TypeCalculator
   def string_PAnyType(t)     ; "Any"     ; end
 
   # @api private
-  def string_PNilType(t)     ; 'Undef'   ; end
+  def string_PUndefType(t)     ; 'Undef'   ; end
 
   # @api private
   def string_PDefaultType(t) ; 'Default' ; end

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

@@ -264,7 +264,7 @@ module Puppet::Pops::Types::TypeFactory
   # Creates an instance of the Undef type
   # @api public
   def self.undef()
-    Types::PNilType.new()
+    Types::PUndefType.new()
   end
 
   # Creates an instance of the Default type

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

@@ -344,10 +344,13 @@ module Puppet::Pops
           self.element_type == o.element_type  &&
           self.size_type    == o.size_type
         end
+
+        def is_the_empty_hash?
+          size_type.is_a?(PIntegerType) && size_type.from == 0 && size_type.to == 0 && key_type.is_a?(PUndefType) && element_type.is_a?(PUndefType)
+        end
       end
     end
 
-
     class PRuntimeType < PAnyType
       module ClassModule
         def hash

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

@@ -36,7 +36,7 @@ module Puppet::Pops::Types
 
   # @api public
   #
-  class PNilType < PAnyType
+  class PUndefType < PAnyType
   end
 
 
@@ -212,7 +212,7 @@ module Puppet::Pops::Types
     has_attr 'title', String
   end
 
-  # Represents a type that accept PNilType instead of the type parameter
+  # Represents a type that accept PUndefType instead of the type parameter
   # required_type - is a short hand for Variant[T, Undef]
   # @api public
   #

data/lib/puppet/pops/validation/checker4_0.rb

@@ -478,11 +478,13 @@ class Puppet::Pops::Validation::Checker4_0
 
   # Checks that variable is either strictly 0, or a non 0 starting decimal number, or a valid VAR_NAME
   def check_VariableExpression(o)
-    # The expression must be a qualified name
-    if !o.expr.is_a?(Model::QualifiedName)
+    # The expression must be a qualified name or an integer
+    name_expr = o.expr
+    return if name_expr.is_a?(Model::LiteralInteger)
+    if !name_expr.is_a?(Model::QualifiedName)
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, :feature => 'name', :container => o)
     else
-      # name must be either a decimal value, or a valid NAME
+      # name must be either a decimal string value, or a valid NAME
       name = o.expr.value
       if name[0,1] =~ /[0-9]/
         unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME

data/lib/puppet/provider/service/systemd.rb

@@ -7,6 +7,7 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
 
   defaultfor :osfamily => [:archlinux]
   defaultfor :osfamily => :redhat, :operatingsystemmajrelease => "7"
+  defaultfor :osfamily => :redhat, :operatingsystem => :fedora, :operatingsystemmajrelease => ["17", "18", "19", "20", "21"]
 
   def self.instances
     i = []