puppet 3.4.3 → 3.5.0.rc1

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

@@ -3,25 +3,27 @@ require 'rgen/metamodel_builder'
 # The Types model is a model of Puppet Language types.
 #
 # The exact relationship between types is not visible in this model wrt. the PDataType which is an abstraction
-# of Literal, Array[Data], and Hash[Literal, Data] nested to any depth. This means it is not possible to
+# of Scalar, Array[Data], and Hash[Scalar, Data] nested to any depth. This means it is not possible to
 # infer the type by simply looking at the inheritance hierarchy. The {Puppet::Pops::Types::TypeCalculator} should
 # be used to answer questions about types. The {Puppet::Pops::Types::TypeFactory} should be used to create an instance
 # of a type whenever one is needed.
 #
+# The implementation of the Types model contains methods that are required for the type objects to behave as
+# expected when comparing them and using them as keys in hashes. (No other logic is, or should be included directly in
+# the model's classes).
+#
 # @api public
 #
 module Puppet::Pops::Types
 
-  # The type of types.
-  # @api public
-  class PType < Puppet::Pops::Model::PopsObject
-  end
-
-  # Base type for all types except {Puppet::Pops::Types::PType PType}, the type of types.
-  # @api public
-  class PObjectType < Puppet::Pops::Model::PopsObject
-
+  class PAbstractType < Puppet::Pops::Model::PopsObject
+    abstract
     module ClassModule
+      # Produce a deep copy of the type
+      def copy
+        Marshal.load(Marshal.dump(self))
+      end
+
       def hash
         self.class.hash
       end
@@ -31,6 +33,33 @@ module Puppet::Pops::Types
       end
 
       alias eql? ==
+
+      def to_s
+        Puppet::Pops::Types::TypeCalculator.string(self)
+      end
+    end
+  end
+
+  # The type of types.
+  # @api public
+  class PType < PAbstractType
+    contains_one_uni 'type', PAbstractType
+    module ClassModule
+      def hash
+        [self.class, type].hash
+      end
+
+      def ==(o)
+        self.class == o.class && type == o.type
+      end
+    end
+  end
+
+  # Base type for all types except {Puppet::Pops::Types::PType PType}, the type of types.
+  # @api public
+  class PObjectType < PAbstractType
+
+    module ClassModule
     end
 
   end
@@ -43,47 +72,251 @@ module Puppet::Pops::Types
   #
   # @api public
   class PDataType < PObjectType
+    module ClassModule
+      def ==(o)
+        self.class == o.class ||
+          o.class == PVariantType && o == Puppet::Pops::Types::TypeCalculator.data_variant()
+      end
+    end
   end
 
-  # Type that is PDataType compatible, but is not a PCollectionType.
+  # A flexible type describing an any? of other types
   # @api public
-  class PLiteralType < PDataType
+  class PVariantType < PObjectType
+    contains_many_uni 'types', PAbstractType, :lowerBound => 1
+
+    module ClassModule
+
+      def hash
+        [self.class, Set.new(self.types)].hash
+      end
+
+      def ==(o)
+        (self.class == o.class && Set.new(types) == Set.new(o.types)) ||
+          (o.class == PDataType && self == Puppet::Pops::Types::TypeCalculator.data_variant())
+      end
+    end
   end
 
+  # Type that is PDataType compatible, but is not a PCollectionType.
   # @api public
-  class PStringType < PLiteralType
+  class PScalarType < PObjectType
+  end
+
+  # A string type describing the set of strings having one of the given values
+  #
+  class PEnumType < PScalarType
+    has_many_attr 'values', String, :lowerBound => 1
+
+    module ClassModule
+      def hash
+        [self.class, Set.new(self.values)].hash
+      end
+
+      def ==(o)
+        self.class == o.class && Set.new(values) == Set.new(o.values)
+      end
+    end
   end
 
   # @api public
-  class PNumericType < PLiteralType
+  class PNumericType < PScalarType
   end
 
   # @api public
   class PIntegerType < PNumericType
+    has_attr 'from', Integer, :lowerBound => 0
+    has_attr 'to', Integer, :lowerBound => 0
+
+    module ClassModule
+      # The integer type is enumerable when it defines a range
+      include Enumerable
+
+      # Returns Float.Infinity if one end of the range is unbound
+      def size
+        return 1.0 / 0.0 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 || -(1.0 / 0.0)
+        t = to || (1.0 / 0.0)
+        if f < t
+          [f, t]
+        else
+          [t,f]
+        end
+      end
+
+      # Returns Enumerator if no block is given
+      # Returns self if size is infinity (does not yield)
+      def each
+        return self.to_enum unless block_given?
+        return nil if from.nil? || to.nil?
+        if to < from
+          from.downto(to) {|x| yield x }
+        else
+          from.upto(to) {|x| yield x }
+        end
+      end
+
+      def hash
+        [self.class, from, to].hash
+      end
+
+      def ==(o)
+        self.class == o.class && from == o.from && to == o.to
+      end
+    end
   end
 
   # @api public
   class PFloatType < PNumericType
