puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/lib/puppet/vendor/rgen/lib/transformers/ecore_to_uml13.rb

@@ -1,79 +0,0 @@
-require 'rgen/transformer'
-require 'rgen/ecore/ecore'
-require 'metamodels/uml13_metamodel'
-
-class ECoreToUML13 < RGen::Transformer
-  include RGen::ECore
-  
-  def transform
-    trans(:class => EPackage)
-    trans(:class => EClass)
-    trans(:class => EEnum)
-  end
-
-  transform EPackage, :to => UML13::Package do
-    {:name => name,
-      :namespace => trans(eSuperPackage) || model,
-      :ownedElement => trans(eClassifiers.select{|c| c.is_a?(EClass)} + eSubpackages)
-    }
-  end
-  
-  transform EClass, :to => UML13::Class do
-    {:name => name,
-      :namespace => trans(ePackage),
-      :feature => trans(eStructuralFeatures.select{|f| f.is_a?(EAttribute)} + eOperations),
-      :associationEnd => trans(eStructuralFeatures.select{|f| f.is_a?(EReference)}),
-      :generalization => eSuperTypes.collect { |st| 
-        @env_out.new(UML13::Generalization, :parent => trans(st), :namespace => trans(ePackage) || model)
-      }
-    }
-  end
-  
-  transform EEnum, :to => UML13::Class do
-    {:name => name,
-      :namespace => trans(ePackage),
-      :feature => trans(eLiterals)
-    }
-  end
-
-  transform EEnumLiteral, :to => UML13::Attribute do
-    {:name => name }
-  end
-
-  transform EAttribute, :to => UML13::Attribute do
-    _typemap = {"String" => "string", "Boolean" => "boolean", "Integer" => "int", "Float" => "float"}
-    {:name => name, 
-     :taggedValue => [@env_out.new(UML13::TaggedValue, :tag => "type", 
-       :value => _typemap[eType.instanceClassName] || eType.name)] 
-    }
-  end
-  
-  transform EReference, :to => UML13::AssociationEnd do
-    _otherAssocEnd = eOpposite ? trans(eOpposite) : 
-      @env_out.new(UML13::AssociationEnd, 
-        :type => trans(eType), :name => name, :multiplicity => createMultiplicity(@current_object), 
-        :aggregation => :none, :isNavigable => true)
-    { :association => trans(@current_object).association || @env_out.new(UML13::Association, 
-        :connection => [_otherAssocEnd], :namespace => trans(eContainingClass.ePackage) || model),
-      :name => eOpposite && eOpposite.name,
-      :multiplicity => eOpposite && createMultiplicity(eOpposite),
-      :aggregation => containment ? :composite : :none,
-      :isNavigable => !eOpposite.nil?
-    }
-  end
-  
-  transform EOperation, :to => UML13::Operation do 
-    {:name => name}
-  end
-  
-  def createMultiplicity(ref)
-    @env_out.new(UML13::Multiplicity, :range => [
-      @env_out.new(UML13::MultiplicityRange, 
-        :lower => ref.lowerBound.to_s.sub("-1","*"), :upper => ref.upperBound.to_s.sub("-1","*"))])    
-  end
-  
-  def model
-    @model ||= @env_out.new(UML13::Model, :name => "Model")
-  end
-  
-end

data/lib/puppet/vendor/rgen/lib/transformers/uml13_to_ecore.rb

