puppet 4.8.2-x64-mingw32 → 4.9.0-x64-mingw32

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

@@ -59,7 +59,7 @@ module Types
         loader)
     end
 
-    # Register a bidiractional regexp mapping
+    # Register a bidirectional regexp mapping
     #
     # @param type_name_subst [Array(Regexp,String)] regexp and replacement mapping type names to runtime names
     # @param impl_name_subst [Array(Regexp,String)] regexp and replacement mapping runtime names to type names

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

@@ -358,14 +358,14 @@ class PObjectType < PMetaType
   #   @param i12n_hash [Hash{String=>Object}] The hash describing the Object features
   #
   # @api private
-  def initialize(name_or_i12n_hash, i12n_hash_expression = nil)
+  def initialize(i12n_hash, i12n_hash_expression = nil)
     @attributes = EMPTY_HASH
     @functions = EMPTY_HASH
 
-    if name_or_i12n_hash.is_a?(Hash)
-      initialize_from_hash(name_or_i12n_hash)
+    if i12n_hash.is_a?(Hash)
+      initialize_from_hash(i12n_hash)
     else
-      @name = TypeAsserter.assert_instance_of('object name', TYPE_OBJECT_NAME, name_or_i12n_hash)
+      @name = TypeAsserter.assert_instance_of('object name', TYPE_OBJECT_NAME, i12n_hash)
       @i12n_hash_expression = i12n_hash_expression
     end
   end
@@ -411,7 +411,7 @@ class PObjectType < PMetaType
     impl_class = implementation_class
     class_name = impl_class.name || "Anonymous Ruby class for #{name}"
 
-    (param_names, param_types, required_param_count) = parameter_info
+    (param_names, param_types, required_param_count) = parameter_info(impl_class)
 
     # Create the callable with a size that reflects the required and optional parameters
     param_types << required_param_count
@@ -442,11 +442,17 @@ class PObjectType < PMetaType
         end
       end
 
-      # Add the dispatch that uses the standard #new method on the class. It's assumed that the #new
+      # Add the dispatch that uses the standard #from_asserted_args or #new method on the class. It's assumed that the
       # method performs no assertions.
       dispatcher.add_dispatch(create_type, :create, param_names, nil, EMPTY_ARRAY, EMPTY_ARRAY, false)
-      def create(*args)
-        self.class.impl_class.new(*args)
+      if impl_class.respond_to?(:from_asserted_args)
+        def create(*args)
+          self.class.impl_class.from_asserted_args(*args)
+        end
+      else
+        def create(*args)
+          self.class.impl_class.new(*args)
+        end
       end
     end
   end
@@ -474,7 +480,7 @@ class PObjectType < PMetaType
 
   # @api private
   # @return [(Array<String>, Array<PAnyType>, Integer)] array of parameter names, array of parameter types, and a count reflecting the required number of parameters
-  def parameter_info(attr_readers = false)
+  def parameter_info(impl_class, attr_readers = false)
     # Create a types and a names array where optional entries ends up last
     opt_types = []
     opt_names = []
@@ -491,6 +497,35 @@ class PObjectType < PMetaType
     end
     param_names = non_opt_names + opt_names
     param_types = non_opt_types + opt_types
+    param_count = param_names.size
+
+    init = impl_class.respond_to?(:from_asserted_args) ? impl_class.method(:from_asserted_args) : impl_class.instance_method(:initialize)
+    init_non_opt_count = 0
+    init_param_names = init.parameters.map do |p|
+      init_non_opt_count += 1 if :req == p[0]
+      p[1].to_s
+    end
+
+    if init_param_names != param_names
+      if init_param_names.size < param_count || init_non_opt_count > param_count
+        raise Serialization::SerializationError, "Initializer for class #{impl_class.name} does not match the attributes of #{name}"
+      end
+      init_param_names = init_param_names[0, param_count] if init_param_names.size > param_count
+      unless init_param_names == param_names
+        # Reorder needed to match initialize method arguments
+        new_param_types = []
+        init_param_names.each do |ip|
+          index = param_names.index(ip)
+          if index.nil?
+            raise Serialization::SerializationError,
+              "Initializer for class #{impl_class.name} parameter '#{ip}' does not match any of the the attributes of type #{name}"
+          end
+          new_param_types << param_types[index]
+        end
+        param_names = init_param_names
+        param_types = new_param_types
+      end
+    end
 
     [param_names, param_types, non_opt_types.size]
   end
