puppet 4.4.0 → 4.5.0

data/lib/puppet/pops/parser/evaluating_parser.rb

@@ -11,6 +11,10 @@ class EvaluatingParser
     @parser = Parser.new()
   end
 
+  def self.singleton
+    @instance ||= new
+  end
+
   def parse_string(s, file_source = nil)
     @file_source = file_source
     clear()

data/lib/puppet/pops/parser/locator.rb

@@ -1,6 +1,8 @@
+module Puppet::Pops
+module Parser
 # Helper class that keeps track of where line breaks are located and can answer questions about positions.
 #
-class Puppet::Pops::Parser::Locator
+class Locator
   # Creates, or recreates a Locator. A Locator is created if index is not given (a scan is then
   # performed of the given source string.
   #
@@ -73,14 +75,14 @@ class Puppet::Pops::Parser::Locator
   #
   # Note that leading_offset must be the same for all lines and measured in characters.
   #
-  class SubLocator < Puppet::Pops::Parser::Locator
+  class SubLocator < Locator
     attr_reader :locator
     attr_reader :leading_line_count
     attr_reader :leading_offset
     attr_reader :leading_line_offset
 
     def self.sub_locator(string, file, leading_line_count, leading_offset, leading_line_offset)
-      self.new(Puppet::Pops::Parser::Locator.locator(string, file),
+      self.new(Locator.locator(string, file),
         leading_line_count,
         leading_offset,
         leading_line_offset)
@@ -130,7 +132,7 @@ class Puppet::Pops::Parser::Locator
 
   private
 
-  class AbstractLocator < Puppet::Pops::Parser::Locator
+  class AbstractLocator < Locator
     attr_accessor :line_index
     attr_accessor :string
     attr_accessor :prev_offset
@@ -286,3 +288,5 @@ class Puppet::Pops::Parser::Locator
     end
   end
 end
+end
+end

data/lib/puppet/pops/pcore.rb

@@ -0,0 +1,30 @@
+require 'uri'
+
+module Puppet::Pops
+module Pcore
+  TYPE_QUALIFIED_REFERENCE = Types::TypeFactory.pattern(Types::TypeFactory.regexp(Patterns::CLASSREF_EXT))
+
+  def self.init(loader, ir)
+    add_alias('Puppet::Pcore::QualifiedReference', TYPE_QUALIFIED_REFERENCE, loader)
+
+    ir.register_implementation_namespace('Puppet::Pcore', 'Puppet::Pops::Pcore', loader)
+  end
+
+  def self.add_alias(name, type, loader)
+    add_type(Types::PTypeAliasType.new(name, nil, type), loader)
+  end
+
+  def self.add_type(type, loader)
+    loader.set_entry(Loader::Loader::TypedName.new(:type, type.name.downcase), type)
+  end
+
+  def self.register_implementations(*impls)
+    Loaders.loaders.register_implementations(*impls)
+  end
+
+  def self.register_aliases(aliases)
+    loader = Loaders.loaders.private_environment_loader
+    aliases.each { |name, type_string| add_type(Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(type_string), nil), loader) }
+  end
+end
+end

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

@@ -76,11 +76,9 @@ class ClassLoader
   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
 

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

@@ -54,7 +54,7 @@ module Puppet::Pops::Types
           Iterator.new(PUnitType::DEFAULT, o.each)
         else
           tc = TypeCalculator.singleton
-          Iterator.new(tc.unwrap_single_variant(PVariantType.new(o.map {|e| tc.infer_set(e) })), o.each)
+          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.
@@ -63,8 +63,8 @@ module Puppet::Pops::Types
         else
           tc = TypeCalculator.singleton
           Iterator.new(PTupleType.new([
-            tc.unwrap_single_variant(PVariantType.new(o.keys.map {|e| tc.infer_set(e) })),
-            tc.unwrap_single_variant(PVariantType.new(o.values.map {|e| tc.infer_set(e) }))], PHashType::KEY_PAIR_TUPLE_SIZE), o.each_pair)
+            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
@@ -210,7 +210,7 @@ module Puppet::Pops::Types
 
     def to_s
       et = element_type
-      et.nil? ? 'Iterator value' : "Iterator[#{et.generalize}] value"
+      et.nil? ? 'Iterator-Value' : "Iterator[#{et.generalize}]-Value"
     end
 
     def unbounded?