puppet 3.8.7 → 4.0.0.rc1

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

@@ -2,9 +2,9 @@
 # @api public
 #
 module Puppet::Pops::Types::TypeFactory
+  @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
+
   Types = Puppet::Pops::Types
-  @type_calculator = Types::TypeCalculator.singleton
-  @undef_t = Types::PUndefType.new
 
   # Produces the Integer type
   # @api public
@@ -17,9 +17,6 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.range(from, to)
-    # NOTE! Do not merge the following line to 4.x. It has the same check in the initialize method
-    raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{from}, #{to}" if from.is_a?(Numeric) && to.is_a?(Numeric) && from > to
-
     t = Types::PIntegerType.new()
     # optimize eq with symbol (faster when it is left)
     t.from = from unless (:default == from || from == 'default')
@@ -31,9 +28,6 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.float_range(from, to)
-    # NOTE! Do not merge the following line to 4.x. It has the same check in the initialize method
-    raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{from}, #{to}" if from.is_a?(Numeric) && to.is_a?(Numeric) && from > to
-
     t = Types::PFloatType.new()
     # optimize eq with symbol (faster when it is left)
     t.from = Float(from) unless :default == from || from.nil?
@@ -72,17 +66,9 @@ module Puppet::Pops::Types::TypeFactory
   end
 
   # Produces the Optional type, i.e. a short hand for Variant[T, Undef]
-  # If the given 'optional_type' argument is a String, then it will be
-  # converted into a String type that represents that string.
-  #
-  # @param optional_type [String,PAnyType,nil] the optional type
-  # @return [POptionalType] the created type
-  #
-  # @api public
-  #
   def self.optional(optional_type = nil)
     t = Types::POptionalType.new
-    t.optional_type = optional_type.is_a?(String) ? string(optional_type) : type_of(optional_type)
+    t.optional_type = type_of(optional_type)
     t
   end
 
@@ -100,53 +86,24 @@ module Puppet::Pops::Types::TypeFactory
   #
   def self.variant(*types)
     t = Types::PVariantType.new()
-    types.each {|v| t.addTypes(type_of(v)) }
+    t.types = types.map {|v| 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 entries where the key is
-  # either a literal String, an Enum with one entry, or a String representing exactly one value.
-  # The key type may also be wrapped in a NotUndef or an Optional.
-  #
-  # The value can be a ruby class, a String (interpreted as the name of a ruby class) or
-  # a Type.
-  #
-  # @param hash [Hash<Object, Object>] key => value hash
-  # @return [PStructType] the created Struct type
+  # 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(hash = {})
-    tc = @type_calculator
+  def self.struct(name_type_hash = {})
     t = Types::PStructType.new
-    t.elements = hash.map do |key_type, value_type|
-      value_type = type_of(value_type)
-      raise ArgumentError, 'Struct element value_type must be a Type' unless value_type.is_a?(Types::PAnyType)
-
-      # 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, @undef_t)
-      else
-        # assert that the key type is one of String[1], NotUndef[String[1]] and Optional[String[1]]
-        case key_type
-        when Types::PNotUndefType
-          # We can loose the NotUndef wrapper here since String[1] isn't optional anyway
-          key_type = key_type.type
-          s = key_type
-        when Types::POptionalType
-          s = key_type.optional_type
-        else
-          s = key_type
-        end
-        unless (s.is_a?(Puppet::Pops::Types::PStringType) || s.is_a?(Puppet::Pops::Types::PEnumType)) && s.values.size == 1 && !s.values[0].empty?
-          raise ArgumentError, 'Unable to extract a non-empty literal string from Struct member key type' if key_type.empty?
-        end
-      end
+    t.elements = name_type_hash.map do |name, type|
       elem = Types::PStructElement.new
-      elem.key_type = key_type
-      elem.value_type = value_type
+      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
     t
@@ -154,7 +111,7 @@ module Puppet::Pops::Types::TypeFactory
 
   def self.tuple(*types)
     t = Types::PTupleType.new
-    types.each {|elem| t.addTypes(type_of(elem)) }
+    t.types = types.map {|elem| type_of(elem) }
     t
   end
 
@@ -394,22 +351,6 @@ module Puppet::Pops::Types::TypeFactory
     type
   end
 
-  # Produces a type for NotUndef[T]
-  # The given 'inst_type' can be a string in which case it will be converted into
-  # the type String[inst_type].
-  #
-  # @param inst_type [Type,String] the type to qualify
-  # @return [Puppet::Pops::Types::PNotUndefType] the NotUndef type
-  #
-  # @api public
-  #
-  def self.not_undef(inst_type = nil)
-    type = Types::PNotUndefType.new()
-    inst_type = string(inst_type) if inst_type.is_a?(String)
-    type.type = inst_type
-    type
-  end
-
   # Produces a type for Type[T]
   # @api public
   #

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

@@ -13,7 +13,6 @@ class Puppet::Pops::Types::TypeParser
   def initialize
     @parser = Puppet::Pops::Parser::Parser.new()
     @type_transformer = Puppet::Pops::Visitor.new(nil, "interpret", 0, 0)
-    @undef_t = TYPES.undef
   end
 
   # Produces a *puppet type* based on the given string.
@@ -164,9 +163,6 @@ class Puppet::Pops::Types::TypeParser
     when "undef"
       TYPES.undef()
 
-    when "notundef"
-      TYPES.not_undef()
-
     when "default"
       TYPES.default()
 
@@ -348,15 +344,14 @@ class Puppet::Pops::Types::TypeParser
     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)
