puppet 5.0.0 → 6.0.0

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

@@ -0,0 +1,254 @@
+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_a
+    result = []
+    loop do
+      result << self.next
+    end
+    result
+  end
+
+  def to_array
+    to_a
+  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

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

@@ -10,7 +10,7 @@ module Types
 #
 module TypeAcceptor
   # @param type [PAnyType] the type that we accept a visit from
-  # @param quard [RecursionGuard] the guard against self recursion
+  # @param guard [RecursionGuard] the guard against self recursion
   def visit(type, guard)
   end
 end

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

@@ -108,7 +108,7 @@ class TypeCalculator
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
   # @param callable [PCallableType] - the callable
   # @param args [PArrayType, PTupleType] args optionally including a lambda callable at the end
-  # @return [Boolan] true if the callable accepts the arguments
+  # @return [Boolean] true if the callable accepts the arguments
   #
   # @api public
   def self.callable?(callable, args)
@@ -159,11 +159,12 @@ class TypeCalculator
       t = type(t)
     end
     t.is_a?(PAnyType) ? t.assignable?(t2) : false
- end
+  end
 
   # Returns an iterable if the t represents something that can be iterated
   def enumerable(t)
-    Puppet.deprecation_warning('TypeCalculator.enumerable is deprecated. Use iterable')
+    #TRANSLATOR 'TypeCalculator.enumerable' and 'iterable' are methods and should not be translated
+    Puppet.deprecation_warning(_('TypeCalculator.enumerable is deprecated. Use iterable'))
     iterable(t)
   end
 
@@ -212,7 +213,7 @@ class TypeCalculator
     when c == FalseClass, c == TrueClass
       type = PBooleanType::DEFAULT
     when c == Class
-      type = PType::DEFAULT
+      type = PTypeType::DEFAULT
     when c == Array
       # Assume array of any
       type = PArrayType::DEFAULT
@@ -347,8 +348,8 @@ class TypeCalculator
     end
 
     # when both are host-classes, reduce to PHostClass[] (since one was not assignable to the other)
-    if t1.is_a?(PHostClassType) && t2.is_a?(PHostClassType)
-      return PHostClassType::DEFAULT
+    if t1.is_a?(PClassType) && t2.is_a?(PClassType)
+      return PClassType::DEFAULT
     end
 
     # when both are resources, reduce to Resource[T] or Resource[] (since one was not assignable to the other)
@@ -427,8 +428,8 @@ class TypeCalculator
     end
 
     # Meta types Type[Integer] + Type[String] => Type[Data]
-    if t1.is_a?(PType) && t2.is_a?(PType)
-      return PType.new(common_type(t1.type, t2.type))
+    if t1.is_a?(PTypeType) && t2.is_a?(PTypeType)
+      return PTypeType.new(common_type(t1.type, t2.type))
     end
 
     if common_rich_data?(t1,t2)
@@ -484,11 +485,11 @@ class TypeCalculator
     reduce_type(enumerable.map {|o| infer(o) })
   end
 
-  # The type of all modules is PType
+  # The type of all modules is PTypeType
   # @api private
   #
   def infer_Module(o)
-    PType::new(PRuntimeType.new(:ruby, o.name))
+    PTypeType::new(PRuntimeType.new(:ruby, o.name))
   end
 
   # @api private
@@ -512,25 +513,30 @@ class TypeCalculator
       o._pcore_type
     else
       name = o.class.name
+      return PRuntimeType.new(:ruby, nil) if name.nil? # anonymous class that doesn't implement PuppetObject is impossible to infer
       ir = Loaders.implementation_registry
       type = ir.nil? ? nil : ir.type_for_module(name)
-      type.nil? ? PRuntimeType.new(:ruby, name) : type
+      return PRuntimeType.new(:ruby, name) if type.nil?
+      if type.is_a?(PObjectType) && type.parameterized?
+        type = PObjectTypeExtension.create_from_instance(type, o)
+      end
+      type
     end
   end
 
