puppet 4.3.2 → 4.4.0

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

@@ -1,18 +1,17 @@
 # This class provides parsing of Type Specification from a string into the Type
-# Model that is produced by the Puppet::Pops::Types::TypeFactory.
+# Model that is produced by the TypeFactory.
 #
 # The Type Specifications that are parsed are the same as the stringified forms
-# of types produced by the {Puppet::Pops::Types::TypeCalculator TypeCalculator}.
+# of types produced by the {TypeCalculator TypeCalculator}.
 #
 # @api public
-class Puppet::Pops::Types::TypeParser
-  # @api private
-  TYPES = Puppet::Pops::Types::TypeFactory
-
+module Puppet::Pops
+module Types
+class TypeParser
   # @api public
   def initialize
-    @parser = Puppet::Pops::Parser::Parser.new
-    @type_transformer = Puppet::Pops::Visitor.new(nil, 'interpret', 0, 0)
+    @parser = Parser::Parser.new
+    @type_transformer = Visitor.new(nil, 'interpret', 1, 1)
   end
 
   # Produces a *puppet type* based on the given string.
@@ -23,12 +22,13 @@ class Puppet::Pops::Types::TypeParser
   #     parser.parse('Hash[Integer, Array[String]]')
   #
   # @param string [String] a string with the type expressed in stringified form as produced by the 
-  #   {Puppet::Pops::Types::TypeCalculator#string TypeCalculator#string} method.
-  # @return [Puppet::Pops::Types::PAnyType] a specialization of the PAnyType representing the type.
+  #   types {"#to_s} method.
+  # @param context [Puppet::Parser::Scope,Loader::Loader] scope or loader to use when loading type aliases
+  # @return [PAnyType] a specialization of the PAnyType representing the type.
   #
   # @api public
   #
-  def parse(string)
+  def parse(string, context = nil)
     # TODO: This state (@string) can be removed since the parse result of newer future parser
     # contains a Locator in its SourcePosAdapter and the Locator keeps the string.
     # This way, there is no difference between a parsed "string" and something that has been parsed
@@ -37,173 +37,198 @@ class Puppet::Pops::Types::TypeParser
     @string = string
     model = @parser.parse_string(@string)
     if model
-      interpret(model.current)
+      interpret(model.current, context)
     else
       raise_invalid_type_specification_error
     end
   end
 
   # @api private
-  def interpret(ast)
-    result = @type_transformer.visit_this_0(self, ast)
-    result = result.body if result.is_a?(Puppet::Pops::Model::Program)
-    raise_invalid_type_specification_error unless result.is_a?(Puppet::Pops::Types::PAnyType)
+  def interpret(ast, context)
+    result = @type_transformer.visit_this_1(self, ast, context)
+    result = result.body if result.is_a?(Model::Program)
+    raise_invalid_type_specification_error unless result.is_a?(PAnyType)
     result
   end
 
   # @api private
-  def interpret_any(ast)
-    @type_transformer.visit_this_0(self, ast)
+  def interpret_any(ast, context)
+    @type_transformer.visit_this_1(self, ast, context)
   end
 
   # @api private
-  def interpret_Object(o)
+  def interpret_Object(o, context)
     raise_invalid_type_specification_error
   end
 
   # @api private
-  def interpret_Program(o)
-    interpret(o.body)
+  def interpret_Program(o, context)
+    interpret(o.body, context)
   end
 
   # @api private
-  def interpret_QualifiedName(o)
+  def interpret_QualifiedName(o, context)
     o.value
   end
 
   # @api private
-  def interpret_LiteralString(o)
+  def interpret_LiteralString(o, context)
     o.value
   end
 
-  def interpret_LiteralRegularExpression(o)
+  def interpret_LiteralRegularExpression(o, context)
     o.value
   end
 
   # @api private
-  def interpret_String(o)
+  def interpret_String(o, context)
     o
   end
 
   # @api private
-  def interpret_LiteralDefault(o)
+  def interpret_LiteralDefault(o, context)
     :default
   end
 
   # @api private
