puppet 4.0.0-x86-mingw32 → 4.1.0-x86-mingw32

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

@@ -13,6 +13,7 @@ class Puppet::Pops::Types::TypeParser
   def initialize
     @parser = Puppet::Pops::Parser::Parser.new()
     @type_transformer = Puppet::Pops::Visitor.new(nil, "interpret", 0, 0)
+    @undef_t = TYPES.undef
   end
 
   # Produces a *puppet type* based on the given string.
@@ -163,6 +164,9 @@ class Puppet::Pops::Types::TypeParser
     when "undef"
       TYPES.undef()
 
+    when "notundef"
+      TYPES.not_undef()
+
     when "default"
       TYPES.default()
 
@@ -344,8 +348,9 @@ class Puppet::Pops::Types::TypeParser
     when "struct"
       # 1..m parameters being types (last two optionally integer or literal default
       raise_invalid_parameters_error("Struct", "1", parameters.size) unless parameters.size == 1
-      assert_struct_parameter(parameters[0])
-      TYPES.struct(parameters[0])
+      h = parameters[0]
+      raise_invalid_type_specification_error unless h.is_a?(Hash)
+      TYPES.struct(h)
 
     when "integer"
       if parameters.size == 1
@@ -400,12 +405,25 @@ class Puppet::Pops::Types::TypeParser
       if parameters.size != 1
         raise_invalid_parameters_error("Optional", 1, parameters.size)
       end
-      assert_type(parameters[0])
-      TYPES.optional(parameters[0])
+      param = parameters[0]
+      assert_type(param) unless param.is_a?(String)
+      TYPES.optional(param)
 
     when "any", "data", "catalogentry", "boolean", "scalar", "undef", "numeric", "default"
       raise_unparameterized_type_error(parameterized_ast.left_expr)
 
+    when "notundef"
+      case parameters.size
+      when 0
+        TYPES.not_undef
+      when 1
+        param = parameters[0]
+        assert_type(param) unless param.is_a?(String)
+        TYPES.not_undef(param)
+      else
+        raise_invalid_parameters_error("NotUndef", "0 to 1", parameters.size)
+      end
+
     when "type"
       if parameters.size != 1
         raise_invalid_parameters_error("Type", 1, parameters.size)
@@ -438,15 +456,6 @@ class Puppet::Pops::Types::TypeParser
     raise_invalid_type_specification_error unless TYPES.is_range_parameter?(t)
   end
 
-  def assert_struct_parameter(h)
-    raise_invalid_type_specification_error unless h.is_a?(Hash)
-    h.each do |k,v|
-      # TODO: Should have stricter name rule
-      raise_invalid_type_specification_error unless k.is_a?(String) && !k.empty?
-      assert_type(v)
-    end
-  end
-
   def raise_invalid_type_specification_error
     raise Puppet::ParseError,
       "The expression <#{@string}> is not a valid type specification."

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

@@ -42,6 +42,18 @@ module Puppet::Pops
       end
     end
 
+    class PNotUndefType < PAnyType
+      module ClassModule
+        def hash
+          [self.class, type].hash
+        end
+
+        def ==(o)
+          self.class == o.class && type == o.type
+        end
+      end
+    end
+
     class PType < PAnyType
       module ClassModule
         def hash
@@ -162,7 +174,8 @@ module Puppet::Pops
     class PRegexpType < PScalarType
       module ClassModule
         def regexp_derived
-          @_regexp = Regexp.new(pattern) unless @_regexp && @_regexp.source == pattern
+          pattern_or_blank = pattern || ''
+          @_regexp = Regexp.new(pattern_or_blank) unless @_regexp && @_regexp.source == pattern_or_blank
           @_regexp
         end
 
@@ -216,11 +229,17 @@ module Puppet::Pops
     class PStructElement < TypeModelObject
       module ClassModule
         def hash
-          [self.class, type, name].hash
+          [self.class, value_type, key_type].hash
+        end
+
+        def name
+          k = key_type
+          k = k.optional_type if k.is_a?(POptionalType)
+          k.values[0]
         end
 
         def ==(o)
-          self.class == o.class && type == o.type && name == o.name
+          self.class == o.class && value_type == o.value_type && key_type == o.key_type
         end
       end
     end
