puppet 4.0.0 → 4.5.0

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

@@ -1,15 +1,17 @@
 require 'rgen/metamodel_builder'
 
+module Puppet::Pops
+module Types
 # The ClassLoader provides a Class instance given a class name or a meta-type.
 # If the class is not already loaded, it is loaded using the Puppet Autoloader.
 # This means it can load a class from a gem, or from puppet modules.
 #
-class Puppet::Pops::Types::ClassLoader
+class ClassLoader
   @autoloader = Puppet::Util::Autoload.new("ClassLoader", "")
 
   # Returns a Class given a fully qualified class name.
   # Lookup of class is never relative to the calling namespace.
-  # @param name [String, Array<String>, Array<Symbol>, Puppet::Pops::Types::PAnyType] A fully qualified
+  # @param name [String, Array<String>, Array<Symbol>, PAnyType] A fully qualified
   #   class name String (e.g. '::Foo::Bar', 'Foo::Bar'), a PAnyType, or a fully qualified name in Array form where each part
   #   is either a String or a Symbol, e.g. `%w{Puppetx Puppetlabs SomeExtension}`.
   # @return [Class, nil] the looked up class or nil if no such class is loaded
@@ -24,7 +26,7 @@ class Puppet::Pops::Types::ClassLoader
     when Array
       provide_from_name_path(name.join('::'), name)
 
-    when Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::PType
+    when PAnyType, PType
       provide_from_type(name)
 
     else
@@ -36,49 +38,47 @@ class Puppet::Pops::Types::ClassLoader
 
   def self.provide_from_type(type)
     case type
-    when Puppet::Pops::Types::PRuntimeType
+    when PRuntimeType
       raise ArgumentError.new("Only Runtime type 'ruby' is supported, got #{type.runtime}") unless type.runtime == :ruby
       provide_from_string(type.runtime_type_name)
 
-    when Puppet::Pops::Types::PBooleanType
+    when PBooleanType
       # There is no other thing to load except this Enum meta type
       RGen::MetamodelBuilder::MMBase::Boolean
 
-    when Puppet::Pops::Types::PType
+    when PType
       # TODO: PType should has a type argument (a PAnyType) so the Class' class could be returned
       #       (but this only matters in special circumstances when meta programming has been used).
       Class
 
-    when Puppet::Pops::Type::POptionalType
+    when POptionalType
       # cannot make a distinction between optional and its type
       provide_from_type(type.optional_type)
 
     # Although not expected to be the first choice for getting a concrete class for these
     # types, these are of value if the calling logic just has a reference to type.
     #
-    when Puppet::Pops::Types::PArrayType    ; Array
-    when Puppet::Pops::Types::PTupleType    ; Array
-    when Puppet::Pops::Types::PHashType     ; Hash
-    when Puppet::Pops::Types::PStructType   ; Hash
-    when Puppet::Pops::Types::PRegexpType   ; Regexp
-    when Puppet::Pops::Types::PIntegerType  ; Integer
-    when Puppet::Pops::Types::PStringType   ; String
-    when Puppet::Pops::Types::PPatternType  ; String
-    when Puppet::Pops::Types::PEnumType     ; String
-    when Puppet::Pops::Types::PFloatType    ; Float
-    when Puppet::Pops::Types::PUndefType      ; NilClass
-    when Puppet::Pops::Types::PCallableType ; Proc
+    when PArrayType    ; Array
+    when PTupleType    ; Array
+    when PHashType     ; Hash
+    when PStructType   ; Hash
+    when PRegexpType   ; Regexp
+    when PIntegerType  ; Integer
+    when PStringType   ; String
+    when PPatternType  ; String
+    when PEnumType     ; String
+    when PFloatType    ; Float
+    when PUndefType      ; NilClass
+    when PCallableType ; Proc
     else
       nil
     end
   end
 
   def self.provide_from_string(name)
-    name_path = name.split('::')
+    name_path = name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
     # always from the root, so remove an empty first segment
-    if name_path[0].empty?
-      name_path = name_path[1..-1]
-    end
+    name_path.shift if name_path[0].empty?
     provide_from_name_path(name, name_path)
   end
 
@@ -127,3 +127,5 @@ class Puppet::Pops::Types::ClassLoader
   end
 
 end
+end
+end

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

@@ -1,34 +1,16 @@
 # The Enumeration class provides default Enumerable::Enumerator creation for Puppet Programming Language
 # runtime objects that supports the concept of enumeration.
 #
