puppet 4.10.12 → 5.0.0

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

@@ -94,7 +94,7 @@ class PRuntimeType < PAnyType
   # @api private
   def _assignable?(o, guard)
     return false unless o.is_a?(PRuntimeType)
-    return false unless @runtime == o.runtime
+    return false unless @runtime.nil? || @runtime == o.runtime
     return true if @name_or_pattern.nil? # t1 is wider
 
     onp = o.name_or_pattern

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

@@ -4,9 +4,9 @@ module Types
 # An unparameterized type that represents all VersionRange instances
 #
 # @api public
-class PSemVerRangeType < PScalarType
+class PSemVerRangeType < PAnyType
   def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'ScalarType')
+    create_ptype(loader, ir, 'AnyType')
   end
 
   # Check if a version is included in a version range. The version can be a string or
@@ -90,6 +90,10 @@ class PSemVerRangeType < PScalarType
     end
   end
 
+  def roundtrip_with_string?
+    true
+  end
+
   def instance?(o, guard = nil)
     o.is_a?(SemanticPuppet::VersionRange)
   end

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

@@ -1,10 +1,61 @@
 module Puppet::Pops
 module Types
-  class PAbstractTimeDataType < PAbstractRangeType
+  class PAbstractTimeDataType < PScalarType
     # @param from [AbstractTime] lower bound for this type. Nil or :default means unbounded
     # @param to [AbstractTime] upper bound for this type. Nil or :default means unbounded
-    def initialize(from = nil, to = nil)
-      super(convert_arg(from, true), convert_arg(to, false))
+    def initialize(from, to)
+      @from = convert_arg(from, true)
+      @to = convert_arg(to, false)
+      raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{@from}, #{@to}" unless @from <= @to
+    end
+
+    # Checks if this numeric range intersects with another
+    #
+    # @param o [PNumericType] the range to compare with
+    # @return [Boolean] `true` if this range intersects with the other range
+    # @api public
+    def intersect?(o)
+      self.class == o.class && !(@to < o.numeric_from || o.numeric_to < @from)
+    end
+
+    # Returns the lower bound of the numeric range or `nil` if no lower bound is set.
+    # @return [Float,Integer]
+    def from
+      @from == -Float::INFINITY ? nil : @from
+    end
+
+    # Returns the upper bound of the numeric range or `nil` if no upper bound is set.
+    # @return [Float,Integer]
+    def to
+      @to == Float::INFINITY ? nil : @to
+    end
+
+    # Same as #from but will return `-Float::Infinity` instead of `nil` if no lower bound is set.
+    # @return [Float,Integer]
+    def numeric_from
+      @from
+    end
+
+    # Same as #to but will return `Float::Infinity` instead of `nil` if no lower bound is set.
+    # @return [Float,Integer]
+    def numeric_to
+      @to
+    end
+
+    def hash
+      @from.hash ^ @to.hash
+    end
+
+    def eql?(o)
+      self.class == o.class && @from == o.numeric_from && @to == o.numeric_to
+    end
+
+    def instance?(o, guard = nil)
+      o.is_a?(Numeric) && o >= @from && o <= @to
+    end
+
+    def unbounded?
+      @from == -Float::INFINITY && @to == Float::INFINITY
     end
 
     def convert_arg(arg, min)
@@ -14,7 +65,7 @@ module Types
       when Hash
         impl_class.from_hash(arg)
       when nil, :default
-        nil
+        min ? -Float::INFINITY : Float::INFINITY
       when String
         impl_class.parse(arg)
       when Integer

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

@@ -47,12 +47,15 @@ class PTypeSetType < PMetaType
     Pcore::KEY_PCORE_VERSION => TYPE_STRING_OR_VERSION,
     TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
     TypeFactory.optional(KEY_NAME) => Pcore::TYPE_QUALIFIED_REFERENCE,
-    KEY_VERSION => TYPE_STRING_OR_VERSION,
+    TypeFactory.optional(KEY_VERSION) => TYPE_STRING_OR_VERSION,
     TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PType::DEFAULT, PCollectionType::NOT_EMPTY_SIZE),
     TypeFactory.optional(KEY_REFERENCES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, TYPE_TYPE_REFERENCE_I12N, PCollectionType::NOT_EMPTY_SIZE),
     TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS,
   })
 
+  def self.register_ptype(loader, ir)
+    create_ptype(loader, ir, 'AnyType', '_pcore_init_hash' => TYPE_TYPESET_I12N.resolve(TypeParser.singleton, loader))
+  end
 
   attr_reader :pcore_uri
   attr_reader :pcore_version
