puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Puppet::Pops::Types
 module Iterable
-
 class TreeIterator
   include Iterable
 
@@ -8,7 +9,7 @@ class TreeIterator
     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
@@ -24,9 +25,9 @@ class TreeIterator
   #   `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 
+  # @option options [Boolean] :include_refs ('false') If (non containment) referenced values in Objects should be included
   #
-  def initialize(enum, options=EMPTY_HASH)
+  def initialize(enum, options = EMPTY_HASH)
     @root = enum
     @element_t = nil
     @value_stack = [enum]
@@ -35,8 +36,9 @@ class TreeIterator
     @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}
+      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)
@@ -44,6 +46,7 @@ class TreeIterator
     unless @with_containers || @with_values
       raise ArgumentError, _("Options 'include_containers' and 'include_values' cannot both be false")
     end
+
     @include_refs = !!options['include_refs']
   end
 
@@ -91,27 +94,24 @@ class TreeIterator
 
   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
+    elsif @include_refs
+      val._pcore_type.attributes.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
+      val._pcore_type.attributes.reject { |_k, v| v.kind == PObjectType::ATTRIBUTE_KIND_REFERENCE }.each_key
     end
   end
   private :indexer_on
 
   def has_next?(iterator)
-    begin
-      iterator.peek
-      true
-    rescue StopIteration
-      false
-    end
+    iterator.peek
+    true
+  rescue StopIteration
+    false
   end
   private :has_next?
 
@@ -123,7 +123,6 @@ class TreeIterator
 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
@@ -168,7 +167,6 @@ class DepthFirstTreeIterator < TreeIterator
           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
@@ -226,7 +224,6 @@ class BreadthFirstTreeIterator < TreeIterator
           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
@@ -248,7 +245,6 @@ class BreadthFirstTreeIterator < TreeIterator
     @recursed = true
   end
   private :shift_level
-
 end
 end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
 # Implements a standard visitor patter for the Puppet Type system.

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Utility module for type assertion
 #
 module Puppet::Pops::Types
@@ -37,11 +39,11 @@ module TypeAsserter
 
   def self.report_type_mismatch(subject, expected_type, actual_type, what = 'has wrong type')
     subject = yield(subject) if block_given?
-    subject = subject[0] % subject[1..-1] if subject.is_a?(Array)
+    subject = subject[0] % subject[1..] if subject.is_a?(Array)
     raise TypeAssertionError.new(
-      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} #{what},", expected_type, actual_type), expected_type, actual_type)
+      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} #{what},", expected_type, actual_type), expected_type, actual_type
+    )
   end
   private_class_method :report_type_mismatch
 end
 end
-

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

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
 
 module Puppet::Pops::Types
   # Raised when an assertion of actual type against an expected type fails.
   #
   class TypeAssertionError < Puppet::Error
-
     # Returns the expected type
     # @return [PAnyType] expected type
     attr_reader :expected_type

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

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/concurrent/thread_local_singleton'
+
 module Puppet::Pops
 module Types
 # The TypeCalculator can answer questions about puppet types.
@@ -99,10 +103,11 @@ module Types
 # @api public
 #
 class TypeCalculator
+  extend Puppet::Concurrent::ThreadLocalSingleton
 
   # @api public
   def self.assignable?(t1, t2)
-    singleton.assignable?(t1,t2)
+    singleton.assignable?(t1, t2)
   end
 
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
@@ -120,6 +125,31 @@ class TypeCalculator
     singleton.infer(o)
   end
 
+  # Infers a type if given object may have callable members, else returns nil.
+  # Caller must check for nil or if returned type supports members.
+  # This is a much cheaper call than doing a call to the general infer(o) method.
+  #
+  # @api private
+  def self.infer_callable_methods_t(o)
+    # If being a value that cannot have Pcore based methods callable from Puppet Language
+    if o.is_a?(String) ||
+       o.is_a?(Numeric) ||
+       o.is_a?(TrueClass) ||
+       o.is_a?(FalseClass) ||
+       o.is_a?(Regexp) ||
+       o.instance_of?(Array) ||
+       o.instance_of?(Hash) ||
+       Types::PUndefType::DEFAULT.instance?(o)
+
+      return nil
+    end
+
+    # For other objects (e.g. PObjectType instances, and runtime types) full inference needed, since that will
+    # cover looking into the runtime type registry.
+    #
+    infer(o)
+  end
+
   # @api public
   def self.generalize(o)
     singleton.generalize(o)
