puppet 4.10.0 → 5.0.0

data/lib/puppet/vendor/rgen/lib/mmgen/mmgen.rb

@@ -1,28 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..")
-
-require 'ea/xmi_ecore_instantiator'
-require 'mmgen/metamodel_generator'
-
-include MMGen::MetamodelGenerator
-
-unless ARGV.length >= 2
-	puts "Usage: mmgen.rb <xmi_class_model_file> <root package> (<module>)*"
-	exit
-else
-	file_name = ARGV.shift
-	root_package_name = ARGV.shift
-	modules = ARGV
-	out_file = file_name.gsub(/\.\w+$/,'.rb')
-	puts out_file
-end
-
-env = RGen::Environment.new
-File.open(file_name) { |f|
-    puts "instantiating ..."
-	XMIECoreInstantiator.new.instantiateECoreModel(env, f.read)
-}
-
-rootPackage = env.find(:class => RGen::ECore::EPackage, :name => root_package_name).first
-
-puts "generating ..."
-generateMetamodel(rootPackage, out_file, modules)

data/lib/puppet/vendor/rgen/lib/mmgen/templates/annotations.tpl

@@ -1,37 +0,0 @@
-<% define 'Annotations', :for => EPackage do %>
-	<% for a in eAnnotations %>
-		annotation <% expand 'AnnotationArgs', :for => a %>
-	<% end %>
-<% end %>
-
-<% define 'Annotations', :for => EClass do %>
-	<% for a in eAnnotations %>
-		annotation <% expand 'AnnotationArgs', :for => a %>
-	<% end %>
-<% end %>
-
-<% define 'Annotations', :for => EStructuralFeature do %>
-	<% oppositeAnnotations = (this.respond_to?(:eOpposite) && eOpposite && eOpposite.eAnnotations) || [] %>
-	<% if eAnnotations.size > 0 || oppositeAnnotations.size > 0 %>
-		do<%iinc%>
-			<% for a in eAnnotations %>
-				annotation <% expand 'AnnotationArgs', :for => a %>
-			<% end %>
-			<% for a in oppositeAnnotations %>
-				opposite_annotation <% expand 'AnnotationArgs', :for => a %>
-			<% end %><%idec%>
-		end<%nows%>
-	<% end %>
-<% end %>
-
-<% define 'AnnotationArgs', :for => EAnnotation do %>
-	<% if source.nil? %>
-		<% expand 'Details' %>
-	<% else %>
-		:source => "<%= source.to_s %>", :details => {<% expand 'Details' %>}<%nows%>
-	<% end %>
-<% end %>
-
-<% define 'Details', :for => EAnnotation do %>
-	<%= details.sort{|a,b| a.key<=>b.key}.collect{ |d| "\'" + d.key + "\' => \'"+ (d.value || "").gsub('\'','\\\'').to_s + "\'"}.join(', ') %><%nows%>
-<% end %>

data/lib/puppet/vendor/rgen/lib/mmgen/templates/metamodel_generator.tpl