-  # The type of all types is PType
+  # The type of all types is PTypeType
   # @api private
   #
   def infer_PAnyType(o)
-    PType.new(o)
+    PTypeType.new(o)
   end
 
-  # The type of all types is PType
+  # The type of all types is PTypeType
   # This is the metatype short circuit.
   # @api private
   #
-  def infer_PType(o)
-    PType.new(o)
+  def infer_PTypeType(o)
+    PTypeType.new(o)
   end
 
   # @api private
@@ -550,7 +556,7 @@ class TypeCalculator
 
   # @api private
   def infer_Regexp(o)
-    PRegexpType.new(o.source)
+    PRegexpType.new(o)
   end
 
   # @api private
@@ -613,12 +619,17 @@ class TypeCalculator
 
   # @api private
   def infer_TrueClass(o)
-    PBooleanType::DEFAULT
+    PBooleanType::TRUE
   end
 
   # @api private
   def infer_FalseClass(o)
-    PBooleanType::DEFAULT
+    PBooleanType::FALSE
+  end
+
+  # @api private
+  def infer_URI(o)
+    PURIType.new(o)
   end
 
   # @api private
@@ -629,7 +640,7 @@ class TypeCalculator
     # A mapping must be made to empty string. A nil value will result in an error later
     title = o.title
     title = '' if :undef == title
-    PType.new(PResourceType.new(o.type.to_s, title))
+    PTypeType.new(PResourceType.new(o.type.to_s, title))
   end
 
   # @api private

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

@@ -6,6 +6,19 @@ module Types
 module TypeFactory
   @type_calculator = TypeCalculator.singleton
 
+  # Clears caches - used when testing
+  def self.clear
+    # these types are cached and needs to be nulled as the representation may change if loaders are cleared
+    @data_t = nil
+    @rich_data_t = nil
+    @rich_data_key_t = nil
+    @array_of_data_t = nil
+    @hash_of_data_t = nil
+    @error_t = nil
+    @task_t = nil
+    @deferred_t = nil
+  end
+
   # Produces the Integer type
   # @api public
   #
@@ -54,6 +67,21 @@ module TypeFactory
     PNumericType::DEFAULT
   end
 
+  # Produces the Init type
+  # @api public
+  def self.init(*args)
+    case args.size
+    when 0
+      PInitType::DEFAULT
+    when 1
+      type = args[0]
+      type.nil? ? PInitType::DEFAULT : PInitType.new(type, EMPTY_ARRAY)
+    else
+      type = args.shift
+      PInitType.new(type, args)
+    end
+  end
+
   # Produces the Iterable type
   # @api public
   #
@@ -85,7 +113,9 @@ module TypeFactory
       size_type_or_value.nil? ? PStringType::DEFAULT : PStringType.new(size_type_or_value)
     else
       if Puppet[:strict] != :off
-        Puppet.warn_once('deprecations', "TypeFactory#string_multi_args", "Passing more than one argument to TypeFactory#string is deprecated")
+        #TRANSLATORS 'TypeFactory#string' is a class and method name and should not be translated
+        message = _("Passing more than one argument to TypeFactory#string is deprecated")
+        Puppet.warn_once('deprecations', "TypeFactory#string_multi_args", message)
       end
       deprecated_second_argument.size == 1 ? PStringType.new(deprecated_second_argument[0]) : PEnumType.new(*deprecated_second_argument)
     end
@@ -101,14 +131,24 @@ module TypeFactory
   # @api public
   #
   def self.optional(optional_type = nil)
-    POptionalType.new(type_of(optional_type.is_a?(String) ? string(optional_type) : type_of(optional_type)))
+    if optional_type.nil?
+      POptionalType::DEFAULT
+    else
+      POptionalType.new(type_of(optional_type.is_a?(String) ? string(optional_type) : type_of(optional_type)))
+    end
   end
 
   # Produces the Enum type, optionally with specific string values
   # @api public
   #
   def self.enum(*values)
