rgen 0.5.3 → 0.5.4

data/CHANGELOG

@@ -115,3 +115,11 @@
 * Fixed string escaping in JSON instantiator and serializer
 * Fixed order of eClassifiers and eSubpackages within an EPackage created by reflection on a RGen module
 
+=0.5.4
+
+* Fixed undeterministic order of child elements in ModelSerializer
+* Fixed undeterministic order of attributes in XMI serializers
+* Fixed ModelSerializer to always serialize the to-one part of bidirectional 1:N references
+* Fixed ModelSerializer to add :as => in case of ambiguous child roles
+* Made JsonInstantiator search subpackages for unqualified class names
+

data/Rakefile

@@ -3,8 +3,8 @@ require 'rake/rdoctask'
 
 RGenGemSpec = Gem::Specification.new do |s|
   s.name = %q{rgen}
-  s.version = "0.5.3"
-  s.date = %q{2010-08-13}
+  s.version = "0.5.4"
+  s.date = Time.now.strftime("%Y-%m-%d")
   s.summary = %q{Ruby Modelling and Generator Framework}
   s.email = %q{martin dot thiede at gmx de}
   s.homepage = %q{http://ruby-gen.org}

data/lib/rgen/instantiator/json_instantiator.rb

@@ -5,19 +5,43 @@ module RGen
 
 module Instantiator
 
+# JsonInstantiator is used to create RGen models from JSON.
+#
+# Each JSON object needs to have an attribute "_class" which is used to find
+# the metamodel class to instantiate. The value of "_class" should be the 
+# the relative qualified class name within the root package as a string. 
+#
+# If the option "short_class_names" is set to true, unqualified class names can be used.
+# In this case, metamodel classes are searched in the metamodel root package first.
+# If this search is not successful, all subpackages will be searched for the class name.
+#
 class JsonInstantiator
 
+  # Model elements will be created in evironment +env+,
+  # classes are looked for in metamodel package module +mm+,
+  # +options+ include:
+  #   short_class_names: if true subpackages will be searched for unqualifed class names (default: true)
+  # The options are also passed to the underlying QualifiedNameResolver.
+  #
   def initialize(env, mm, options={})
     @env = env
     @mm = mm
     @options = options
+    @short_class_names = !@options.has_key?(:short_class_names) || @options[:short_class_names]
     @unresolvedReferences = []
+    @classes = {}
+    @classes_flat = {}
+    mm.ecore.eAllClasses.each do |c|
+      @classes[c.instanceClass.name.sub(mm.name+"::","")] = c
+      @classes_flat[c.name] = c
+    end
     @parser = JsonParser.new(self)
   end
 
-  # creates the elements described by the json string +str+
-  # returns an array of ReferenceResolver::UnresolvedReference
+  # Creates the elements described by the json string +str+.
+  # Returns an array of ReferenceResolver::UnresolvedReference
   # describing the references which could not be resolved
+  #
   def instantiate(str)
     root = @parser.parse(str)
     resolver = QualifiedNameResolver.new(root, @options)
@@ -27,8 +51,13 @@ class JsonInstantiator
   def createObject(hash)
     className = hash["_class"]
     raise "no class information" unless className
-    clazz = @mm.const_get(className)
-    raise "class not found: #{className}" unless clazz
+    if @classes[className]
+      clazz = @classes[className].instanceClass
+    elsif @short_class_names && @classes_flat[className]
+      clazz = @classes_flat[className].instanceClass
+    else 
+      raise "class not found: #{className}"
+    end
     hash.delete("_class")
     urefs = []
     hash.keys.each do |k|
@@ -68,7 +97,11 @@ class JsonInstantiator
   def eFeature(name, clazz) 
     @eFeature ||= {}
     @eFeature[clazz] ||= {}
-    @eFeature[clazz][name] ||= clazz.ecore.eAllStructuralFeatures.find{|f| f.name == name}
+    unless @eFeature[clazz][name] 
+      feature = clazz.ecore.eAllStructuralFeatures.find{|f| f.name == name}
+      raise "feature '#{name}' not found in class '#{clazz}'" unless feature
+    end
+    @eFeature[clazz][name] ||= feature
   end
   
 end

data/lib/rgen/model_builder/model_serializer.rb

@@ -31,7 +31,7 @@ class ModelSerializer
     cmd = className[0..0].downcase+className[1..-1]
     args = ["\"#{@internalElementName[element]}\""]
     namePath = namePath + [@internalElementName[element]]
-    childs = {}
+    childs = [] 
     eAllStructuralFeatures(element).each do |f|
       next if f.derived
       if f.is_a?(RGen::ECore::EAttribute)
@@ -50,11 +50,11 @@ class ModelSerializer
         if cs.is_a?(Array)
           cs.compact!
           rcs = cs.select{|c| serializeChild?(c, namePath)}
-          childs[f] = rcs unless rcs.empty?
+          childs << [f, rcs] unless rcs.empty?
           refString = serializeReference(element, f, cs-rcs)
         else
           if cs && serializeChild?(cs, namePath)
-            childs[f] = [cs]
+            childs << [f, [cs]]
           else
             refString = serializeReference(element, f, cs)
           end
@@ -62,12 +62,15 @@ class ModelSerializer
         args << ":#{f.name} => #{refString}" if refString
       end
     end
+
+    args << ":as => :#{viaRef.name}" if viaRef && containmentRefs(viaRef.eContainingClass, element.class.ecore).size > 1
     cmd = elementPackage(element)+"."+cmd if elementPackage(element).size > 0
     @writable.write "  " * indent + cmd + " " + args.join(", ")
     if childs.size > 0
       @writable.write " do\n"
       oldPackage, @currentPackage = @currentPackage, element.class.ecore.ePackage
-      childs.each_pair do |f,cs|
+      childs.each do |pair|
+        f, cs = pair
         cs.each {|c| serializeElement(c, f, namePath, indent+1) }
       end
       @currentPackage = oldPackage
@@ -96,21 +99,29 @@ class ModelSerializer
   def serializeReference(element, ref, value)
     if value.is_a?(Array)
       value = value.compact
-      value = value.select{|v| compareWithOppositeReference(element, v) > 0} if ref.eOpposite
+      value = value.select{|v| compareWithOppositeReference(ref, element, v) > 0} if ref.eOpposite
       qualNames = value.collect do |v|
         relativeQualifiedElementName(v, element).join(".")
       end
       !qualNames.empty? && ("[" + qualNames.collect { |v| "\"#{v}\"" }.join(", ") + "]")
-    elsif value && (!ref.eOpposite || compareWithOppositeReference(element, value) > 0)
+    elsif value && (!ref.eOpposite || compareWithOppositeReference(ref, element, value) > 0)
       qualName = relativeQualifiedElementName(value, element).join(".")
       ("\"#{qualName}\"")        
     end
   end
   
-  def compareWithOppositeReference(element, target)
+  # descide which part of a bidirectional reference get serialized
+  def compareWithOppositeReference(ref, element, target)
+    result = 0
+    # first try to make the reference from the many side to the one side
+    result = -1 if ref.many && !ref.eOpposite.many
+    result = 1 if !ref.many && ref.eOpposite.many
+    return result if result != 0
+    # for 1:1 or many:many perfer, shorter references
     result = relativeQualifiedElementName(element, target).size <=> 
       relativeQualifiedElementName(target, element).size
     return result if result != 0
+    # there just needs to be a descision, use class name or object_id
     result = element.class.name <=> target.class.name
     return result if result != 0
     element.object_id <=> target.object_id    
@@ -194,8 +205,21 @@ class ModelSerializer
     @eAllStructuralFeatures[element.class] ||= element.class.ecore.eAllStructuralFeatures
   end
     
+  def eAllReferences(eClass)
+    @eAllReferences ||= {}
+    @eAllReferences[eClass] ||= eClass.eAllReferences
+  end
+    
+  def containmentRefs(contextClass, eClass)
+    @containmentRefs ||= {}
+    @containmentRefs[[contextClass, eClass]] ||=
+      eAllReferences(contextClass).select do |r| 
+        r.containment && (eClass.eAllSuperTypes << eClass).include?(r.eType)
+      end
+  end
+
 end
 
 end
 
-end
+end

data/lib/rgen/serializer/xmi11_serializer.rb

@@ -19,10 +19,10 @@ class XMI11Serializer < XMLSerializer
   end
   
   def serialize(rootElement, headerInfo=nil)
-    attrs = {}
-    attrs['xmi.version'] = "1.1"
-    attrs['xmlns:'+@namespaceShortcut] = @namespaceUrl if @namespaceUrl
-    attrs['timestamp'] = Time.now.to_s
+    attrs = []
+    attrs << ['xmi.version', "1.1"]
+    attrs << ['xmlns:'+@namespaceShortcut, @namespaceUrl] if @namespaceUrl
+    attrs << ['timestamp', Time.now.to_s]
     startTag("XMI", attrs)
     if headerInfo
       startTag("XMI.header")
@@ -56,7 +56,7 @@ class XMI11Serializer < XMLSerializer
   
   def writeElement(element)
     tag = @namespacePrefix + element.class.ecore.name
-    attrs = attributeHash(element)
+    attrs = attributeValues(element)
     startTag(tag, attrs)
     containmentReferences(element).each do |r|
       roletag = @namespacePrefix + r.eContainingClass.name + "." + r.name
@@ -77,22 +77,21 @@ class XMI11Serializer < XMLSerializer
     endTag(tag)
   end
 
-  def attributeHash(element)
-    result = {"xmi.id" => xmiId(element)}
+  def attributeValues(element)
+    result = [["xmi.id", xmiId(element)]]
     eAllAttributes(element).select{|a| !a.derived}.each do |a|
       val = element.getGeneric(a.name)
-      result[a.name] = val unless val.nil? || val == ""
+      result << [a.name, val] unless val.nil? || val == ""
     end
     eAllReferences(element).each do |r|
       next if r.derived
       next if r.containment
       next if r.eOpposite && r.eOpposite.containment && xmiLevel(element).nil?
       next if r.eOpposite && r.many && !r.eOpposite.many
-      targetElements = element.getGeneric(r.name)
-      targetElements = [targetElements] unless targetElements.is_a?(Array)
+      targetElements = element.getGenericAsArray(r.name)
       targetElements.compact!
       val = targetElements.collect{|te| xmiId(te)}.compact.join(' ')
-      result[r.name] = val unless val == ""
+      result << [r.name, val] unless val == ""
     end
     result  
   end
@@ -114,4 +113,4 @@ end
 
 end
 
-end
+end

data/lib/rgen/serializer/xmi20_serializer.rb

@@ -10,11 +10,11 @@ class XMI20Serializer < XMLSerializer
 		@referenceStrings = {}
 		buildReferenceStrings(rootElement, "#/")
     addBuiltinReferenceStrings
-		attrs = attributeHash(rootElement)
-		attrs['xmi:version'] = "2.0"
-		attrs['xmlns:xmi'] = "http://www.omg.org/XMI"
-		attrs['xmlns:xsi'] = "http://www.w3.org/2001/XMLSchema-instance"
-		attrs['xmlns:ecore'] = "http://www.eclipse.org/emf/2002/Ecore" 
+		attrs = attributeValues(rootElement)
+		attrs << ['xmi:version', "2.0"]
+		attrs << ['xmlns:xmi', "http://www.omg.org/XMI"]
+		attrs << ['xmlns:xsi', "http://www.w3.org/2001/XMLSchema-instance"]
+		attrs << ['xmlns:ecore', "http://www.eclipse.org/emf/2002/Ecore" ]
 		tag = "ecore:"+rootElement.class.ecore.name
 		startTag(tag, attrs)
 		writeComposites(rootElement)
@@ -23,8 +23,8 @@ class XMI20Serializer < XMLSerializer
 	
 	def writeComposites(element)
 		eachReferencedElement(element, containmentReferences(element)) do |r,te|
-			attrs = attributeHash(te)
-			attrs['xsi:type'] = "ecore:"+te.class.ecore.name
+			attrs = attributeValues(te)
+			attrs << ['xsi:type', "ecore:"+te.class.ecore.name]
 			tag = r.name
 			startTag(tag, attrs)
 			writeComposites(te)
@@ -32,17 +32,16 @@ class XMI20Serializer < XMLSerializer
 		end
 	end
 
-	def attributeHash(element)
-		result = {}
+	def attributeValues(element)
+		result = [] 
 		eAllAttributes(element).select{|a| !a.derived}.each do |a|
 			val = element.getGeneric(a.name)
-			result[a.name] = val unless val.nil? || val == ""
+			result << [a.name, val] unless val.nil? || val == ""
 		end
 		eAllReferences(element).select{|r| !r.containment && !(r.eOpposite && r.eOpposite.containment) && !r.derived}.each do |r|
-			targetElements = element.getGeneric(r.name)
-			targetElements = [targetElements] unless targetElements.is_a?(Array)
+			targetElements = element.getGenericAsArray(r.name)
 			val = targetElements.collect{|te| @referenceStrings[te]}.compact.join(' ')
-			result[r.name] = val unless val.nil? || val == ""
+			result << [r.name, val] unless val.nil? || val == ""
 		end
 		result	
 	end

data/lib/rgen/serializer/xml_serializer.rb

@@ -20,8 +20,12 @@ class XMLSerializer
   def startTag(tag, attributes={})
     @textContent = false
     handleLastStartTag(false, true)
-    @lastStartTag = " "*@indent*INDENT_SPACE +
-    	"<#{tag} "+attributes.keys.collect{|k| "#{k}=\"#{attributes[k]}\""}.join(" ")
+    if attributes.is_a?(Hash)
+      attrString = attributes.keys.collect{|k| "#{k}=\"#{attributes[k]}\""}.join(" ")
+    else
+      attrString = attributes.collect{|pair| "#{pair[0]}=\"#{pair[1]}\""}.join(" ")
+    end
+    @lastStartTag = " "*@indent*INDENT_SPACE + "<#{tag} "+attrString
     @indent += 1
   end
   

data/test/json_test.rb

@@ -18,6 +18,27 @@ class JsonTest < Test::Unit::TestCase
     end
   end
 
+  module TestMMData
+    extend RGen::MetamodelBuilder::ModuleExtension
+    # class "Data" exists in the standard Ruby namespace
+    class Data < RGen::MetamodelBuilder::MMBase
+      has_attr 'notTheBuiltin', String
+    end
+  end
+
+  module TestMMSubpackage
+    extend RGen::MetamodelBuilder::ModuleExtension
+    module SubPackage
+      extend RGen::MetamodelBuilder::ModuleExtension
+      class Data < RGen::MetamodelBuilder::MMBase
+        has_attr 'notTheBuiltin', String
+      end
+      class Data2 < RGen::MetamodelBuilder::MMBase
+        has_attr 'data2', String
+      end
+    end
+  end
+
   class StringWriter < String
     alias write concat
   end
@@ -95,5 +116,41 @@ class JsonTest < Test::Unit::TestCase
     inst.instantiate(%q({ "_class": "TestNode", "float": 1.23 }))
     assert_equal 1.23, env.elements.first.float
   end
+
+  def test_json_instantiator_conflict_builtin
+    env = RGen::Environment.new
+    inst = RGen::Instantiator::JsonInstantiator.new(env, TestMMData)
+    inst.instantiate(%q({ "_class": "Data", "notTheBuiltin": "for sure" }))
+    assert_equal "for sure", env.elements.first.notTheBuiltin
+  end
+
+  def test_json_serializer_subpacakge
+    testModel = TestMMSubpackage::SubPackage::Data2.new(:data2 => "xxx")
+    output = StringWriter.new
+    ser = RGen::Serializer::JsonSerializer.new(output)
+    assert_equal %q({ "_class": "Data2", "data2": "xxx" }), ser.serialize(testModel) 
+  end
+
+  def test_json_instantiator_builtin_in_subpackage
+    env = RGen::Environment.new
+    inst = RGen::Instantiator::JsonInstantiator.new(env, TestMMSubpackage)
+    inst.instantiate(%q({ "_class": "Data", "notTheBuiltin": "for sure" }))
+    assert_equal "for sure", env.elements.first.notTheBuiltin
+  end
+
+  def test_json_instantiator_subpackage
+    env = RGen::Environment.new
+    inst = RGen::Instantiator::JsonInstantiator.new(env, TestMMSubpackage)
+    inst.instantiate(%q({ "_class": "Data2", "data2": "something" }))
+    assert_equal "something", env.elements.first.data2
+  end
+
+  def test_json_instantiator_subpackage_no_shortname_opt
+    env = RGen::Environment.new
+    inst = RGen::Instantiator::JsonInstantiator.new(env, TestMMSubpackage, :short_class_names => false)
+    assert_raise RuntimeError do
+      inst.instantiate(%q({ "_class": "Data2", "data2": "something" }))
+    end
+  end
 end
 	

data/test/metamodel_roundtrip_test/using_builtin_types.ecore

@@ -1,8 +1,8 @@
-<ecore:EPackage xmi:version="2.0" name="P1" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore">
-  <eClassifiers name="C1" xsi:type="ecore:EClass">
-    <eStructuralFeatures name="a1" derived="false" transient="false" changeable="true" unsettable="false" iD="false" xsi:type="ecore:EAttribute" upperBound="1" ordered="true" volatile="false" lowerBound="0" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString" unique="true"/>
-    <eStructuralFeatures name="a2" derived="false" transient="false" changeable="true" unsettable="false" iD="false" xsi:type="ecore:EAttribute" upperBound="1" ordered="true" volatile="false" lowerBound="0" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt" unique="true"/>
-    <eStructuralFeatures name="a3" derived="false" transient="false" changeable="true" unsettable="false" iD="false" xsi:type="ecore:EAttribute" upperBound="1" ordered="true" volatile="false" lowerBound="0" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EFloat" unique="true"/>
-    <eStructuralFeatures name="a4" derived="false" transient="false" changeable="true" unsettable="false" iD="false" xsi:type="ecore:EAttribute" upperBound="1" ordered="true" volatile="false" lowerBound="0" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean" unique="true"/>
-  </eClassifiers>
-</ecore:EPackage>
+<ecore:EPackage name="P1" xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore">
+  <eClassifiers name="C1" xsi:type="ecore:EClass">
+    <eStructuralFeatures iD="false" changeable="true" derived="false" transient="false" unsettable="false" volatile="false" lowerBound="0" ordered="true" unique="true" upperBound="1" name="a1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString" xsi:type="ecore:EAttribute"/>
+    <eStructuralFeatures iD="false" changeable="true" derived="false" transient="false" unsettable="false" volatile="false" lowerBound="0" ordered="true" unique="true" upperBound="1" name="a2" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt" xsi:type="ecore:EAttribute"/>
+    <eStructuralFeatures iD="false" changeable="true" derived="false" transient="false" unsettable="false" volatile="false" lowerBound="0" ordered="true" unique="true" upperBound="1" name="a3" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EFloat" xsi:type="ecore:EAttribute"/>
+    <eStructuralFeatures iD="false" changeable="true" derived="false" transient="false" unsettable="false" volatile="false" lowerBound="0" ordered="true" unique="true" upperBound="1" name="a4" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean" xsi:type="ecore:EAttribute"/>
+  </eClassifiers>
+</ecore:EPackage>

data/test/model_builder/serializer_test.rb

@@ -36,29 +36,59 @@ class ModelSerializerTest < Test::Unit::TestCase
     end
   end
   
-  def xxx_test_ecore_original
-    env = RGen::Environment.new
-    File.open(File.dirname(__FILE__)+"/Ecore.ecore") { |f|
-      ECoreXMLInstantiator.new(env,ECoreXMLInstantiator::ERROR).instantiate(f.read)
-    }
-    serializeEcore(env, "ecore", File.dirname(__FILE__)+"/ecore_original.rb")
-    b = nil
-    env2 = RGen::Environment.new
-    RGen::ModelBuilder.build(RGen::ECore, env2) do
-      b = binding
+  def test_roundtrip
+    model = %{\
+statemachine "Airconditioner" do
+  state "Off", :kind => :START
+  compositeState "On" do
+    state "Heating"
+    state "Cooling"
+    state "Dumm"
+  end
+  transition "_Transition1", :sourceState => "On.Cooling", :targetState => "On.Heating"
+  transition "_Transition2", :sourceState => "On.Heating", :targetState => "On.Cooling"
+end
+}
+    check_roundtrip(StatemachineMetamodel, model)
+  end
+  
+  module AmbiguousRoleMM
+    extend RGen::MetamodelBuilder::ModuleExtension
+    class A < RGen::MetamodelBuilder::MMBase
+    end
+    class B < RGen::MetamodelBuilder::MMBase
     end
-    File.open(File.dirname(__FILE__)+"/ecore_original.rb") do |f|
-      eval(f.read, b)
+    class C < B
     end
-    serializeEcore(env2, "ecore", File.dirname(__FILE__)+"/ecore_original_regenerated.rb")    
+    A.contains_many 'role1', B, 'back1'
+    A.contains_many 'role2', B, 'back2'
   end
-  
-  def serializeEcore(env, rootPackageName, fileName)
-    env.find(:class => RGen::ECore::EClass).each {|c| c.eOperations = []}
-    env.find(:class => RGen::ECore::EModelElement).each {|e| e.eAnnotations = []}
-    File.open(fileName,"w") do |f|
-      serializer = RGen::ModelBuilder::ModelSerializer.new(f, RGen::ECore.ecore)
-      serializer.serialize(env.find(:class => RGen::ECore::EPackage, :name => rootPackageName))
+
+  def test_roundtrip_ambiguous_role
+    model = %{\
+a "_A1" do
+  b "_B1", :as => :role1
+  b "_B2", :as => :role2
+  c "_C1", :as => :role2
+end
+}
+    check_roundtrip(AmbiguousRoleMM, model)
+  end
+
+  private
+
+  def build_model(mm, model)
+    RGen::ModelBuilder.build(mm) do
+      eval(model)
     end
   end
-end
+
+  def check_roundtrip(mm, model)
+    sm = build_model(mm, model)
+    f = StringIO.new
+    serializer = RGen::ModelBuilder::ModelSerializer.new(f, mm.ecore)
+    serializer.serialize(sm)
+    assert_equal model, f.string
+  end
+
+end

data/test/model_builder_test.rb

@@ -1,3 +1,5 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
 require 'model_builder/builder_test'
 require 'model_builder/serializer_test'
 require 'model_builder/builder_context_test'

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 5
-  - 3
-  version: 0.5.3
+  - 4
+  version: 0.5.4
 platform: ruby
 authors: 
 - Martin Thiede
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-13 00:00:00 +02:00
+date: 2010-11-07 00:00:00 +01:00
 default_executable: 
 dependencies: []