@@ -1,172 +0,0 @@
-
-<% define 'GenerateMetamodel', :for => EPackage do |filename| %>
-  <% file filename do %>
-    require 'rgen/metamodel_builder'
-    <%nl%>
-    <% if needClassReorder? %>
-      <% expand 'GeneratePackagesOnly' %>
-      <% expand 'GenerateClassesReordered' %>
-    <% else %>
-      <% expand 'GeneratePackage' %>
-    <% end %>
-    <%nl%>
-    <% expand 'GenerateAssocs' %>
-  <% end %>
-<% end %>
-    
-<% define 'GeneratePackage', :for => EPackage do %>
-  module <%= moduleName %><% iinc %>
-    extend RGen::MetamodelBuilder::ModuleExtension
-    include RGen::MetamodelBuilder::DataTypes
-    <% expand 'annotations::Annotations' %>
-    <%nl%>
-    <% expand 'EnumTypes' %>
-    <% for c in ownClasses %><%nl%>
-      <% expand 'ClassHeader', this, :for => c %><%iinc%>
-        <% if c.abstract %>abstract<% end %>
-        <% expand 'annotations::Annotations', :for => c %>
-        <% expand 'Attribute', this, :foreach => c.eAttributes %>
-        <%idec%>
-      end
-    <% end %><%nl%>
-    <% for p in eSubpackages %>
-      <%nl%><% expand 'GeneratePackage', :for => p %>
-    <% end %><%idec%>
-  end
-<% end %>
-
-<% define 'GenerateClassesReordered', :for => EPackage do %>
-  <% for c in allClassesSorted %><%nl%>
-    <% expand 'ClassHeaderFullyQualified', this, :for => c %><%iinc%>
-      <% if c.abstract %>abstract<% end %>
-      <% expand 'annotations::Annotations', :for => c %>
-      <% expand 'Attribute', this, :foreach => c.eAttributes %>
-      <%idec%>
-    end
-  <% end %><%nl%>
-<% end %>
-
-<% define 'GeneratePackagesOnly', :for => EPackage do %>
-  module <%= moduleName %><% iinc %>
-    extend RGen::MetamodelBuilder::ModuleExtension
-    include RGen::MetamodelBuilder::DataTypes
-    <% expand 'annotations::Annotations' %>
-    <%nl%>
-    <% expand 'EnumTypes' %>
-    <% for p in eSubpackages %>
-      <%nl%><% expand 'GeneratePackagesOnly', :for => p %>
-    <% end %><%idec%>
-  end
-<% end %>
-
-<% define 'Attribute', :for => EAttribute do |rootp| %>
-  <% if upperBound == 1%>has_attr<% else %>has_many_attr<% end %> '<%= name %>', <%nows%>
-  <% if eType.is_a?(EEnum) %><%nows%>
-    <%= eType.qualifiedClassifierName(rootp) %><%nows%>
-  <% else %><%nows%>
-    <%= eType && eType.instanceClass.to_s %><%nows%>
-  <% end %><%nows%>
-  <% for p in RGen::MetamodelBuilder::Intermediate::Attribute.properties %>
-    <% unless p == :name || (p == :upperBound && (upperBound == 1 || upperBound == -1)) || 
-      RGen::MetamodelBuilder::Intermediate::Attribute.default_value(p) == getGeneric(p) %>
-        , :<%=p%> => <%nows%>
-        <% if getGeneric(p).is_a?(String) %>
-          "<%= getGeneric(p) %>"<%nows%>
-        <% elsif getGeneric(p).is_a?(Symbol) %>
-          :<%= getGeneric(p) %><%nows%>
-        <% else %>
-          <%= getGeneric(p) %><%nows%>
-        <% end %>
-    <% end %>
-  <% end %>
-  <%ws%><% expand 'annotations::Annotations' %><%nl%>
-<% end %>
-
-<% define 'EnumTypes', :for => EPackage do %>
-  <% for enum in eClassifiers.select{|c| c.is_a?(EEnum)} %>
-    <%= enum.name %> = Enum.new(:name => '<%= enum.name %>', :literals =>[ <%nows%>
-    <%= enum.eLiterals.collect { |lit| ":"+(lit.name =~ /^\d|\W/ ? "'"+lit.name+"'" : lit.name) }.join(', ') %> ])
-  <% end %>
-<% end %>
-
-<% define 'GenerateAssocs', :for => EPackage do %>
-  <% refDone = {} %>
-  <% for ref in eAllClassifiers.select{|c| c.is_a?(EClass)}.eReferences %>
-    <% if !refDone[ref] && ref.eOpposite %>
-      <% ref = ref.eOpposite if ref.eOpposite.containment %>
-      <% refDone[ref] = refDone[ref.eOpposite] = true %>
-      <% if !ref.many && !ref.eOpposite.many %>
-        <% if ref.containment %>
-          <% expand 'Reference', "contains_one", this, :for => ref %>
-        <% else %>
-          <% expand 'Reference', "one_to_one", this, :for => ref %>
-        <% end %>
-      <% elsif !ref.many && ref.eOpposite.many %>
-        <% expand 'Reference', "many_to_one", this, :for => ref %>
-      <% elsif ref.many && !ref.eOpposite.many %>
-        <% if ref.containment %>
-          <% expand 'Reference', "contains_many", this, :for => ref %>
-        <% else %>
-          <% expand 'Reference', "one_to_many", this, :for => ref %>
-        <% end %>
-      <% elsif ref.many && ref.eOpposite.many %>
-        <% expand 'Reference', "many_to_many", this, :for => ref %>
-      <% end %>
-      <% expand 'annotations::Annotations', :for => ref %><%nl%>
-    <% elsif !refDone[ref] %>
-      <% refDone[ref] = true %>
-      <% if !ref.many %>
-        <% if ref.containment %>
-          <% expand 'Reference', "contains_one_uni", this, :for => ref %>
-        <% else %>
-          <% expand 'Reference', "has_one", this, :for => ref %>
-        <% end %>
-      <% elsif ref.many %>
-        <% if ref.containment %>
-          <% expand 'Reference', "contains_many_uni", this, :for => ref %>
-        <% else %>
-          <% expand 'Reference', "has_many", this, :for => ref %>
-        <% end %>
-      <% end %>
-      <% expand 'annotations::Annotations', :for => ref %><%nl%>
-    <% end %>
-  <% end %>
-<% end %>
-
-<% define 'Reference', :for => EReference do |cmd, rootpackage| %>
-  <%= eContainingClass.qualifiedClassifierName(rootpackage) %>.<%= cmd %> '<%= name %>', <%= eType && eType.qualifiedClassifierName(rootpackage) %><%nows%>
-  <% if eOpposite %><%nows%>
-    , '<%= eOpposite.name%>'<%nows%>
-  <% end %><%nows%>
-  <% pset = RGen::MetamodelBuilder::Intermediate::Reference.properties.reject{|p| p == :name || p == :upperBound || p == :containment} %>
-  <% for p in pset.reject{|p| RGen::MetamodelBuilder::Intermediate::Reference.default_value(p) == getGeneric(p)} %>
-      , :<%=p%> => <%=getGeneric(p)%><%nows%>
-  <% end %>
-  <% if eOpposite %>
-    <% for p in pset.reject{|p| RGen::MetamodelBuilder::Intermediate::Reference.default_value(p) == eOpposite.getGeneric(p)} %>
-        , :opposite_<%=p%> => <%=eOpposite.getGeneric(p)%><%nows%>
-    <% end %>
-  <% end %><%ws%>
-<% end %>
-
-<% define 'ClassHeader', :for => EClass do |rootp| %>
-  class <%= classifierName %> < <% nows %>
-  <% if eSuperTypes.size > 1 %><% nows %>
-    RGen::MetamodelBuilder::MMMultiple(<%= eSuperTypes.collect{|t| t.qualifiedClassifierNameIfRequired(rootp)}.join(', ') %>)
-  <% elsif eSuperTypes.size > 0 %><% nows %>
-    <%= eSuperTypes.first.qualifiedClassifierNameIfRequired(rootp) %>
-  <% else %><% nows %>
-    RGen::MetamodelBuilder::MMBase
-  <% end %>
-<% end %>
-
-<% define 'ClassHeaderFullyQualified', :for => EClass do |rootp| %>
-  class <%= qualifiedClassifierName(rootp) %> < <% nows %>
-  <% if eSuperTypes.size > 1 %><% nows %>
-    RGen::MetamodelBuilder::MMMultiple(<%= eSuperTypes.collect{|t| t.qualifiedClassifierName(rootp)}.join(', ') %>)
-  <% elsif eSuperTypes.size > 0 %><% nows %>
-    <%= eSuperTypes.first.qualifiedClassifierName(rootp) %>
-  <% else %><% nows %>
-    RGen::MetamodelBuilder::MMBase
-  <% end %>
-<% end %>

