puppet 5.0.1 → 5.1.0

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

@@ -10,6 +10,8 @@ KEY_VALUE = 'value'.freeze
 class PMetaType < PAnyType
   include Annotatable
 
+  attr_reader :loader
+
   def self.register_ptype(loader, ir)
     # Abstract type. It doesn't register anything
   end
@@ -31,16 +33,17 @@ class PMetaType < PAnyType
   # @param loader [Loader::Loader] loader to use when loading type aliases
   # @return [PTypeAliasType] the receiver of the call, i.e. `self`
   # @api private
-  def resolve(type_parser, loader)
+  def resolve(loader)
     unless @init_hash_expression.nil?
+      @loader = loader
       @self_recursion = true # assumed while it being found out below
 
       init_hash_expression = @init_hash_expression
       @init_hash_expression = nil
       if init_hash_expression.is_a?(Model::LiteralHash)
-        init_hash = resolve_literal_hash(type_parser, loader, init_hash_expression)
+        init_hash = resolve_literal_hash(loader, init_hash_expression)
       else
-        init_hash = resolve_hash(type_parser, loader, init_hash_expression)
+        init_hash = resolve_hash(loader, init_hash_expression)
       end
       _pcore_init_from_hash(init_hash)
 
@@ -54,22 +57,22 @@ class PMetaType < PAnyType
     self
   end
 
-  def resolve_literal_hash(type_parser, loader, init_hash_expression)
-    type_parser.interpret_LiteralHash(init_hash_expression, loader)
+  def resolve_literal_hash(loader, init_hash_expression)
+    TypeParser.singleton.interpret_LiteralHash(init_hash_expression, loader)
   end
 
-  def resolve_hash(type_parser, loader, init_hash)
-    resolve_type_refs(type_parser, loader, init_hash)
+  def resolve_hash(loader, init_hash)
+    resolve_type_refs(loader, init_hash)
   end
 
-  def resolve_type_refs(type_parser, loader, o)
+  def resolve_type_refs(loader, o)
     case o
     when Hash
-      Hash[o.map { |k, v| [resolve_type_refs(type_parser, loader, k), resolve_type_refs(type_parser, loader, v)] }]
+      Hash[o.map { |k, v| [resolve_type_refs(loader, k), resolve_type_refs(loader, v)] }]
     when Array
-      o.map { |e| resolve_type_refs(type_parser, loader, e) }
+      o.map { |e| resolve_type_refs(loader, e) }
     when PAnyType
-      o.resolve(type_parser, loader)
+      o.resolve(loader)
     else
       o
     end

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