@@ -66,58 +69,58 @@ class PTypeSetType < PMetaType
   # Initialize a TypeSet Type instance. The initialization will use either a name and an initialization
   # hash expression, or a fully resolved initialization hash.
   #
-  # @overload initialize(name, i12n_hash_expression)
+  # @overload initialize(name, init_hash_expression)
   #   Used when the TypeSet type is loaded using a type alias expression. When that happens, it is important that
   #   the actual resolution of the expression is deferred until all definitions have been made known to the current
   #   loader. The package will then be resolved when it is loaded by the {TypeParser}. "resolved" here, means that
-  #   the hash expression is fully resolved, and then passed to the {#initialize_from_hash} method.
+  #   the hash expression is fully resolved, and then passed to the {#_pcore_init_from_hash} method.
   #   @param name [String] The name of the type set
-  #   @param i12n_hash_expression [Model::LiteralHash] The hash describing the TypeSet features
+  #   @param init_hash_expression [Model::LiteralHash] The hash describing the TypeSet features
   #   @param name_authority [String] The default name authority for the type set
   #
-  # @overload initialize(i12n_hash)
-  #   Used when the package is created by the {TypeFactory}. The i12n_hash must be fully resolved.
-  #   @param i12n_hash [Hash{String=>Object}] The hash describing the TypeSet features
+  # @overload initialize(init_hash)
+  #   Used when the package is created by the {TypeFactory}. The init_hash must be fully resolved.
+  #   @param init_hash [Hash{String=>Object}] The hash describing the TypeSet features
   #
   # @api private
-  def initialize(name_or_i12n_hash, i12n_hash_expression = nil, name_authority = nil)
+  def initialize(name_or_init_hash, init_hash_expression = nil, name_authority = nil)
     @types = EMPTY_HASH
     @references = EMPTY_HASH
 
-    if name_or_i12n_hash.is_a?(Hash)
-      initialize_from_hash(name_or_i12n_hash)
+    if name_or_init_hash.is_a?(Hash)
+      _pcore_init_from_hash(name_or_init_hash)
     else
       # Creation using "type XXX = TypeSet[{}]". This means that the name is given
-      @name = TypeAsserter.assert_instance_of('TypeSet name', Pcore::TYPE_QUALIFIED_REFERENCE, name_or_i12n_hash)
+      @name = TypeAsserter.assert_instance_of('TypeSet name', Pcore::TYPE_QUALIFIED_REFERENCE, name_or_init_hash)
       @name_authority = TypeAsserter.assert_instance_of('TypeSet name_authority', Pcore::TYPE_URI, name_authority, true)
-      @i12n_hash_expression = i12n_hash_expression
+      @init_hash_expression = init_hash_expression
     end
   end
 
   # @api private
-  def initialize_from_hash(i12n_hash)
-    TypeAsserter.assert_instance_of('TypeSet initializer', TYPE_TYPESET_I12N, i12n_hash)
+  def _pcore_init_from_hash(init_hash)
+    TypeAsserter.assert_instance_of('TypeSet initializer', TYPE_TYPESET_I12N, init_hash)
 
     # Name given to the loader have higher precedence than a name declared in the type
-    @name ||= i12n_hash[KEY_NAME].freeze
-    @name_authority ||= i12n_hash[KEY_NAME_AUTHORITY].freeze
+    @name ||= init_hash[KEY_NAME].freeze
+    @name_authority ||= init_hash[KEY_NAME_AUTHORITY].freeze
 
-    @pcore_version = PSemVerType.convert(i12n_hash[Pcore::KEY_PCORE_VERSION]).freeze
+    @pcore_version = PSemVerType.convert(init_hash[Pcore::KEY_PCORE_VERSION]).freeze
     unless Pcore::PARSABLE_PCORE_VERSIONS.include?(@pcore_version)
       raise ArgumentError,
         "The pcore version for TypeSet '#{@name}' is not understood by this runtime. Expected range #{Pcore::PARSABLE_PCORE_VERSIONS}, got #{@pcore_version}"
     end
 
-    @pcore_uri = i12n_hash[Pcore::KEY_PCORE_URI].freeze
-    @version = PSemVerType.convert(i12n_hash[KEY_VERSION])
-    @types = i12n_hash[KEY_TYPES] || EMPTY_HASH
+    @pcore_uri = init_hash[Pcore::KEY_PCORE_URI].freeze
+    @version = PSemVerType.convert(init_hash[KEY_VERSION])
+    @types = init_hash[KEY_TYPES] || EMPTY_HASH
     @types.freeze
 
     # Map downcase names to their camel-cased equivalent
     @dc_to_cc_map = {}
     @types.keys.each { |key| @dc_to_cc_map[key.downcase] = key }
 