@@ -229,7 +248,7 @@ module Puppet::Pops
     class PStructType < PAnyType
       module ClassModule
         def hashed_elements_derived
-          @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e.type; memo }
+          @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e; memo }
           @_hashed
         end
 

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

@@ -27,6 +27,15 @@ module Puppet::Pops::Types
   class PAnyType < TypeModelObject
   end
 
+  # A type that is assignable from the same types as its contained `type` except the
+  # types assignable from {Puppet::Pops::Types::PUndefType}
+  #
+  # @api public
+  #
+  class PNotUndefType < PAnyType
+    contains_one_uni 'type', PAnyType
+  end
+
   # The type of types.
   # @api public
   #
@@ -135,8 +144,10 @@ module Puppet::Pops::Types
   # @api public
   #
   class PStructElement < TypeModelObject
-    has_attr 'name', String, :lowerBound => 1
-    contains_one_uni 'type', PAnyType
+    # key_type must be either String[1] or Optional[String[1]] and the String[1] must
+    # have a values collection with exactly one element
+    contains_one_uni 'key_type', PAnyType, :lowerBound => 1
+    contains_one_uni 'value_type', PAnyType
   end
 
   # @api public

data/lib/puppet/pops/validation.rb

@@ -93,11 +93,12 @@ module Puppet::Pops::Validation
     @@severity_hash = {:ignore => true, :warning => true, :error => true, :deprecation => true }
 
     # Creates a new instance where all issues are diagnosed as :error unless overridden.
+    # @param [Symbol] specifies default severity if :error is not wanted as the default
     # @api public
     #
-    def initialize
+    def initialize(default_severity = :error)
       # If diagnose is not set, the default is returned by the block
-      @severities = Hash.new :error
+      @severities = Hash.new default_severity
     end
 
     # Returns the severity of the given issue.
@@ -227,6 +228,28 @@ module Puppet::Pops::Validation
       # debugging or similar - this to catch internal problems reported as higher level issues.
       @exception = exception
     end
+
+    # Two diagnostics are considered equal if the have the same issue, location and severity
+    # (arguments and exception are ignored)
+    #
+    def ==(o)
+      self.class            == o.class             &&
+        same_position?(o)                          &&
+        issue.issue_code    == o.issue.issue_code  &&
+        file                == o.file              &&
+        severity            == o.severity
+    end
+    alias eql? ==
+
+    # Position is equal if the diagnostic is not located or if referring to the same offset
+    def same_position?(o)
+      source_pos.nil? && o.source_pos.nil? || source_pos.offset == o.source_pos.offset
+    end
+    private :same_position?
+
+    def hash
+      @hash ||= [file, source_pos.offset, issue.issue_code, severity].hash
+    end
   end
 
   # Formats a diagnostic for output.

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

@@ -14,6 +14,8 @@ class Puppet::Pops::Validation::Checker4_0
   Model = Puppet::Pops::Model
 
   attr_reader :acceptor
+  attr_reader :migration_checker
+
   # Initializes the validator with a diagnostics producer. This object must respond to
   # `:will_accept?` and `:accept`.
   #
@@ -28,6 +30,9 @@ class Puppet::Pops::Validation::Checker4_0
     @@idem_visitor        ||= Puppet::Pops::Visitor.new(self, "idem", 0, 0)
 
     @acceptor = diagnostics_producer
+
+    # Use null migration checker unless given in context
+    @migration_checker = (Puppet.lookup(:migration_checker) { Puppet::Pops::Migration::MigrationChecker.new() })
   end
 
   # Validates the entire model by visiting each model element and calling `check`.
@@ -47,8 +52,8 @@ class Puppet::Pops::Validation::Checker4_0
 
   # Performs check if this is a vaid hostname expression
   # @param single_feature_name [String, nil] the name of a single valued hostname feature of the value's container. e.g. 'parent'
-  def hostname(o, semantic, single_feature_name = nil)
-    @@hostname_visitor.visit_this_2(self, o, semantic, single_feature_name)
+  def hostname(o, semantic)
+    @@hostname_visitor.visit_this_1(self, o, semantic)
   end
 
   # Performs check if this is valid as a query