@@ -135,18 +165,11 @@ class TypeCalculator
     singleton.iterable(t)
   end
 
-  # @return [TypeCalculator] the singleton instance
-  #
-  # @api private
-  def self.singleton
-    @tc_instance ||= new
-  end
-
   # @api public
   #
   def initialize
-    @@infer_visitor ||= Visitor.new(nil, 'infer',0,0)
-    @@extract_visitor ||= Visitor.new(nil, 'extract',0,0)
+    @infer_visitor = Visitor.new(nil, 'infer', 0, 0)
+    @extract_visitor = Visitor.new(nil, 'extract', 0, 0)
   end
 
   # Answers 'can an instance of type t2 be assigned to a variable of type t'.
@@ -161,13 +184,6 @@ class TypeCalculator
     t.is_a?(PAnyType) ? t.assignable?(t2) : false
   end
 
-  # Returns an iterable if the t represents something that can be iterated
-  def enumerable(t)
-    #TRANSLATOR 'TypeCalculator.enumerable' and 'iterable' are methods and should not be translated
-    Puppet.deprecation_warning(_('TypeCalculator.enumerable is deprecated. Use iterable'))
-    iterable(t)
-  end
-
   # Returns an iterable if the t represents something that can be iterated
   def iterable(t)
     # Create an iterable on the type if possible
@@ -183,6 +199,7 @@ class TypeCalculator
   # Answers if the two given types describe the same type
   def equals(left, right)
     return false unless left.is_a?(PAnyType) && right.is_a?(PAnyType)
+
     # Types compare per class only - an extra test must be made if the are mutually assignable
     # to find all types that represent the same type of instance
     #
@@ -197,30 +214,29 @@ class TypeCalculator
     raise ArgumentError, 'Argument must be a Module' unless c.is_a? Module
 
     # Can't use a visitor here since we don't have an instance of the class
-    case
-    when c <= Integer
+    if c <= Integer
       type = PIntegerType::DEFAULT
-    when c == Float
+    elsif c == Float
       type = PFloatType::DEFAULT
-    when c == Numeric
+    elsif c == Numeric
       type = PNumericType::DEFAULT
-    when c == String
+    elsif c == String
       type = PStringType::DEFAULT
-    when c == Regexp
+    elsif c == Regexp
       type = PRegexpType::DEFAULT
-    when c == NilClass
+    elsif c == NilClass
       type = PUndefType::DEFAULT
-    when c == FalseClass, c == TrueClass
+    elsif c == FalseClass || c == TrueClass
       type = PBooleanType::DEFAULT
-    when c == Class
+    elsif c == Class
       type = PTypeType::DEFAULT
-    when c == Array
+    elsif c == Array
       # Assume array of any
       type = PArrayType::DEFAULT
-    when c == Hash
+    elsif c == Hash
       # Assume hash of any
       type = PHashType::DEFAULT
-   else
+    else
       type = PRuntimeType.new(:ruby, c.name)
     end
     type
@@ -239,18 +255,19 @@ class TypeCalculator
   def infer(o)
     # Optimize the most common cases into direct calls.
     # Explicit if/elsif/else is faster than case
-    if o.is_a?(String)
+    case o
+    when String
       infer_String(o)
-    elsif o.is_a?(Integer) # need subclasses for Ruby < 2.4
+    when Integer # need subclasses for Ruby < 2.4
       infer_Integer(o)
-    elsif o.is_a?(Array)
+    when Array
       infer_Array(o)
-    elsif o.is_a?(Hash)
+    when Hash
       infer_Hash(o)
-    elsif o.is_a?(Evaluator::PuppetProc)
+    when Evaluator::PuppetProc
       infer_PuppetProc(o)
     else
