rgen 0.5.4 → 0.6.0

data/lib/transformers/uml13_to_ecore.rb

@@ -4,71 +4,114 @@ require 'rgen/ecore/ecore'
 require 'rgen/array_extensions'
 
 class UML13ToECore < RGen::Transformer
-	include RGen::ECore
+  include RGen::ECore
 
-	def transform
-		trans(:class => UML13::Class)
-	end
+  # 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
 
-	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,
-			: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 + clientDependency.select{|d| d.stereotype.name == "implements"}.supplier),
+  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
+  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::Interface, :to => EClass do
-		{ :name => name && name.strip,
-			: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::Attribute, :to => EAttribute do
-		typemap = { "string" => EString, "boolean" => EBoolean, "int" => EInt, "float" => EFloat }
-		{	:name => name && name.strip, :eType => getType && typemap[getType.name && getType.name.downcase],
+  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 &&
+  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 && 
+      :upperBound => (otherEnd.multiplicity && otherEnd.multiplicity.range.first.upper && 
         otherEnd.multiplicity.range.first.upper.gsub('*','-1').to_i) || 1,
-			:containment => (aggregation == :composite),
+      :containment => (aggregation == :composite),
       :eAnnotations => createAnnotations(association.taggedValue) }
-	end
-	
-	method :isReference do
-	  otherEnd = association.connection.find{|ae| ae != @current_object}
-      otherEnd.name && otherEnd.name.size > 0
-	end			
+  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
@@ -78,7 +121,7 @@ class UML13ToECore < RGen::Transformer
     end
   end
 
-	transform UML13::TaggedValue, :to => EStringToStringMapEntry do
-	 { :key => tag, :value => value}
-	end
-end
+  transform UML13::TaggedValue, :to => EStringToStringMapEntry do
+   { :key => tag, :value => value}
+  end
+end

data/test/ecore_self_test.rb

@@ -5,49 +5,50 @@ 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
+  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 \
+      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).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_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
+    assert_nil EAttribute.ecore.eAllAttributes.
+      find{|a|a.name == "defaultValueLiteral"}.defaultValueLiteral
+    assert_nil EAttribute.ecore.eAllAttributes.
+      find{|a|a.name == "defaultValueLiteral"}.defaultValue
 
-	end
-end
+  end
+end

data/test/json_test.rb

@@ -14,6 +14,7 @@ class JsonTest < Test::Unit::TestCase
       has_attr 'text', String
       has_attr 'integer', Integer
       has_attr 'float', Float
+      has_one 'other', TestNode
       contains_many 'childs', TestNode, 'parent'
     end
   end
@@ -152,5 +153,19 @@ class JsonTest < Test::Unit::TestCase
       inst.instantiate(%q({ "_class": "Data2", "data2": "something" }))
     end
   end
+
+  def test_json_instantiator_references
+    env = RGen::Environment.new
+    inst = RGen::Instantiator::JsonInstantiator.new(env, TestMM, :nameAttribute => "text")
+    inst.instantiate(%q([
+    { "_class": "TestNode", "text": "A", "childs": [ 
+      { "_class": "TestNode", "text": "B" } ]},
+    { "_class": "TestNode", "text": "C", "other": "/A/B"}]
+    ))
+    nodeA = env.find(:class => TestMM::TestNode, :text => "A").first
+    nodeC = env.find(:class => TestMM::TestNode, :text => "C").first
+    assert_equal 1, nodeA.childs.size
+    assert_equal nodeA.childs[0], nodeC.other 
+  end
 end
 	

data/test/metamodel_builder_test.rb

@@ -6,18 +6,150 @@ require 'rgen/array_extensions'
 
 class MetamodelBuilderTest < Test::Unit::TestCase
   