@@ -110,9 +115,9 @@ class Puppet::Pops::Validation::Checker4_0
         acceptor.accept(Issues::CROSS_SCOPE_ASSIGNMENT, o, :name => varname_string)
       end
     end
+
     # TODO: Could scan for reassignment of the same variable if done earlier in the same container
     #       Or if assigning to a parameter (more work).
-    # TODO: Investigate if there are invalid cases for += assignment
   end
 
   def assign_AccessExpression(o, via_index)
@@ -125,6 +130,10 @@ class Puppet::Pops::Validation::Checker4_0
     end
   end
 
+  def assign_LiteralList(o, via_index)
+    o.values.each {|x| assign(x) }
+  end
+
   def assign_Object(o, via_index)
     # Can not assign to anything else (differentiate if this is via index or not)
     # i.e. 10 = 'hello' vs. 10['x'] = 'hello' (the root is reported as being in error in both cases)
@@ -182,12 +191,18 @@ class Puppet::Pops::Validation::Checker4_0
 
   def check_AttributesOperation(o)
     # Append operator use is constrained
-    parent = o.eContainer
-    parent = parent.eContainer unless parent.nil?
-    unless parent.is_a?(Model::ResourceExpression)
-      acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, o, :operator=>'* =>')
+    parent1 = o.eContainer
+    case parent1
+    when Model::AbstractResource
+    when Model::CollectExpression
+    else
+      # protect against just testing a snippet that has no parent, error message will be a bit strange
+      # but it is not for a real program.
+      parent2 = parent1.nil? ? o : parent1.eContainer
+      unless parent2.is_a?(Model::AbstractResource)
+        acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, parent2, :operator=>'* =>')
+      end
     end
-
     rvalue(o.expr)
   end
 
@@ -294,22 +309,34 @@ class Puppet::Pops::Validation::Checker4_0
     if RESERVED_TYPE_NAMES[o.name()]
       acceptor.accept(Issues::RESERVED_TYPE_NAME, o, {:name => o.name})
     end
+  end
 
-    if violator = ends_with_idem(o.body)
-      acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o})
-    end
+  def check_FunctionDefinition(o)
+    # TODO PUP-2080: more strict rule for top - can only be contained in Program (for now)
+    #  sticking functions in classes would create functions in the class name space
+    #  but not be special in any other way
+    #
+    check_NamedDefinition(o)
   end
 
   def check_HostClassDefinition(o)
     check_NamedDefinition(o)
     internal_check_no_capture(o)
     internal_check_reserved_params(o)
+    internal_check_no_idem_last(o)
   end
 
   def check_ResourceTypeDefinition(o)
     check_NamedDefinition(o)
     internal_check_no_capture(o)
     internal_check_reserved_params(o)
+    internal_check_no_idem_last(o)
+  end
+
+  def internal_check_no_idem_last(o)
+    if violator = ends_with_idem(o.body)
+      acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o})
+    end
   end
 
   def internal_check_capture_last(o)
@@ -364,7 +391,6 @@ class Puppet::Pops::Validation::Checker4_0
   def check_NodeDefinition(o)
     # Check that hostnames are valid hostnames (or regular expressions)
     hostname(o.host_matches, o)
-    hostname(o.parent, o, 'parent') unless o.parent.nil?
     top(o.eContainer, o)
     if violator = ends_with_idem(o.body)
       acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o})
@@ -407,6 +433,15 @@ class Puppet::Pops::Validation::Checker4_0
     if o.name =~ /^(?:0x)?[0-9]+$/
       acceptor.accept(Issues::ILLEGAL_NUMERIC_PARAMETER, o, :name => o.name)
     end
+    return unless o.value
+
+    if o.value.is_a?(Puppet::Pops::Model::AssignmentExpression)
+      [o.value]
+    else
+      o.value.eAllContents.select {|model| model.is_a? Puppet::Pops::Model::AssignmentExpression }
+    end.each do |assignment|
+      acceptor.accept(Issues::ILLEGAL_ASSIGNMENT_CONTEXT, assignment)
+    end
   end
 
   #relationship_side: resource
@@ -501,14 +536,11 @@ class Puppet::Pops::Validation::Checker4_0
   #--- HOSTNAME CHECKS
 
   # Transforms Array of host matching expressions into a (Ruby) array of AST::HostName