-      @@infer_visitor.visit_this_0(self, o)
+      @infer_visitor.visit_this_0(self, o)
     end
   end
 
@@ -277,7 +294,7 @@ class TypeCalculator
   # @api public
   #
   def self.instance?(t, o)
-    singleton.instance?(t,o)
+    singleton.instance?(t, o)
   end
 
   # Answers 'is o an instance of type t'
@@ -355,7 +372,7 @@ class TypeCalculator
     # when both are resources, reduce to Resource[T] or Resource[] (since one was not assignable to the other)
     if t1.is_a?(PResourceType) && t2.is_a?(PResourceType)
       # only Resource[] unless the type name is the same
-      return t1.type_name == t2.type_name ?  PResourceType.new(t1.type_name, nil) : PResourceType::DEFAULT
+      return t1.type_name == t2.type_name ? PResourceType.new(t1.type_name, nil) : PResourceType::DEFAULT
     end
 
     # Integers have range, expand the range to the common range
@@ -369,7 +386,7 @@ class TypeCalculator
     end
 
     if t1.is_a?(PStringType) && (t2.is_a?(PStringType) || t2.is_a?(PEnumType))
-      if(t2.is_a?(PEnumType))
+      if t2.is_a?(PEnumType)
         return t1.value.nil? ? PEnumType::DEFAULT : PEnumType.new(t2.values | [t1.value])
       end
 
@@ -423,7 +440,7 @@ class TypeCalculator
       return PScalarType::DEFAULT
     end
 
-    if common_data?(t1,t2)
+    if common_data?(t1, t2)
       return TypeFactory.data
     end
 
@@ -432,7 +449,7 @@ class TypeCalculator
       return PTypeType.new(common_type(t1.type, t2.type))
     end
 
-    if common_rich_data?(t1,t2)
+    if common_rich_data?(t1, t2)
       return TypeFactory.rich_data
     end
 
@@ -441,13 +458,14 @@ class TypeCalculator
       if t1.runtime == t2.runtime && t1.runtime_type_name == t2.runtime_type_name
         return t1
       end
+
       # finding the common super class requires that names are resolved to class
       # NOTE: This only supports runtime type of :ruby
       c1 = ClassLoader.provide_from_type(t1)
       c2 = ClassLoader.provide_from_type(t2)
       if c1 && c2
         c2_superclasses = superclasses(c2)
-        superclasses(c1).each do|c1_super|
+        superclasses(c1).each do |c1_super|
           c2_superclasses.each do |c2_super|
             if c1_super == c2_super
               return PRuntimeType.new(:ruby, c1_super.name)
@@ -464,7 +482,7 @@ class TypeCalculator
   # Produces the superclasses of the given class, including the class
   def superclasses(c)
     result = [c]
-    while s = c.superclass
+    while s = c.superclass # rubocop:disable Lint/AssignmentInCondition
       result << s
       c = s
     end
@@ -475,21 +493,21 @@ class TypeCalculator
   # @api public
   #
   def reduce_type(enumerable)
-    enumerable.reduce(nil) {|memo, t| common_type(memo, t) }
+    enumerable.reduce(nil) { |memo, t| common_type(memo, t) }
   end
 
   # Reduce an enumerable of objects to a single common type
   # @api public
   #
   def infer_and_reduce_type(enumerable)
-    reduce_type(enumerable.map {|o| infer(o) })
+    reduce_type(enumerable.map { |o| infer(o) })
   end
 
   # The type of all modules is PTypeType
   # @api private
   #
   def infer_Module(o)
-    PTypeType::new(PRuntimeType.new(:ruby, o.name))
+    PTypeType.new(PRuntimeType.new(:ruby, o.name))
   end
 
   # @api private
@@ -514,9 +532,11 @@ class TypeCalculator
     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)
       return PRuntimeType.new(:ruby, name) if type.nil?
+
       if type.is_a?(PObjectType) && type.parameterized?
         type = PObjectTypeExtension.create_from_instance(type, o)
       end