+    has_attr 'from', Float, :lowerBound => 0
+    has_attr 'to', Float, :lowerBound => 0
+
+    module ClassModule
+      def hash
+        [self.class, from, to].hash
+      end
+
+      def ==(o)
+        self.class == o.class && from == o.from && to == o.to
+      end
+    end
+  end
+
+  # @api public
+  class PStringType < PScalarType
+    has_many_attr 'values', String, :lowerBound => 0, :upperBound => -1, :unique => true
+    contains_one_uni 'size_type', PIntegerType
+
+    module ClassModule
+
+      def hash
+        [self.class, self.size_type, Set.new(self.values)].hash
+      end
+
+      def ==(o)
+        self.class == o.class && self.size_type == o.size_type && Set.new(values) == Set.new(o.values)
+      end
+    end
+  end
+
+  # @api public
+  class PRegexpType < PScalarType
+    has_attr 'pattern', String, :lowerBound => 1
+    has_attr 'regexp', Object, :derived => true
+
+    module ClassModule
+      def regexp_derived
+        @_regexp = Regexp.new(pattern) unless @_regexp && @_regexp.source == pattern
+        @_regexp
+      end
+
+      def hash
+        [self.class, pattern].hash
+      end
+
+      def ==(o)
+        self.class == o.class && pattern == o.pattern
+      end
+    end
   end
 
+  # Represents a subtype of String that narrows the string to those matching the patterns
+  # If specified without a pattern it is basically the same as the String type.
+  #
   # @api public
-  class PPatternType < PLiteralType
+  class PPatternType < PScalarType
+    contains_many_uni 'patterns', PRegexpType
+
+    module ClassModule
+
+      def hash
+        [self.class, Set.new(patterns)].hash
+      end
+
+      def ==(o)
+        self.class == o.class && Set.new(patterns) == Set.new(o.patterns)
+      end
+    end
   end
 
   # @api public
-  class PBooleanType < PLiteralType
+  class PBooleanType < PScalarType
   end
 
   # @api public
   class PCollectionType < PObjectType
-    contains_one_uni 'element_type', PObjectType
+    contains_one_uni 'element_type', PAbstractType
+    contains_one_uni 'size_type', PIntegerType
+    module ClassModule
+      def hash
+        [self.class, element_type, size].hash
+      end
+
+      def ==(o)
+        self.class == o.class && element_type == o.element_type && size_type == o.size_type
+      end
+    end
+  end
+
+  class PStructElement < Puppet::Pops::Model::PopsObject
+    has_attr 'name', String, :lowerBound => 1
+    contains_one_uni 'type', PAbstractType
+
+    module ClassModule
+      def hash
+        [self.class, type, name].hash
+      end
+
+      def ==(o)
+        self.class == o.class && type == o.type && name == o.name
+      end
+    end
+  end
+
+  # @api public
+  class PStructType < PObjectType
+    contains_many_uni 'elements', PStructElement, :lowerBound => 1
+    has_attr 'hashed_elements', Object, :derived => true
+
+    module ClassModule
+      def hashed_elements_derived
+        @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e.type; memo }
+        @_hashed
+      end
+
+      def clear_hashed_elements
+        @_hashed = nil
+      end
+
+      def hash
+        [self.class, Set.new(elements)].hash
+      end
+
+      def ==(o)
+        self.class == o.class && hashed_elements == o.hashed_elements
+      end
+    end
+  end
+
+  # @api public
+  class PTupleType < PObjectType
+    contains_many_uni 'types', PAbstractType, :lowerBound => 1
+    # If set, describes repetition of the last type in types
+    contains_one_uni 'size_type', PIntegerType, :lowerBound => 0
+
     module ClassModule
       def hash
-        [self.class, element_type].hash
+        [self.class, size_type, Set.new(types)].hash
       end
 
       def ==(o)
-        self.class == o.class && element_type == o.element_type
+        self.class == o.class && types == o.types && size_type == o.size_type
       end
     end
   end
@@ -92,25 +325,28 @@ module Puppet::Pops::Types
   class PArrayType < PCollectionType
     module ClassModule
       def hash
-        [self.class, element_type].hash
+        [self.class, self.element_type, self.size_type].hash
       end
 
       def ==(o)
-        self.class == o.class && element_type == o.element_type
+        self.class == o.class && self.element_type == o.element_type && self.size_type == o.size_type
       end
     end
   end
 
   # @api public
   class PHashType < PCollectionType
-    contains_one_uni 'key_type', PObjectType
+    contains_one_uni 'key_type', PAbstractType
     module ClassModule
       def hash