-    refs = i12n_hash[KEY_REFERENCES]
+    refs = init_hash[KEY_REFERENCES]
     if refs.nil?
       @references = EMPTY_HASH
     else
@@ -155,22 +158,22 @@ class PTypeSetType < PMetaType
       @references = ref_map.freeze
     end
     @dc_to_cc_map.freeze
-    init_annotatable(i12n_hash)
+    init_annotatable(init_hash)
   end
 
   # Produce a hash suitable for the initializer
   # @return [Hash{String => Object}] the initialization hash
   #
   # @api private
-  def i12n_hash
+  def _pcore_init_hash
     result = super()
     result[Pcore::KEY_PCORE_URI] = @pcore_uri unless @pcore_uri.nil?
     result[Pcore::KEY_PCORE_VERSION] =  @pcore_version.to_s
     result[KEY_NAME_AUTHORITY] = @name_authority unless @name_authority.nil?
     result[KEY_NAME] = @name
-    result[KEY_VERSION] = @version.to_s
+    result[KEY_VERSION] = @version.to_s unless @version.nil?
     result[KEY_TYPES] = @types unless @types.empty?
-    result[KEY_REFERENCES] = Hash[@references.map { |ref_alias, ref| [ref_alias, ref.i12n_hash] }] unless @references.empty?
+    result[KEY_REFERENCES] = Hash[@references.map { |ref_alias, ref| [ref_alias, ref._pcore_init_hash] }] unless @references.empty?
     result
   end
 
@@ -178,11 +181,16 @@ class PTypeSetType < PMetaType
   # or a type defined in a type set that is referenced by this type set (nesting may occur to any level).
   # The name resolution is case insensitive.
   #
-  # @param qname [String] the qualified name of the type to resolve
+  # @param qname [String,Loader::TypedName] the qualified name of the type to resolve
   # @return [PAnyType,nil] the resolved type, or `nil` in case no type could be found
   #
   # @api public
   def [](qname)
+    if qname.is_a?(Loader::TypedName)
+      return nil unless qname.type == :type && qname.name_authority == @name_authority
+      qname = qname.name
+    end
+
     type = @types[qname] || @types[@dc_to_cc_map[qname.downcase]]
     if type.nil? && !@references.empty?
       segments = qname.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
@@ -255,9 +263,9 @@ class PTypeSetType < PMetaType
   end
 
   # @api private
-  def resolve_literal_hash(type_parser, loader, i12n_hash_expression)
+  def resolve_literal_hash(type_parser, loader, init_hash_expression)
     result = {}
-    i12n_hash_expression.entries.each do |entry|
+    init_hash_expression.entries.each do |entry|
       key = type_parser.interpret_any(entry.key, loader)
       if (key == KEY_TYPES || key == KEY_REFERENCES) && entry.value.is_a?(Model::LiteralHash)
         # Skip type parser interpretation and convert qualified references directly to String keys.
@@ -281,7 +289,7 @@ class PTypeSetType < PMetaType
         full_name = "#{@name}::#{type_name}".freeze
         typed_name = Loader::TypedName.new(:type, full_name, name_auth)
         type = Loader::TypeDefinitionInstantiator.create_type(full_name, value, name_auth)
-        loader.set_entry(typed_name, type, Adapters::SourcePosAdapter.adapt(value).to_uri)
+        loader.set_entry(typed_name, type, value.locator.to_uri(value))
         types[type_name] = type
       end
     end
@@ -289,8 +297,8 @@ class PTypeSetType < PMetaType
   end
 
   # @api private