@@ -25,7 +25,7 @@ class PObjectType < PMetaType
   TYPE_OBJECT_NAME = Pcore::TYPE_QUALIFIED_REFERENCE
 
   TYPE_ATTRIBUTE = TypeFactory.struct({
-    KEY_TYPE => PType::DEFAULT,
+    KEY_TYPE => PTypeType::DEFAULT,
     TypeFactory.optional(KEY_FINAL) => PBooleanType::DEFAULT,
     TypeFactory.optional(KEY_OVERRIDE) => PBooleanType::DEFAULT,
     TypeFactory.optional(KEY_KIND) => TYPE_ATTRIBUTE_KIND,
@@ -35,7 +35,7 @@ class PObjectType < PMetaType
   TYPE_ATTRIBUTES = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, TypeFactory.not_undef)
   TYPE_ATTRIBUTE_CALLABLE = TypeFactory.callable(0,0)
 
-  TYPE_FUNCTION_TYPE = PType.new(PCallableType::DEFAULT)
+  TYPE_FUNCTION_TYPE = PTypeType.new(PCallableType::DEFAULT)
 
   TYPE_FUNCTION = TypeFactory.struct({
     KEY_TYPE => TYPE_FUNCTION_TYPE,
@@ -51,7 +51,7 @@ class PObjectType < PMetaType
 
   TYPE_OBJECT_I12N = TypeFactory.struct({
     TypeFactory.optional(KEY_NAME) => TYPE_OBJECT_NAME,
-    TypeFactory.optional(KEY_PARENT) => PType::DEFAULT,
+    TypeFactory.optional(KEY_PARENT) => PTypeType::DEFAULT,
     TypeFactory.optional(KEY_ATTRIBUTES) => TYPE_ATTRIBUTES,
     TypeFactory.optional(KEY_FUNCTIONS) => TYPE_FUNCTIONS,
     TypeFactory.optional(KEY_EQUALITY) => TYPE_EQUALITY,
@@ -64,7 +64,7 @@ class PObjectType < PMetaType
     type = create_ptype(loader, ir, 'AnyType', '_pcore_init_hash' => TYPE_OBJECT_I12N)
 
     # Now, when the Object type exists, add annotations with keys derived from Annotation and freeze the types.
-    annotations = TypeFactory.optional(PHashType.new(PType.new(Annotation._pcore_type), TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, PAnyType::DEFAULT)))
+    annotations = TypeFactory.optional(PHashType.new(PTypeType.new(Annotation._pcore_type), TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, PAnyType::DEFAULT)))
     TYPE_ATTRIBUTE.hashed_elements[KEY_ANNOTATIONS].replace_value_type(annotations)
     TYPE_FUNCTION.hashed_elements[KEY_ANNOTATIONS].replace_value_type(annotations)
     TYPE_OBJECT_I12N.hashed_elements[KEY_ANNOTATIONS].replace_value_type(annotations)
@@ -96,7 +96,7 @@ class PObjectType < PMetaType
     # @option init_hash [PAnyType] 'type' The member type (required)
     # @option init_hash [Boolean] 'override' `true` if this feature must override an inherited feature. Default is `false`.
     # @option init_hash [Boolean] 'final' `true` if this feature cannot be overridden. Default is `false`.
-    # @option init_hash [Hash{PType => Hash}] 'annotations' Annotations hash. Default is `nil`.
+    # @option init_hash [Hash{PTypeType => Hash}] 'annotations' Annotations hash. Default is `nil`.
     # @api public
     def initialize(name, container, init_hash)
       @name = name
@@ -392,8 +392,8 @@ class PObjectType < PMetaType
   end
 
   # @api private
-  def new_function(loader)
-    @new_function ||= create_new_function(loader)
+  def new_function
+    @new_function ||= create_new_function
   end
 
   # Assign a new instance reader to this type
@@ -428,7 +428,7 @@ class PObjectType < PMetaType
   end
 
     # @api private
-  def create_new_function(loader)
+  def create_new_function
     impl_class = implementation_class
     class_name = impl_class.name || "Anonymous Ruby class for #{name}"
 
@@ -439,7 +439,7 @@ class PObjectType < PMetaType
     param_types << param_names.size
 
     create_type = TypeFactory.callable(*param_types)
-    from_hash_type = TypeFactory.callable(i12n_type, 1, 1)
+    from_hash_type = TypeFactory.callable(init_hash_type, 1, 1)
 
     # Create and return a #new_XXX function where the dispatchers are added programmatically.
     Puppet::Functions.create_loaded_function(:"new_#{name}", loader) do
@@ -514,7 +514,7 @@ class PObjectType < PMetaType
     opt_names = []
     non_opt_types = []
     non_opt_names = []
-    i12n_type.elements.each do |se|
+    init_hash_type.elements.each do |se|
       if se.key_type.is_a?(POptionalType)
         opt_names << se.name
         opt_types << se.value_type
@@ -598,7 +598,7 @@ class PObjectType < PMetaType
     unless attr_specs.nil? || attr_specs.empty?
       @attributes = Hash[attr_specs.map do |key, attr_spec|
         unless attr_spec.is_a?(Hash)
-          attr_type = TypeAsserter.assert_instance_of(nil, PType::DEFAULT, attr_spec) { "attribute #{label}[#{key}]" }
+          attr_type = TypeAsserter.assert_instance_of(nil, PTypeType::DEFAULT, attr_spec) { "attribute #{label}[#{key}]" }
           attr_spec = { KEY_TYPE => attr_type }
           attr_spec[KEY_VALUE] = nil if attr_type.is_a?(POptionalType)
         end
@@ -684,8 +684,8 @@ class PObjectType < PMetaType
   #
   # @return [PStructType] the initialization hash type
   # @api public
-  def i12n_type
-    @i12n_type ||= create_i12n_type
+  def init_hash_type
+    @init_hash_type ||= create_init_hash_type
   end
 
   def allocate
@@ -704,7 +704,7 @@ class PObjectType < PMetaType
   #
   # @return [PStructType] the initialization hash type
   # @api private
-  def create_i12n_type
+  def create_init_hash_type
     struct_elems = {}
     attributes(true).values.each do |attr|
       unless attr.kind == ATTRIBUTE_KIND_CONSTANT || attr.kind == ATTRIBUTE_KIND_DERIVED
@@ -818,7 +818,7 @@ class PObjectType < PMetaType
 
   # @api private
   def label
-    @name || '<anonymous object type>'
+    @name || 'Object'
   end
 
   # @api private

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

@@ -106,9 +106,9 @@ class PSemVerRangeType < PAnyType
     super ^ @version_range.hash
   end
 
-  def self.new_function(_, loader)
+  def self.new_function(type)
     range_expr = "\\A#{range_pattern}\\Z"
-    @@new_function ||= Puppet::Functions.create_loaded_function(:new_VersionRange, loader) do
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_VersionRange, type.loader) do
       local_types do
         type 'SemVerRangeString = String[1]'
         type 'SemVerRangeHash = Struct[{min=>Variant[default,SemVer],Optional[max]=>Variant[default,SemVer],Optional[exclude_max]=>Boolean}]'

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

@@ -55,8 +55,8 @@ class PSemVerType < PScalarType
   end
 
   # @api private
-  def self.new_function(_, loader)
-    @@new_function ||= Puppet::Functions.create_loaded_function(:new_Version, loader) do
+  def self.new_function(type)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_Version, type.loader) do
       local_types do
         type 'PositiveInteger = Integer[0,default]'
         type 'SemVerQualifier = Pattern[/\A(?<part>[0-9A-Za-z-]+)(?:\.\g<part>)*\Z/]'

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

@@ -38,8 +38,8 @@ class PSensitiveType < PTypeWithContainedType
     o.is_a?(Sensitive) && @type.instance?(o.unwrap, guard)
   end
 
-  def self.new_function(_, loader)
-    @new_function ||= Puppet::Functions.create_loaded_function(:new_Sensitive, loader) do
+  def self.new_function(type)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_Sensitive, type.loader) do
 
       dispatch :from_sensitive do
         param 'Sensitive', :value

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

@@ -50,10 +50,6 @@ module Types
       self.class == o.class && @from == o.numeric_from && @to == o.numeric_to
     end
 
-    def instance?(o, guard = nil)
-      o.is_a?(Numeric) && o >= @from && o <= @to
-    end
-
     def unbounded?
       @from == -Float::INFINITY && @to == Float::INFINITY
     end
@@ -107,8 +103,8 @@ module Types
       )
     end
 
