puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,69 @@
+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

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

@@ -0,0 +1,47 @@
+module RGen
+
+module ECore
+
+# Mixin to provide access to the ECore model describing a Ruby class or module
+# built using MetamodelBuilder.
+# The module should be used to +extend+ a class or module, i.e. to make its
+# methods class methods.
+# 
+module ECoreInterface
+  
+  # This method will lazily build to ECore model element belonging to the calling
+  # class or module using RubyToECore.
+  # Alternatively, the ECore model element can be provided up front. This is used
+  # when the Ruby metamodel classes and modules are created from ECore.
+  # 
+  def ecore
+    if defined?(@ecore)
+      @ecore
+    else
+      unless defined?(@@transformer)
+        require 'rgen/ecore/ruby_to_ecore'
+        @@transformer = RubyToECore.new
+      end
+      @@transformer.trans(self)
+    end
+  end  
+
+  # This method can be used to clear the ecore cache after the metamodel classes
+  # or modules have been changed; the ecore model will be recreated on next access
+  # to the +ecore+ method
+  # Beware, the ecore cache is global, i.e. for all metamodels.
+  #
+  def self.clear_ecore_cache
+    require 'rgen/ecore/ruby_to_ecore'
+    @@transformer = RubyToECore.new
+  end
+
+  def _set_ecore_internal(ecore) # :nodoc:
+    @ecore = ecore
+  end
+
+end
+
+end
+
+end

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

@@ -0,0 +1,167 @@
+require 'rgen/ecore/ecore'
+
+module RGen
+  
+module ECore
+
+class ECoreToRuby
+  
+  def initialize
+    @modules = {}
+    @classifiers = {}
+    @features_added = {}
+    @in_create_module = false
+  end
+
+  def create_module(epackage)
+    return @modules[epackage] if @modules[epackage]
+    
+    top = (@in_create_module == false)
+    @in_create_module = true
+
+    m = Module.new do
+      extend RGen::MetamodelBuilder::ModuleExtension
+    end
+    @modules[epackage] = m
+
+    epackage.eSubpackages.each{|p| create_module(p)}
+    m._set_ecore_internal(epackage)
+
+    create_module(epackage.eSuperPackage).const_set(epackage.name, m) if epackage.eSuperPackage
+
+    # create classes only after all modules have been created
+    # otherwise classes may be created multiple times
+    if top
+      epackage.eAllClassifiers.each do |c| 
+        if c.is_a?(RGen::ECore::EClass)
+          create_class(c)
+        elsif c.is_a?(RGen::ECore::EEnum)
+          create_enum(c)
+        end
+      end
+      @in_create_module = false
+    end
+    m
+  end
+
+  def create_class(eclass)
+    return @classifiers[eclass] if @classifiers[eclass]
+
+    c = Class.new(super_class(eclass)) do
+      abstract if eclass.abstract
+      class << self
+        attr_accessor :_ecore_to_ruby
+      end
+    end
+    class << eclass
+      attr_accessor :instanceClass
+      def instanceClassName
+        instanceClass.to_s
+      end
+    end
+    eclass.instanceClass = c
+    c::ClassModule.module_eval do
+      alias _method_missing method_missing
+      def method_missing(m, *args)
+        if self.class._ecore_to_ruby.add_features(self.class.ecore)
+          send(m, *args)
+        else
+          _method_missing(m, *args)
+        end
+      end
+      alias _respond_to respond_to?
+      def respond_to?(m, include_all=false)
+        self.class._ecore_to_ruby.add_features(self.class.ecore)
+        _respond_to(m)
+      end
+    end
+    @classifiers[eclass] = c
+    c._set_ecore_internal(eclass)
+    c._ecore_to_ruby = self
+
+    create_module(eclass.ePackage).const_set(eclass.name, c)
+    c
+  end
+
+  def create_enum(eenum)
+    return @classifiers[eenum] if @classifiers[eenum]
+
+    e = RGen::MetamodelBuilder::DataTypes::Enum.new(eenum.eLiterals.collect{|l| l.name.to_sym})
+    @classifiers[eenum] = e
+
+    create_module(eenum.ePackage).const_set(eenum.name, e)
+    e
+  end
+
+  class FeatureWrapper
+    def initialize(efeature, classifiers)
+      @efeature = efeature
+      @classifiers = classifiers
+    end
+    def value(prop)
+      return false if prop == :containment && @efeature.is_a?(RGen::ECore::EAttribute)
+      @efeature.send(prop)
+    end
+    def many?
+      @efeature.many
+    end
+    def reference?
+      @efeature.is_a?(RGen::ECore::EReference)
+    end
+    def opposite
+      @efeature.eOpposite
+    end
+    def impl_type
+      etype = @efeature.eType
+      if etype.is_a?(RGen::ECore::EClass) || etype.is_a?(RGen::ECore::EEnum)
+        @classifiers[etype]
+      else
+        ic = etype.instanceClass
+        if ic
+          ic
+        else
+          raise "unknown type: #{etype.name}" 
+        end
+      end
+    end
+  end
+
+  def add_features(eclass)
+    return false if @features_added[eclass]
+    c = @classifiers[eclass]
+    eclass.eStructuralFeatures.each do |f|
+      w1 = FeatureWrapper.new(f, @classifiers) 
+      w2 = FeatureWrapper.new(f.eOpposite, @classifiers) if f.is_a?(RGen::ECore::EReference) && f.eOpposite
+      c.module_eval do
+        if w1.many?
+          _build_many_methods(w1, w2)
+        else
+          _build_one_methods(w1, w2)
+        end
+      end
+    end
+    @features_added[eclass] = true
+    eclass.eSuperTypes.each do |t|
+      add_features(t)
+    end
+    true
+  end
+
+  def super_class(eclass)
+    super_types = eclass.eSuperTypes
+    case super_types.size
+    when 0
+      RGen::MetamodelBuilder::MMBase
+    when 1
+      create_class(super_types.first)
+    else
+      RGen::MetamodelBuilder::MMMultiple(*super_types.collect{|t| create_class(t)})
+    end
+  end
+
+end
+
+end
+
+end
+

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