-  def resolve_hash(type_parser, loader, i12n_hash)
-    result = Hash[i12n_hash.map do |key, value|
+  def resolve_hash(type_parser, loader, init_hash)
+    result = Hash[init_hash.map do |key, value|
       key = resolve_type_refs(type_parser, loader, key)
       value = resolve_type_refs(type_parser, loader, value) unless key == KEY_TYPES && value.is_a?(Hash)
       [key, value]
@@ -335,13 +343,13 @@ class PTypeSetType < PMetaType
 
   private
 
-  def resolve_name_authority(i12n_hash, loader)
+  def resolve_name_authority(init_hash, loader)
     name_auth = @name_authority
     if name_auth.nil?
-      name_auth = i12n_hash[KEY_NAME_AUTHORITY]
+      name_auth = init_hash[KEY_NAME_AUTHORITY]
       name_auth = loader.name_authority if name_auth.nil? && loader.is_a?(TypeSetLoader)
       if name_auth.nil?
-        name = @name || i12n_hash[KEY_NAME]
+        name = @name || init_hash[KEY_NAME]
         raise ArgumentError, "No 'name_authority' is declared in TypeSet '#{name}' and it cannot be inferred"
       end
     end

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

@@ -5,11 +5,21 @@ module Types
 # @api public
 module PuppetObject
   # Returns the Puppet Type for this instance. The implementing class must
-  # add the {#_ptype} as a class method.
+  # add the {#_pcore_type} as a class method.
   #
   # @return [PObjectType] the type
-  def _ptype
-    self.class._ptype
+  def _pcore_type
+    self.class._pcore_type
+  end
+
+  def _pcore_all_contents(path, &block)
+  end
+
+  def _pcore_contents
+  end
+
+  def _pcore_init_hash
+    EMPTY_HASH
   end
 end
 end

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

@@ -18,36 +18,54 @@ class RubyGenerator < TypeFormatter
 
   def create_class(obj)
     @dynamic_classes ||= Hash.new do |hash, key|
-      rp = key.resolved_parent
-      parent_class = rp.is_a?(PObjectType) ? create_class(rp) : Object
-      class_def = ''
-      class_body(key, EMPTY_ARRAY, class_def)
-      cls = Class.new(parent_class)
-      cls.class_eval(class_def)
-      cls.define_singleton_method(:_ptype) { return key }
+      cls = key.implementation_class(false)
+      if cls.nil?
+        rp = key.resolved_parent
+        parent_class = rp.is_a?(PObjectType) ? rp.implementation_class : Object
+        class_def = ''
+        class_body(key, EMPTY_ARRAY, class_def)
+        cls = Class.new(parent_class)
+        cls.class_eval(class_def)
+        cls.define_singleton_method(:_pcore_type) { return key }
+        key.implementation_class = cls
+      end
       hash[key] = cls
     end
     raise ArgumentError, "Expected a Puppet Type, got '#{obj.class.name}'" unless obj.is_a?(PAnyType)
     @dynamic_classes[obj]
   end
 
-  def module_definition_from_typeset(typeset)
+  def module_definition_from_typeset(typeset, *impl_subst)
     module_definition(
       typeset.types.values,
-      "# Generated by #{self.class.name} from TypeSet #{typeset.name} on #{Date.new}\n")
+      "# Generated by #{self.class.name} from TypeSet #{typeset.name} on #{Date.new}\n",
+      *impl_subst)
   end
 
-  def module_definition(types, comment)
+  def module_definition(types, comment, *impl_subst)
     object_types, aliased_types = types.partition { |type| type.is_a?(PObjectType) }
-    impl_names = implementation_names(object_types)
+    if impl_subst.empty?
+      impl_names = implementation_names(object_types)
+    else
+      impl_names = object_types.map { |type| type.name.gsub(*impl_subst) }
+    end
 
     # extract common implementation module prefix
+    names_by_prefix = Hash.new { |hash, key| hash[key] = [] }
+    index = 0
+    min_prefix_length = impl_names.reduce(Float::INFINITY) do |len, impl_name|
+      segments = impl_name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
+      leaf_name = segments.pop
+      names_by_prefix[segments.freeze] << [index, leaf_name, impl_name]
+      index += 1
+      len > segments.size ? segments.size : len
+    end
+
     common_prefix = []
-    segmented_names = impl_names.map { |impl_name| impl_name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR) }
-    segments = segmented_names[0]
-    segments.size.times do |idx|
-      segment = segments[idx]
-      break unless segmented_names.all? { |sn| sn[idx] == segment }
+    segments_array = names_by_prefix.keys
+    min_prefix_length.times do |idx|
+      segment = segments_array[0][idx]
+      break unless segments_array.all? { |sn| sn[idx] == segment }
       common_prefix << segment
     end
 
@@ -55,9 +73,15 @@ class RubyGenerator < TypeFormatter
     bld = ''
     start_module(common_prefix, comment, bld)
     class_names = []
-    object_types.each_with_index do |type, index|
-      class_names << class_definition(type, common_prefix, bld, impl_names[index])
-      bld << "\n"
+    names_by_prefix.each_pair do |seg_array, index_and_name_array|
+      added_to_common_prefix = seg_array[common_prefix.length..-1]
+      added_to_common_prefix.each { |name| bld << 'module ' << name << "\n" }
+      index_and_name_array.each do |idx, name, full_name|
+        scoped_class_definition(object_types[idx], name, bld, full_name, *impl_subst)
+        class_names << (added_to_common_prefix + [name]).join(TypeFormatter::NAME_SEGMENT_SEPARATOR)
+        bld << "\n"
+      end
+      added_to_common_prefix.size.times { bld << "end\n" }
     end
 
     aliases = Hash[aliased_types.map { |type| [type.name, type.resolved_type] }]
