puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/types/types.rb

@@ -0,0 +1,397 @@
+require 'rgen/metamodel_builder'
+
+# The Types model is a model of Puppet Language types.
+# It consists of two parts; the meta-model expressed using RGen (in types_meta.rb) and this file which
+# mixes in the implementation.
+#
+# @api public
+#
+module Puppet::Pops
+  require 'puppet/pops/types/types_meta'
+
+  # TODO: See PUP-2978 for possible performance optimization
+
+  # 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
+      include Puppet::Pops::Containment
+    end
+
+    class PAnyType < TypeModelObject
+      module ClassModule
+        # Produce a deep copy of the type
+        def copy
+          Marshal.load(Marshal.dump(self))
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        def ==(o)
+          self.class == o.class
+        end
+
+        alias eql? ==
+
+        def to_s
+          Puppet::Pops::Types::TypeCalculator.string(self)
+        end
+      end
+    end
+
+    class PType < PAnyType
+      module ClassModule
+        def hash
+          [self.class, type].hash
+        end
+
+        def ==(o)
+          self.class == o.class && type == o.type
+        end
+      end
+    end
+
+    class PDataType < PAnyType
+      module ClassModule
+        def ==(o)
+          self.class == o.class ||
+            o.class == PVariantType && o == Puppet::Pops::Types::TypeCalculator.data_variant()
+        end
+      end
+    end
+
+    class PVariantType < PAnyType
+      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
+
+    class PEnumType < PScalarType
+      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
+
+    class PIntegerType < PNumericType
+      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 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
+          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
+
+    class PFloatType < PNumericType
+      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
+
+    class PStringType < PScalarType
+      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
+
+    class PRegexpType < PScalarType
+      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
+
+    class PPatternType < PScalarType
+      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
+
+    class PCollectionType < PAnyType
+      module ClassModule
+        # Returns an array with from (min) size to (max) size
+        def size_range
+          return [0, INFINITY] if size_type.nil?
+          f = size_type.from || 0
+          t = size_type.to || INFINITY
+          if f < t
+            [f, t]
+          else
+            [t,f]
+          end
+        end
+
+        def hash
+          [self.class, element_type, size_type].hash
+        end
+
+        def ==(o)
+          self.class == o.class && element_type == o.element_type && size_type == o.size_type
+        end
+      end
+    end
+
+    class PStructElement < TypeModelObject
+      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
+
+
+    class PStructType < PAnyType
+      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
+
+    class PTupleType < PAnyType
+      module ClassModule
+        # Returns the number of elements accepted [min, max] in the tuple
+        def size_range
+          types_size = types.size
+          size_type.nil? ? [types_size, types_size] : size_type.range
+        end
+
+        # Returns the number of accepted occurrences [min, max] of the last type in the tuple
+        # The defaults is [1,1]
+        #
+        def repeat_last_range
+          types_size = types.size
+          if size_type.nil?
+            return [1, 1]
+          end
+          from, to = size_type.range()
+          min = from - (types_size-1)
+          min = min <= 0 ? 0 : min
+          max = to - (types_size-1)
+          [min, max]
+        end
+
+        def hash
+          [self.class, size_type, Set.new(types)].hash
+        end
+
+        def ==(o)
+          self.class == o.class && types == o.types && size_type == o.size_type
+        end
+      end
+    end
+
+    class PCallableType < PAnyType
+      module ClassModule
+        # Returns the number of accepted arguments [min, max]
+        def size_range
+          param_types.size_range
+        end
+
+        # Returns the number of accepted arguments for the last parameter type [min, max]
+        #
+        def last_range
+          param_types.repeat_last_range
+        end
+
+        # Range [0,0], [0,1], or [1,1] for the block
+        #
+        def block_range
+          case block_type
+          when Puppet::Pops::Types::POptionalType
+            [0,1]
+          when Puppet::Pops::Types::PVariantType, Puppet::Pops::Types::PCallableType
+            [1,1]
+          else
+            [0,0]
+          end
+        end
+
+        def hash
+          [self.class, Set.new(param_types), block_type].hash
+        end
+
+        def ==(o)
+          self.class == o.class && args_type == o.args_type && block_type == o.block_type
+        end
+      end
+    end
+
+    class PArrayType < PCollectionType
+      module ClassModule
+        def hash
+          [self.class, self.element_type, self.size_type].hash
+        end
+
+        def ==(o)
+          self.class == o.class && self.element_type == o.element_type && self.size_type == o.size_type
+        end
+      end
+    end
+
+    class PHashType < PCollectionType
+      module ClassModule
+        def hash
+          [self.class, key_type, self.element_type, self.size_type].hash
+        end
+
+        def ==(o)
+          self.class        == o.class         &&
+          key_type          == o.key_type      &&
+          self.element_type == o.element_type  &&
+          self.size_type    == o.size_type
+        end
+      end
+    end
+
+
+    class PRuntimeType < PAnyType
+      module ClassModule
+        def hash
+          [self.class, runtime, runtime_type_name].hash
+        end
+
+        def ==(o)
+          self.class == o.class && runtime == o.runtime && runtime_type_name == o.runtime_type_name 
+        end
+      end
+    end
+
+    class PHostClassType < PCatalogEntryType
+      module ClassModule
+        def hash
+          [self.class, class_name].hash
+        end
+        def ==(o)
+          self.class == o.class && class_name == o.class_name
+        end
+      end
+    end
+
+    class PResourceType < PCatalogEntryType
+      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
+
+    class POptionalType < PAnyType
+      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
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/types/types_meta.rb