-class Puppet::Pops::Types::Enumeration
-  # Produces an Enumerable::Enumerator for Array, Hash, Integer, Integer Range, and String.
-  #
-  def self.enumerator(o)
-    @@singleton ||= new
-    @@singleton.enumerator(o)
-  end
+module Puppet::Pops::Types
+  class Enumeration
+    def self.enumerator(o)
+      Puppet.deprecation_warning('Enumeration.enumerator is deprecated. Use Iterable.on instead')
+      Iterable.on(o)
+    end
 
-  # Produces an Enumerator for Array, Hash, Integer, Integer Range, and String.
-  #
-  def enumerator(o)
-    case o
-    when String
-      x = o.chars
-      # Ruby 1.9.3 returns an Enumerator, and 2.0.0 an Array
-      x.is_a?(Array) ? x.each : x
-    when Integer
-      o.times
-    when Array
-      o.each
-    when Hash
-      o.each
-    when Puppet::Pops::Types::PIntegerType
-      # Not enumerable if representing an infinite range
-      return nil if o.to.nil? || o.from.nil?
-      o.each
-    else
-      nil
+    def enumerator(o)
+      Puppet.deprecation_warning('Enumeration.enumerator is deprecated. Use Iterable.on instead')
+      Iterable.on(o)
     end
   end
 end

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