-  def interpret_LiteralInteger(o)
+  def interpret_LiteralInteger(o, context)
     o.value
   end
 
   # @api private
-  def interpret_LiteralFloat(o)
+  def interpret_UnaryMinusExpression(o, context)
+    -@type_transformer.visit_this_1(self, o.expr, context)
+  end
+
+  # @api private
+  def interpret_LiteralFloat(o, context)
     o.value
   end
 
   # @api private
-  def interpret_LiteralHash(o)
+  def interpret_LiteralHash(o, context)
     result = {}
     o.entries.each do |entry|
-      result[@type_transformer.visit_this_0(self, entry.key)] = @type_transformer.visit_this_0(self, entry.value)
+      result[@type_transformer.visit_this_1(self, entry.key, context)] = @type_transformer.visit_this_1(self, entry.value, context)
     end
     result
   end
 
   # @api private
-  def interpret_QualifiedReference(name_ast)
-    case name_ast.value
+  def interpret_QualifiedReference(name_ast, context)
+    name = name_ast.value
+    case name
     when 'integer'
-      TYPES.integer
+      TypeFactory.integer
 
     when 'float'
-      TYPES.float
+      TypeFactory.float
 
     when 'numeric'
-        TYPES.numeric
+        TypeFactory.numeric
+
+    when 'iterable'
+      TypeFactory.iterable
+
+    when 'iterator'
+      TypeFactory.iterator
 
     when 'string'
-      TYPES.string
+      TypeFactory.string
 
     when 'enum'
-      TYPES.enum
+      TypeFactory.enum
 
     when 'boolean'
-      TYPES.boolean
+      TypeFactory.boolean
 
     when 'pattern'
-      TYPES.pattern
+      TypeFactory.pattern
 
     when 'regexp'
-      TYPES.regexp
+      TypeFactory.regexp
 
     when 'data'
-      TYPES.data
+      TypeFactory.data
 
     when 'array'
-      TYPES.array_of_data
+      TypeFactory.array_of_data
 
     when 'hash'
-      TYPES.hash_of_data
+      TypeFactory.hash_of_data
 
     when 'class'
-      TYPES.host_class
+      TypeFactory.host_class
 
     when 'resource'
-      TYPES.resource
+      TypeFactory.resource
 
     when 'collection'
-      TYPES.collection
+      TypeFactory.collection
 
     when 'scalar'
-      TYPES.scalar
+      TypeFactory.scalar
 
     when 'catalogentry'
-      TYPES.catalog_entry
+      TypeFactory.catalog_entry
 
     when 'undef'
-      TYPES.undef
+      TypeFactory.undef
 
     when 'notundef'
-      TYPES.not_undef()
+      TypeFactory.not_undef()
 
     when 'default'
-      TYPES.default()
+      TypeFactory.default()
  
     when 'any'
-      TYPES.any
+      TypeFactory.any
 
     when 'variant'
-      TYPES.variant
+      TypeFactory.variant
 
     when 'optional'
-      TYPES.optional
+      TypeFactory.optional
 
     when 'runtime'
-      TYPES.runtime
+      TypeFactory.runtime
 
     when 'type'
-      TYPES.type_type
+      TypeFactory.type_type
 
     when 'tuple'
-      TYPES.tuple
+      TypeFactory.tuple
 
     when 'struct'
-      TYPES.struct
+      TypeFactory.struct
 
     when 'callable'
       # A generic callable as opposed to one that does not accept arguments
-      TYPES.all_callables
+      TypeFactory.all_callables
 
     else
-      TYPES.resource(name_ast.value)
+      if context.nil?
+        TypeFactory.type_reference(name.capitalize)
+      else
+        if context.is_a?(Puppet::Pops::Loader::Loader)
+          loader = context
+        else
+          loader = Puppet::Pops::Adapters::LoaderAdapter.loader_for_model_object(name_ast, context)
+        end
+        unless loader.nil?
+          type = loader.load(:type, name)
+          type = type.resolve(self, loader) unless type.nil?
+        end
+        type || TypeFactory.resource(name)
+      end
     end
   end
 
   # @api private