-    def self.new_function(_, loader)
-      @new_function ||= Puppet::Functions.create_loaded_function(:new_timespan, loader) do
+    def self.new_function(type)
+      @new_function ||= Puppet::Functions.create_loaded_function(:new_timespan, type.loader) do
         local_types do
           type 'Formats = Variant[String[2],Array[String[2]], 1]'
         end
@@ -186,6 +182,10 @@ module Types
       Time::Timespan
     end
 
+    def instance?(o, guard = nil)
+      o.is_a?(Time::Timespan) && o >= @from && o <= @to
+    end
+
     DEFAULT = PTimespanType.new(nil, nil)
   end
 end

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

@@ -8,8 +8,8 @@ module Types
       )
     end
 
-    def self.new_function(_, loader)
-      @new_function ||= Puppet::Functions.create_loaded_function(:new_timestamp, loader) do
+    def self.new_function(type)
+      @new_function ||= Puppet::Functions.create_loaded_function(:new_timestamp, type.loader) do
         local_types do
           type 'Formats = Variant[String[2],Array[String[2]], 1]'
         end
@@ -63,6 +63,10 @@ module Types
       Time::Timestamp
     end
 
+    def instance?(o, guard = nil)
+      o.is_a?(Time::Timestamp) && o >= @from && o <= @to
+    end
+
     DEFAULT = PTimestampType.new(nil, nil)
   end
 end

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