@@ -700,18 +720,18 @@ class TypeCalculator
     if o.empty?
       PArrayType::EMPTY
     else
-      PTupleType.new(o.map {|x| infer_set(x) })
+      PTupleType.new(o.map { |x| infer_set(x) })
     end
   end
 
   def infer_set_Hash(o)
     if o.empty?
       PHashType::EMPTY
-    elsif o.keys.all? {|k| PStringType::NON_EMPTY.instance?(k) }
-      PStructType.new(o.each_pair.map { |k,v| PStructElement.new(PStringType.new(k), infer_set(v)) })
+    elsif o.keys.all? { |k| PStringType::NON_EMPTY.instance?(k) }
+      PStructType.new(o.each_pair.map { |k, v| PStructElement.new(PStringType.new(k), infer_set(v)) })
     else
-      ktype = PVariantType.maybe_create(o.keys.map {|k| infer_set(k) })
-      etype = PVariantType.maybe_create(o.values.map {|e| infer_set(e) })
+      ktype = PVariantType.maybe_create(o.keys.map { |k| infer_set(k) })
+      etype = PVariantType.maybe_create(o.values.map { |e| infer_set(e) })
       PHashType.new(unwrap_single_variant(ktype), unwrap_single_variant(etype), size_as_type(o))
     end
   end
@@ -735,7 +755,8 @@ class TypeCalculator
   # if range.to == nil max size == Infinity
   #
   def size_range(range)
-    return [1,1] if range.nil?
+    return [1, 1] if range.nil?
+
     from = range.from
     to = range.to
     x = from.nil? ? 1 : from
@@ -748,11 +769,11 @@ class TypeCalculator
     t.is_a?(PAnyType) && t.kind_of_callable?(optional)
   end
 
-  def max(a,b)
-    a >=b ? a : b
+  def max(a, b)
+    a >= b ? a : b
   end
 
-  def min(a,b)
+  def min(a, b)
     a <= b ? a : b
   end
 
@@ -803,7 +824,6 @@ class TypeCalculator
   def common_numeric?(t1, t2)
     PNumericType::DEFAULT.assignable?(t1) && PNumericType::DEFAULT.assignable?(t2)
   end
-
 end
 end
 end

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

@@ -1,15 +1,7 @@
+# frozen_string_literal: true
 
 module Puppet::Pops::Types
   # Raised when a conversion of a value to another type failed.
   #
-  class TypeConversionError < Puppet::Error
-
-    # Creates a new instance with a given message
-    #
-    # @param message [String] The error message describing what failed
-    #
-    def initialize(message)
-      super(message)
-    end
-  end
+  class TypeConversionError < Puppet::Error; end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
 # Helper module that makes creation of type objects simpler.
@@ -113,7 +115,7 @@ module TypeFactory
       size_type_or_value.nil? ? PStringType::DEFAULT : PStringType.new(size_type_or_value)
     else
       if Puppet[:strict] != :off
-        #TRANSLATORS 'TypeFactory#string' is a class and method name and should not be translated
+        # 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
@@ -155,7 +157,7 @@ module TypeFactory
   # @api public
   #
   def self.variant(*types)
-    PVariantType.maybe_create(types.map {|v| type_of(v) })
+    PVariantType.maybe_create(types.map { |v| type_of(v) })
   end
 
   # Produces the Struct type, either a non parameterized instance representing
@@ -178,6 +180,7 @@ module TypeFactory
       # TODO: Should have stricter name rule
       if key_type.is_a?(String)
         raise ArgumentError, 'Struct element key cannot be an empty String' if key_type.empty?
+
         key_type = string(key_type)
         # Must make key optional if the value can be Undef
         key_type = optional(key_type) if tc.assignable?(value_type, PUndefType::DEFAULT)
@@ -238,14 +241,18 @@ module TypeFactory
   end
 
   def self.tuple(types = [], size_type = nil)
-    PTupleType.new(types.map {|elem| type_of(elem) }, size_type)
+    PTupleType.new(types.map { |elem| type_of(elem) }, size_type)
   end
 
   # Produces the Boolean type
   # @api public
   #
   def self.boolean(value = nil)