@@ -0,0 +1,223 @@
+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 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
+  extend RGen::MetamodelBuilder::ModuleExtension
+
+  class TypeModelObject < RGen::MetamodelBuilder::MMBase
+    abstract
+  end
+
+  # Base type for all types except {Puppet::Pops::Types::PType PType}, the type of types.
+  # @api public
+  #
+  class PAnyType < TypeModelObject
+  end
+
+  # The type of types.
+  # @api public
+  #
+  class PType < PAnyType
+    contains_one_uni 'type', PAnyType
+  end
+
+  # @api public
+  #
+  class PNilType < PAnyType
+  end
+
+
+  # A type private to the type system that describes "ignored type" - i.e. "I am what you are"
+  # @api private
+  #
+  class  PUnitType < PAnyType
+  end
+
+  # @api public
+  #
+  class PDefaultType < PAnyType
+  end
+
+  # A flexible data type, being assignable to its subtypes as well as PArrayType and PHashType with element type assignable to PDataType.
+  #
+  # @api public
+  #
+  class PDataType < PAnyType
+  end
+
+  # A flexible type describing an any? of other types
+  # @api public
+  #
+  class PVariantType < PAnyType
+    contains_many_uni 'types', PAnyType, :lowerBound => 1
+  end
+
+  # Type that is PDataType compatible, but is not a PCollectionType.
+  # @api public
+  #
+  class PScalarType < PAnyType
+  end
+
+  # A string type describing the set of strings having one of the given values
+  # @api public
+  #
+  class PEnumType < PScalarType
+    has_many_attr 'values', String, :lowerBound => 1
+  end
+
+  # @api public
+  #
+  class PNumericType < PScalarType
+  end
+
+  # @api public
+  #
+  class PIntegerType < PNumericType
+    has_attr 'from', Integer, :lowerBound => 0
+    has_attr 'to', Integer, :lowerBound => 0
+  end
+
+  # @api public
+  #
+  class PFloatType < PNumericType
+    has_attr 'from', Float, :lowerBound => 0
+    has_attr 'to', Float, :lowerBound => 0
+  end
+
+  # @api public
+  #
+  class PStringType < PScalarType
+    has_many_attr 'values', String, :lowerBound => 0, :upperBound => -1, :unique => true
+    contains_one_uni 'size_type', PIntegerType
+  end
+
+  # @api public
+  #
+  class PRegexpType < PScalarType
+    has_attr 'pattern', String, :lowerBound => 1
+    has_attr 'regexp', Object, :derived => true
+  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 < PScalarType
+    contains_many_uni 'patterns', PRegexpType
+  end
+
+  # @api public
+  #
+  class PBooleanType < PScalarType
+  end
+
+  # @api public
+  #
+  class PCollectionType < PAnyType
+    contains_one_uni 'element_type', PAnyType
+    contains_one_uni 'size_type', PIntegerType
+  end
+
+  # @api public
+  #
+  class PStructElement < TypeModelObject
+    has_attr 'name', String, :lowerBound => 1
+    contains_one_uni 'type', PAnyType
+  end
+
+  # @api public
+  #
+  class PStructType < PAnyType
+    contains_many_uni 'elements', PStructElement, :lowerBound => 1
+    has_attr 'hashed_elements', Object, :derived => true
+  end
+
+  # @api public
+  #
+  class PTupleType < PAnyType
+    contains_many_uni 'types', PAnyType, :lowerBound => 1
+    # If set, describes min and max required of the given types - if max > size of
+    # types, the last type entry repeats
+    #
+    contains_one_uni 'size_type', PIntegerType, :lowerBound => 0
+  end
+
+  # @api public
+  #
+  class PCallableType < PAnyType
+    # Types of parameters as a Tuple with required/optional count, or an Integer with min (required), max count
+    contains_one_uni 'param_types', PAnyType, :lowerBound => 1
+
+    # Although being an abstract type reference, only Callable, or all Callables wrapped in
+    # Optional or Variant are supported
+    # If not set, the meaning is that block is not supported.
+    #
+    contains_one_uni 'block_type', PAnyType, :lowerBound => 0
+  end
+
+  # @api public
+  #
+  class PArrayType < PCollectionType
+  end
+
+  # @api public
+  #
+  class PHashType < PCollectionType
+    contains_one_uni 'key_type', PAnyType
+  end
+
+  RuntimeEnum = RGen::MetamodelBuilder::DataTypes::Enum.new(
+    :name => 'RuntimeEnum',
+    :literals => [:'ruby', ])
+
+  # @api public
+  #
+  class PRuntimeType < PAnyType
+    has_attr 'runtime', RuntimeEnum, :lowerBound => 1
+    has_attr 'runtime_type_name', String
+  end
+
+  # Abstract representation of a type that can be placed in a Catalog.
+  # @api public
+  #
+  class PCatalogEntryType < PAnyType
+  end
+
+  # Represents a (host-) class in the Puppet Language.
+  # @api public
+  #
+  class PHostClassType < PCatalogEntryType
+    has_attr 'class_name', String
+  end
+
+  # Represents a Resource Type in the Puppet Language
+  # @api public
+  #
+  class PResourceType < PCatalogEntryType
+    has_attr 'type_name', String
+    has_attr 'title', String
+  end
+
+  # Represents a type that accept PNilType instead of the type parameter
+  # required_type - is a short hand for Variant[T, Undef]
+  # @api public
+  #
+  class POptionalType < PAnyType
+    contains_one_uni 'optional_type', PAnyType
+  end
+
+end