-        [self.class, key_type, element_type].hash
+        [self.class, key_type, self.element_type, self.size_type].hash
       end
 
       def ==(o)
-        self.class == o.class && key_type == o.key_type && element_type == o.element_type
+        self.class        == o.class         &&
+        key_type          == o.key_type      &&
+        self.element_type == o.element_type  &&
+        self.size_type    == o.size_type
       end
     end
   end
@@ -127,6 +363,60 @@ module Puppet::Pops::Types
         self.class == o.class && ruby_class == o.ruby_class
       end
     end
+  end
+
+  # Abstract representation of a type that can be placed in a Catalog.
+  # @api public
+  #
+  class PCatalogEntryType < PObjectType
+  end
+
+  # Represents a (host-) class in the Puppet Language.
+  # @api public
+  #
+  class PHostClassType < PCatalogEntryType
+    has_attr 'class_name', String
+    # contains_one_uni 'super_type', PHostClassType
+    module ClassModule
+      def hash
+        [self.class, host_class].hash
+      end
+      def ==(o)
+        self.class == o.class && class_name == o.class_name
+      end
+    end
+  end
 
+  # Represents a Resource Type in the Puppet Language
+  # @api public
+  #
+  class PResourceType < PCatalogEntryType
+    has_attr 'type_name', String
+    has_attr 'title', String
+    module ClassModule
+      def hash
+        [self.class, type_name, title].hash
+      end
+      def ==(o)
+        self.class == o.class && type_name == o.type_name && title == o.title
+      end
+    end
   end
+
+  # Represents a type that accept PNilType instead of the type parameter
+  # required_type - is a short hand for Variant[T, Undef]
+  #
+  class POptionalType < PAbstractType
+    contains_one_uni 'optional_type', PAbstractType
+    module ClassModule
+      def hash
+        [self.class, optional_type].hash
+      end
+
+      def ==(o)
+        self.class == o.class && optional_type == o.optional_type
+      end
+    end
+  end
+
 end

data/lib/puppet/pops/utils.rb

@@ -14,8 +14,8 @@ module Puppet::Pops::Utils
     end
   end
 
-  # To LiteralNumber with radix, or nil if not a number.
-  # If the value is already a number it is returned verbatim with a radix of 10.
+  # To Numeric with radix, or nil if not a number.
+  # If the value is already Numeric it is returned verbatim with a radix of 10.
   # @param o [String, Number] a string containing a number in octal, hex, integer (decimal) or floating point form
   # @return [Array<Number, Integer>, nil] array with converted number and radix, or nil if not possible to convert
   # @api public
@@ -35,10 +35,13 @@ module Puppet::Pops::Utils
           radix = 10
           if match[1].to_s.length > 0
             radix = 16
-          elsif match[2].to_s.length > 1 && match[2][0] == '0'
+          elsif match[2].to_s.length > 1 && match[2][0,1] == '0'
             radix = 8
           end
-          [Integer(match[0], radix), radix]
+          # Ruby 1.8.7 does not have a second argument to Kernel method that creates an
+          # integer from a string, it relies on the prefix 0x, 0X, 0 (and unsupported in puppet binary 'b')
+          # We have the correct string here, match[0] is safe to parse without passing on radix
+          [Integer(match[0]), radix]
         end
       when Numeric, Fixnum, Integer, Float
         # Impossible to calculate radix, assume decimal
@@ -90,15 +93,28 @@ module Puppet::Pops::Utils
     is_absolute?(name) ? name[2..-1] : name
   end
 
-  # Finds an adapter for o or for one of its containers, or nil, if none of the containers
+  # Finds an existing adapter for o or for one of its containers, or nil, if none of the containers
   # was adapted with the given adapter.
   # This method can only be used with objects that respond to `:eContainer`.
-  # with true, and Adaptable#adapters.
+  # with true.
+  #
+  # @see #find_closest_positioned
   #
   def self.find_adapter(o, adapter)
-    return nil unless o
+    return nil if o.nil? || (o.is_a?(Array) && o.empty?)
     a = adapter.get(o)
     return a if a
     return find_adapter(o.eContainer, adapter)
   end
+
+  # Finds the closest positioned Puppet::Pops::Model::Positioned object, or object decorated with
+  # a SourcePosAdapter, and returns
+  # a SourcePosAdapter for the first found, or nil if not found.
+  #
+  def self.find_closest_positioned(o)
+    return nil if o.nil? || o.is_a?(Puppet::Pops::Model::Program) || (o.is_a?(Array) && o.empty?)
+    return find_adapter(o, Puppet::Pops::Adapters::SourcePosAdapter) unless o.is_a?(Puppet::Pops::Model::Positioned)
+    o.offset.nil? ? find_closest_positioned(o.eContainer) : Puppet::Pops::Adapters::SourcePosAdapter.adapt(o)
+  end
+
 end