-    value.nil? ? PBooleanType::DEFAULT : (value ? PBooleanType::TRUE : PBooleanType::FALSE)
+    if value.nil?
+      PBooleanType::DEFAULT
+    else
+      value ? PBooleanType::TRUE : PBooleanType::FALSE
+    end
   end
 
   # Produces the Any type
@@ -269,7 +276,7 @@ module TypeFactory
       case re
       when String
         re_t = PRegexpType.new(re)
-        re_t.regexp  # compile it to catch errors
+        re_t.regexp # compile it to catch errors
         re_t
 
       when Regexp
@@ -281,8 +288,8 @@ module TypeFactory
       when PPatternType
         re.patterns
 
-     else
-       raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}"
+      else
+        raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}"
       end
     end.flatten.uniq
     PPatternType.new(patterns)
@@ -306,7 +313,7 @@ module TypeFactory
   # @api public
   #
   def self.all_callables
-    return PCallableType::DEFAULT
+    PCallableType::DEFAULT
   end
 
   # Produces a Callable type with one signature without support for a block
@@ -346,7 +353,7 @@ module TypeFactory
       size_type = nil
     end
 
-    types = params.map {|p| type_of(p) }
+    types = params.map { |p| type_of(p) }
 
     # If the specification requires types, and none were given, a Unit type is used
     if types.empty? && !size_type.nil? && size_type.range[1] > 0
@@ -415,7 +422,7 @@ module TypeFactory
 
   # Produces an instance of the SemVer type
   def self.sem_ver(*ranges)
-    ranges.empty? ? PSemVerType::DEFAULT : PSemVerType::new(ranges)
+    ranges.empty? ? PSemVerType::DEFAULT : PSemVerType.new(ranges)
   end
 
   # Produces a PResourceType with a String type_name A PResourceType with a nil
@@ -430,9 +437,11 @@ module TypeFactory
     when String
       type_name = TypeFormatter.singleton.capitalize_segments(type_name)
       raise ArgumentError, "Illegal type name '#{type_name}'" unless type_name =~ Patterns::CLASSREF_EXT
+
       PResourceType.new(type_name, title)
     when nil
       raise ArgumentError, 'The type name cannot be nil, if title is given' unless title.nil?
+
       PResourceType::DEFAULT
     else
       raise ArgumentError, "The type name cannot be a #{type_name.class.name}"
@@ -555,11 +564,12 @@ module TypeFactory
   # a classname.
   #
   def self.type_of(o)
-    if o.is_a?(Class)
+    case o
+    when Class
       @type_calculator.type(o)
-    elsif o.is_a?(PAnyType)
+    when PAnyType
       o
-    elsif o.is_a?(String)
+    when String
       PRuntimeType.new(:ruby, o)
     else
       @type_calculator.infer_generic(o)
@@ -599,7 +609,7 @@ module TypeFactory
   # Generic creator of a RuntimeType - allows creating the type with nil or
   # String runtime_type_name.  Also see ruby_type(o) and ruby(o).
   #
-  def self.runtime(runtime=nil, runtime_type_name = nil)
+  def self.runtime(runtime = nil, runtime_type_name = nil)
     runtime = runtime.to_sym if runtime.is_a?(String)
     PRuntimeType.new(runtime, runtime_type_name)
   end
@@ -617,7 +627,7 @@ module TypeFactory
   # @param type_string [String] the string form of the type
   # @return [PTypeReferenceType] the type reference
   def self.type_reference(type_string = nil)
-    type_string == nil ? PTypeReferenceType::DEFAULT : PTypeReferenceType.new(type_string)
+    type_string.nil? ? PTypeReferenceType::DEFAULT : PTypeReferenceType.new(type_string)
   end
 
   # Returns true if the given type t is of valid range parameter type (integer
@@ -625,7 +635,6 @@ module TypeFactory
   def self.is_range_parameter?(t)
     t.is_a?(Integer) || t == 'default' || :default == t
   end
-
 end
 end
 end