puppet 3.4.3 → 3.5.0.rc1

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

@@ -13,6 +13,26 @@ module Puppet::Pops::Types::TypeFactory
     Types::PIntegerType.new()
   end
 
+  # Produces an Integer range type
+  # @api public
+  #
+  def self.range(from, to)
+    t = Types::PIntegerType.new()
+    t.from = from unless (from == :default || from == 'default')
+    t.to = to unless (to == :default || to == 'default')
+    t
+  end
+
+  # Produces a Float range type
+  # @api public
+  #
+  def self.float_range(from, to)
+    t = Types::PFloatType.new()
+    t.from = Float(from) unless from == :default || from.nil?
+    t.to = Float(to) unless to == :default || to.nil?
+    t
+  end
+
   # Produces the Float type
   # @api public
   #
@@ -20,6 +40,13 @@ module Puppet::Pops::Types::TypeFactory
     Types::PFloatType.new()
   end
 
+  # Produces the Numeric type
+  # @api public
+  #
+  def self.numeric()
+    Types::PNumericType.new()
+  end
+
   # Produces a string representation of the type
   # @api public
   #
@@ -27,11 +54,62 @@ module Puppet::Pops::Types::TypeFactory
     @type_calculator.string(t)
   end
 
-  # Produces the String type
+  # Produces the String type, optionally with specific string values
+  # @api public
+  #
+  def self.string(*values)
+    t = Types::PStringType.new()
+    values.each {|v| t.addValues(v) }
+    t
+  end
+
+  # Produces the Optional type, i.e. a short hand for Variant[T, Undef]
+  def self.optional(optional_type = nil)
+    t = Types::POptionalType.new
+    t.optional_type = type_of(optional_type)
+    t
+  end
+
+  # Produces the Enum type, optionally with specific string values
+  # @api public
+  #
+  def self.enum(*values)
+    t = Types::PEnumType.new()
+    values.each {|v| t.addValues(v) }
+    t
+  end
+
+  # Produces the Variant type, optionally with the "one of" types
   # @api public
   #
-  def self.string()
-    Types::PStringType.new()
+  def self.variant(*types)
+    t = Types::PVariantType.new()
+    types.each {|v| t.addTypes(type_of(v)) }
+    t
+  end
+
+  # Produces the Struct type, either a non parameterized instance representing all structs (i.e. all hashes)
+  # or a hash with a given set of keys of String type (names), bound to a value of a given type. Type may be
+  # a Ruby Class, a Puppet Type, or an instance from which the type is inferred.
+  #
+  def self.struct(name_type_hash = {})
+    t = Types::PStructType.new
+    name_type_hash.map do |name, type|
+      elem = Types::PStructElement.new
+      if name.is_a?(String) && name.empty?
+        raise ArgumentError, "An empty String can not be used where a String[1, default] is expected"
+      end
+      elem.name = name
+      elem.type = type_of(type)
+      elem
+    end.each {|elem| t.addElements(elem) }
+    t
+  end
+
+  def self.tuple(*types)
+    t = Types::PTupleType.new
+    types.each {|elem| t.addTypes(type_of(elem)) }
+    t
   end
 
   # Produces the Boolean type
@@ -41,18 +119,62 @@ module Puppet::Pops::Types::TypeFactory
     Types::PBooleanType.new()
   end
 
-  # Produces the Pattern type
+  # Produces the Object type
+  # @api public
+  #
+  def self.object()
+    Types::PObjectType.new()
+  end
+
+  # Produces the Regexp type
+  # @param pattern [Regexp, String, nil] (nil) The regular expression object or a regexp source string, or nil for bare type
   # @api public
   #