-  def hostname_Array(o, semantic, single_feature_name)
-    if single_feature_name
-      acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=>single_feature_name, :container=>semantic})
-    end
-    o.each {|x| hostname(x, semantic, false) }
+  def hostname_Array(o, semantic)
+    o.each {|x| hostname(x, semantic) }
   end
 
-  def hostname_String(o, semantic, single_feature_name)
+  def hostname_String(o, semantic)
     # The 3.x checker only checks for illegal characters - if matching /[^-\w.]/ the name is invalid,
     # but this allows pathological names like "a..b......c", "----"
     # TODO: Investigate if more illegal hostnames should be flagged.
@@ -518,11 +550,11 @@ class Puppet::Pops::Validation::Checker4_0
     end
   end
 
-  def hostname_LiteralValue(o, semantic, single_feature_name)
-    hostname_String(o.value.to_s, o, single_feature_name)
+  def hostname_LiteralValue(o, semantic)
+    hostname_String(o.value.to_s, o)
   end
 
-  def hostname_ConcatenatedString(o, semantic, single_feature_name)
+  def hostname_ConcatenatedString(o, semantic)
     # Puppet 3.1. only accepts a concatenated string without interpolated expressions
     if the_expr = o.segments.index {|s| s.is_a?(Model::TextExpression) }
       acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o.segments[the_expr].expr)
@@ -532,32 +564,32 @@ class Puppet::Pops::Validation::Checker4_0
     else
       # corner case, may be ok, but lexer may have replaced with plain string, this is
       # here if it does not
-      hostname_String(o.segments[0], o.segments[0], false)
+      hostname_String(o.segments[0], o.segments[0])
     end
   end
 
-  def hostname_QualifiedName(o, semantic, single_feature_name)
-    hostname_String(o.value.to_s, o, single_feature_name)
+  def hostname_QualifiedName(o, semantic)
+    hostname_String(o.value.to_s, o)
   end
 
-  def hostname_QualifiedReference(o, semantic, single_feature_name)
-    hostname_String(o.value.to_s, o, single_feature_name)
+  def hostname_QualifiedReference(o, semantic)
+    hostname_String(o.value.to_s, o)
   end
 
-  def hostname_LiteralNumber(o, semantic, single_feature_name)
+  def hostname_LiteralNumber(o, semantic)
     # always ok
   end
 
-  def hostname_LiteralDefault(o, semantic, single_feature_name)
+  def hostname_LiteralDefault(o, semantic)
     # always ok
   end
 
-  def hostname_LiteralRegularExpression(o, semantic, single_feature_name)
+  def hostname_LiteralRegularExpression(o, semantic)
     # always ok
   end
 
-  def hostname_Object(o, semantic, single_feature_name)
-    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=> single_feature_name || 'hostname', :container=>semantic})
+  def hostname_Object(o, semantic)
+    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature => 'hostname', :container => semantic})
   end
 
   #---QUERY CHECKS

data/lib/puppet/provider/group/windows_adsi.rb

@@ -9,6 +9,11 @@ Puppet::Type.type(:group).provide :windows_adsi do
 
   has_features :manages_members
 
+  def initialize(value={})
+    super(value)
+    @deleted = false
+  end
+
   def members_insync?(current, should)
     return false unless current
 
@@ -17,9 +22,6 @@ Puppet::Type.type(:group).provide :windows_adsi do
 
     # Cannot use munge of the group property to canonicalize @should
     # since the default array_matching comparison is not commutative
-    should_empty = should.nil? or should.empty?
-
-    return false if current.empty? != should_empty
 
     # dupes automatically weeded out when hashes built
     current_users = Puppet::Util::Windows::ADSI::Group.name_sid_hash(current)
@@ -72,11 +74,13 @@ Puppet::Type.type(:group).provide :windows_adsi do
 
   def delete
     Puppet::Util::Windows::ADSI::Group.delete(@resource[:name])
+
+    @deleted = true
   end
 
   # Only flush if we created or modified a group, not deleted
   def flush
-    @group.commit if @group
+    @group.commit if @group && !@deleted
   end
 
   def gid