-  class SimpleClass < RGen::MetamodelBuilder::MMBase
-    KindType = RGen::MetamodelBuilder::DataTypes::Enum.new([:simple, :extended])
-    has_attr 'name' # default is String
-    has_attr 'stringWithDefault', String, :defaultValueLiteral => "xtest"
-    has_attr 'anything', Object
-    has_attr 'allowed', RGen::MetamodelBuilder::DataTypes::Boolean
-    has_attr 'kind', KindType
-    has_attr 'kindWithDefault', KindType, :defaultValueLiteral => "extended"
+  module TestMetamodel
+    extend RGen::MetamodelBuilder::ModuleExtension
+
+    class SimpleClass < RGen::MetamodelBuilder::MMBase
+      KindType = RGen::MetamodelBuilder::DataTypes::Enum.new([:simple, :extended])
+      has_attr 'name' # default is String
+      has_attr 'stringWithDefault', String, :defaultValueLiteral => "xtest"
+      has_attr 'integerWithDefault', Integer, :defaultValueLiteral => "123"
+      has_attr 'floatWithDefault', Float, :defaultValueLiteral => "0.123"
+      has_attr 'boolWithDefault', Boolean, :defaultValueLiteral => "true"
+      has_attr 'anything', Object
+      has_attr 'allowed', RGen::MetamodelBuilder::DataTypes::Boolean
+      has_attr 'kind', KindType
+      has_attr 'kindWithDefault', KindType, :defaultValueLiteral => "extended"
+    end
+
+    class ManyAttrClass < RGen::MetamodelBuilder::MMBase
+      has_many_attr 'literals', String
+      has_many_attr 'bools', Boolean
+      has_many_attr 'integers', Integer
+      has_many_attr 'enums', RGen::MetamodelBuilder::DataTypes::Enum.new([:a, :b, :c])
+      has_many_attr 'limitTest', Integer, :upperBound => 2
+    end
+
+    class ClassA < RGen::MetamodelBuilder::MMBase
+      # metamodel accessors must work independent of the ==() method
+      module ClassModule
+        def ==(o)
+          o.is_a?(ClassA)
+        end
+      end
+    end
+    
+    class ClassB < RGen::MetamodelBuilder::MMBase
+    end
+    
+    class ClassC < RGen::MetamodelBuilder::MMBase
+    end
+    
+    class HasOneTestClass < RGen::MetamodelBuilder::MMBase
+      has_one 'classA', ClassA
+      has_one 'classB', ClassB
+    end
+    
+    class HasManyTestClass < RGen::MetamodelBuilder::MMBase
+      has_many 'classA', ClassA
+    end
+    
+    class OneClass < RGen::MetamodelBuilder::MMBase
+    end
+    class ManyClass < RGen::MetamodelBuilder::MMBase
+    end
+    OneClass.one_to_many 'manyClasses', ManyClass, 'oneClass', :upperBound => 5
+    
+    class AClassMM < RGen::MetamodelBuilder::MMBase
+    end
+    class BClassMM < RGen::MetamodelBuilder::MMBase
+    end
+    AClassMM.many_to_many 'bClasses', BClassMM, 'aClasses'
+    
+    module SomePackage 
+      extend RGen::MetamodelBuilder::ModuleExtension
+      
+      class ClassA < RGen::MetamodelBuilder::MMBase
+      end
+      
+      module SubPackage 
+        extend RGen::MetamodelBuilder::ModuleExtension
+      
+        class ClassB < RGen::MetamodelBuilder::MMBase
+        end
+      end
+    end
+    
+    class OneClass2 < RGen::MetamodelBuilder::MMBase
+    end
+    class ManyClass2 < RGen::MetamodelBuilder::MMBase
+    end
+    ManyClass2.many_to_one 'oneClass', OneClass2, 'manyClasses'
+    
+    class AClassOO < RGen::MetamodelBuilder::MMBase
+    end
+    class BClassOO < RGen::MetamodelBuilder::MMBase
+    end
+    AClassOO.one_to_one 'bClass', BClassOO, 'aClass'
+    
+    class SomeSuperClass < RGen::MetamodelBuilder::MMBase
+      has_attr "name"
+      has_many "classAs", ClassA
+    end
+    
+    class SomeSubClass < SomeSuperClass
+      has_attr "subname"
+      has_many "classBs", ClassB
+    end
+    
+    class OtherSubClass < SomeSuperClass
+      has_attr "othersubname"
+      has_many "classCs", ClassC
+    end
+
+    class SubSubClass < RGen::MetamodelBuilder::MMMultiple(SomeSubClass, OtherSubClass)
+      has_attr "subsubname"
+    end
+    
+    module AnnotatedModule 
+      extend RGen::MetamodelBuilder::ModuleExtension
+
+      annotation "moduletag" => "modulevalue"
+      
+      class AnnotatedClass < RGen::MetamodelBuilder::MMBase
+        annotation "sometag" => "somevalue", "othertag" => "othervalue"
+        annotation :source => "rgen/test", :details => {"thirdtag" => "thirdvalue"}
+      
+        has_attr "boolAttr", Boolean do
+          annotation "attrtag" => "attrval"
+          annotation :source => "rgen/test2", :details => {"attrtag2" => "attrvalue2", "attrtag3" => "attrvalue3"}
+        end
+
+        has_many "others", AnnotatedClass do
+          annotation "reftag" => "refval"
+          annotation :source => "rgen/test3", :details => {"reftag2" => "refvalue2", "reftag3" => "refvalue3"}
+        end
+
+        many_to_many "m2m", AnnotatedClass, "m2mback" do
+          annotation "m2mtag" => "m2mval"
+          opposite_annotation "opposite_m2mtag" => "opposite_m2mval"
+        end
+      end
+      
+    end
+    
+    class AbstractClass < RGen::MetamodelBuilder::MMBase
+      abstract
+    end
+
   end
-  
+   
+  def mm
+    TestMetamodel
+  end
+
   def test_has_attr