@@ -0,0 +1,146 @@
+module Puppet::Pops
+module Types
+  # The {ImplementationRegistry} maps names types in the Puppet Type System to names of corresponding implementation
+  # modules/classes. Each mapping is unique and bidirectional so that for any given type name there is only one
+  # implementation and vice versa.
+  #
+  # @api private
+  class ImplementationRegistry
+    TYPE_REGEXP_SUBST = TypeFactory.tuple([PRegexpType::DEFAULT, PStringType::NON_EMPTY])
+
+    def self.singleton
+      @singleton ||= new(Loaders.static_loader)
+    end
+
+    # Create a new instance. This method is normally only called once
+    #
+    # The initializer will create mappings for well known types that can be loaded using the static loader
+    #
+    def initialize(static_loader)
+      @type_names_per_implementation = {}
+      @implementations_per_type_name = {}
+      @type_name_substitutions = []
+      @impl_name_substitutions = []
+      @type_parser = Types::TypeParser.new
+
+      register_implementation('Pcore::AST::Locator', 'Puppet::Pops::Parser::Locator::Locator19', static_loader)
+      register_implementation_namespace('Pcore::AST', 'Puppet::Pops::Model', static_loader)
+
+      TypeParser.type_map.values.each { |type| register_implementation(type.simple_name, type.class.name, static_loader) }
+    end
+
+    # Register a bidirectional type mapping.
+    #
+    # @overload register_type_mapping(runtime_type, puppet_type)
+    #   @param runtime_type [PRuntimeType] type that represents the runtime module or class to map to a puppet type
+    #   @param puppet_type [PAnyType] type that will be mapped to the runtime module or class
+    #   @param loader [Loader::Loader] the loader to use when resolving names
+    # @overload register_type_mapping(runtime_type, pattern_replacement)
+    #   @param runtime_type [PRuntimeType] type containing the pattern and replacement to map the runtime type to a puppet type
+    #   @param puppet_type [Array(Regexp,String)] the pattern and replacement to map a puppet type to a runtime type
+    #   @param loader [Loader::Loader] the loader to use when resolving names
+    def register_type_mapping(runtime_type, puppet_type_or_pattern, loader)
+      TypeAsserter.assert_assignable('First argument of type mapping', PRuntimeType::RUBY, runtime_type)
+      expr = runtime_type.name_or_pattern
+      if expr.is_a?(Array)
+        TypeAsserter.assert_instance_of('Second argument of type mapping', TYPE_REGEXP_SUBST, puppet_type_or_pattern)
+        register_implementation_regexp(puppet_type_or_pattern, expr, loader)
+      else
+        TypeAsserter.assert_instance_of('Second argument of type mapping', PType::DEFAULT, puppet_type_or_pattern)
+        register_implementation(puppet_type_or_pattern, expr, loader)
+      end
+    end
+
+    # Register a bidirectional namespace mapping
+    #
+    # @param type_namespace [String] the namespace for the puppet types
+    # @param impl_namespace [String] the namespace for the implementations
+    # @param loader [Loader::Loader] the loader to use when resolving names
+    def register_implementation_namespace(type_namespace, impl_namespace, loader)
+      ns = TypeFormatter::NAME_SEGMENT_SEPARATOR
+      register_implementation_regexp(
+        [Regexp.compile("^#{type_namespace}#{ns}(\\w+)$"), "#{impl_namespace}#{ns}\\1"],
+        [Regexp.compile("^#{impl_namespace}#{ns}(\\w+)$"), "#{type_namespace}#{ns}\\1"],
+        loader)
+    end
+
+    # Register a bidiractional 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
+    # @param loader [Loader::Loader] the loader to use when resolving names
+    def register_implementation_regexp(type_name_subst, impl_name_subst, loader)
+      @type_name_substitutions << [type_name_subst, loader]
+      @impl_name_substitutions << [impl_name_subst, loader]
+      nil
+    end
+
+    # Register a bidirectional mapping between a type and an implementation
+    #
+    # @param type [PAnyType,String] the type or type name
+    # @param impl_module[Module,String] the module or module name
+    # @param loader [Loader::Loader] the loader to use when resolving names
+    def register_implementation(type, impl_module, loader)
+      type = type.name if type.is_a?(PAnyType)
+      impl_module = impl_module.name if impl_module.is_a?(Module)
+      @type_names_per_implementation[impl_module] = [type, loader]
+      @implementations_per_type_name[type] = [impl_module, loader]
+      nil
+    end
+
+    # Find the name for the module that corresponds to the given type or type name
+    #
+    # @param type [PAnyType,String] the name of the type
+    # @return [String,nil] the name of the implementation module, or `nil` if no mapping was found
+    def module_name_for_type(type)
+      type = type.name if type.is_a?(PAnyType)
+      find_mapping(type, @implementations_per_type_name, @type_name_substitutions)
+    end
+
+    # Find the module that corresponds to the given type or type name
+    #
+    # @param type [PAnyType,String] the name of the type
+    # @return [Module,nil] the name of the implementation module, or `nil` if no mapping was found
+    def module_for_type(type)
+      name_and_loader = module_name_for_type(type)
+      # TODO Shouldn't ClassLoader be module specific?
+      name_and_loader.nil? ? nil : ClassLoader.provide(name_and_loader[0])
+    end
+
+    # Find the type name and loader that corresponds to the given runtime module or module name
+    #
+    # @param impl_module [Module,String] the implementation class or class name
+    # @return [Array(String,Loader::Loader),nil] the name and loader of the type, or `nil` if no mapping was found
+    def type_name_for_module(impl_module)
+      impl_module = impl_module.name if impl_module.is_a?(Module)
+      find_mapping(impl_module, @type_names_per_implementation, @impl_name_substitutions)
+    end
+
+    # Find the name for, and then load, the type  that corresponds to the given runtime module or module name
+    # The method will return `nil` if no mapping is found, a TypeReference if a mapping was found but the
+    # loader didn't find the type, or the loaded type.
+    #
+    # @param impl_module [Module,String] the implementation class or class name
+    # @return [PAnyType,nil] the type, or `nil` if no mapping was found
+    def type_for_module(impl_module)
+      name_and_loader = type_name_for_module(impl_module)
+      if name_and_loader.nil?
+        nil
+      else
+        @type_parser.parse(*name_and_loader)
+      end
+    end
+
+    def find_mapping(name, names, substitutions)
+      found = names[name]
+      if found.nil?
+        substitutions.each do |subst|
+          substituted = name.sub(*subst[0])
+          return [substituted, subst[1]] unless substituted == name
+        end
+      end
+      found
+    end
+  end
+end
+end

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