@@ -48,13 +48,13 @@ class PTypeSetType < PMetaType
     TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
     TypeFactory.optional(KEY_NAME) => Pcore::TYPE_QUALIFIED_REFERENCE,
     TypeFactory.optional(KEY_VERSION) => TYPE_STRING_OR_VERSION,
-    TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PType::DEFAULT, PCollectionType::NOT_EMPTY_SIZE),
+    TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PTypeType::DEFAULT, PCollectionType::NOT_EMPTY_SIZE),
     TypeFactory.optional(KEY_REFERENCES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, TYPE_TYPE_REFERENCE_I12N, PCollectionType::NOT_EMPTY_SIZE),
     TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS,
   })
 
   def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'AnyType', '_pcore_init_hash' => TYPE_TYPESET_I12N.resolve(TypeParser.singleton, loader))
+    create_ptype(loader, ir, 'AnyType', '_pcore_init_hash' => TYPE_TYPESET_I12N.resolve(loader))
   end
 
   attr_reader :pcore_uri
@@ -254,17 +254,18 @@ class PTypeSetType < PMetaType
   end
 
   # @api private
-  def resolve(type_parser, loader)
+  def resolve(loader)
     super
-    @references.each_value { |ref| ref.resolve(type_parser, loader) }
+    @references.each_value { |ref| ref.resolve(loader) }
     tsa_loader = TypeSetLoader.new(self, loader)
-    @types.values.each { |type| type.resolve(type_parser, tsa_loader) }
+    @types.values.each { |type| type.resolve(tsa_loader) }
     self
   end
 
   # @api private
-  def resolve_literal_hash(type_parser, loader, init_hash_expression)
+  def resolve_literal_hash(loader, init_hash_expression)
     result = {}
+    type_parser = TypeParser.singleton
     init_hash_expression.entries.each do |entry|
       key = type_parser.interpret_any(entry.key, loader)
       if (key == KEY_TYPES || key == KEY_REFERENCES) && entry.value.is_a?(Model::LiteralHash)
@@ -297,10 +298,10 @@ class PTypeSetType < PMetaType
   end
 
   # @api private
-  def resolve_hash(type_parser, loader, init_hash)
+  def resolve_hash(loader, init_hash)
     result = Hash[init_hash.map do |key, value|
-      key = resolve_type_refs(type_parser, loader, key)
-      value = resolve_type_refs(type_parser, loader, value) unless key == KEY_TYPES && value.is_a?(Hash)
+      key = resolve_type_refs(loader, key)
+      value = resolve_type_refs(loader, value) unless key == KEY_TYPES && value.is_a?(Hash)
       [key, value]
     end]
     name_auth = resolve_name_authority(result, loader)

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

@@ -60,6 +60,7 @@ class RubyGenerator < TypeFormatter
       index += 1
       len > segments.size ? segments.size : len
     end
+    min_prefix_length = 0 if min_prefix_length == Float::INFINITY
 
     common_prefix = []
     segments_array = names_by_prefix.keys
@@ -190,17 +191,17 @@ class RubyGenerator < TypeFormatter
 
     unless obj.parent.is_a?(PObjectType) && obj_attrs.empty?
       # Output type safe hash constructor
-      bld << "\n  def self.from_hash(i12n)\n"
+      bld << "\n  def self.from_hash(init_hash)\n"
       bld << '    from_asserted_hash(' << namespace_relative(segments, TypeAsserter.name) << '.assert_instance_of('
-      bld << "'" << obj.label << " initializer', _pcore_type.i12n_type, i12n))\n  end\n\n  def self.from_asserted_hash(i12n)\n    new"
+      bld << "'" << obj.label << " initializer', _pcore_type.init_hash_type, init_hash))\n  end\n\n  def self.from_asserted_hash(init_hash)\n    new"
       unless non_opt.empty? && opt.empty?
         bld << "(\n"
-        non_opt.each { |ip| bld << "      i12n['" << ip.name << "'],\n" }
+        non_opt.each { |ip| bld << "      init_hash['" << ip.name << "'],\n" }
         opt.each do |ip|
           if ip.value.nil?
-            bld << "      i12n['" << ip.name << "'],\n"
+            bld << "      init_hash['" << ip.name << "'],\n"
           else