@@ -0,0 +1,91 @@
+require 'rgen/transformer'
+require 'rgen/ecore/ecore'
+
+module RGen
+  
+module ECore
+  
+# This transformer creates an ECore model from Ruby classes built
+# by RGen::MetamodelBuilder.
+# 
+class RubyToECore < Transformer
+  
+  transform Class, :to => EClass, :if => :convert? do
+    { :name => name.gsub(/.*::(\w+)$/,'\1'),
+      :abstract => _abstract_class,
+      :interface => false,
+      :eStructuralFeatures => trans(_metamodel_description),
+      :ePackage =>  trans(name =~ /(.*)::\w+$/ ? eval($1) : nil),
+      :eSuperTypes => trans(superclasses),
+      :instanceClassName => name,
+      :eAnnotations => trans(_annotations)
+    }
+  end
+  
+  method :superclasses do
+    if superclass.respond_to?(:multiple_superclasses) && superclass.multiple_superclasses
+      superclass.multiple_superclasses
+    else
+      [ superclass ]
+    end
+  end
+  
+  transform Module, :to => EPackage, :if => :convert?  do
+    @enumParentModule ||= {}
+    _constants = _constantOrder + (constants - _constantOrder)
+    _constants.select {|c| const_get(c).is_a?(MetamodelBuilder::DataTypes::Enum)}.
+      each {|c| @enumParentModule[const_get(c)] = @current_object}
+    { :name => name.gsub(/.*::(\w+)$/,'\1'),
+      :eClassifiers => trans(_constants.collect{|c| const_get(c)}.select{|c| c.is_a?(Class) || 
+        (c.is_a?(MetamodelBuilder::DataTypes::Enum) && c != MetamodelBuilder::DataTypes::Boolean) }),
+      :eSuperPackage => trans(name =~ /(.*)::\w+$/ ? eval($1) : nil),
+      :eSubpackages => trans(_constants.collect{|c| const_get(c)}.select{|c| c.is_a?(Module) && !c.is_a?(Class)}),
+      :eAnnotations => trans(_annotations)
+    }
+  end
+  
+  method :convert? do
+    @current_object.respond_to?(:ecore) && @current_object != RGen::MetamodelBuilder::MMBase
+  end
+  
+  transform MetamodelBuilder::Intermediate::Attribute, :to => EAttribute do
+    Hash[*MetamodelBuilder::Intermediate::Attribute.properties.collect{|p| [p, value(p)]}.flatten].merge({
+      :eType => (etype == :EEnumerable ? trans(impl_type) : RGen::ECore.const_get(etype)),
+      :eAnnotations => trans(annotations)
+    })
+  end
+  
+  transform MetamodelBuilder::Intermediate::Reference, :to => EReference do
+    Hash[*MetamodelBuilder::Intermediate::Reference.properties.collect{|p| [p, value(p)]}.flatten].merge({
+      :eType => trans(impl_type),
+      :eOpposite => trans(opposite),
+      :eAnnotations => trans(annotations)
+    })
+  end
+  
+  transform MetamodelBuilder::Intermediate::Annotation, :to => EAnnotation do
+    { :source => source,
+      :details => details.keys.collect do |k|
+        e = RGen::ECore::EStringToStringMapEntry.new
+        e.key = k
+        e.value = details[k]
+        e
+      end
+    }
+  end
+  
+  transform MetamodelBuilder::DataTypes::Enum, :to => EEnum do
+    { :name => name, 
+      :instanceClassName => @enumParentModule && @enumParentModule[@current_object] && @enumParentModule[@current_object].name+"::"+name,
+      :eLiterals => literals.collect do |l|
+        lit = RGen::ECore::EEnumLiteral.new
+        lit.name = l.to_s
+        lit
+      end }
+  end
+  
+end
+  
+end
+  
+end