-  def self.pattern()
-    Types::PPatternType.new()
+  def self.regexp(pattern = nil)
+    t = Types::PRegexpType.new()
+    if pattern
+      t.pattern = pattern.is_a?(Regexp) ? pattern.inspect[1..-2] : pattern
+    end
+    t
+  end
+
+  def self.pattern(*regular_expressions)
+    t = Types::PPatternType.new()
+    regular_expressions.each do |re|
+      case re
+      when String
+        re_T = Types::PRegexpType.new()
+        re_T.pattern = re
+        t.addPatterns(re_T)
+
+      when Regexp
+        re_T = Types::PRegexpType.new()
+        # Regep.to_s includes options user did not enter and does not escape source
+        # to work either as a string or as a // regexp. The inspect method does a better
+        # job, but includes the //
+        re_T.pattern = re.inspect[1..-2]
+        t.addPatterns(re_T)
+
+      when Types::PRegexpType
+        t.addPatterns(re.copy)
+
+      when Types::PPatternType
+        re.patterns.each do |p|
+          t.addPatterns(p.copy)
+        end
+
+     else
+       raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}"
+      end
+    end
+    t
   end
 
   # Produces the Literal type
   # @api public
   #
-  def self.literal()
-    Types::PLiteralType.new()
+  def self.scalar()
+    Types::PScalarType.new()
   end
 
   # Produces the abstract type Collection
@@ -69,6 +191,40 @@ module Puppet::Pops::Types::TypeFactory
     Types::PDataType.new()
   end
 
+  # Creates an instance of the Undef type
+  # @api public
+  def self.undef()
+    Types::PNilType.new()
+  end
+
+  # Produces an instance of the abstract type PCatalogEntryType
+  def self.catalog_entry()
+    Types::PCatalogEntryType.new()
+  end
+
+  # Produces a PResourceType with a String type_name
+  # A PResourceType with a nil or empty name is compatible with any other PResourceType.
+  # A PResourceType with a given name is only compatible with a PResourceType with the same name.
+  # (There is no resource-type subtyping in Puppet (yet)).
+  #
+  def self.resource(type_name = nil, title = nil)
+    type = Types::PResourceType.new()
+    type_name = type_name.type_name if type_name.is_a?(Types::PResourceType)
+    type.type_name = type_name.downcase unless type_name.nil?
+    type.title = title
+    type
+  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 with the same name.
+  #
+  def self.host_class(class_name = nil)
+    type = Types::PHostClassType.new()
+    type.class_name = class_name
+    type
+  end
+
   # Produces a type for Array[o] where o is either a type, or an instance for which a type is inferred.
   # @api public
   #
@@ -78,10 +234,10 @@ module Puppet::Pops::Types::TypeFactory
     type
   end
 
-  # Produces a type for Hash[Literal, o] where o is either a type, or an instance for which a type is inferred.
+  # Produces a type for Hash[Scalar, o] where o is either a type, or an instance for which a type is inferred.
   # @api public
   #
-  def self.hash_of(value, key = literal())
+  def self.hash_of(value, key = scalar())
     type = Types::PHashType.new()
     type.key_type = type_of(key)
     type.element_type = type_of(value)
@@ -97,30 +253,39 @@ module Puppet::Pops::Types::TypeFactory
     type
   end
 
-  # Produces a type for Hash[Literal, Data]
+  # Produces a type for Hash[Scalar, Data]
   # @api public
   #
   def self.hash_of_data()
     type = Types::PHashType.new()
-    type.key_type = literal()
+    type.key_type = scalar()
     type.element_type = data()
     type
   end
 
-  # Produce a type corresponding to the class of given unless given is a String, Class or a PObjectType.
+  # Produces a type for Type[T]
+  # @api public
+  #
+  def self.type_type(inst_type = nil)
+    type = Types::PType.new()
+    type.type = inst_type
+    type
+  end
+
+  # Produce a type corresponding to the class of given unless given is a String, Class or a PAbstractType.
   # When a String is given this is taken as a classname.
   #
   def self.type_of(o)
     if o.is_a?(Class)
       @type_calculator.type(o)
-    elsif o.is_a?(Types::PObjectType)
+    elsif o.is_a?(Types::PAbstractType)
       o
     elsif o.is_a?(String)
       type = Types::PRubyType.new()
       type.ruby_class = o
       type
     else