@@ -100,38 +124,41 @@ class RubyGenerator < TypeFormatter
     end
   end
 
-  def class_definition(obj, namespace_segments, bld, class_name)
+  def class_definition(obj, namespace_segments, bld, class_name, *impl_subst)
     module_segments = remove_common_namespace(namespace_segments, class_name)
     leaf_name = module_segments.pop
     module_segments.each { |segment| bld << 'module ' << segment << "\n" }
+    scoped_class_definition(obj,leaf_name, bld, class_name, *impl_subst)
+    module_segments.size.times { bld << "end\n" }
+    module_segments << leaf_name
+    module_segments.join(TypeFormatter::NAME_SEGMENT_SEPARATOR)
+  end
+
+  def scoped_class_definition(obj, leaf_name, bld, class_name, *impl_subst)
     bld << 'class ' << leaf_name
     segments = class_name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
 
     unless obj.parent.nil?
-      ir = Loaders.implementation_registry
-      parent_impl = ir.module_name_for_type(obj.parent)
-      raise Puppet::Error, "Unable to create an instance of #{obj.parent.name}. No mapping exists to runtime object" if parent_impl.nil?
-      bld << ' < ' << namespace_relative(segments, parent_impl[0])
+      if impl_subst.empty?
+        ir = Loaders.implementation_registry
+        parent_impl = ir.module_name_for_type(obj.parent)
+        raise Puppet::Error, "Unable to create an instance of #{obj.parent.name}. No mapping exists to runtime object" if parent_impl.nil?
+        parent_name = parent_impl[0]
+      else
+        parent_name = obj.parent.name.gsub(*impl_subst)
+      end
+      bld << ' < ' << namespace_relative(segments, parent_name)
     end
 
     bld << "\n"
-    bld << "  def self._plocation\n"
-    bld << "    loc = Puppet::Util.path_to_uri(\"\#{__FILE__}\")\n"
-    bld << "    URI(\"#\{loc}?line=#\{__LINE__.to_i - 3}\")\n"
-    bld << "  end\n"
-
-    bld << "\n"
-    bld << "  def self._ptype\n"
-    bld << '    @_ptype ||= ' << namespace_relative(segments, obj.class.name) << ".new('" << obj.name << "',\n"
-    bld << TypeFormatter.new.ruby_string('ref', 3, obj.i12n_hash(false)) << "    )\n"
+    bld << "  def self._pcore_type\n"
+    bld << '    @_pcore_type ||= ' << namespace_relative(segments, obj.class.name) << ".new('" << obj.name << "', "
+    bld << TypeFormatter.singleton.ruby('ref').indented(2).string(obj._pcore_init_hash(false)) << ")\n"
     bld << "  end\n"
 
     class_body(obj, segments, bld)
 
     bld << "end\n"
-    module_segments.size.times { bld << "end\n" }
-    module_segments << leaf_name
-    module_segments.join(TypeFormatter::NAME_SEGMENT_SEPARATOR)
   end
 
   def class_body(obj, segments, bld)
@@ -146,130 +173,267 @@ class RubyGenerator < TypeFormatter
     constants, others = obj.attributes(true).values.partition { |a| a.kind == PObjectType::ATTRIBUTE_KIND_CONSTANT }
     constants = constants.select { |ca| ca.container.equal?(obj) }
     unless constants.empty?
-      constants.each { |ca| bld << "\n  def self." << ca.name << "\n    _ptype['" << ca.name << "'].value\n  end\n" }
+      constants.each { |ca| bld << "\n  def self." << ca.name << "\n    _pcore_type['" << ca.name << "'].value\n  end\n" }
       constants.each { |ca| bld << "\n  def " << ca.name << "\n    self.class." << ca.name << "\n  end\n" }
     end
 
     init_params = others.reject { |a| a.kind == PObjectType::ATTRIBUTE_KIND_DERIVED }
     opt, non_opt = init_params.partition { |ip| ip.value? }
+    derived_attrs, obj_attrs = others.select { |a| a.container.equal?(obj) }.partition { |ip| ip.kind == PObjectType::ATTRIBUTE_KIND_DERIVED }
 