-  def interpret_AccessExpression(parameterized_ast)
-    parameters = parameterized_ast.keys.collect { |param| interpret_any(param) }
+  def interpret_AccessExpression(parameterized_ast, context)
+    parameters = parameterized_ast.keys.collect { |param| interpret_any(param, context) }
 
-    unless parameterized_ast.left_expr.is_a?(Puppet::Pops::Model::QualifiedReference)
+    unless parameterized_ast.left_expr.is_a?(Model::QualifiedReference)
       raise_invalid_type_specification_error
     end
 
@@ -213,45 +238,45 @@ class Puppet::Pops::Types::TypeParser
       when 1
       when 2
         size_type =
-          if parameters[1].is_a?(Puppet::Pops::Types::PIntegerType)
+          if parameters[1].is_a?(PIntegerType)
             parameters[1]
           else
             assert_range_parameter(parameters[1])
-            TYPES.range(parameters[1], :default)
+            TypeFactory.range(parameters[1], :default)
           end
       when 3
         assert_range_parameter(parameters[1])
         assert_range_parameter(parameters[2])
-        size_type = TYPES.range(parameters[1], parameters[2])
+        size_type = TypeFactory.range(parameters[1], parameters[2])
       else
         raise_invalid_parameters_error('Array', '1 to 3', parameters.size)
       end
       assert_type(parameters[0])
-      TYPES.array_of(parameters[0], size_type)
+      TypeFactory.array_of(parameters[0], size_type)
 
     when 'hash'
       case parameters.size
       when 2
         assert_type(parameters[0])
         assert_type(parameters[1])
-        TYPES.hash_of(parameters[1], parameters[0])
+        TypeFactory.hash_of(parameters[1], parameters[0])
       when 3
         size_type =
-          if parameters[2].is_a?(Puppet::Pops::Types::PIntegerType)
+          if parameters[2].is_a?(PIntegerType)
             parameters[2]
           else
             assert_range_parameter(parameters[2])
-            TYPES.range(parameters[2], :default)
+            TypeFactory.range(parameters[2], :default)
           end
         assert_type(parameters[0])
         assert_type(parameters[1])
-        TYPES.hash_of(parameters[1], parameters[0], size_type)
+        TypeFactory.hash_of(parameters[1], parameters[0], size_type)
       when 4
         assert_range_parameter(parameters[2])
         assert_range_parameter(parameters[3])
         assert_type(parameters[0])
         assert_type(parameters[1])
-        TYPES.hash_of(parameters[1], parameters[0], TYPES.range(parameters[2], parameters[3]))
+        TypeFactory.hash_of(parameters[1], parameters[0], TypeFactory.range(parameters[2], parameters[3]))
       else
         raise_invalid_parameters_error('Hash', '2 to 4', parameters.size)
       end
@@ -259,62 +284,62 @@ class Puppet::Pops::Types::TypeParser
     when 'collection'
       size_type = case parameters.size
         when 1
-          if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
+          if parameters[0].is_a?(PIntegerType)
             parameters[0]
           else
             assert_range_parameter(parameters[0])
-            TYPES.range(parameters[0], :default)
+            TypeFactory.range(parameters[0], :default)
           end
         when 2
           assert_range_parameter(parameters[0])
           assert_range_parameter(parameters[1])
-          TYPES.range(parameters[0], parameters[1])
+          TypeFactory.range(parameters[0], parameters[1])
         else
           raise_invalid_parameters_error('Collection', '1 to 2', parameters.size)
         end
-      TYPES.collection(size_type)
+      TypeFactory.collection(size_type)
 
     when 'class'
       if parameters.size != 1
         raise_invalid_parameters_error('Class', 1, parameters.size)
       end
-      TYPES.host_class(parameters[0])
+      TypeFactory.host_class(parameters[0])
 
     when 'resource'
       if parameters.size == 1
-        TYPES.resource(parameters[0])
+        TypeFactory.resource(parameters[0])
       elsif parameters.size != 2
         raise_invalid_parameters_error('Resource', '1 or 2', parameters.size)
       else