-    sc = SimpleClass.new
+    sc = mm::SimpleClass.new
     
     assert_respond_to sc, :name
     assert_respond_to sc, :name=
@@ -28,10 +160,13 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_raise StandardError do
       sc.name = 5
     end
-    assert_equal "EString", SimpleClass.ecore.eAttributes.find{|a| a.name=="name"}.eType.name
+    assert_equal "EString", mm::SimpleClass.ecore.eAttributes.find{|a| a.name=="name"}.eType.name
 
     assert_equal "xtest", sc.stringWithDefault
     assert_equal :extended, sc.kindWithDefault
+    assert_equal 123, sc.integerWithDefault
+    assert_equal 0.123, sc.floatWithDefault
+    assert_equal true, sc.boolWithDefault
     
     sc.anything = :asymbol
     assert_equal :asymbol, sc.anything
@@ -52,7 +187,7 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_raise StandardError do
       sc.allowed = "a string"
     end
-    assert_equal "EBoolean", SimpleClass.ecore.eAttributes.find{|a| a.name=="allowed"}.eType.name
+    assert_equal "EBoolean", mm::SimpleClass.ecore.eAttributes.find{|a| a.name=="allowed"}.eType.name
     
     assert_respond_to sc, :kind
     assert_respond_to sc, :kind=
@@ -69,20 +204,12 @@ class MetamodelBuilderTest < Test::Unit::TestCase
       sc.kind = "a string"
     end
     
-    enum = SimpleClass.ecore.eAttributes.find{|a| a.name=="kind"}.eType
+    enum = mm::SimpleClass.ecore.eAttributes.find{|a| a.name=="kind"}.eType
     assert_equal ["extended", "simple"], enum.eLiterals.name.sort
   end
   
-  class ManyAttrClass < RGen::MetamodelBuilder::MMBase
-    has_many_attr 'literals', String
-    has_many_attr 'bools', Boolean
-    has_many_attr 'integers', Integer
-    has_many_attr 'enums', RGen::MetamodelBuilder::DataTypes::Enum.new([:a, :b, :c])
-    has_many_attr 'limitTest', Integer, :upperBound => 2
-  end
-
   def test_many_attr
-    o = ManyAttrClass.new
+    o = mm::ManyAttrClass.new
 
     assert_respond_to o, :literals
     assert_respond_to o, :addLiterals
@@ -102,13 +229,13 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal ["a", "b", "b"], o.literals
     # but the same string object "a" can only occur once
     o.addLiterals(o.literals.first)
-    assert_equal ["a", "b", "b"], o.literals
+    assert_equal ["a", "b", "b", "a"], o.literals
     # removing works by object identity, so providing a new string won't delete an existing one
     o.removeLiterals("a")
-    assert_equal ["a", "b", "b"], o.literals
+    assert_equal ["a", "b", "b", "a"], o.literals
     theA = o.literals.first
     o.removeLiterals(theA)
-    assert_equal ["b", "b"], o.literals
+    assert_equal ["b", "b", "a"], o.literals
     # removing something which is not present has no effect
     o.removeLiterals(theA)
     assert_equal ["b", "b"], o.literals
@@ -120,54 +247,42 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     # setting multiple elements at a time
     o.literals = ["a", "b", "c"]
     assert_equal ["a", "b", "c"], o.literals
-    # can only take arrays
+    # can only take enumerables
     assert_raise(StandardError) do
-      o.literals = "a"
+      o.literals = 1
     end
  
     o.bools = [true, false, true, false]
-    assert_equal [true, false], o.bools
+    assert_equal [true, false, true, false], o.bools
 
     o.integers = [1, 2, 2, 3, 3]
-    assert_equal [1, 2, 3], o.integers
+    assert_equal [1, 2, 2, 3, 3], o.integers
 
     o.enums = [:a, :a, :b, :c, :c]
-    assert_equal [:a, :b, :c], o.enums
+    assert_equal [:a, :a, :b, :c, :c], o.enums
 
-    lit = ManyAttrClass.ecore.eAttributes.find{|a| a.name == "literals"}
+    lit = mm::ManyAttrClass.ecore.eAttributes.find{|a| a.name == "literals"}
     assert lit.is_a?(RGen::ECore::EAttribute)
     assert lit.many
 
-    lim = ManyAttrClass.ecore.eAttributes.find{|a| a.name == "limitTest"}
+    lim = mm::ManyAttrClass.ecore.eAttributes.find{|a| a.name == "limitTest"}
     assert lit.many
     assert_equal 2, lim.upperBound
   end
 