-    # Output type safe hash constructor
-    bld << "\n  def self.from_hash(i12n)\n"
-    bld << '    from_asserted_hash(' << namespace_relative(segments, TypeAsserter.name) << '.assert_instance_of('
-    bld << "'" << obj.label << " initializer', _ptype.i12n_type, i12n))\n  end\n\n  def self.from_asserted_hash(i12n)\n    new(\n"
-    non_opt.each { |ip| bld << "      i12n['" << ip.name << "'],\n" }
-    opt.each { |ip| bld << "      i12n.fetch('" << ip.name << "') { _ptype['" << ip.name << "'].value },\n" }
-    bld.chomp!(",\n")
-    bld << ")\n  end\n"
-
-    # Output type safe constructor
-    bld << "\n  def self.create"
-    if init_params.empty?
-      bld << "\n    new"
+    include_type = obj.equality_include_type? && !(obj.parent.is_a?(PObjectType) && obj.parent.equality_include_type?)
+    if obj.equality.nil?
+      eq_names = obj_attrs.reject { |a| a.kind == PObjectType::ATTRIBUTE_KIND_CONSTANT }.map(&:name)
     else
-      bld << '('
-      non_opt.each { |ip| bld << ip.name << ', ' }
-      opt.each { |ip| bld << ip.name << ' = ' << "_ptype['#{ip.name}'].value" << ', ' }
-      bld.chomp!(', ')
-      bld << ")\n"
-      bld << '    ta = ' << namespace_relative(segments, TypeAsserter.name) << "\n"
-      bld << "    attrs = _ptype.attributes(true)\n"
-      init_params.each do |a|
-        bld << "    ta.assert_instance_of('" << a.container.name << '[' << a.name << ']'
-        bld << "', attrs['" << a.name << "'].type, " << a.name << ")\n"
-      end
-      bld << '    new('
-      non_opt.each { |a| bld << a.name << ', ' }
-      opt.each { |a| bld << a.name << ', ' }
-      bld.chomp!(', ')
-      bld << ')'
+      eq_names = obj.equality
     end
-    bld << "\n  end\n"
-
-    # Output initializer
-    bld << "\n  def initialize"
-    unless init_params.empty?
-      bld << '('
-      non_opt.each { |ip| bld << ip.name << ', ' }
-      opt.each { |ip| bld << ip.name << ' = ' << "_ptype['#{ip.name}'].value" << ', ' }
-      bld.chomp!(', ')
-      bld << ')'
-      unless obj.parent.nil?
-        bld << "\n    super"
-        super_args = (non_opt + opt).select { |ip| !ip.container.equal?(obj) }
-        unless super_args.empty?
-          bld << '('
-          super_args.each { |ip| bld << ip.name << ', ' }
-          bld.chomp!(', ')
-          bld << ')'
+
+    unless obj.parent.is_a?(PObjectType) && obj_attrs.empty?
+      # Output type safe hash constructor
+      bld << "\n  def self.from_hash(i12n)\n"
+      bld << '    from_asserted_hash(' << namespace_relative(segments, TypeAsserter.name) << '.assert_instance_of('
+      bld << "'" << obj.label << " initializer', _pcore_type.i12n_type, i12n))\n  end\n\n  def self.from_asserted_hash(i12n)\n    new"
+      unless non_opt.empty? && opt.empty?
+        bld << "(\n"
+        non_opt.each { |ip| bld << "      i12n['" << ip.name << "'],\n" }
+        opt.each do |ip|
+          if ip.value.nil?
+            bld << "      i12n['" << ip.name << "'],\n"
+          else
+            bld << "      i12n.fetch('" << ip.name << "') { "
+            default_string(bld, ip)
+            bld << " },\n"
+          end
         end
+        bld.chomp!(",\n")
+        bld << ')'
       end
-    end
-    bld << "\n"
+      bld << "\n  end\n"
 
-    init_params.each { |a| bld << '    @' << a.name << ' = ' << a.name << "\n" if a.container.equal?(obj) }
-    bld << "  end\n\n"
+      # Output type safe constructor
+      bld << "\n  def self.create"
+      if init_params.empty?
+        bld << "\n    new"
+      else
+        bld << '('
+        non_opt.each { |ip| bld << ip.name << ', ' }
+        opt.each do |ip|
+          bld << ip.name << ' = '
+          default_string(bld, ip)
+          bld << ', '
+        end
+        bld.chomp!(', ')
+        bld << ")\n"
+        bld << '    ta = ' << namespace_relative(segments, TypeAsserter.name) << "\n"
+        bld << "    attrs = _pcore_type.attributes(true)\n"
+        init_params.each do |a|
+          bld << "    ta.assert_instance_of('" << a.container.name << '[' << a.name << ']'
+          bld << "', attrs['" << a.name << "'].type, " << a.name << ")\n"
+        end
+        bld << '    new('
+        non_opt.each { |a| bld << a.name << ', ' }
+        opt.each { |a| bld << a.name << ', ' }
+        bld.chomp!(', ')
+        bld << ')'
+      end
+      bld << "\n  end\n"
 