-        TYPES.resource(parameters[0], parameters[1])
+        TypeFactory.resource(parameters[0], parameters[1])
       end
 
     when 'regexp'
       # 1 parameter being a string, or regular expression
       raise_invalid_parameters_error('Regexp', '1', parameters.size) unless parameters.size == 1
-      TYPES.regexp(parameters[0])
+      TypeFactory.regexp(parameters[0])
 
     when 'enum'
       # 1..m parameters being strings
       raise_invalid_parameters_error('Enum', '1 or more', parameters.size) unless parameters.size >= 1
-      TYPES.enum(*parameters)
+      TypeFactory.enum(*parameters)
 
     when 'pattern'
       # 1..m parameters being strings or regular expressions
       raise_invalid_parameters_error('Pattern', '1 or more', parameters.size) unless parameters.size >= 1
-      TYPES.pattern(*parameters)
+      TypeFactory.pattern(*parameters)
 
     when 'variant'
       # 1..m parameters being strings or regular expressions
       raise_invalid_parameters_error('Variant', '1 or more', parameters.size) unless parameters.size >= 1
-      TYPES.variant(*parameters)
+      TypeFactory.variant(*parameters)
 
     when 'tuple'
       # 1..m parameters being types (last two optionally integer or literal default
       raise_invalid_parameters_error('Tuple', '1 or more', parameters.size) unless parameters.size >= 1
       length = parameters.size
       size_type = nil
-      if TYPES.is_range_parameter?(parameters[-2])
+      if TypeFactory.is_range_parameter?(parameters[-2])
         # min, max specification
         min = parameters[-2]
         min = (min == :default || min == 'default') ? 0 : min
@@ -322,73 +347,87 @@ class Puppet::Pops::Types::TypeParser
         max = parameters[-1]
         max = max == :default ? nil : max
         parameters = parameters[0, length-2]
-        size_type = TYPES.range(min, max)
-      elsif TYPES.is_range_parameter?(parameters[-1])
+        size_type = TypeFactory.range(min, max)
+      elsif TypeFactory.is_range_parameter?(parameters[-1])
         min = parameters[-1]
         min = (min == :default || min == 'default') ? 0 : min
         max = nil
         parameters = parameters[0, length-1]
-        size_type = TYPES.range(min, max)
+        size_type = TypeFactory.range(min, max)
       end
-      TYPES.tuple(parameters, size_type)
+      TypeFactory.tuple(parameters, size_type)
 
     when 'callable'
       # 1..m parameters being types (last three optionally integer or literal default, and a callable)
-      TYPES.callable(*parameters)
+      TypeFactory.callable(*parameters)
 
     when 'struct'
       # 1..m parameters being types (last two optionally integer or literal default
       raise_invalid_parameters_error('Struct', '1', parameters.size) unless parameters.size == 1
       h = parameters[0]
       raise_invalid_type_specification_error unless h.is_a?(Hash)
-      TYPES.struct(h)
+      TypeFactory.struct(h)
 
     when 'integer'
       if parameters.size == 1
         case parameters[0]
         when Integer
-          TYPES.range(parameters[0], :default)
+          TypeFactory.range(parameters[0], :default)
         when :default
-          TYPES.integer # unbound
+          TypeFactory.integer # unbound
         end
       elsif parameters.size != 2
         raise_invalid_parameters_error('Integer', '1 or 2', parameters.size)
      else
-       TYPES.range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
+       TypeFactory.range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
      end
 
+    when 'iterable'
+      if parameters.size != 1
+        raise_invalid_parameters_error('Iterable', 1, parameters.size)
+      end
+      assert_type(parameters[0])
+      TypeFactory.iterable(parameters[0])
+
+    when 'iterator'
+      if parameters.size != 1
+        raise_invalid_parameters_error('Iterator', 1, parameters.size)
+      end
+      assert_type(parameters[0])
+      TypeFactory.iterator(parameters[0])
+
     when 'float'
       if parameters.size == 1
         case parameters[0]
         when Integer, Float
-          TYPES.float_range(parameters[0], :default)
+          TypeFactory.float_range(parameters[0], :default)
         when :default