+      assert_struct_parameter(parameters[0])
+      TYPES.struct(parameters[0])
 
     when "integer"
       if parameters.size == 1
         case parameters[0]
         when Integer
-          TYPES.range(parameters[0], :default)
+          TYPES.range(parameters[0], parameters[0])
         when :default
           TYPES.integer # unbound
         end
@@ -370,7 +365,7 @@ class Puppet::Pops::Types::TypeParser
       if parameters.size == 1
         case parameters[0]
         when Integer, Float
-          TYPES.float_range(parameters[0], :default)
+          TYPES.float_range(parameters[0], parameters[0])
         when :default
           TYPES.float # unbound
         end
@@ -405,25 +400,12 @@ class Puppet::Pops::Types::TypeParser
       if parameters.size != 1
         raise_invalid_parameters_error("Optional", 1, parameters.size)
       end
-      param = parameters[0]
-      assert_type(param) unless param.is_a?(String)
-      TYPES.optional(param)
+      assert_type(parameters[0])
+      TYPES.optional(parameters[0])
 
     when "any", "data", "catalogentry", "boolean", "scalar", "undef", "numeric", "default"
       raise_unparameterized_type_error(parameterized_ast.left_expr)
 
-    when "notundef"
-      case parameters.size
-      when 0
-        TYPES.not_undef
-      when 1
-        param = parameters[0]
-        assert_type(param) unless param.is_a?(String)
-        TYPES.not_undef(param)
-      else
-        raise_invalid_parameters_error("NotUndef", "0 to 1", parameters.size)
-      end
-
     when "type"
       if parameters.size != 1
         raise_invalid_parameters_error("Type", 1, parameters.size)
@@ -456,6 +438,15 @@ class Puppet::Pops::Types::TypeParser
     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."

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

@@ -13,10 +13,6 @@ module Puppet::Pops
 
   # Mix in implementation part of the Bindings Module
   module Types
-    # Used as end in a range
-    INFINITY = 1.0 / 0.0
-    NEGATIVE_INFINITY = -INFINITY
-
     class TypeModelObject < RGen::MetamodelBuilder::MMBase
       include Puppet::Pops::Visitable
       include Puppet::Pops::Adaptable
@@ -46,18 +42,6 @@ module Puppet::Pops
       end
     end
 
-    class PNotUndefType < PAnyType
-      module ClassModule
-        def hash
-          [self.class, type].hash
-        end
-
-        def ==(o)
-          self.class == o.class && type == o.type
-        end
-      end
-    end
-
     class PType < PAnyType
       module ClassModule
         def hash
@@ -112,16 +96,20 @@ module Puppet::Pops
 
         # Returns Float.Infinity if one end of the range is unbound
         def size
-          return INFINITY if from.nil? || to.nil?
+          return Float::INFINITY if from.nil? || to.nil?
           1+(to-from).abs
         end
 
         # Returns the range as an array ordered so the smaller number is always first.
         # The number may be Infinity or -Infinity.
         def range
-          f = from || NEGATIVE_INFINITY
-          t = to || INFINITY
-          [f, t]
+          f = from || -Float::INFINITY
+          t = to || Float::INFINITY
+          if f < t
+            [f, t]
+          else
+            [t,f]
+          end
         end
 
         # Returns Enumerator if no block is given
@@ -129,7 +117,11 @@ module Puppet::Pops
         def each
           return self.to_enum unless block_given?
           return nil if from.nil? || to.nil?
-          from.upto(to) {|x| yield x }
+          if to < from
+            from.downto(to) {|x| yield x }
+          else
+            from.upto(to) {|x| yield x }
+          end
         end
 
         def hash
@@ -201,10 +193,14 @@ module Puppet::Pops
       module ClassModule
         # Returns an array with from (min) size to (max) size
         def size_range
-          return [0, INFINITY] if size_type.nil?
+          return [0, Float::INFINITY] if size_type.nil?
           f = size_type.from || 0