@@ -620,6 +655,14 @@ class PObjectType < PMetaType
     @i12n_type ||= create_i12n_type
   end
 
+  def create(*args)
+    implementation_class.create(*args)
+  end
+
+  def from_hash(hash)
+    implementation_class.from_hash(hash)
+  end
+
   # Creates the type that a initialization hash used for creating instances of this type must conform to.
   #
   # @return [PStructType] the initialization hash type
@@ -816,8 +859,8 @@ class PObjectType < PMetaType
   def find_equality_definer_of(attr)
     type = self
     while !type.nil? do
-      p = type.parent
-      return type if p.nil?
+      p = type.resolved_parent
+      return type unless p.is_a?(PObjectType)
       return type unless p.equality_attributes.include?(attr.name)
       type = p
     end
@@ -827,7 +870,7 @@ class PObjectType < PMetaType
   def guarded_recursion(guard, dflt)
     if @self_recursion
       guard ||= RecursionGuard.new
-      (guard.add_this(self) & RecursionGuard::SELF_RECURSION_IN_THIS) == 0 ? yield(guard) : dflt
+      guard.with_this(self) { |state| (state & RecursionGuard::SELF_RECURSION_IN_THIS) == 0 ? yield(guard) : dflt }
     else
       yield(guard)
     end

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

@@ -10,21 +10,21 @@ class PSemVerRangeType < PScalarType
   end
 
   # Check if a version is included in a version range. The version can be a string or
-  # a `Semantic::SemVer`
+  # a `SemanticPuppet::SemVer`
   #
-  # @param range [Semantic::VersionRange] the range to match against
-  # @param version [Semantic::Version,String] the version to match
+  # @param range [SemanticPuppet::VersionRange] the range to match against
+  # @param version [SemanticPuppet::Version,String] the version to match
   # @return [Boolean] `true` if the range includes the given version
   #
   # @api public
   def self.include?(range, version)
     case version
-    when Semantic::Version
+    when SemanticPuppet::Version
       range.include?(version)
     when String
       begin
-        range.include?(Semantic::Version.parse(version))
-      rescue Semantic::Version::ValidationFailure
+        range.include?(SemanticPuppet::Version.parse(version))
+      rescue SemanticPuppet::Version::ValidationFailure
         false
       end
     else
@@ -32,28 +32,28 @@ class PSemVerRangeType < PScalarType
     end
   end
 
-  # Creates a {Semantic::VersionRange} from the given _version_range_ argument. If the argument is `nil` or
-  # a {Semantic::VersionRange}, it is returned. If it is a {String}, it will be parsed into a
-  # {Semantic::VersionRange}. Any other class will raise an {ArgumentError}.
+  # Creates a {SemanticPuppet::VersionRange} from the given _version_range_ argument. If the argument is `nil` or
+  # a {SemanticPuppet::VersionRange}, it is returned. If it is a {String}, it will be parsed into a
+  # {SemanticPuppet::VersionRange}. Any other class will raise an {ArgumentError}.
   #
-  # @param version_range [Semantic::VersionRange,String,nil] the version range to convert
-  # @return [Semantic::VersionRange] the converted version range
+  # @param version_range [SemanticPuppet::VersionRange,String,nil] the version range to convert
+  # @return [SemanticPuppet::VersionRange] the converted version range
   # @raise [ArgumentError] when the argument cannot be converted into a version range
   #
   def self.convert(version_range)
     case version_range
-    when nil, Semantic::VersionRange
+    when nil, SemanticPuppet::VersionRange
       version_range
     when String
-      Semantic::VersionRange.parse(version_range)
+      SemanticPuppet::VersionRange.parse(version_range)
     else
       raise ArgumentError, "Unable to convert a #{version_range.class.name} to a SemVerRange"
     end
   end
 
   # Checks if range _a_ is a sub-range of (i.e. completely covered by) range _b_
-  # @param a [Semantic::VersionRange] the first range
-  # @param b [Semantic::VersionRange] the second range
+  # @param a [SemanticPuppet::VersionRange] the first range
+  # @param b [SemanticPuppet::VersionRange] the second range
   #
   # @return [Boolean] `true` if _a_ is completely covered by _b_
   def self.covered_by?(a, b)
@@ -63,9 +63,9 @@ class PSemVerRangeType < PScalarType
   # Merge two ranges so that the result matches all versions matched by both. A merge
   # is only possible when the ranges are either adjacent or have an overlap.
   #