-      @type_calculator.infer(o)
+      @type_calculator.infer_generic(o)
     end
   end
 
@@ -144,4 +309,27 @@ module Puppet::Pops::Types::TypeFactory
       type
     end
   end
+
+  # Generic creator of a RubyType - allows creating the Ruby type with nil name, or String name.
+  # Also see ruby(o) which performs inference, or mapps a Ruby Class to its name.
+  #
+  def self.ruby_type(class_name = nil)
+    type = Types::PRubyType.new()
+    type.ruby_class = class_name
+    type
+  end
+
+  # Sets the accepted size range of a collection if something other than the default 0 to Infinity
+  # is wanted. The semantics for from/to are the same as for #range
+  #
+  def self.constrain_size(collection_t, from, to)
+    collection_t.size_type = range(from, to)
+    collection_t
+  end
+
+  # Returns true if the given type t is of valid range parameter type (integer or literal default).
+  def self.is_range_parameter?(t)
+    t.is_a?(Integer) || t == 'default' || t == :default
+  end
+
 end

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

@@ -29,6 +29,11 @@ class Puppet::Pops::Types::TypeParser
   # @api public
   #
   def parse(string)
+    # 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
+    # earlier and fed to 'interpret'
+    #
     @string = string
     model = @parser.parse_string(@string)
     if model
@@ -40,62 +45,396 @@ class Puppet::Pops::Types::TypeParser
 
   # @api private
   def interpret(ast)
-    @type_transformer.visit_this(self, 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::PAbstractType)
+    result
   end
 
   # @api private
-  def interpret_Object(anything)
+  def interpret_any(ast)
+    @type_transformer.visit_this_0(self, ast)
+  end
+
+  # @api private
+  def interpret_Object(o)
     raise_invalid_type_specification_error
   end
 
+  # @api private
+  def interpret_Program(o)
+    interpret(o.body)
+  end
+
+  # @api private
+  def interpret_QualifiedName(o)
+    o.value
+  end
+
+  # @api private
+  def interpret_LiteralString(o)
+    o.value
+  end
+
+  # @api private
+  def interpret_String(o)
+    o
+  end
+
+  # @api private
+  def interpret_LiteralDefault(o)
+    :default
+  end
+
+  # @api private
+  def interpret_LiteralInteger(o)
+    o.value
+  end
+
+  # @api private
+  def interpret_LiteralFloat(o)
+    o.value
+  end
+
+  # @api private
+  def interpret_LiteralHash(o)
+    result = {}
+    o.entries.each do |entry|
+      result[@type_transformer.visit_this_0(self, entry.key)] = @type_transformer.visit_this_0(self, entry.value)
+    end
+    result
+  end
+
   # @api private
   def interpret_QualifiedReference(name_ast)
     case name_ast.value
     when "integer"
       TYPES.integer
+
     when "float"
       TYPES.float
+
+    when "numeric"
+        TYPES.numeric
+
     when "string"
       TYPES.string
+
+    when "enum"
+      TYPES.enum
+
     when "boolean"
       TYPES.boolean
+
     when "pattern"
       TYPES.pattern
+
+    when "regexp"
+      TYPES.regexp
+
     when "data"
       TYPES.data
+
     when "array"
       TYPES.array_of_data
+
     when "hash"
       TYPES.hash_of_data
+
+    when "class"
+      TYPES.host_class()
+
+    when "resource"
+      TYPES.resource()
+
+    when "collection"
+      TYPES.collection()
+
+    when "scalar"
+      TYPES.scalar()
+
+    when "catalogentry"
+      TYPES.catalog_entry()
+
+    when "undef"
+      # Should not be interpreted as Resource type
+      TYPES.undef()
+
+    when "object"
+      TYPES.object()
+
+    when "variant"
+      TYPES.variant()
+
+    when "optional"
+      TYPES.optional()
+
+    when "ruby"
+      TYPES.ruby_type()
+
+    when "type"
+      TYPES.type_type()
+
+    when "tuple"
+      TYPES.tuple()
+
+    when "struct"
+      TYPES.struct()
     else