-          t = size_type.to || INFINITY
-          [f, t]
+          t = size_type.to || Float::INFINITY
+          if f < t
+            [f, t]
+          else
+            [t,f]
+          end
         end
 
         def hash
@@ -220,17 +216,11 @@ module Puppet::Pops
     class PStructElement < TypeModelObject
       module ClassModule
         def hash
-          [self.class, value_type, key_type].hash
-        end
-
-        def name
-          k = key_type
-          k = k.optional_type if k.is_a?(POptionalType)
-          k.values[0]
+          [self.class, type, name].hash
         end
 
         def ==(o)
-          self.class == o.class && value_type == o.value_type && key_type == o.key_type
+          self.class == o.class && type == o.type && name == o.name
         end
       end
     end
@@ -239,7 +229,7 @@ module Puppet::Pops
     class PStructType < PAnyType
       module ClassModule
         def hashed_elements_derived
-          @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e; memo }
+          @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e.type; memo }
           @_hashed
         end
 
@@ -321,7 +311,7 @@ module Puppet::Pops
         end
 
         def ==(o)
-          self.class == o.class && args_type == o.args_type && block_type == o.block_type
+          self.class == o.class && param_types == o.param_types && block_type == o.block_type
         end
       end
     end
@@ -364,7 +354,7 @@ module Puppet::Pops
         end
 
         def ==(o)
-          self.class == o.class && runtime == o.runtime && runtime_type_name == o.runtime_type_name 
+          self.class == o.class && runtime == o.runtime && runtime_type_name == o.runtime_type_name
         end
       end
     end

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

@@ -27,15 +27,6 @@ module Puppet::Pops::Types
   class PAnyType < TypeModelObject
   end
 
-  # A type that is assignable from the same types as its contained `type` except the
-  # types assignable from {Puppet::Pops::Types::PUndefType}
-  #
-  # @api public
-  #
-  class PNotUndefType < PAnyType
-    contains_one_uni 'type', PAnyType
-  end
-
   # The type of types.
   # @api public
   #
@@ -144,10 +135,8 @@ module Puppet::Pops::Types
   # @api public
   #
   class PStructElement < TypeModelObject
-    # key_type must be either String[1] or Optional[String[1]] and the String[1] must
-    # have a values collection with exactly one element
-    contains_one_uni 'key_type', PAnyType, :lowerBound => 1
-    contains_one_uni 'value_type', PAnyType
+    has_attr 'name', String, :lowerBound => 1
+    contains_one_uni 'type', PAnyType
   end
 
   # @api public

data/lib/puppet/pops/utils.rb

@@ -25,7 +25,7 @@ module Puppet::Pops::Utils
         nil
       else
         fp_value = Float(match[2])
-        if fp_value != Puppet::Pops::Types::TypeCalculator::TheInfinity
+        if fp_value != Float::INFINITY
           match[1] == '-' ? -fp_value : fp_value
         else
           nil

data/lib/puppet/pops/validation.rb

@@ -93,12 +93,11 @@ module Puppet::Pops::Validation
     @@severity_hash = {:ignore => true, :warning => true, :error => true, :deprecation => true }
 
     # Creates a new instance where all issues are diagnosed as :error unless overridden.
-    # @param [Symbol] specifies default severity if :error is not wanted as the default
     # @api public
     #
-    def initialize(default_severity = :error)
+    def initialize
       # If diagnose is not set, the default is returned by the block
-      @severities = Hash.new default_severity
+      @severities = Hash.new :error
     end
 
     # Returns the severity of the given issue.
@@ -228,28 +227,6 @@ module Puppet::Pops::Validation
       # debugging or similar - this to catch internal problems reported as higher level issues.
       @exception = exception
     end
-
-    # Two diagnostics are considered equal if the have the same issue, location and severity
-    # (arguments and exception are ignored)
-    #
-    def ==(o)
-      self.class            == o.class             &&
-        same_position?(o)                          &&
-        issue.issue_code    == o.issue.issue_code  &&
-        file                == o.file              &&
-        severity            == o.severity
-    end
-    alias eql? ==
-
-    # Position is equal if the diagnostic is not located or if referring to the same offset
-    def same_position?(o)
-      source_pos.nil? && o.source_pos.nil? || source_pos.offset == o.source_pos.offset
-    end
-    private :same_position?
-
-    def hash
-      @hash ||= [file, source_pos.offset, issue.issue_code, severity].hash
-    end
   end
 
   # Formats a diagnostic for output.
@@ -320,7 +297,7 @@ module Puppet::Pops::Validation
 
       if file && line && pos
         " at #{file}:#{line}:#{pos}"
-      elsif file and line
+      elsif file && line
         " at #{file}:#{line}"
       elsif line && pos
         " at line #{line}:#{pos}"