puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

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

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

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

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

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