-      raise_unknown_type_error(name_ast)
+      TYPES.resource(name_ast.value)
     end
   end
 
   # @api private
   def interpret_AccessExpression(parameterized_ast)
-    parameters = parameterized_ast.keys.collect { |param| interpret(param) }
+    parameters = parameterized_ast.keys.collect { |param| interpret_any(param) }
+
+    unless parameterized_ast.left_expr.is_a?(Puppet::Pops::Model::QualifiedReference)
+      raise_invalid_type_specification_error
+    end
+
     case parameterized_ast.left_expr.value
     when "array"
-      if parameters.size != 1
-        raise_invalid_parameters_error("Array", 1, parameters.size)
+      case parameters.size
+      when 1
+      when 2
+        size_type =
+        if parameters[1].is_a?(Puppet::Pops::Types::PIntegerType)
+          parameters[1].copy
+        else
+          assert_range_parameter(parameters[1])
+          TYPES.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])
+      else
+        raise_invalid_parameters_error("Array", "1 to 3", parameters.size)
       end
-      TYPES.array_of(parameters[0])
+      assert_type(parameters[0])
+      t = TYPES.array_of(parameters[0])
+      t.size_type = size_type if size_type
+      t
+
     when "hash"
-      if parameters.size == 1
+      result = case parameters.size
+      when 1
+        assert_type(parameters[0])
         TYPES.hash_of(parameters[0])
+      when 2
+        assert_type(parameters[0])
+        assert_type(parameters[1])
+        TYPES.hash_of(parameters[1], parameters[0])
+      when 3
+        size_type =
+        if parameters[2].is_a?(Puppet::Pops::Types::PIntegerType)
+          parameters[2].copy
+        else
+          assert_range_parameter(parameters[2])
+          TYPES.range(parameters[2], :default)
+        end
+        assert_type(parameters[0])
+        assert_type(parameters[1])
+        TYPES.hash_of(parameters[1], parameters[0])
+      when 4
+        assert_range_parameter(parameters[2])
+        assert_range_parameter(parameters[3])
+        size_type = TYPES.range(parameters[2], parameters[3])
+        assert_type(parameters[0])
+        assert_type(parameters[1])
+        TYPES.hash_of(parameters[1], parameters[0])
+      else
+        raise_invalid_parameters_error("Hash", "1 to 4", parameters.size)
+      end
+      result.size_type = size_type if size_type
+      result
+
+    when "collection"
+      size_type = case parameters.size
+      when 1
+        if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
+          parameters[0].copy
+        else
+          assert_range_parameter(parameters[0])
+          TYPES.range(parameters[0], :default)
+        end
+      when 2
+        assert_range_parameter(parameters[0])
+        assert_range_parameter(parameters[1])
+        TYPES.range(parameters[0], parameters[1])
+      else
+        raise_invalid_parameters_error("Collection", "1 to 2", parameters.size)
+      end
+      result = TYPES.collection
+      result.size_type = size_type
+      result
+
+    when "class"
+      if parameters.size != 1
+        raise_invalid_parameters_error("Class", 1, parameters.size)
+      end
+      TYPES.host_class(parameters[0])
+
+    when "resource"
+      if parameters.size == 1
+        TYPES.resource(parameters[0])
       elsif parameters.size != 2
-        raise_invalid_parameters_error("Hash", "1 or 2", parameters.size)
+        raise_invalid_parameters_error("Resource", "1 or 2", parameters.size)
       else