-  # @param a [Semantic::VersionRange] the first range
-  # @param b [Semantic::VersionRange] the second range
-  # @return [Semantic::VersionRange,nil] the result of the merge
+  # @param a [SemanticPuppet::VersionRange] the first range
+  # @param b [SemanticPuppet::VersionRange] the second range
+  # @return [SemanticPuppet::VersionRange,nil] the result of the merge
   #
   # @api public
   def self.merge(a, b)
@@ -77,13 +77,13 @@ class PSemVerRangeType < PScalarType
       elsif b.exclude_end?
         exclude_end = max == b.end && (max > a.end || a.exclude_end?)
       end
-      Semantic::VersionRange.new([a.begin, b.begin].min, max, exclude_end)
+      SemanticPuppet::VersionRange.new([a.begin, b.begin].min, max, exclude_end)
     elsif a.exclude_end? && a.end == b.begin
       # Adjacent, a before b
-      Semantic::VersionRange.new(a.begin, b.end, b.exclude_end?)
+      SemanticPuppet::VersionRange.new(a.begin, b.end, b.exclude_end?)
     elsif b.exclude_end? && b.end == a.begin
       # Adjacent, b before a
-      Semantic::VersionRange.new(b.begin, a.end, a.exclude_end?)
+      SemanticPuppet::VersionRange.new(b.begin, a.end, a.exclude_end?)
     else
       # No overlap
       nil
@@ -91,7 +91,7 @@ class PSemVerRangeType < PScalarType
   end
 
   def instance?(o, guard = nil)
-    o.is_a?(Semantic::VersionRange)
+    o.is_a?(SemanticPuppet::VersionRange)
   end
 
   def eql?(o)
@@ -115,7 +115,7 @@ class PSemVerRangeType < PScalarType
       # https://github.com/npm/node-semver#range-grammar
       #
       # The logical or || operator is not implemented since it effectively builds
-      # an array of ranges that may be disparate. The {{Semantic::VersionRange}} inherits
+      # an array of ranges that may be disparate. The {{SemanticPuppet::VersionRange}} inherits
       # from the standard ruby range. It must be possible to describe that range in terms
       # of min, max, and exclude max.
       #
@@ -144,13 +144,13 @@ class PSemVerRangeType < PScalarType
       end
 
       def from_string(str)
-        Semantic::VersionRange.parse(str)
+        SemanticPuppet::VersionRange.parse(str)
       end
 
       def from_versions(min, max = :default, exclude_max = false)
-        min = Semantic::Version::MIN if min == :default
-        max = Semantic::Version::MAX if max == :default
-        Semantic::VersionRange.new(min, max, exclude_max)
+        min = SemanticPuppet::Version::MIN if min == :default
+        max = SemanticPuppet::Version::MAX if max == :default
+        SemanticPuppet::VersionRange.new(min, max, exclude_max)
       end
 
       def from_hash(hash)

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

@@ -1,7 +1,7 @@
 module Puppet::Pops
 module Types
 
-# A Puppet Language Type that exposes the {{Semantic::Version}} and {{Semantic::VersionRange}}.
+# A Puppet Language Type that exposes the {{SemanticPuppet::Version}} and {{SemanticPuppet::VersionRange}}.
 # The version type is parameterized with version ranges.
 #
 # @api public
@@ -18,13 +18,13 @@ class PSemVerType < PScalarType
   attr_reader :ranges
 
   def initialize(ranges)
-    ranges = ranges.map { |range| range.is_a?(Semantic::VersionRange) ? range : Semantic::VersionRange.parse(range) }
+    ranges = ranges.map { |range| range.is_a?(SemanticPuppet::VersionRange) ? range : SemanticPuppet::VersionRange.parse(range) }
     ranges = merge_ranges(ranges) if ranges.size > 1
     @ranges = ranges
   end
 
   def instance?(o, guard = nil)
-    o.is_a?(Semantic::Version) && (@ranges.empty? || @ranges.any? {|range| range.include?(o) })
+    o.is_a?(SemanticPuppet::Version) && (@ranges.empty? || @ranges.any? {|range| range.include?(o) })
   end
 
   def eql?(o)
@@ -36,19 +36,19 @@ class PSemVerType < PScalarType
   end
 
   # Creates a SemVer version from the given _version_ argument. If the argument is `nil` or