-  class ClassA < RGen::MetamodelBuilder::MMBase
-    # metamodel accessors must work independent of the ==() method
-    module ClassModule
-      def ==(o)
-        o.is_a?(ClassA)
-      end
-    end
-  end
-  
-  class ClassB < RGen::MetamodelBuilder::MMBase
-  end
-  
-  class ClassC < RGen::MetamodelBuilder::MMBase
-  end
-  
-  class HasOneTestClass < RGen::MetamodelBuilder::MMBase
-    has_one 'classA', ClassA
-    has_one 'classB', ClassB
+  def test_many_attr_insert
+    o = mm::ManyAttrClass.new
+    o.addLiterals("a")
+    o.addLiterals("b", 0)
+    o.addLiterals("c", 1)
+    assert_equal ["b", "c", "a"], o.literals
   end
-  
+
   def test_has_one
-    sc = HasOneTestClass.new
+    sc = mm::HasOneTestClass.new
     assert_respond_to sc, :classA
     assert_respond_to sc, :classA=
-    ca = ClassA.new
+    ca = mm::ClassA.new
     sc.classA = ca
     assert_equal ca, sc.classA
     sc.classA = nil
@@ -175,7 +290,7 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     
     assert_respond_to sc, :classB
     assert_respond_to sc, :classB=
-    cb = ClassB.new
+    cb = mm::ClassB.new
     sc.classB = cb
     assert_equal cb, sc.classB
     
@@ -183,22 +298,18 @@ class MetamodelBuilderTest < Test::Unit::TestCase
       sc.classB = ca
     end
     
-    assert_equal [], ClassA.ecore.eReferences
-    assert_equal [], ClassB.ecore.eReferences
-    assert_equal ["classA", "classB"].sort, HasOneTestClass.ecore.eReferences.name.sort
-    assert_equal [], HasOneTestClass.ecore.eReferences.select { |a| a.many == true }
-    assert_equal [], HasOneTestClass.ecore.eAttributes
-  end
-  
-  class HasManyTestClass < RGen::MetamodelBuilder::MMBase
-    has_many 'classA', ClassA
+    assert_equal [], mm::ClassA.ecore.eReferences
+    assert_equal [], mm::ClassB.ecore.eReferences
+    assert_equal ["classA", "classB"].sort, mm::HasOneTestClass.ecore.eReferences.name.sort
+    assert_equal [], mm::HasOneTestClass.ecore.eReferences.select { |a| a.many == true }
+    assert_equal [], mm::HasOneTestClass.ecore.eAttributes
   end
   
   def test_has_many
-    o = HasManyTestClass.new
-    ca1 = ClassA.new
-    ca2 = ClassA.new
-    ca3 = ClassA.new
+    o = mm::HasManyTestClass.new
+    ca1 = mm::ClassA.new
+    ca2 = mm::ClassA.new
+    ca3 = mm::ClassA.new
     o.addClassA(ca1)
     o.addClassA(ca2)
     assert_equal [ca1, ca2], o.classA
@@ -210,24 +321,33 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     o.removeClassA(ca2)
     assert_equal [ca1], o.classA
     assert_raise StandardError do
-      o.addClassA(ClassB.new)
+      o.addClassA(mm::ClassB.new)
     end
-    assert_equal [], HasManyTestClass.ecore.eReferences.select{|r| r.many == false}
-    assert_equal ["classA"], HasManyTestClass.ecore.eReferences.select{|r| r.many == true}.name
+    assert_equal [], mm::HasManyTestClass.ecore.eReferences.select{|r| r.many == false}
+    assert_equal ["classA"], mm::HasManyTestClass.ecore.eReferences.select{|r| r.many == true}.name
   end
-  
-  class OneClass < RGen::MetamodelBuilder::MMBase
-  end
-  class ManyClass < RGen::MetamodelBuilder::MMBase
+
+  def test_has_many_insert
+    o = mm::HasManyTestClass.new
+    ca1 = mm::ClassA.new
+    ca2 = mm::ClassA.new
+    ca3 = mm::ClassA.new
+    ca4 = mm::ClassA.new
+    ca5 = mm::ClassA.new
+    o.addClassA(ca1)
+    o.addClassA(ca2)
+    o.addClassA(ca3,0)
+    o.addClassA(ca4,1)
+    o.addGeneric("classA",ca5,2)
+    assert_equal [ca3, ca4, ca5, ca1, ca2], o.classA
   end
-  OneClass.one_to_many 'manyClasses', ManyClass, 'oneClass', :upperBound => 5
   
   def test_one_to_many
-    oc = OneClass.new
+    oc = mm::OneClass.new
     assert_respond_to oc, :manyClasses
     assert oc.manyClasses.empty?
     
-    mc = ManyClass.new
+    mc = mm::ManyClass.new
     assert_respond_to mc, :oneClass
     assert_respond_to mc, :oneClass=
     assert_nil mc.oneClass
@@ -252,17 +372,17 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert !oc.manyClasses.include?(mc)
     assert_equal nil, mc.oneClass
     