-    PEnumType.new(values)
+    last = values.last
+    case_insensitive = false
+    if last == true || last == false
+      case_insensitive = last
+      values = values[0...-1]
+    end
+    PEnumType.new(values, case_insensitive)
   end
 
   # Produces the Variant type, optionally with the "one of" types
@@ -171,8 +211,8 @@ module TypeFactory
   # @param hash [{String=>Object}] the hash of feature groups
   # @return [PObjectType] the created type
   #
-  def self.object(hash = nil)
-    hash.nil? || hash.empty? ? PObjectType::DEFAULT : PObjectType.new(hash)
+  def self.object(hash = nil, loader = nil)
+    hash.nil? || hash.empty? ? PObjectType::DEFAULT : PObjectType.new(hash, loader)
   end
 
   def self.type_set(hash = nil)
@@ -183,8 +223,6 @@ module TypeFactory
     case args.size
     when 0
       PTimestampType::DEFAULT
-    when 1
-      PTimestampType.new(args[0], args[0])
     else
       PTimestampType.new(*args)
     end
@@ -194,8 +232,6 @@ module TypeFactory
     case args.size
     when 0
       PTimespanType::DEFAULT
-    when 1
-      PTimespanType.new(args[0], args[0])
     else
       PTimespanType.new(*args)
     end
@@ -208,8 +244,8 @@ module TypeFactory
   # Produces the Boolean type
   # @api public
   #
-  def self.boolean
-    PBooleanType::DEFAULT
+  def self.boolean(value = nil)
+    value.nil? ? PBooleanType::DEFAULT : (value ? PBooleanType::TRUE : PBooleanType::FALSE)
   end
 
   # Produces the Any type
@@ -342,6 +378,13 @@ module TypeFactory
     @rich_data_t ||= TypeParser.singleton.parse('RichData', Loaders.static_loader)
   end
 
+  # Produces the RichData type
+  # @api public
+  #
+  def self.rich_data_key
+    @rich_data_key_t ||= TypeParser.singleton.parse('RichDataKey', Loaders.static_loader)
+  end
+
   # Creates an instance of the Undef type
   # @api public
   def self.undef
@@ -396,16 +439,16 @@ module TypeFactory
     end
   end
 
-  # Produces PHostClassType with a string class_name.  A PHostClassType with
-  # nil or empty name is compatible with any other PHostClassType.  A
-  # PHostClassType with a given name is only compatible with a PHostClassType
+  # Produces PClassType with a string class_name.  A PClassType with
+  # nil or empty name is compatible with any other PClassType.  A
+  # PClassType with a given name is only compatible with a PClassType
   # with the same name.
   #
   def self.host_class(class_name = nil)
     if class_name.nil?
-      PHostClassType::DEFAULT
+      PClassType::DEFAULT
     else
-      PHostClassType.new(class_name.sub(/^::/, ''))
+      PClassType.new(class_name.sub(/^::/, ''))
     end
   end
 
@@ -482,7 +525,29 @@ module TypeFactory
   # @api public
   #
   def self.type_type(inst_type = nil)
-    inst_type.nil? ? PType::DEFAULT : PType.new(inst_type)
+    inst_type.nil? ? PTypeType::DEFAULT : PTypeType.new(inst_type)
+  end
+
+  # Produces a type for Error
+  # @api public
+  #
+  def self.error
+    @error_t ||= TypeParser.singleton.parse('Error', Loaders.loaders.puppet_system_loader)
+  end
+
+  def self.task
+    @task_t ||= TypeParser.singleton.parse('Task')
+  end
+
+  def self.deferred
+    @deferred_t ||= TypeParser.singleton.parse('Deferred')
+  end
+
+  # Produces a type for URI[String or Hash]
+  # @api public
+  #
+  def self.uri(string_uri_or_hash = nil)
+    string_uri_or_hash.nil? ? PURIType::DEFAULT : PURIType.new(string_uri_or_hash)
   end
 
   # Produce a type corresponding to the class of given unless given is a