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

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

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

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

@@ -0,0 +1,64 @@
+$:.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

@@ -0,0 +1,35 @@
+$:.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

@@ -0,0 +1,23 @@
+$:.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

@@ -0,0 +1,54 @@
+$:.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

@@ -0,0 +1,90 @@
+$:.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