-    assert_equal [], OneClass.ecore.eReferences.select{|r| r.many == false}
-    assert_equal ["manyClasses"], OneClass.ecore.eReferences.select{|r| r.many == true}.name
-    assert_equal 5, OneClass.ecore.eReferences.find{|r| r.many == true}.upperBound
-    assert_equal ["oneClass"], ManyClass.ecore.eReferences.select{|r| r.many == false}.name
-    assert_equal [], ManyClass.ecore.eReferences.select{|r| r.many == true}
+    assert_equal [], mm::OneClass.ecore.eReferences.select{|r| r.many == false}
+    assert_equal ["manyClasses"], mm::OneClass.ecore.eReferences.select{|r| r.many == true}.name
+    assert_equal 5, mm::OneClass.ecore.eReferences.find{|r| r.many == true}.upperBound
+    assert_equal ["oneClass"], mm::ManyClass.ecore.eReferences.select{|r| r.many == false}.name
+    assert_equal [], mm::ManyClass.ecore.eReferences.select{|r| r.many == true}
   end
   
   def test_one_to_many_replace1
-    oc1 = OneClass.new
-    oc2 = OneClass.new
-    mc = ManyClass.new  	
+    oc1 = mm::OneClass.new
+    oc2 = mm::OneClass.new
+    mc = mm::ManyClass.new  	
     
     oc1.manyClasses = [mc]
     assert_equal [mc], oc1.manyClasses
@@ -276,9 +396,9 @@ class MetamodelBuilderTest < Test::Unit::TestCase
 	end
 
   def test_one_to_many_replace2
-    oc = OneClass.new
-    mc1 = ManyClass.new  	
-    mc2 = ManyClass.new  	
+    oc = mm::OneClass.new
+    mc1 = mm::ManyClass.new  	
+    mc2 = mm::ManyClass.new  	
     
     mc1.oneClass = oc
     assert_equal [mc1], oc.manyClasses
@@ -291,18 +411,24 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal oc, mc2.oneClass
 	end
 	
-  class OneClass2 < RGen::MetamodelBuilder::MMBase
-  end
-  class ManyClass2 < RGen::MetamodelBuilder::MMBase
+  def test_one_to_many_insert
+    oc = mm::OneClass.new
+    mc1 = mm::ManyClass.new  	
+    mc2 = mm::ManyClass.new  	
+
+    oc.addManyClasses(mc1, 0)
+    oc.addManyClasses(mc2, 0)
+    assert_equal [mc2, mc1], oc.manyClasses
+    assert_equal oc, mc1.oneClass
+    assert_equal oc, mc2.oneClass
   end
-  ManyClass2.many_to_one 'oneClass', OneClass2, 'manyClasses'
-  
+
   def test_one_to_many2
-    oc = OneClass2.new
+    oc = mm::OneClass2.new
     assert_respond_to oc, :manyClasses
     assert oc.manyClasses.empty?
     
-    mc = ManyClass2.new
+    mc = mm::ManyClass2.new
     assert_respond_to mc, :oneClass
     assert_respond_to mc, :oneClass=
     assert_nil mc.oneClass
@@ -327,25 +453,19 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert !oc.manyClasses.include?(mc)
     assert_equal nil, mc.oneClass
     
-    assert_equal [], OneClass2.ecore.eReferences.select{|r| r.many == false}
-    assert_equal ["manyClasses"], OneClass2.ecore.eReferences.select{|r| r.many == true}.name
-    assert_equal ["oneClass"], ManyClass2.ecore.eReferences.select{|r| r.many == false}.name
-    assert_equal [], ManyClass2.ecore.eReferences.select{|r| r.many == true}
-  end
-  
-  class AClassOO < RGen::MetamodelBuilder::MMBase
-  end
-  class BClassOO < RGen::MetamodelBuilder::MMBase
+    assert_equal [], mm::OneClass2.ecore.eReferences.select{|r| r.many == false}
+    assert_equal ["manyClasses"], mm::OneClass2.ecore.eReferences.select{|r| r.many == true}.name
+    assert_equal ["oneClass"], mm::ManyClass2.ecore.eReferences.select{|r| r.many == false}.name
+    assert_equal [], mm::ManyClass2.ecore.eReferences.select{|r| r.many == true}
   end
-  AClassOO.one_to_one 'bClass', BClassOO, 'aClass'
   
   def test_one_to_one
-    ac = AClassOO.new
+    ac = mm::AClassOO.new
     assert_respond_to ac, :bClass
     assert_respond_to ac, :bClass=
     assert_nil ac.bClass
     
-    bc = BClassOO.new
+    bc = mm::BClassOO.new
     assert_respond_to bc, :aClass
     assert_respond_to bc, :aClass=
     assert_nil bc.aClass
@@ -370,16 +490,16 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal nil, ac.bClass
     assert_equal nil, bc.aClass
     