-    bld << "  def i12n_hash\n    result = "
-    bld << (obj.parent.nil? ? '{}' : 'super')
-    bld << "\n"
-    init_params.each { |a| bld << "    result['" << a.name << "'] = @" << a.name << "\n" if a.container.equal?(obj) }
-    bld << "    result\n  end\n\n"
-
-    bld << "  def to_s\n"
-    bld << "    " << namespace_relative(segments, TypeFormatter.name) << ".string(self)\n"
-    bld << "  end\n\n"
-
-    # Output attr_readers
-    others.each do |a|
-      next unless a.container.equal?(obj)
-      if a.kind == PObjectType::ATTRIBUTE_KIND_DERIVED || a.kind == PObjectType::ATTRIBUTE_KIND_GIVEN_OR_DERIVED
-        bld << '  def ' << a.name << "\n"
-        bld << "    raise Puppet::Error, \"no method is implemented for derived attribute #{a.label}\"\n"
+      # Output attr_readers
+      unless obj_attrs.empty?
+        bld << "\n"
+        obj_attrs.each { |a| bld << '  attr_reader :' << a.name << "\n" }
+      end
+
+      bld << "  attr_reader :hash\n" if obj.parent.nil?
+
+      derived_attrs.each do |a|
+        bld << "\n  def " << a.name << "\n"
+        code_annotation = RubyMethod.annotate(a)
+        ruby_body = code_annotation.nil? ? nil: code_annotation.body
+        if ruby_body.nil?
+          bld << "    raise Puppet::Error, \"no method is implemented for derived #{a.label}\"\n"
+        else
+          bld << '    ' << ruby_body << "\n"
+        end
         bld << "  end\n"
+      end
+
+      if init_params.empty?
+        bld << "\n  def initialize\n    @hash = " << obj.hash.to_s << "\n  end" if obj.parent.nil?
       else
-        bld << '  attr_reader :' << a.name << "\n"
+        # Output initializer
+        bld << "\n  def initialize"
+        bld << '('
+        non_opt.each { |ip| bld << ip.name << ', ' }
+        opt.each do |ip|
+          bld << ip.name << ' = '
+          default_string(bld, ip)
+          bld << ', '
+        end
+        bld.chomp!(', ')
+        bld << ')'
+
+        hash_participants = init_params.select { |ip| eq_names.include?(ip.name) }
+        if obj.parent.nil?
+          bld << "\n    @hash = "
+          bld << obj.hash.to_s << "\n" if hash_participants.empty?
+        else
+          bld << "\n    super("
+          super_args = (non_opt + opt).select { |ip| !ip.container.equal?(obj) }
+          unless super_args.empty?
+            super_args.each { |ip| bld << ip.name << ', ' }
+            bld.chomp!(', ')
+          end
+          bld << ")\n"
+          bld << '    @hash = @hash ^ ' unless hash_participants.empty?
+        end
+        unless hash_participants.empty?
+          hash_participants.each { |a| bld << a.name << '.hash ^ ' if a.container.equal?(obj) }
+          bld.chomp!(' ^ ')
+          bld << "\n"
+        end
+        init_params.each { |a| bld << '    @' << a.name << ' = ' << a.name << "\n" if a.container.equal?(obj) }
+        bld << "  end\n"
       end
     end
 
-    # Output function placeholders
-    obj.functions(false).each_value do |func|
-      bld << "\n  def " << func.name << "(*args)\n"
-      bld << "    # Placeholder for #{func.type}\n"
-      bld << "    raise Puppet::Error, \"no method is implemented for #{func.label}\"\n"
-      bld << "  end\n"
+    if obj_attrs.empty?
+      bld << "\n  def _pcore_init_hash\n    {}\n  end\n" unless obj.parent.is_a?(PObjectType)
+    else
+      bld << "\n  def _pcore_init_hash\n"
+      bld << '    result = '
+      bld << (obj.parent.nil? ? '{}' : 'super')
+      bld << "\n"
+      obj_attrs.each do |a|
+        bld << "    result['" << a.name << "'] = @" << a.name
+        if a.value?
+          bld << ' unless '
+          equals_default_string(bld, a)
+        end
+        bld << "\n"
+      end
+      bld << "    result\n  end\n"
     end
 
-    # output hash and equality
-    include_class = obj.include_class_in_equality?
-    if obj.equality.nil?
-      eq_names = obj.attributes(false).values.select { |a| a.kind != PObjectType::ATTRIBUTE_KIND_CONSTANT }.map(&:name)
+    content_participants = init_params.select { |a| content_participant?(a) }
+    if content_participants.empty?
+      unless obj.parent.is_a?(PObjectType)
+        bld << "\n  def _pcore_contents\n  end\n"
+        bld << "\n  def _pcore_all_contents(path)\n  end\n"
+      end
     else