@@ -1,127 +0,0 @@
-require 'metamodels/uml13_metamodel'
-require 'rgen/transformer'
-require 'rgen/ecore/ecore'
-require 'rgen/array_extensions'
-
-class UML13ToECore < RGen::Transformer
-  include RGen::ECore
-
-  # Options:
-  #
-  # :reference_filter:
-  #   a proc which receives an AssociationEnd or a Dependency and should return
-  #   true or false, depending on if a referece should be created for it or not
-  #
-  def initialize(*args)
-    options = {}
-    if args.last.is_a?(Hash)
-      options = args.pop
-    end
-    @reference_filter = options[:reference_filter] || proc do |e|
-      if e.is_a?(UML13::AssociationEnd)
-        otherEnd = e.association.connection.find{|ae| ae != e}
-        otherEnd.name && otherEnd.name.size > 0
-      else
-        false
-      end
-    end
-    super(*args)
-  end
-
-  def transform
-    trans(:class => UML13::Class)
-  end
-
-  transform UML13::Model, :to => EPackage do
-      trans(ownedClassOrPackage)
-    { :name => name && name.strip }
-  end
-    
-  transform UML13::Package, :to => EPackage do
-      trans(ownedClassOrPackage)
-    { :name => name && name.strip, 
-      :eSuperPackage => trans(namespace.is_a?(UML13::Package) ? namespace : nil) }
-  end
-  
-  method :ownedClassOrPackage do
-   ownedElement.select{|e| e.is_a?(UML13::Package) || e.is_a?(UML13::Class)}
-  end
-  
-  transform UML13::Class, :to => EClass do
-    { :name => name && name.strip,
-      :abstract => isAbstract,
-      :ePackage => trans(namespace.is_a?(UML13::Package) ? namespace : nil),
-      :eStructuralFeatures => trans(feature.select{|f| f.is_a?(UML13::Attribute)} + 
-        associationEnd + clientDependency),
-      :eOperations => trans(feature.select{|f| f.is_a?(UML13::Operation)}),
-      :eSuperTypes =>  trans(generalization.parent + clientDependency.select{|d| d.stereotype && d.stereotype.name == "implements"}.supplier),
-      :eAnnotations => createAnnotations(taggedValue) }
-  end
-
-  transform UML13::Interface, :to => EClass do
-    { :name => name && name.strip,
-      :abstract => isAbstract,
-      :ePackage => trans(namespace.is_a?(UML13::Package) ? namespace : nil),
-      :eStructuralFeatures => trans(feature.select{|f| f.is_a?(UML13::Attribute)} + associationEnd),
-      :eOperations => trans(feature.select{|f| f.is_a?(UML13::Operation)}),
-      :eSuperTypes =>  trans(generalization.parent)}
-  end
-
-  transform UML13::Attribute, :to => EAttribute do
-    { :name => name && name.strip, :eType => trans(getType),
-      :lowerBound => (multiplicity && multiplicity.range.first.lower &&
-        multiplicity.range.first.lower.to_i) || 0,
-      :upperBound => (multiplicity && multiplicity.range.first.upper && 
-        multiplicity.range.first.upper.gsub('*','-1').to_i) || 1,
-      :eAnnotations => createAnnotations(taggedValue) }
-  end
-
-  transform UML13::DataType, :to => EDataType do
-    { :name => name && name.strip,
-      :ePackage => trans(namespace.is_a?(UML13::Package) ? namespace : nil),
-      :eAnnotations => createAnnotations(taggedValue) }
-  end
-  
-  transform UML13::Operation, :to => EOperation do
-    { :name => name && name.strip }
-  end
-  
-  transform UML13::AssociationEnd, :to => EReference, :if => :isReference do
-      otherEnd = association.connection.find{|ae| ae != @current_object}
-    { :eType => trans(otherEnd.type),
-      :name => otherEnd.name && otherEnd.name.strip,
-      :eOpposite => trans(otherEnd),
-      :lowerBound => (otherEnd.multiplicity && otherEnd.multiplicity.range.first.lower &&
-        otherEnd.multiplicity.range.first.lower.to_i) || 0,
-      :upperBound => (otherEnd.multiplicity && otherEnd.multiplicity.range.first.upper && 
-        otherEnd.multiplicity.range.first.upper.gsub('*','-1').to_i) || 1,
-      :containment => (aggregation == :composite),
-      :eAnnotations => createAnnotations(association.taggedValue) }
-  end
-
-  transform UML13::Dependency, :to => EReference, :if => :isReference do
-    { :eType => trans(supplier.first),
-      :name => name,
-      :lowerBound => 0,
-      :upperBound => 1,
-      :containment => false,
-      :eAnnotations => createAnnotations(taggedValue)
-    }
-  end
-  
-  method :isReference do
-    @reference_filter.call(@current_object)
-  end      
-  
-  def createAnnotations(taggedValues)
-    if taggedValues.size > 0
-      [ EAnnotation.new(:details => trans(taggedValues)) ]
-    else
-      []
-    end
-  end
-
-  transform UML13::TaggedValue, :to => EStringToStringMapEntry do
-   { :key => tag, :value => value}
-  end
-end

data/lib/puppet/vendor/rgen/test/array_extensions_test.rb