-    assert_equal ["bClass"], AClassOO.ecore.eReferences.select{|r| r.many == false}.name
-    assert_equal [], AClassOO.ecore.eReferences.select{|r| r.many == true}
-    assert_equal ["aClass"], BClassOO.ecore.eReferences.select{|r| r.many == false}.name
-    assert_equal [], BClassOO.ecore.eReferences.select{|r| r.many == true}
+    assert_equal ["bClass"], mm::AClassOO.ecore.eReferences.select{|r| r.many == false}.name
+    assert_equal [], mm::AClassOO.ecore.eReferences.select{|r| r.many == true}
+    assert_equal ["aClass"], mm::BClassOO.ecore.eReferences.select{|r| r.many == false}.name
+    assert_equal [], mm::BClassOO.ecore.eReferences.select{|r| r.many == true}
   end
   
   def test_one_to_one_replace
-    a = AClassOO.new
-    b1 = BClassOO.new
-    b2 = BClassOO.new
+    a = mm::AClassOO.new
+    b1 = mm::BClassOO.new
+    b2 = mm::BClassOO.new
     
     a.bClass = b1
     assert_equal b1, a.bClass
@@ -392,19 +512,13 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal a, b2.aClass
 	end	
   
-  class AClassMM < RGen::MetamodelBuilder::MMBase
-  end
-  class BClassMM < RGen::MetamodelBuilder::MMBase
-  end
-  AClassMM.many_to_many 'bClasses', BClassMM, 'aClasses'
-  
   def test_many_to_many
     
-    ac = AClassMM.new
+    ac = mm::AClassMM.new
     assert_respond_to ac, :bClasses
     assert ac.bClasses.empty?
     
-    bc = BClassMM.new
+    bc = mm::BClassMM.new
     assert_respond_to bc, :aClasses
     assert bc.aClasses.empty?
     
@@ -438,69 +552,50 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert !ac.bClasses.include?(bc)
     assert !bc.aClasses.include?(ac)
     
-    assert_equal [], AClassMM.ecore.eReferences.select{|r| r.many == false}
-    assert_equal  ["bClasses"], AClassMM.ecore.eReferences.select{|r| r.many == true}.name
-    assert_equal [], BClassMM.ecore.eReferences.select{|r| r.many == false}
-    assert_equal  ["aClasses"], BClassMM.ecore.eReferences.select{|r| r.many == true}.name
-  end
-  
-  class SomeSuperClass < RGen::MetamodelBuilder::MMBase
-    has_attr "name"
-    has_many "classAs", ClassA
-  end
-  
-  class SomeSubClass < SomeSuperClass
-    has_attr "subname"
-    has_many "classBs", ClassB
-  end
-  
-  class OtherSubClass < SomeSuperClass
-    has_attr "othersubname"
-    has_many "classCs", ClassC
+    assert_equal [], mm::AClassMM.ecore.eReferences.select{|r| r.many == false}
+    assert_equal  ["bClasses"], mm::AClassMM.ecore.eReferences.select{|r| r.many == true}.name
+    assert_equal [], mm::BClassMM.ecore.eReferences.select{|r| r.many == false}
+    assert_equal  ["aClasses"], mm::BClassMM.ecore.eReferences.select{|r| r.many == true}.name
   end
   
-  def test_inheritance
-    assert_equal ["name"], SomeSuperClass.ecore.eAllAttributes.name
-    assert_equal ["classAs"], SomeSuperClass.ecore.eAllReferences.name
-    assert_equal ["name", "subname"], SomeSubClass.ecore.eAllAttributes.name.sort
-    assert_equal ["classAs", "classBs"], SomeSubClass.ecore.eAllReferences.name.sort
-    assert_equal ["name", "othersubname"], OtherSubClass.ecore.eAllAttributes.name.sort
-    assert_equal ["classAs", "classCs"], OtherSubClass.ecore.eAllReferences.name.sort
-  end
-  
-  module AnnotatedModule 
-    extend RGen::MetamodelBuilder::ModuleExtension
+  def test_many_to_many_insert
+    ac1 = mm::AClassMM.new
+    ac2 = mm::AClassMM.new
+    bc1= mm::BClassMM.new
+    bc2= mm::BClassMM.new
 
-    annotation "moduletag" => "modulevalue"
-    
-    class AnnotatedClass < RGen::MetamodelBuilder::MMBase
-      annotation "sometag" => "somevalue", "othertag" => "othervalue"
-      annotation :source => "rgen/test", :details => {"thirdtag" => "thirdvalue"}
-    
-      has_attr "boolAttr", Boolean do
-        annotation "attrtag" => "attrval"
-        annotation :source => "rgen/test2", :details => {"attrtag2" => "attrvalue2", "attrtag3" => "attrvalue3"}
-      end
-
-      has_many "others", AnnotatedClass do
-        annotation "reftag" => "refval"
-        annotation :source => "rgen/test3", :details => {"reftag2" => "refvalue2", "reftag3" => "refvalue3"}
-      end
+    ac1.addBClasses(bc1)
+    ac1.addBClasses(bc2, 0)
+    ac2.addBClasses(bc1)
+    ac2.addBClasses(bc2, 0)
 