@@ -0,0 +1,308 @@
+module Puppet::Pops::Types
+  # The runtime Iterable type for an Iterable
+  module Iterable
+    # Produces an `Iterable` for one of the following types with the following characterstics:
+    #
+    # `String`       - yields each character in the string
+    # `Array`        - yields each element in the array
+    # `Hash`         - yields each key/value pair as a two element array
+    # `Integer`      - when positive, yields each value from zero to the given number
+    # `PIntegerType` - yields each element from min to max (inclusive) provided min < max and neither is unbounded.
+    # `PEnumtype`    - yields each possible value of the enum.
+    # `Range`        - yields an iterator for all elements in the range provided that the range start and end
+    #                  are both integers or both strings and start is less than end using natural ordering.
+    # `Dir`          - yields each name in the directory
+    #
+    # An `ArgumentError` is raised for all other objects.
+    #
+    # @param o [Object] The object to produce an `Iterable` for
+    # @return [Iterable,nil] The produced `Iterable`
+    # @raise [ArgumentError] In case an `Iterable` cannot be produced
+    # @api public
+    def self.asserted_iterable(caller, obj)
+      iter = self.on(obj)
+      raise ArgumentError, "#{caller.class}(): wrong argument type (#{obj.class}; is not Iterable." if iter.nil?
+      iter
+    end
+
+    # Produces an `Iterable` for one of the following types with the following characterstics:
+    #
+    # `String`       - yields each character in the string
+    # `Array`        - yields each element in the array
+    # `Hash`         - yields each key/value pair as a two element array
+    # `Integer`      - when positive, yields each value from zero to the given number
+    # `PIntegerType` - yields each element from min to max (inclusive) provided min < max and neither is unbounded.
+    # `PEnumtype`    - yields each possible value of the enum.
+    # `Range`        - yields an iterator for all elements in the range provided that the range start and end
+    #                  are both integers or both strings and start is less than end using natural ordering.
+    # `Dir`          - yields each name in the directory
+    #
+    # The value `nil` is returned for all other objects.
+    #
+    # @param o [Object] The object to produce an `Iterable` for
+    # @return [Iterable,nil] The produced `Iterable` or `nil` if it couldn't be produced
+    #
+    # @api public
+    def self.on(o)
+      case o
+      when Iterable
+        o
+      when String
+        Iterator.new(PStringType.new(PIntegerType.new(1, 1)), o.each_char)
+      when Array
+        if o.empty?
+          Iterator.new(PUnitType::DEFAULT, o.each)
+        else
+          tc = TypeCalculator.singleton
+          Iterator.new(PVariantType.maybe_create(o.map {|e| tc.infer_set(e) }), o.each)
+        end
+      when Hash
+        # Each element is a two element [key, value] tuple.
+        if o.empty?
+          Iterator.new(PHashType::DEFAULT_KEY_PAIR_TUPLE, o.each)
+        else
+          tc = TypeCalculator.singleton
+          Iterator.new(PTupleType.new([
+            PVariantType.maybe_create(o.keys.map {|e| tc.infer_set(e) }),
+            PVariantType.maybe_create(o.values.map {|e| tc.infer_set(e) })], PHashType::KEY_PAIR_TUPLE_SIZE), o.each_pair)
+        end
+      when Integer
+        if o == 0
+          Iterator.new(PUnitType::DEFAULT, o.times)
+        elsif o > 0
+          IntegerRangeIterator.new(PIntegerType.new(0, o - 1))
+        else
+          nil
+        end
+      when PIntegerType
+        # a finite range will always produce at least one element since it's inclusive
+        o.finite_range? ? IntegerRangeIterator.new(o) : nil
+      when PEnumType
+        Iterator.new(o, o.values.each)
+      when Range
+        min = o.min
+        max = o.max
+        if min.is_a?(Integer) && max.is_a?(Integer) && max >= min
+          IntegerRangeIterator.new(PIntegerType.new(min, max))
+        elsif min.is_a?(String) && max.is_a?(String) && max >= min
+          # A generalized element type where only the size is inferred is used here since inferring the full
+          # range might waste a lot of memory.
+          if min.length < max.length
+            shortest = min
+            longest = max
+          else
+            shortest = max
+            longest = min
+          end
+          Iterator.new(PStringType.new(PIntegerType.new(shortest.length, longest.length)), o.each)
+        else
+          # Unsupported range. It's either descending or nonsensical for other reasons (float, mixed types, etc.)
+          nil
+        end
+      else
+        # Not supported. We cannot determine the element type
+        nil
+      end
+    end
+
+    # Answers the question if there is an end to the iteration. Puppet does not currently provide any unbounded
+    # iterables.
+    #
+    # @return [Boolean] `true` if the iteration is unbounded
+    def self.unbounded?(object)
+      case object
+      when Iterable
+        object.unbounded?
+      when String,Integer,Array,Hash,Enumerator,PIntegerType,PEnumType,Dir
+        false
+      else
+        TypeAsserter.assert_instance_of('', PIterableType::DEFAULT, object, false)
+        !object.respond_to?(:size)
+      end
+    end
+
+    def each(&block)
+      step(1, &block)
+    end
+
+    def element_type
+      PAnyType::DEFAULT
+    end
+
+    def reverse_each(&block)
+      # Default implementation cannot propagate reverse_each to a new enumerator so chained
+      # calls must put reverse_each last.
+      raise ArgumentError 'Step is not implemented'
+    end
+
+    def step(step, &block)
+      # Default implementation cannot propagate step to a new enumerator so chained
+      # calls must put stepping last.
+      raise ArgumentError 'Step is not implemented'
+    end
+
+    def to_a
+      raise Puppet::Error, 'Attempt to create an Array from an unbounded Iterable' if unbounded?
+      super
+    end
+
+    def unbounded?
+      true
+    end
+  end
+
+  # @api private
+  class Iterator
+    # Note! We do not include Enumerable module here since that would make this class respond
+    # in a bad way to all enumerable methods. We want to delegate all those calls directly to
+    # the contained @enumeration
+    include Iterable
+
+    def initialize(element_type, enumeration)
+      @element_type = element_type
+      @enumeration = enumeration
+    end
+
+    def element_type
+      @element_type
+    end
+
+    def size
+      @enumeration.size
+    end
+
+    def respond_to_missing?(name, include_private)
+      @enumeration.respond_to?(name, include_private)
+    end
+
+    def method_missing(name, *arguments, &block)
+      @enumeration.send(name, *arguments, &block)
+    end
+
+    def step(step, &block)
+      raise ArgumentError if step <= 0
+      r = self
+      r = r.step_iterator(step) if step > 1
+
+      if block_given?
+        begin
+        if block.arity == 1
+          loop { yield(r.next) }
+        else
+          loop { yield(*r.next) }
+        end
+        rescue StopIteration
+        end
+        self
+      else
+        r
+      end
+    end
+
+    def reverse_each(&block)
+      r = Iterator.new(@element_type, @enumeration.reverse_each)
+      block_given? ? r.each(&block) : r
+    end
+
+    def step_iterator(step)
+      StepIterator.new(@element_type, self, step)
+    end
+
+    def to_s
+      et = element_type
+      et.nil? ? 'Iterator-Value' : "Iterator[#{et.generalize}]-Value"
+    end
+
+    def unbounded?
+      Iterable.unbounded?(@enumeration)
+    end
+  end
+
+  # @api private
+  class StepIterator < Iterator
+    include Enumerable
+
+    def initialize(element_type, enumeration, step_size)
+      super(element_type, enumeration)
+      raise ArgumentError if step_size <= 0
+      @step_size = step_size
+    end
+
+    def next
+      result = @enumeration.next
+      skip = @step_size - 1
+      if skip > 0
+        begin
+          skip.times { @enumeration.next }
+        rescue StopIteration
+        end
+      end
+      result
+    end
+
+    def reverse_each(&block)
+      r = Iterator.new(@element_type, to_a.reverse_each)
+      block_given? ? r.each(&block) : r
+    end
+
+    def size
+      super / @step_size
+    end
+  end
+
+  # @api private
+  class IntegerRangeIterator < Iterator
+    include Enumerable
+
+    def initialize(range, step = 1)
+      raise ArgumentError if step == 0
+      @range = range
+      @step_size = step
+      @current = (step < 0 ? range.to : range.from) - step
+    end
+
+    def element_type
+      @range
+    end
+
+    def next
+      value = @current + @step_size
+      if @step_size < 0
+        raise StopIteration if value < @range.from
+      else
+        raise StopIteration if value > @range.to
+      end
+      @current = value
+    end
+
+    def reverse_each(&block)
+      r = IntegerRangeIterator.new(@range, -@step_size)
+      block_given? ? r.each(&block) : r
+    end
+
+    def size
+      (@range.to - @range.from) / @step_size.abs
+    end
+
+    def step_iterator(step)
+      # The step iterator must use a range that has its logical end truncated at an even step boundary. This will
+      # fulfil two objectives:
+      # 1. The element_type method should not report excessive integers as possible numbers
+      # 2. A reversed iterator must start at the correct number
+      #
+      range = @range
+      step = @step_size * step
+      mod = (range.to - range.from) % step
+      if mod < 0
+        range = PIntegerType.new(range.from - mod, range.to)
+      elsif mod > 0
+        range = PIntegerType.new(range.from, range.to - mod)
+      end
+      IntegerRangeIterator.new(range, step)
+    end
+
+    def unbounded?
+      false
+    end
+  end
+end