data/lib/puppet/vendor/rgen/lib/rgen/array_extensions.rb

@@ -1,45 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-require 'rgen/metamodel_builder'
-
-class Array
-
-  def >>(method)
-    compact.inject([]) { |r,e| r | ( (o=e.send(method)).is_a?(Array) ? o : [o] ) }
-  end
-  
-  def method_missing(m, *args)
-
-    # This extensions has the side effect that it allows to call any method on any
-    # empty array with an empty array as the result. This behavior is required for
-    # navigating models.
-    #
-    # This is a problem for Hash[] called with an (empty) array of tupels.
-    # It will call to_hash expecting a Hash as the result. When it gets an array instead,
-    # it fails with an exception. Make sure it gets a NoMethodException as without this
-    # extension and it will catch that and return an empty hash as expected.
-    #
-    # Similar problems exist for other Ruby built-in methods which are expected to fail.
-    #
-    return super unless (size == 0 && 
-      m != :to_hash && m != :to_str) ||
-      compact.any?{|e| e.is_a? RGen::MetamodelBuilder::MMBase}
-    # use an array to build the result to achiev similar ordering
-    result = []
-    inResult = {}
-    compact.each do |e|
-      if e.is_a? RGen::MetamodelBuilder::MMBase        
-        ((o=e.send(m)).is_a?(Array) ? o : [o] ).each do |v|
-          next if inResult[v.object_id]
-          inResult[v.object_id] = true
-          result << v
-        end
-      else
-        raise StandardError.new("Trying to call a method on an array element not a RGen MMBase")
-      end
-    end
-    result.compact
-  end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/ecore/ecore.rb