@@ -1,64 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-
-require 'test/unit'
-require 'rgen/array_extensions'
-
-class ArrayExtensionsTest < Test::Unit::TestCase
-
-  def test_element_methods
-    c = Struct.new("SomeClass",:name,:age)
-    a = []
-    a << c.new('MyName',33)
-    a << c.new('YourName',22)
-    assert_equal ["MyName", "YourName"], a >> :name
-    assert_raise NoMethodError do
-      a.name
-    end
-    assert_equal [33, 22], a>>:age
-    assert_raise NoMethodError do
-      a.age
-    end
-    # unfortunately, any method can be called on an empty array
-    assert_equal [], [].age
-  end
-  
-  class MMBaseClass < RGen::MetamodelBuilder::MMBase
-    has_attr 'name'
-    has_attr 'age', Integer
-  end
-  
-  def test_with_mmbase
-    e1 = MMBaseClass.new
-    e1.name = "MyName"
-    e1.age = 33
-    e2 = MMBaseClass.new
-    e2.name = "YourName"
-    e2.age = 22
-    a = [e1, e2]
-    assert_equal ["MyName", "YourName"], a >> :name
-    assert_equal ["MyName", "YourName"], a.name
-    assert_equal [33, 22], a>>:age
-    assert_equal [33, 22], a.age
-    # put something into the array that is not an MMBase
-    a << "not a MMBase"
-    # the dot operator will tell that there is something not a MMBase
-    assert_raise StandardError do
-      a.age
-    end
-    # the >> operator will try to call the method anyway
-    assert_raise NoMethodError do
-      a >> :age
-    end
-  end
-
-  def test_hash_square
-    assert_equal({}, Hash[[]])
-  end
-
-  def test_to_str_on_empty_array
-    assert_raise NoMethodError do
-      [].to_str
-    end
-  end
-  
-end

data/lib/puppet/vendor/rgen/test/ea_instantiator_test.rb

@@ -1,35 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-
-require 'test/unit'
-require 'rgen/environment'
-require 'metamodels/uml13_metamodel'
-require 'ea_support/ea_support'
-require 'transformers/uml13_to_ecore'
-require 'testmodel/class_model_checker'
-require 'testmodel/object_model_checker'
-require 'testmodel/ecore_model_checker'
-
-class EAInstantiatorTest < Test::Unit::TestCase
-
-    include Testmodel::ClassModelChecker
-    include Testmodel::ObjectModelChecker
-    include Testmodel::ECoreModelChecker
-    
-	MODEL_DIR = File.join(File.dirname(__FILE__),"testmodel")
-		
-	def test_instantiator
-		envUML = RGen::Environment.new
-    EASupport.instantiateUML13FromXMI11(envUML, MODEL_DIR+"/ea_testmodel.xml") 
-    checkClassModel(envUML)
-    checkObjectModel(envUML)
-    envECore = RGen::Environment.new
-    UML13ToECore.new(envUML, envECore).transform
-    checkECoreModel(envECore)
-	end
-	
-	def test_partial
-		envUML = RGen::Environment.new
-    EASupport.instantiateUML13FromXMI11(envUML, MODEL_DIR+"/ea_testmodel_partial.xml") 
-		checkClassModelPartial(envUML)
-	end
-end

data/lib/puppet/vendor/rgen/test/ea_serializer_test.rb

@@ -1,23 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-
-require 'test/unit'
-require 'rgen/environment'
-require 'metamodels/uml13_metamodel'
-require 'ea_support/ea_support'
-require 'rgen/serializer/xmi11_serializer'
-
-class EASerializerTest < Test::Unit::TestCase
-
-	MODEL_DIR = File.join(File.dirname(__FILE__),"testmodel")
-	TEST_DIR = File.join(File.dirname(__FILE__),"ea_serializer_test")
-  
-	def test_serializer
-		envUML = RGen::Environment.new
-    EASupport.instantiateUML13FromXMI11(envUML, MODEL_DIR+"/ea_testmodel.xml") 
-    models = envUML.find(:class => UML13::Model)
-    assert_equal 1, models.size
-    
-    EASupport.serializeUML13ToXMI11(envUML, MODEL_DIR+"/ea_testmodel_regenerated.xml") 
-	end
-	
-end

data/lib/puppet/vendor/rgen/test/ecore_self_test.rb