-        TYPES.hash_of(parameters[1], parameters[0])
+        TYPES.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])
+
+    when "enum"
+      # 1..m parameters being strings
+      raise_invalid_parameters_error("Enum", "1 or more", parameters.size) unless parameters.size > 1
+      TYPES.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)
+
+    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)
+
+    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
+      if TYPES.is_range_parameter?(parameters[-2])
+        # min, max specification
+        min = parameters[-2]
+        min = (min == :default || min == 'default') ? 0 : min
+        assert_range_parameter(parameters[-1])
+        max = parameters[-1]
+        max = max == :default ? nil : max
+        parameters = parameters[0, length-2]
+      elsif TYPES.is_range_parameter?(parameters[-1])
+        min = parameters[-1]
+        min = (min == :default || min == 'default') ? 0 : min
+        max = nil
+        parameters = parameters[0, length-1]
+      end
+      t = TYPES.tuple(*parameters)
+      if min || max
+        TYPES.constrain_size(t, min, max)
       end
+      t
+
+    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
+      assert_struct_parameter(parameters[0])
+      TYPES.struct(parameters[0])
+
+    when "integer"
+      if parameters.size == 1
+        case parameters[0]
+        when Integer
+          TYPES.range(parameters[0], parameters[0])
+        when :default
+          TYPES.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])
+     end
+
+    when "float"
+      if parameters.size == 1
+        case parameters[0]
+        when Integer, Float
+          TYPES.float_range(parameters[0], parameters[0])
+        when :default
+          TYPES.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])
+     end
+
+    when "string"
+      size_type =
+      case parameters.size
+      when 1
+        if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
+          parameters[0].copy
+        else
+          assert_range_parameter(parameters[0])
+          TYPES.range(parameters[0], :default)
+        end
+      when 2
+        assert_range_parameter(parameters[0])
+        assert_range_parameter(parameters[1])
+        TYPES.range(parameters[0], parameters[1])
+      else
+        raise_invalid_parameters_error("String", "1 to 2", parameters.size)
+      end
+      result = TYPES.string
+      result.size_type = size_type
+      result
+
+    when "optional"
+      if parameters.size != 1
+        raise_invalid_parameters_error("Optional", 1, parameters.size)
+      end
+      assert_type(parameters[0])
+      TYPES.optional(parameters[0])
+
+    when "object", "data", "catalogentry", "boolean", "scalar", "undef", "numeric"
+      raise_unparameterized_type_error(parameterized_ast.left_expr)
+
+    when "type"
+      if parameters.size != 1
+        raise_invalid_parameters_error("Type", 1, parameters.size)
+      end
+      assert_type(parameters[0])
+      TYPES.type_type(parameters[0])
+
+    when "ruby"
+      raise_invalid_parameters_error("Ruby", "1", parameters.size) unless parameters.size == 1
+      TYPES.ruby_type(parameters[0])
+
     else
-      raise_unknown_type_error(parameterized_ast.left_expr)
+      # 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)
+      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::PObjectType)
+    true
+  end
+
+  def assert_range_parameter(t)
+    raise_invalid_type_specification_error unless TYPES.is_range_parameter?(t)
+  end
+
+  def assert_struct_parameter(h)
+    raise_invalid_type_specification_error unless h.is_a?(Hash)
+    h.each do |k,v|
+      # TODO: Should have stricter name rule
+      raise_invalid_type_specification_error unless k.is_a?(String) && !k.empty?
+      assert_type(v)
+    end
+  end
+
   def raise_invalid_type_specification_error
     raise Puppet::ParseError,
       "The expression <#{@string}> is not a valid type specification."
@@ -106,12 +445,16 @@ class Puppet::Pops::Types::TypeParser
       "Invalid number of type parameters specified: #{type} requires #{required}, #{given} provided"
   end
 
+  def raise_unparameterized_type_error(ast)
+    raise Puppet::ParseError, "Not a parameterized type <#{original_text_of(ast)}>"
+  end
+
   def raise_unknown_type_error(ast)
     raise Puppet::ParseError, "Unknown type <#{original_text_of(ast)}>"
   end
 
   def original_text_of(ast)
     position = Puppet::Pops::Adapters::SourcePosAdapter.adapt(ast)
-    position.extract_text_from_string(@string)
+    position.extract_text()
   end
 end