@@ -1,218 +0,0 @@
-require 'rgen/metamodel_builder'
-
-module RGen
-  extend RGen::MetamodelBuilder::ModuleExtension
-  
-  # This is the ECore metamodel described using the RGen::MetamodelBuilder language.
-  #
-  # Known differences to the Java/EMF implementation are:
-  # * Attributes can not be "many"
-  # 
-  module ECore
-    extend RGen::MetamodelBuilder::ModuleExtension
-    
-    class EObject < RGen::MetamodelBuilder::MMBase
-    end
-    
-    class EModelElement < RGen::MetamodelBuilder::MMBase
-    end
-    
-    class EAnnotation < RGen::MetamodelBuilder::MMMultiple(EModelElement, EObject)
-      has_attr 'source', String
-    end
-    
-    class ENamedElement < EModelElement
-      has_attr 'name', String
-    end
-    
-    class ETypedElement < ENamedElement
-      has_attr 'lowerBound', Integer, :defaultValueLiteral => "0"
-      has_attr 'ordered', Boolean, :defaultValueLiteral => "true"
-      has_attr 'unique', Boolean, :defaultValueLiteral => "true"
-      has_attr 'upperBound', Integer, :defaultValueLiteral => "1"
-      has_attr 'many', Boolean, :derived=>true
-      has_attr 'required', Boolean, :derived=>true
-      module ClassModule
-        def many_derived
-          upperBound > 1 || upperBound == -1
-        end
-        def required_derived
-          lowerBound > 0
-        end
-      end
-    end
-    
-    class EStructuralFeature < ETypedElement
-      has_attr 'changeable', Boolean, :defaultValueLiteral => "true"
-      has_attr 'defaultValue', Object, :derived=>true
-      has_attr 'defaultValueLiteral', String
-      has_attr 'derived', Boolean, :defaultValueLiteral => "false"
-      has_attr 'transient', Boolean, :defaultValueLiteral => "false"
-      has_attr 'unsettable', Boolean, :defaultValueLiteral => "false"
-      has_attr 'volatile', Boolean, :defaultValueLiteral => "false"
-      module ClassModule
-        def defaultValue_derived
-          return nil if defaultValueLiteral.nil?
-          case eType
-            when EInt, ELong
-              defaultValueLiteral.to_i
-            when EFloat
-              defaultValueLiteral.to_f
-            when EEnum
-              defaultValueLiteral.to_sym
-            when EBoolean
-              defaultValueLiteral == "true"
-            when EString
-              defaultValueLiteral
-            else
-              raise "Unhandled type"
-            end
-        end
-      end
-    end
-    
-    class EAttribute < EStructuralFeature
-      has_attr 'iD', Boolean, :defaultValueLiteral => "false"
-    end
-    
-    class EClassifier < ENamedElement
-      has_attr 'defaultValue', Object, :derived=>true
-      has_attr 'instanceClass', Object, :derived=>true
-      has_attr 'instanceClassName', String
-      module ClassModule
-        def instanceClass_derived
-          map = {"java.lang.string" => "String", 
-                 "boolean" => "RGen::MetamodelBuilder::DataTypes::Boolean", 
-                 "int" => "Integer",
-                 "long" => "RGen::MetamodelBuilder::DataTypes::Long"}
-          icn = instanceClassName
-          icn = "NilClass" if icn.nil?
-          icn = map[icn.downcase] if map[icn.downcase]
-          eval(icn)
-        end
-      end
-    end
-    
-    class EDataType < EClassifier
-      has_attr 'serializable', Boolean
-    end
-
-    class EGenericType < EDataType
-      has_one 'eClassifier', EDataType
-    end
-
-    class ETypeArgument < EModelElement
-      has_one 'eClassifier', EDataType
-    end
-    
-    class EEnum < EDataType
-    end
-    
-    class EEnumLiteral < ENamedElement
-      # instance may point to a "singleton object" (e.g. a Symbol) representing the literal
-      #      has_attr 'instance', Object, :eType=>:EEnumerator, :transient=>true
-      has_attr 'literal', String
-      has_attr 'value', Integer
-    end
-    
-    # TODO: check if required
-    class EFactory < EModelElement
-    end
-    
-    class EOperation < ETypedElement
-    end
-    
-    class EPackage < ENamedElement
-      has_attr 'nsPrefix', String
-      has_attr 'nsURI', String
-    end
-    
-    class EParameter < ETypedElement
-    end
-    
-    class EReference < EStructuralFeature
-      has_attr 'container', Boolean, :derived=>true
-      has_attr 'containment', Boolean, :defaultValueLiteral => "false"
-      has_attr 'resolveProxies', Boolean, :defaultValueLiteral => "true"
-    end
-    
-    class EStringToStringMapEntry < RGen::MetamodelBuilder::MMBase
-      has_attr 'key', String
-      has_attr 'value', String
-    end
-    
-    class EClass < EClassifier
-      has_attr 'abstract', Boolean
-      has_attr 'interface', Boolean
-      has_one  'eIDAttribute', ECore::EAttribute, :derived=>true, :resolveProxies=>false
-      
-      has_many 'eAllAttributes', ECore::EAttribute, :derived=>true
-      has_many 'eAllContainments', ECore::EReference, :derived=>true
-      has_many 'eAllOperations', ECore::EOperation, :derived=>true
-      has_many 'eAllReferences', ECore::EReference, :derived=>true
-      has_many 'eAllStructuralFeatures', ECore::EStructuralFeature, :derived=>true
-      has_many 'eAllSuperTypes', ECore::EClass, :derived=>true
-      has_many 'eAttributes', ECore::EAttribute, :derived=>true
-      has_many 'eReferences', ECore::EReference, :derived=>true
-      
-      module ClassModule		
-        def eAllAttributes_derived
-          eAttributes + eSuperTypes.eAllAttributes
-        end
-        def eAllContainments_derived
-          eReferences.select{|r| r.containment} + eSuperTypes.eAllContainments
-        end
-        def eAllReferences_derived
-          eReferences + eSuperTypes.eAllReferences
-        end
-        def eAllStructuralFeatures_derived
-          eStructuralFeatures + eSuperTypes.eAllStructuralFeatures
-        end
-        def eAllSuperTypes_derived
-          eSuperTypes + eSuperTypes.eAllSuperTypes
-        end
-        def eAttributes_derived
-          eStructuralFeatures.select{|f| f.is_a?(EAttribute)}
-        end
-        def eReferences_derived
-          eStructuralFeatures.select{|f| f.is_a?(EReference)}
-        end
-      end
-    end
-    
-    # predefined datatypes
-    
-    EString = EDataType.new(:name => "EString", :instanceClassName => "String")
-    EInt = EDataType.new(:name => "EInt", :instanceClassName => "Integer")
-    ELong = EDataType.new(:name => "ELong", :instanceClassName => "Long")
-    EBoolean = EDataType.new(:name => "EBoolean", :instanceClassName => "Boolean")
-    EFloat = EDataType.new(:name => "EFloat", :instanceClassName => "Float")
-    ERubyObject = EDataType.new(:name => "ERubyObject", :instanceClassName => "Object")
-    EJavaObject = EDataType.new(:name => "EJavaObject")
-    ERubyClass = EDataType.new(:name => "ERubyClass", :instanceClassName => "Class")
-    EJavaClass = EDataType.new(:name => "EJavaClass")
-    
-  end
-  
-  ECore::EModelElement.contains_many 'eAnnotations', ECore::EAnnotation, 'eModelElement', :resolveProxies=>false
-  ECore::EAnnotation.contains_many_uni 'details', ECore::EStringToStringMapEntry, :resolveProxies=>false
-  ECore::EAnnotation.contains_many_uni 'contents', ECore::EObject, :resolveProxies=>false
-  ECore::EAnnotation.has_many 'references', ECore::EObject
-  ECore::EPackage.contains_many 'eClassifiers', ECore::EClassifier, 'ePackage'
-  ECore::EPackage.contains_many 'eSubpackages', ECore::EPackage, 'eSuperPackage'
-  ECore::ETypedElement.has_one 'eType', ECore::EClassifier
-  ECore::EClass.contains_many 'eOperations', ECore::EOperation, 'eContainingClass', :resolveProxies=>false
-  ECore::EClass.contains_many 'eStructuralFeatures', ECore::EStructuralFeature, 'eContainingClass', :resolveProxies=>false
-  ECore::EClass.has_many 'eSuperTypes', ECore::EClass
-  ECore::EEnum.contains_many 'eLiterals', ECore::EEnumLiteral, 'eEnum', :resolveProxies=>false
-  ECore::EFactory.one_to_one 'ePackage', ECore::EPackage, 'eFactoryInstance', :lowerBound=>1, :transient=>true, :resolveProxies=>false
-  ECore::EOperation.contains_many 'eParameters', ECore::EParameter, 'eOperation', :resolveProxies=>false
-  ECore::EOperation.has_many 'eExceptions', ECore::EClassifier
-  ECore::EReference.has_one 'eOpposite', ECore::EReference
-  
-  ECore::EAttribute.has_one 'eAttributeType', ECore::EDataType, :lowerBound=>1, :derived=>true
-  ECore::EReference.has_one 'eReferenceType', ECore::EClass, :lowerBound=>1, :derived=>true
-  ECore::EParameter.contains_one 'eGenericType', ECore::EGenericType, 'eParameter'
-  ECore::EGenericType.contains_many 'eTypeArguments', ECore::ETypeArgument, 'eGenericType'
-  
-end