-            bld << "      i12n.fetch('" << ip.name << "') { "
+            bld << "      init_hash.fetch('" << ip.name << "') { "
             default_string(bld, ip)
             bld << " },\n"
           end

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

@@ -12,8 +12,8 @@ module Types
       )
     end
 
-    def self.from_hash(i12n)
-      from_asserted_hash(Types::TypeAsserter.assert_instance_of('RubyMethod initializer', _pcore_type.i12n_type, i12n))
+    def self.from_hash(init_hash)
+      from_asserted_hash(Types::TypeAsserter.assert_instance_of('RubyMethod initializer', _pcore_type.init_hash_type, init_hash))
     end
 
     def self.from_asserted_hash(init_hash)

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

@@ -1073,7 +1073,7 @@ class StringConverter
   end
 
   # @api private
-  def string_PType(val_type, val, format_map, _)
+  def string_PTypeType(val_type, val, format_map, _)
     f = get_format(val_type, format_map)
     case f.format
     when :s

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

@@ -0,0 +1,250 @@
+module Puppet::Pops::Types
+module Iterable
+
+class TreeIterator
+  include Iterable
+
+  DEFAULT_CONTAINERS = TypeFactory.variant(
+    PArrayType::DEFAULT,
+    PHashType::DEFAULT,
+    PObjectType::DEFAULT
+    )
+
+  # Creates a TreeIterator that by default treats all Array, Hash and Object instances as
+  # containers - the 'containers' option can be set to a type that denotes which types of values
+  # should be treated as containers - a `Variant[Array, Hash]` would for instance not treat
+  # Object values as containers, whereas just `Object` would only treat objects as containers.
+  #
+  # Unrecognized options are silently ignored
+  #
+  # @param [Hash] options the options
+  # @option options [PTypeType] :container_type ('Variant[Hash, Array, Object]') The type(s) that should be treated as containers. The
+  #   given type(s) must be assignable to the default container_type.
+  # @option options [Boolean] :include_root ('true') If the root container itself should be included in the iteration (requires
+  #   `include_containers` to also be `true` to take effect).
+  # @option options [Boolean] :include_containers ('true') If containers should be included in the iteration
+  # @option options [Boolean] :include_values ('true') If non containers (values) should be included in the iteration
+  # @option options [Boolean] :include_refs ('false') If (non containment) referenced values in Objects should be included 
+  #
+  def initialize(enum, options=EMPTY_HASH)
+    @root = enum
+    @element_t = nil
+    @value_stack = [enum]
+    @indexer_stack = []
+    @current_path = []
+    @recursed = false
+    @containers_t = options['container_type'] || DEFAULT_CONTAINERS
+    unless DEFAULT_CONTAINERS.assignable?(@containers_t)
+      raise ArgumentError, _("Only Array, Hash, and Object types can be used as container types. Got %{type}") % {type: @containers_t}
+    end
+    @with_root       = extract_option(options, 'include_root', true)
+    @with_containers = extract_option(options, 'include_containers', true)
+    @with_values     = extract_option(options, 'include_values', true)
+    @with_root       = @with_containers && extract_option(options, 'include_root', true)
+    unless @with_containers || @with_values
+      raise ArgumentError, _("Options 'include_containers' and 'include_values' cannot both be false")
+    end
+    @include_refs = !!options['include_refs']
+  end
+
+  # Yields each `path, value` if the block arity is 2, and only `value` if arity is 1
+  #
+  def each(&block)
+    loop do
+      if block.arity == 1
+        yield(self.next)
+      else
+        yield(*self.next)
+      end
+    end
+  end
+
+  def size
+    raise "Not yet implemented - computes size lazily"
+  end
+
+  def unbounded?
+    false
+  end
+
+  def to_array
+    result = []
+    loop do
+      result << self.next
+    end
+    result
+  end
+
+  def reverse_each(&block)
+    r = Iterator.new(PAnyType::DEFAULT, to_array.reverse_each)
+    block_given? ? r.each(&block) : r
+  end
+
+  def step(step, &block)
+    r = StepIterator.new(PAnyType::DEFAULT, self, step)
+    block_given? ? r.each(&block) : r
+  end
+
+  def indexer_on(val)
+    return nil unless @containers_t.instance?(val)
+    if val.is_a?(Array)
+      val.size.times
+    elsif val.is_a?(Hash)
+      val.each_key
+    else
+      if @include_refs
+        val._pcore_type.attributes.each_key
+      else
+        val._pcore_type.attributes.reject {|k,v| v.kind == PObjectType::ATTRIBUTE_KIND_REFERENCE }.each_key
+      end
+    end
+  end
+  private :indexer_on
+
+  def has_next?(iterator)
+    begin
+      iterator.peek
+      true
+    rescue StopIteration
+      false
+    end
+  end
+  private :has_next?
+
+  def extract_option(options, key, default)
+    v = options[key]
+    v.nil? ? default : !!v
+  end
+  private :extract_option
+end
+
+class DepthFirstTreeIterator < TreeIterator
+
+  # Creates a DepthFirstTreeIterator that by default treats all Array, Hash and Object instances as
+  # containers - the 'containers' option can be set to a type that denotes which types of values
+  # should be treated as containers - a `Variant[Array, Hash]` would for instance not treat
+  # Object values as containers, whereas just `Object` would only treat objects as containers.
+  #
+  # @param [Hash] options the options
+  # @option options [PTypeType] :containers ('Variant[Hash, Array, Object]') The type(s) that should be treated as containers
+  # @option options [Boolean] :with_root ('true') If the root container itself should be included in the iteration
+  #
+  def initialize(enum, options = EMPTY_HASH)
+    super
+  end
+
+  def next
+    loop do
+      break if @value_stack.empty?
+
+      # first call
+      if @indexer_stack.empty?
+        @indexer_stack << indexer_on(@root)
+        @recursed = true
+        return [[], @root] if @with_root
+      end
+
+      begin
+        if @recursed
+          @current_path << nil
+          @recursed = false
+        end
+        idx = @indexer_stack[-1].next
+        @current_path[-1] = idx
+        v = @value_stack[-1]
+        value = v.is_a?(PuppetObject) ? v.send(idx) : v[idx]
+        indexer = indexer_on(value)
+        if indexer
+          # recurse
+          @recursed = true
+          @value_stack << value
+          @indexer_stack << indexer
+          redo unless @with_containers
+        else
+          redo unless @with_values
+        end
+        return [@current_path.dup, value]
+
+      rescue StopIteration
+        # end of current value's range of content
+        # pop all until out of next values
+        at_the_very_end = false
+        loop do
+          pop_level
+          at_the_very_end = @indexer_stack.empty?
+          break if at_the_very_end || has_next?(@indexer_stack[-1])
+        end
+      end
+    end
+    raise StopIteration
+  end
+
+  def pop_level
+    @value_stack.pop
+    @indexer_stack.pop
+    @current_path.pop
+  end
+  private :pop_level
+end
+
+class BreadthFirstTreeIterator < TreeIterator
+  def initialize(enum, options = EMPTY_HASH)
+    @path_stack = []
+    super
+  end
+
+  def next
+    loop do
+      break if @value_stack.empty?
+
+      # first call
+      if @indexer_stack.empty?
+        @indexer_stack << indexer_on(@root)
+        @recursed = true
+        return [[], @root] if @with_root
+      end
+
+      begin
+        if @recursed
+          @current_path << nil
+          @recursed = false
+        end
+
+        idx = @indexer_stack[0].next
+        @current_path[-1] = idx
+        v = @value_stack[0]
+        value = v.is_a?(PuppetObject) ? v.send(idx) : v[idx]
+        indexer = indexer_on(value)
+        if indexer
+          @value_stack << value
+          @indexer_stack << indexer
+          @path_stack << @current_path.dup
+          next unless @with_containers
+        end
+        return [@current_path.dup, value]
+
+      rescue StopIteration
+        # end of current value's range of content
+        # shift all until out of next values
+        at_the_very_end = false
+        loop do
+          shift_level
+          at_the_very_end = @indexer_stack.empty?
+          break if at_the_very_end || has_next?(@indexer_stack[0])
+        end
+      end
+    end
+    raise StopIteration
+  end
+
+  def shift_level
+    @value_stack.shift
+    @indexer_stack.shift
+    @current_path = @path_stack.shift
+    @recursed = true
+  end
+  private :shift_level
+
+end
+end
+end