@@ -1,54 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-
-require 'test/unit'
-require 'rgen/ecore/ecore'
-require 'rgen/array_extensions'
-
-class ECoreSelfTest < Test::Unit::TestCase
-  include RGen::ECore
-  
-  def test_simple
-    assert_equal \
-      %w(lowerBound ordered unique upperBound many required eType).sort,
-      ETypedElement.ecore.eStructuralFeatures.name.sort
-      
-    assert_equal \
-      EClassifier.ecore,
-      ETypedElement.ecore.eStructuralFeatures.find{|f| f.name=="eType"}.eType
-    assert_equal %w(ENamedElement), ETypedElement.ecore.eSuperTypes.name
-
-    assert_equal \
-      EModelElement.ecore,
-      EModelElement.ecore.eStructuralFeatures.find{|f| f.name=="eAnnotations"}.eOpposite.eType
-
-    assert_equal \
-      %w(eType),
-      ETypedElement.ecore.eReferences.name
-      
-    assert_equal \
-      %w(lowerBound ordered unique upperBound many required).sort,
-      ETypedElement.ecore.eAttributes.name.sort
-      
-    assert RGen::ECore.ecore.is_a?(EPackage)
-    assert_equal "ECore", RGen::ECore.ecore.name
-    assert_equal "RGen", RGen::ECore.ecore.eSuperPackage.name
-    assert_equal %w(ECore), RGen.ecore.eSubpackages.name
-    assert_equal\
-      %w(EObject EModelElement EAnnotation ENamedElement ETypedElement 
-        EStructuralFeature EAttribute EClassifier EDataType EEnum EEnumLiteral EFactory
-        EOperation EPackage EParameter EReference EStringToStringMapEntry EClass 
-        ETypeArgument EGenericType).sort,
-      RGen::ECore.ecore.eClassifiers.name.sort
-      
-    assert_equal "false", EAttribute.ecore.eAllAttributes.
-      find{|a|a.name == "derived"}.defaultValueLiteral
-    assert_equal false, EAttribute.ecore.eAllAttributes.
-      find{|a|a.name == "derived"}.defaultValue
-
-    assert_nil EAttribute.ecore.eAllAttributes.
-      find{|a|a.name == "defaultValueLiteral"}.defaultValueLiteral
-    assert_nil EAttribute.ecore.eAllAttributes.
-      find{|a|a.name == "defaultValueLiteral"}.defaultValue
-
-  end
-end

data/lib/puppet/vendor/rgen/test/environment_test.rb

@@ -1,90 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-
-require 'test/unit'
-require 'rgen/environment'
-require 'rgen/metamodel_builder'
-
-class EnvironmentTest < Test::Unit::TestCase
-
-	class Model
-		attr_accessor :name
-	end
-	
-	class ModelSub < Model
-	end
-	
-	class ClassSuperA < RGen::MetamodelBuilder::MMBase
-	end
-	
-	class ClassSuperB < RGen::MetamodelBuilder::MMBase
-	end
-	
-	class ClassC < RGen::MetamodelBuilder::MMMultiple(ClassSuperA, ClassSuperB)
-		has_attr 'name', String
-	end
-	
-	class ClassSubD < ClassC
-	end
-	
-	class ClassSubE < ClassC
-	end
-
-	def test_find_mmbase
-		env = RGen::Environment.new
-		mA1 = env.new(ClassSuperA)
-		mB1 = env.new(ClassSuperB)
-		mD1 = env.new(ClassSubD, :name => "mD1")
-		mD2 = env.new(ClassSubD, :name => "mD2")
-		mE = env.new(ClassSubE, :name => "mE")
-		
-		resultA = env.find(:class => ClassSuperA)
-		assert_equal sortById([mA1,mD1,mD2,mE]), sortById(resultA)
-		resultNamedA = env.find(:class => ClassSuperA, :name => "mD1")
-		assert_equal sortById([mD1]), sortById(resultNamedA)
-		
-		resultB = env.find(:class => ClassSuperB)
-		assert_equal sortById([mB1,mD1,mD2,mE]), sortById(resultB)
-		resultNamedB = env.find(:class => ClassSuperB, :name => "mD1")
-		assert_equal sortById([mD1]), sortById(resultNamedB)
-		
-		resultC = env.find(:class => ClassC)
-		assert_equal sortById([mD1,mD2,mE]), sortById(resultC)
-		
-		resultD = env.find(:class => ClassSubD)
-		assert_equal sortById([mD1,mD2]), sortById(resultD)
-	end
-	
-	def test_find
-		m1 = Model.new
-		m1.name = "M1"
-		m2 = ModelSub.new
-		m2.name = "M2"
-		m3 = "justAString"
-		env = RGen::Environment.new << m1 << m2 << m3
-		
-		result = env.find(:class => Model, :name => "M1")
-		assert result.is_a?(Array)
-		assert_equal 1, result.size
-		assert_equal m1, result.first
-
-		result = env.find(:class => Model)
-		assert result.is_a?(Array)
-		assert_equal sortById([m1,m2]), sortById(result)
-		
-		result = env.find(:name => "M2")
-		assert result.is_a?(Array)
-		assert_equal 1, result.size
-		assert_equal m2, result.first		
-		
-		result = env.find(:class => [Model, String])
-		assert result.is_a?(Array)
-		assert_equal sortById([m1,m2,m3]), sortById(result)
-	end
-	
-	private
-	
-	def sortById(array)
-		array.sort{|a,b| a.object_id <=> b.object_id}
-	end
-	
-end