data/lib/puppet/vendor/rgen/lib/rgen/ecore/ecore_builder_methods.rb

@@ -1,81 +0,0 @@
-module RGen
-  
-module ECore
-  
-module ECoreBuilderMethods
-  def eAttr(name, type, argHash={}, &block)
-    eAttribute(name, {:eType => type}.merge(argHash), &block)
-  end
-  
-  def eRef(name, type, argHash={}, &block)
-    eReference(name, {:eType => type}.merge(argHash), &block)
-  end
-  
-  # create bidirectional reference at once
-  def eBiRef(name, type, oppositeName, argHash={})
-    raise BuilderError.new("eOpposite attribute not allowed for bidirectional references") \
-      if argHash[:eOpposite] || argHash[:opposite_eOpposite]
-    eReference(name, {:eType => type}.merge(argHash.reject{|k,v| k.to_s =~ /^opposite_/})) do 
-      eReference oppositeName, {:eContainingClass => type, :eType => _context(2),
-        :as => :eOpposite, :eOpposite => _context(1)}.
-          merge(Hash[*(argHash.select{|k,v| k.to_s =~ /^opposite_/}.
-            collect{|p| [p[0].to_s.sub(/^opposite_/,"").to_sym, p[1]]}.flatten)])
-    end
-  end
-  
-  # reference shortcuts
-  
-  alias references_1 eRef
-  alias references_one eRef
-  
-  def references_N(name, type, argHash={})
-    eRef(name, type, {:upperBound => -1}.merge(argHash))
-  end
-  alias references_many references_N
-  
-  def references_1to1(name, type, oppositeName, argHash={})
-    eBiRef(name, type, oppositeName, {:upperBound => 1, :opposite_upperBound => 1}.merge(argHash))
-  end
-  alias references_one_to_one references_1to1
-  
-  def references_1toN(name, type, oppositeName, argHash={})
-    eBiRef(name, type, oppositeName, {:upperBound => -1, :opposite_upperBound => 1}.merge(argHash))
-  end
-  alias references_one_to_many references_1toN
-  
-  def references_Nto1(name, type, oppositeName, argHash={})
-    eBiRef(name, type, oppositeName, {:upperBound => 1, :opposite_upperBound => -1}.merge(argHash))
-  end
-  alias references_many_to_one references_Nto1
-  
-  def references_MtoN(name, type, oppositeName, argHash={})
-    eBiRef(name, type, oppositeName, {:upperBound => -1, :opposite_upperBound => -1}.merge(argHash))
-  end
-  alias references_many_to_many references_MtoN
-  
-  # containment reference shortcuts
-  
-  def contains_1(name, type, argHash={})
-    references_1(name, type, {:containment => true}.merge(argHash))  
-  end
-  alias contains_one contains_1
-  
-  def contains_N(name, type, argHash={})
-    references_N(name, type, {:containment => true}.merge(argHash))  
-  end
-  alias contains_many contains_N
-  
-  def contains_1to1(name, type, oppositeName, argHash={})
-    references_1to1(name, type, oppositeName, {:containment => true}.merge(argHash))  
-  end
-  alias contains_one_to_one contains_1to1
-  
-  def contains_1toN(name, type, oppositeName, argHash={})
-    references_1toN(name, type, oppositeName, {:containment => true}.merge(argHash))  
-  end
-  alias contains_one_to_many contains_1toN  
-end
-
-end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/ecore/ecore_ext.rb