-          TYPES.float # unbound
+          TypeFactory.float # unbound
         end
       elsif parameters.size != 2
         raise_invalid_parameters_error('Float', '1 or 2', parameters.size)
      else
-       TYPES.float_range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
+       TypeFactory.float_range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
      end
 
     when 'string'
       size_type =
       case parameters.size
       when 1
-        if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
+        if parameters[0].is_a?(PIntegerType)
           parameters[0]
         else
           assert_range_parameter(parameters[0])
-          TYPES.range(parameters[0], :default)
+          TypeFactory.range(parameters[0], :default)
         end
       when 2
         assert_range_parameter(parameters[0])
         assert_range_parameter(parameters[1])
-        TYPES.range(parameters[0], parameters[1])
+        TypeFactory.range(parameters[0], parameters[1])
       else
         raise_invalid_parameters_error('String', '1 to 2', parameters.size)
       end
-      TYPES.string(size_type)
+      TypeFactory.string(size_type)
 
     when 'optional'
       if parameters.size != 1
@@ -396,7 +435,7 @@ class Puppet::Pops::Types::TypeParser
       end
       param = parameters[0]
       assert_type(param) unless param.is_a?(String)
-      TYPES.optional(param)
+      TypeFactory.optional(param)
 
     when 'any', 'data', 'catalogentry', 'boolean', 'scalar', 'undef', 'numeric', 'default'
       raise_unparameterized_type_error(parameterized_ast.left_expr)
@@ -404,11 +443,11 @@ class Puppet::Pops::Types::TypeParser
     when 'notundef'
       case parameters.size
       when 0
-        TYPES.not_undef
+        TypeFactory.not_undef
       when 1
         param = parameters[0]
         assert_type(param) unless param.is_a?(String)
-        TYPES.not_undef(param)
+        TypeFactory.not_undef(param)
       else
         raise_invalid_parameters_error("NotUndef", "0 to 1", parameters.size)
       end
@@ -418,31 +457,37 @@ class Puppet::Pops::Types::TypeParser
         raise_invalid_parameters_error('Type', 1, parameters.size)
       end
       assert_type(parameters[0])
-      TYPES.type_type(parameters[0])
+      TypeFactory.type_type(parameters[0])
 
     when 'runtime'
       raise_invalid_parameters_error('Runtime', '2', parameters.size) unless parameters.size == 2
-      TYPES.runtime(*parameters)
+      TypeFactory.runtime(*parameters)
 
     else
-      # It is a resource such a File['/tmp/foo']
       type_name = parameterized_ast.left_expr.value
-      if parameters.size != 1
-        raise_invalid_parameters_error(type_name.capitalize, 1, parameters.size)
+      if context.nil?
+        # Will be impossible to tell from a typed alias (when implemented) so a type reference
+        # is returned here for now
+        TypeFactory.type_reference(type_name.capitalize, parameters)
+      else
+        # It is a resource such a File['/tmp/foo']
+       if parameters.size != 1
+          raise_invalid_parameters_error(type_name.capitalize, 1, parameters.size)
+        end
+        TypeFactory.resource(type_name, parameters[0])
       end
-      TYPES.resource(type_name, parameters[0])
     end
   end
 
   private
 
   def assert_type(t)
-    raise_invalid_type_specification_error unless t.is_a?(Puppet::Pops::Types::PAnyType)
+    raise_invalid_type_specification_error unless t.is_a?(PAnyType)
     true
   end
 
   def assert_range_parameter(t)
-    raise_invalid_type_specification_error unless TYPES.is_range_parameter?(t)
+    raise_invalid_type_specification_error unless TypeFactory.is_range_parameter?(t)
   end
 
   def raise_invalid_type_specification_error
@@ -464,7 +509,9 @@ class Puppet::Pops::Types::TypeParser
   end
 
   def original_text_of(ast)
-    position = Puppet::Pops::Adapters::SourcePosAdapter.adapt(ast)
+    position = Adapters::SourcePosAdapter.adapt(ast)
     position.extract_text
   end
 end
+end
+end