-      many_to_many "m2m", AnnotatedClass, "m2mback" do
-        annotation "m2mtag" => "m2mval"
-        opposite_annotation "opposite_m2mtag" => "opposite_m2mval"
-      end
-    end
-    
+    assert_equal [bc2, bc1], ac1.bClasses
+    assert_equal [bc2, bc1], ac2.bClasses
+    assert_equal [ac1, ac2], bc1.aClasses
+    assert_equal [ac1, ac2], bc2.aClasses
+  end
+   
+  def test_inheritance
+    assert_equal ["name"], mm::SomeSuperClass.ecore.eAllAttributes.name
+    assert_equal ["classAs"], mm::SomeSuperClass.ecore.eAllReferences.name
+    assert_equal ["name", "subname"], mm::SomeSubClass.ecore.eAllAttributes.name.sort
+    assert_equal ["classAs", "classBs"], mm::SomeSubClass.ecore.eAllReferences.name.sort
+    assert_equal ["name", "othersubname"], mm::OtherSubClass.ecore.eAllAttributes.name.sort
+    assert_equal ["classAs", "classCs"], mm::OtherSubClass.ecore.eAllReferences.name.sort
+    assert mm::SomeSubClass.new.is_a?(mm::SomeSuperClass)
+    assert_equal ["name", "othersubname", "subname", "subsubname"], mm::SubSubClass.ecore.eAllAttributes.name.sort
+    assert_equal ["classAs", "classBs", "classCs"], mm::SubSubClass.ecore.eAllReferences.name.sort
+    assert mm::SubSubClass.new.is_a?(mm::SomeSuperClass)
+    assert mm::SubSubClass.new.is_a?(mm::SomeSubClass)
+    assert mm::SubSubClass.new.is_a?(mm::OtherSubClass)
   end
   
   def test_annotations
-    assert_equal 1, AnnotatedModule.ecore.eAnnotations.size
-    anno = AnnotatedModule.ecore.eAnnotations.first
+    assert_equal 1, mm::AnnotatedModule.ecore.eAnnotations.size
+    anno = mm::AnnotatedModule.ecore.eAnnotations.first
     checkAnnotation(anno, nil, {"moduletag" => "modulevalue"})
 
-    eClass = AnnotatedModule::AnnotatedClass.ecore
+    eClass = mm::AnnotatedModule::AnnotatedClass.ecore
     assert_equal 2, eClass.eAnnotations.size
     anno = eClass.eAnnotations.find{|a| a.source == "rgen/test"}
     checkAnnotation(anno, "rgen/test", {"thirdtag" => "thirdvalue"})
@@ -542,25 +637,11 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     end
   end
   
-	module SomePackage 
-  	extend RGen::MetamodelBuilder::ModuleExtension
-		
-		class ClassA < RGen::MetamodelBuilder::MMBase
-		end
-		
-		module SubPackage 
-	  	extend RGen::MetamodelBuilder::ModuleExtension
-		
-			class ClassB < RGen::MetamodelBuilder::MMBase
-			end
-		end
-	end
-	
 	def test_ecore_identity
-		subPackage = SomePackage::SubPackage.ecore
-		assert_equal subPackage.eClassifiers.first.object_id, SomePackage::SubPackage::ClassB.ecore.object_id
+		subPackage = mm::SomePackage::SubPackage.ecore
+		assert_equal subPackage.eClassifiers.first.object_id, mm::SomePackage::SubPackage::ClassB.ecore.object_id
 		
-		somePackage = SomePackage.ecore
+		somePackage = mm::SomePackage.ecore
 		assert_equal somePackage.eSubpackages.first.object_id, subPackage.object_id
 	end
 
@@ -569,14 +650,18 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal "test", p.targetIdentifier
     p.targetIdentifier = 123
     assert_equal 123, p.targetIdentifier
+    p.data = "additional info"
+    assert_equal "additional info", p.data
+    q = RGen::MetamodelBuilder::MMProxy.new("ident", "data")
+    assert_equal "data", q.data
   end
  
   def test_proxies_has_one
-    e = HasOneTestClass.new 
+    e = mm::HasOneTestClass.new 
     proxy = RGen::MetamodelBuilder::MMProxy.new
     e.classA = proxy
     assert_equal proxy, e.classA
-    a = ClassA.new 
+    a = mm::ClassA.new 
     # displace proxy
     e.classA = a
     assert_equal a, e.classA
@@ -586,7 +671,7 @@ class MetamodelBuilderTest < Test::Unit::TestCase
   end
 
   def test_proxies_has_many