@@ -1,69 +0,0 @@
-require 'rgen/array_extensions'
-require 'rgen/ecore/ecore'
-
-module RGen
-  module ECore
-  	
-    # make super type reference bidirectional
-    EClass.many_to_many 'eSuperTypes', ECore::EClass, 'eSubTypes'
-    
-	  module EModelElement::ClassModule
-	    
-	    def annotationValue(source, tag)
-  			detail = eAnnotations.select{ |a| a.source == source }.details.find{ |d| d.key == tag }
-			  detail && detail.value
-  		end
-      
-  	end
-		
-  	module EPackage::ClassModule
-  	  
-			def qualifiedName
-				if eSuperPackage
-					eSuperPackage.qualifiedName+"::"+name
-				else
-					name
-				end
-			end
-      
-  		def eAllClassifiers
-  			eClassifiers + eSubpackages.eAllClassifiers
-  		end
-      def eAllSubpackages
-        eSubpackages + eSubpackages.eAllSubpackages
-      end
-      
-      def eClasses
-        eClassifiers.select{|c| c.is_a?(ECore::EClass)}
-      end
-      
-      def eAllClasses
-        eClasses + eSubpackages.eAllClasses
-      end
-      
-      def eDataTypes
-        eClassifiers.select{|c| c.is_a?(ECore::EDataType)}
-      end
-      
-      def eAllDataTypes
-        eDataTypes + eSubpackages.eAllDataTypes
-      end      
-  	end
-		
-		module EClass::ClassModule
-		  
-			def qualifiedName
-				if ePackage
-					ePackage.qualifiedName+"::"+name
-				else
-					name
-				end
-			end
-      
-      def eAllSubTypes
-        eSubTypes + eSubTypes.eAllSubTypes
-      end
-      
-		end
-  end
-end