-      eq_names = obj.equality
+      bld << "\n  def _pcore_contents\n"
+      content_participants.each do |cp|
+        if array_type?(cp.type)
+          bld << '    @' << cp.name << ".each { |value| yield(value) }\n"
+        else
+          bld << '    yield(@' << cp.name << ') unless @' << cp.name  << ".nil?\n"
+        end
+      end
+      bld << "  end\n\n  def _pcore_all_contents(path, &block)\n    path << self\n"
+      content_participants.each do |cp|
+        if array_type?(cp.type)
+          bld << '    @' << cp.name << ".each do |value|\n"
+          bld << "      block.call(value, path)\n"
+          bld << "      value._pcore_all_contents(path, &block)\n"
+        else
+          bld << '    unless @' << cp.name << ".nil?\n"
+          bld << '      block.call(@' << cp.name << ", path)\n"
+          bld << '      @' << cp.name << "._pcore_all_contents(path, &block)\n"
+        end
+        bld << "    end\n"
+      end
+      bld << "    path.pop\n  end\n"
     end
 
-    unless eq_names.empty? && !include_class
-      bld << "\n  def hash\n    "
-      bld << 'super.hash ^ ' unless obj.parent.nil?
-      if eq_names.empty?
-        bld << "self.class.hash\n"
+    unless obj.parent.is_a?(PObjectType)
+      bld << "\n  def to_s\n"
+      bld << '    ' << namespace_relative(segments, TypeFormatter.name) << ".string(self)\n"
+      bld << "  end\n"
+    end
+
+    # Output function placeholders
+    obj.functions(false).each_value do |func|
+      code_annotation = RubyMethod.annotate(func)
+      if code_annotation
+        body = code_annotation.body
+        params = code_annotation.parameters
+        bld << "\n  def " << func.name
+        unless params.nil? || params.empty?
+          bld << '(' << params << ')'
+        end
+        bld << "\n    " << body << "\n"
       else
-        bld << '['
-        bld << 'self.class, ' if include_class
-        eq_names.each { |eqn| bld << '@' << eqn << ', ' }
-        bld.chomp!(', ')
-        bld << "].hash\n"
+        bld << "\n  def " << func.name << "(*args)\n"
+        bld << "    # Placeholder for #{func.type}\n"
+        bld << "    raise Puppet::Error, \"no method is implemented for #{func.label}\"\n"
       end
       bld << "  end\n"
+    end
 
+    unless eq_names.empty? && !include_type
       bld << "\n  def eql?(o)\n"
       bld << "    super &&\n" unless obj.parent.nil?
-      bld << "    self.class.eql?(o.class) &&\n" if include_class
+      bld << "    o.instance_of?(self.class) &&\n" if include_type
       eq_names.each { |eqn| bld << '    @' << eqn << '.eql?(o.' <<  eqn << ") &&\n" }
       bld.chomp!(" &&\n")
       bld << "\n  end\n  alias == eql?\n"
     end
   end
+
+  def content_participant?(a)
+    a.kind != PObjectType::ATTRIBUTE_KIND_REFERENCE && obj_type?(a.type)
+  end
+
+  def obj_type?(t)
+    case t
+    when PObjectType
+      true
+    when POptionalType
+      obj_type?(t.optional_type)
+    when PNotUndefType
+      obj_type?(t.type)
+    when PArrayType
+      obj_type?(t.element_type)
+    when PVariantType
+      t.types.all? { |v| obj_type?(v) }
+    else
+      false
+    end
+  end
+
+  def array_type?(t)
+    case t
+    when PArrayType
+      true
+    when POptionalType
+      array_type?(t.optional_type)
+    when PNotUndefType
+      array_type?(t.type)
+    when PVariantType
+      t.types.all? { |v| array_type?(v) }
+    else
+      false
+    end
+  end
+
+  def default_string(bld, a)
+    case a.value
+    when nil, true, false, Numeric, String
+      bld << a.value.inspect
+    else
+      bld << "_pcore_type['" << a.name << "'].value"
+    end
+  end
+
+  def equals_default_string(bld, a)
+    case a.value
+    when nil, true, false, Numeric, String
+      bld << '@' << a.name << ' == ' << a.value.inspect
+    else
+      bld << "_pcore_type['" << a.name << "'].default_value?(@" << a.name << ')'
+    end
+  end
 end
 end
 end