-  # a {Semantic::Version}, it is returned. If it is a {String}, it will be parsed into a
-  # {Semantic::Version}. Any other class will raise an {ArgumentError}.
+  # a {SemanticPuppet::Version}, it is returned. If it is a {String}, it will be parsed into a
+  # {SemanticPuppet::Version}. Any other class will raise an {ArgumentError}.
   #
-  # @param version [Semantic::Version,String,nil] the version to convert
-  # @return [Semantic::Version] the converted version
+  # @param version [SemanticPuppet::Version,String,nil] the version to convert
+  # @return [SemanticPuppet::Version] the converted version
   # @raise [ArgumentError] when the argument cannot be converted into a version
   #
   def self.convert(version)
     case version
-    when nil, Semantic::Version
+    when nil, SemanticPuppet::Version
       version
     when String
-      Semantic::Version.parse(version)
+      SemanticPuppet::Version.parse(version)
     else
       raise ArgumentError, "Unable to convert a #{version.class.name} to a SemVer"
     end
@@ -87,15 +87,15 @@ class PSemVerType < PScalarType
       end
 
       def from_string(str)
-        Semantic::Version.parse(str)
+        SemanticPuppet::Version.parse(str)
       end
 
       def from_args(major, minor, patch, prerelease = nil, build = nil)
-        Semantic::Version.new(major, minor, patch, prerelease, build)
+        SemanticPuppet::Version.new(major, minor, patch, prerelease, build)
       end
 
       def from_hash(hash)
-        Semantic::Version.new(hash['major'], hash['minor'], hash['patch'], hash['prerelease'], hash['build'])
+        SemanticPuppet::Version.new(hash['major'], hash['minor'], hash['patch'], hash['prerelease'], hash['build'])
       end
     end
   end

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

@@ -1,10 +1,10 @@
 module Puppet::Pops
 module Types
   class PAbstractTimeDataType < PAbstractRangeType
-    # @param [AbstractTime] min lower bound for this type. Nil or :default means unbounded
-    # @param [AbstractTime] max upper bound for this type. Nil or :default means unbounded
-    def initialize(min = nil, max = nil)
-      super(convert_arg(min, true), convert_arg(max, false))
+    # @param from [AbstractTime] lower bound for this type. Nil or :default means unbounded
+    # @param to [AbstractTime] upper bound for this type. Nil or :default means unbounded
+    def initialize(from = nil, to = nil)
+      super(convert_arg(from, true), convert_arg(to, false))
     end
 
     def convert_arg(arg, min)
@@ -51,8 +51,8 @@ module Types
   class PTimespanType < PAbstractTimeDataType
     def self.register_ptype(loader, ir)
       create_ptype(loader, ir, 'ScalarType',
-        'from' => { KEY_TYPE => PTimespanType::DEFAULT, KEY_VALUE => :default },
-        'to' => { KEY_TYPE => PTimespanType::DEFAULT, KEY_VALUE => :default }
+        'from' => { KEY_TYPE => POptionalType.new(PTimespanType::DEFAULT), KEY_VALUE => nil },
+        'to' => { KEY_TYPE => POptionalType.new(PTimespanType::DEFAULT), KEY_VALUE => nil }
       )
     end
 

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

@@ -3,8 +3,8 @@ module Types
   class PTimestampType < PAbstractTimeDataType
     def self.register_ptype(loader, ir)
       create_ptype(loader, ir, 'ScalarType',
-        'from' => { KEY_TYPE => PTimestampType::DEFAULT, KEY_VALUE => :default },
-        'to' => { KEY_TYPE => PTimestampType::DEFAULT, KEY_VALUE => :default }
+        'from' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil },
+        'to' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil }
       )
     end
 

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

@@ -216,27 +216,18 @@ class PTypeSetType < PMetaType
   # @return [String] the name by which the type is referenced within this type set
   #
   # @api private
-  def name_for(t)
+  def name_for(t, default_name)
     key = @types.key(t)
     if key.nil?
       qname = t.name
       if @references.empty?
-        qname
+        default_name
       else
-        segments = qname.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
-        first = segments[0]
-        type_set = @references[first]
-        if type_set.nil?
-          qname
-        else
-          if segments.size == 1
-            qname
-          else
-            sub_name = type_set.name_for(t)
-            sub_name = "#{first}::#{sub_name}" unless sub_name == qname
-            sub_name
-          end
+        @references.each_pair do |ref_key, ref|
+          ref_name = ref.type_set.name_for(t, nil)
+          return "#{ref_key}::#{ref_name}" unless ref_name.nil?
         end