-    e = HasManyTestClass.new
+    e = mm::HasManyTestClass.new
     proxy = RGen::MetamodelBuilder::MMProxy.new
     e.addClassA(proxy)
     assert_equal [proxy], e.classA 
@@ -606,8 +691,8 @@ class MetamodelBuilderTest < Test::Unit::TestCase
   end
 
   def test_proxies_one_to_one
-    ea = AClassOO.new
-    eb = BClassOO.new
+    ea = mm::AClassOO.new
+    eb = mm::BClassOO.new
     proxy1 = RGen::MetamodelBuilder::MMProxy.new
     proxy2 = RGen::MetamodelBuilder::MMProxy.new
     ea.bClass = proxy1
@@ -625,8 +710,8 @@ class MetamodelBuilderTest < Test::Unit::TestCase
   end
 
   def test_proxies_one_to_many
-    eo = OneClass.new
-    em = ManyClass.new
+    eo = mm::OneClass.new
+    em = mm::ManyClass.new
     proxy1 = RGen::MetamodelBuilder::MMProxy.new
     proxy2 = RGen::MetamodelBuilder::MMProxy.new
     eo.addManyClasses(proxy1)
@@ -652,8 +737,8 @@ class MetamodelBuilderTest < Test::Unit::TestCase
   end
 
   def test_proxies_many_to_many
-    e1 = AClassMM.new
-    e2 = BClassMM.new
+    e1 = mm::AClassMM.new
+    e2 = mm::BClassMM.new
     proxy1 = RGen::MetamodelBuilder::MMProxy.new
     proxy2 = RGen::MetamodelBuilder::MMProxy.new
     e1.addBClasses(proxy1)
@@ -670,10 +755,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
   end
   
   def test_genericAccess
-    e1 = OneClass.new
-    e2 = ManyClass.new
-    e3 = OneClass.new
-    e4 = ManyClass.new
+    e1 = mm::OneClass.new
+    e2 = mm::ManyClass.new
+    e3 = mm::OneClass.new
+    e4 = mm::ManyClass.new
     # use on "many" feature
     e1.setOrAddGeneric("manyClasses", e2)
     assert_equal [e2], e1.manyClasses
@@ -688,4 +773,74 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal [], e4.getGenericAsArray("oneClass")
   end
 
+  def test_abstract
+    assert_raise StandardError do
+      mm::AbstractClass.new
+    end
+  end
+
+  module BadDefaultValueLiteralContainer
+    Test1 = proc do 
+      class BadClass < RGen::MetamodelBuilder::MMBase
+        has_attr 'integerWithDefault', Integer, :defaultValueLiteral => "1.1"
+      end
+    end
+    Test2 = proc do 
+      class BadClass < RGen::MetamodelBuilder::MMBase
+        has_attr 'integerWithDefault', Integer, :defaultValueLiteral => "x"
+      end
+    end
+    Test3 = proc do 
+      class BadClass < RGen::MetamodelBuilder::MMBase
+        has_attr 'boolWithDefault', Boolean, :defaultValueLiteral => "1"
+      end
+    end
+    Test4 = proc do 
+      class BadClass < RGen::MetamodelBuilder::MMBase
+        has_attr 'floatWithDefault', Float, :defaultValueLiteral => "1"
+      end
+    end
+    Test5 = proc do 
+      class BadClass < RGen::MetamodelBuilder::MMBase
+        has_attr 'floatWithDefault', Float, :defaultValueLiteral => "true"
+      end
+    end
+    Test6 = proc do 
+      class BadClass < RGen::MetamodelBuilder::MMBase
+        kindType = RGen::MetamodelBuilder::DataTypes::Enum.new([:simple, :extended])
+        has_attr 'enumWithDefault', kindType, :defaultValueLiteral => "xxx"
+      end
+    end
+    Test7 = proc do 
+      class BadClass < RGen::MetamodelBuilder::MMBase
+        kindType = RGen::MetamodelBuilder::DataTypes::Enum.new([:simple, :extended])
+        has_attr 'enumWithDefault', kindType, :defaultValueLiteral => "7"
+      end
+    end
+  end
+
+  def test_bad_default_value_literal
+    assert_raise StandardError do
+      BadDefaultValueLiteralContainer::Test1.call
+    end
+    assert_raise StandardError do
+      BadDefaultValueLiteralContainer::Test2.call
+    end
+    assert_raise StandardError do
+      BadDefaultValueLiteralContainer::Test3.call
+    end
+    assert_raise StandardError do
+      BadDefaultValueLiteralContainer::Test4.call
+    end
+    assert_raise StandardError do
+      BadDefaultValueLiteralContainer::Test5.call
+    end
+    assert_raise StandardError do
+      BadDefaultValueLiteralContainer::Test6.call
+    end
+    assert_raise StandardError do
+      BadDefaultValueLiteralContainer::Test7.call
+    end
+  end
+
 end