+        default_name
       end
     else
       key
@@ -332,7 +323,7 @@ class PTypeSetType < PMetaType
     KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,
     Pcore::KEY_PCORE_URI => Pcore::PCORE_URI,
     Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
-    KEY_VERSION => Semantic::Version.new(0,0,0)
+    KEY_VERSION => SemanticPuppet::Version.new(0,0,0)
   })
 
   protected

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

@@ -24,14 +24,54 @@ class RecursionGuard
   # @param instance [Object] the instance to check
   # @return [Integer] the resulting state
   def recursive_this?(instance)
-    this_map[instance.object_id] == true
+    instance_variable_defined?(:@recursive_this_map) && @recursive_this_map.has_key?(instance.object_id)
   end
 
   # Checks if recursion was detected for the given argument in the 'that' context
   # @param instance [Object] the instance to check
   # @return [Integer] the resulting state
   def recursive_that?(instance)
-    that_map[instance.object_id] == true
+    instance_variable_defined?(:@recursive_that_map) && @recursive_that_map.has_key?(instance.object_id)
+  end
+
+  # Add the given argument as 'this' invoke the given block with the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Object] the result of yielding
+  def with_this(instance)
+    if (@state & SELF_RECURSION_IN_THIS) == 0
+      tc = this_count
+      @state = @state | SELF_RECURSION_IN_THIS if this_put(instance)
+      if tc < this_count
+        # recursive state detected
+        result = yield(@state)
+
+        # pop state
+        @state &= ~SELF_RECURSION_IN_THIS
+        @this_map.delete(instance.object_id)
+        return result
+      end
+    end
+    yield(@state)
+  end
+
+  # Add the given argument as 'that' invoke the given block with the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Object] the result of yielding
+  def with_that(instance)
+    if (@state & SELF_RECURSION_IN_THAT) == 0
+      tc = that_count
+      @state = @state | SELF_RECURSION_IN_THAT if that_put(instance)
+      if tc < that_count
+        # recursive state detected
+        result = yield(@state)
+
+        # pop state
+        @state &= ~SELF_RECURSION_IN_THAT
+        @that_map.delete(instance.object_id)
+        return result
+      end
+    end
+    yield(@state)
   end
 
   # Add the given argument as 'this' and return the resulting state
@@ -39,7 +79,7 @@ class RecursionGuard
   # @return [Integer] the resulting state
   def add_this(instance)
     if (@state & SELF_RECURSION_IN_THIS) == 0
-      @state = @state | SELF_RECURSION_IN_THIS if map_put(this_map, instance)
+      @state = @state | SELF_RECURSION_IN_THIS if this_put(instance)
     end
     @state
   end
@@ -49,43 +89,47 @@ class RecursionGuard
   # @return [Integer] the resulting state
   def add_that(instance)
     if (@state & SELF_RECURSION_IN_THAT) == 0
-      @state = @state | SELF_RECURSION_IN_THAT if map_put(that_map, instance)
+      @state = @state | SELF_RECURSION_IN_THAT if that_put(instance)
     end
     @state
   end
 
   # @return the number of objects added to the `this` map
   def this_count
-    this_map.size
+    instance_variable_defined?(:@this_map) ? @this_map.size : 0
   end
 
   # @return the number of objects added to the `that` map
   def that_count
-    that_map.size
+    instance_variable_defined?(:@that_map) ? @that_map.size : 0
   end
 
   private
 
-  def map_put(map, o)
+  def this_put(o)
     id = o.object_id
-    case map[id]
-    when true
-      true # Recursion already detected
-    when false
-      map[id] = true
-      true # Recursion occured. This was the second time this entry was added
+    @this_map ||= {}
+    if @this_map.has_key?(id)
+      @recursive_this_map ||= {}
+      @recursive_this_map[id] = true
+      true
     else
-      map[id] = false
-      false # First time add. No recursion
+      @this_map[id] = true
+      false
     end
   end
 
-  def this_map
-    @this_map ||= {}
-  end
-
-  def that_map
+  def that_put(o)
+    id = o.object_id
     @that_map ||= {}
+    if @that_map.has_key?(id)
+      @recursive_that_map ||= {}
+      @recursive_that_map[id] = true
+      true
+    else
+      @that_map[id] = true
+      false
+    end
   end
 end
 end