rgen 0.6.1 → 0.6.2

data/CHANGELOG

@@ -161,3 +161,8 @@
 * Fixed ModelFragment#elements not containing root elements
 * Added optional output of invalidation reason to FileCacheMap#load_data
 
+=0.6.2
+
+* Made qualified name provider work with unidirectional containment references
+* Fixed array_extension breaking the Hash[] method
+

data/Rakefile

@@ -3,7 +3,7 @@ require 'rdoc/task'
 
 RGenGemSpec = Gem::Specification.new do |s|
   s.name = %q{rgen}
-  s.version = "0.6.1"
+  s.version = "0.6.2"
   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}

data/lib/rgen/array_extensions.rb

@@ -5,27 +5,39 @@ require 'rgen/metamodel_builder'
 
 class Array
 
-	def >>(method)
-		compact.inject([]) { |r,e| r | ( (o=e.send(method)).is_a?(Array) ? o : [o] ) }
-	end
-	
-	def method_missing(m, *args)
-		super unless size == 0 or compact.any?{|e| e.is_a? RGen::MetamodelBuilder::MMBase}
-		# use an array to build the result to achiev similar ordering
-		result = []
-		inResult = {}
-		compact.each do |e|
-			if e.is_a? RGen::MetamodelBuilder::MMBase				
-				((o=e.send(m)).is_a?(Array) ? o : [o] ).each do |v|
-					next if inResult[v.object_id]
-					inResult[v.object_id] = true
-					result << v
-				end
-			else
-				raise StandardError.new("Trying to call a method on an array element not a RGen MMBase")
-			end
-		end
-		result.compact
-	end
+  def >>(method)
+    compact.inject([]) { |r,e| r | ( (o=e.send(method)).is_a?(Array) ? o : [o] ) }
+  end
+  
+  def method_missing(m, *args)
 
-end
+    # This extensions has the side effect that it allows to call any method on any
+    # empty array with an empty array as the result. This behavior is required for
+    # navigating models.
+    #
+    # This is a problem for Hash[] called with an (empty) array of tupels.
+    # It will call to_hash expecting a Hash as the result. When it gets an array instead,
+    # it fails with an exception. Make sure it gets a NoMethodException as without this
+    # extension and it will catch that and return an empty hash as expected.
+    #
+    return super unless (size == 0 && 
+      m != :to_hash) ||
+      compact.any?{|e| e.is_a? RGen::MetamodelBuilder::MMBase}
+    # use an array to build the result to achiev similar ordering
+    result = []
+    inResult = {}
+    compact.each do |e|
+      if e.is_a? RGen::MetamodelBuilder::MMBase        
+        ((o=e.send(m)).is_a?(Array) ? o : [o] ).each do |v|
+          next if inResult[v.object_id]
+          inResult[v.object_id] = true
+          result << v
+        end
+      else
+        raise StandardError.new("Trying to call a method on an array element not a RGen MMBase")
+      end
+    end
+    result.compact
+  end
+
+end

data/lib/rgen/serializer/qualified_name_provider.rb

@@ -2,10 +2,10 @@ module RGen
 
 module Serializer
 
-# simple identifier calculation based on qualified names
-# prerequisits:
-# * containment relations must be bidirectionsl
-# * local name stored in single attribute +@attribute_name+ for all classes
+# simple identifier calculation based on qualified names.
+# as a prerequisit, elements must have a local name stored in single attribute +attribute_name+.
+# there may be classes without the name attribute though and there may be elements without a
+# local name. in both cases the element will have the same qualified name as its container.
 #
 class QualifiedNameProvider
 
@@ -17,23 +17,25 @@ class QualifiedNameProvider
   end
 
   def identifier(element)
-    (element.is_a?(RGen::MetamodelBuilder::MMProxy) && element.targetIdentifier) || qualified_name(element)
+    if element.is_a?(RGen::MetamodelBuilder::MMProxy) 
+      element.targetIdentifier
+    else
+      qualified_name(element)
+    end
   end
 
   def qualified_name(element)
     return @qualified_name_cache[element] if @qualified_name_cache[element]
-    localIdent = ((element.respond_to?(@attribute_name) && element.getGeneric(@attribute_name)) || "").strip
-    parentRef = element.class.ecore.eAllReferences.select{|r| r.eOpposite && r.eOpposite.containment}.first
-    parent = parentRef && element.getGeneric(parentRef.name)
+    local_ident = ((element.respond_to?(@attribute_name) && element.getGeneric(@attribute_name)) || "").strip
+    parent = element.eContainer
     if parent
-      if localIdent.size > 0
-        parentIdent = qualified_name(parent)
-        result = parentIdent + @separator + localIdent
+      if local_ident.size > 0
+        result = qualified_name(parent) + @separator + local_ident
       else
         result = qualified_name(parent)
       end
     else
-      result = (@leading_separator ? @separator : "") + localIdent
+      result = (@leading_separator ? @separator : "") + local_ident
     end
     @qualified_name_cache[element] = result
   end

data/test/array_extensions_test.rb

@@ -5,50 +5,54 @@ 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_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
+  
 end

data/test/metamodel_builder_test.rb

@@ -167,9 +167,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal "TestName", sc.name
     sc.name = nil
     assert_equal nil, sc.name
-    assert_raise StandardError do
+    err = assert_raise StandardError do
       sc.name = 5
     end
+    assert_match /In (\w+::)+SimpleClass : Can not use a Fixnum where a String is expected/, err.message
     assert_equal "EString", mm::SimpleClass.ecore.eAttributes.find{|a| a.name=="name"}.eType.name
 
     assert_equal "xtest", sc.stringWithDefault
@@ -195,12 +196,14 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal false, sc.allowed
     sc.allowed = nil
     assert_equal nil, sc.allowed
-    assert_raise StandardError do
+    err = assert_raise StandardError do
       sc.allowed = :someSymbol
     end
-    assert_raise StandardError do
+    assert_match /In (\w+::)+SimpleClass : Can not use a Symbol\(:someSymbol\) where a \[true,false\] is expected/, err.message
+    err = assert_raise StandardError do
       sc.allowed = "a string"
     end
+    assert_match /In (\w+::)+SimpleClass : Can not use a String where a \[true,false\] is expected/, err.message
     assert_equal "EBoolean", mm::SimpleClass.ecore.eAttributes.find{|a| a.name=="allowed"}.eType.name
     
     assert_respond_to sc, :kind
@@ -211,12 +214,14 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal :extended, sc.kind
     sc.kind = nil
     assert_equal nil, sc.kind
-    assert_raise StandardError do
+    err = assert_raise StandardError do
       sc.kind = :false
     end
-    assert_raise StandardError do
+    assert_match /In (\w+::)+SimpleClass : Can not use a Symbol\(:false\) where a \[:simple,:extended\] is expected/, err.message
+    err = assert_raise StandardError do
       sc.kind = "a string"
     end
+    assert_match /In (\w+::)+SimpleClass : Can not use a String where a \[:simple,:extended\] is expected/, err.message
     
     enum = mm::SimpleClass.ecore.eAttributes.find{|a| a.name=="kind"}.eType
     assert_equal ["extended", "simple"], enum.eLiterals.name.sort
@@ -229,9 +234,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_respond_to o, :addLiterals
     assert_respond_to o, :removeLiterals
 
-    assert_raise(StandardError) do
+    err = assert_raise(StandardError) do
       o.addLiterals(1)
     end
+    assert_match /In (\w+::)+ManyAttrClass : Can not use a Fixnum where a String is expected/, err.message
 
     assert_equal [], o.literals
     o.addLiterals("a")
@@ -263,9 +269,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     o.literals = ["a", "b", "c"]
     assert_equal ["a", "b", "c"], o.literals
     # can only take enumerables
-    assert_raise(StandardError) do
+    err = assert_raise(StandardError) do
       o.literals = 1
     end
+    assert_match /In (\w+::)+ManyAttrClass : Can not use a Fixnum where a Enumerable is expected/, err.message
  
     o.bools = [true, false, true, false]
     assert_equal [true, false, true, false], o.bools
@@ -309,9 +316,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     sc.classB = cb
     assert_equal cb, sc.classB
     
-    assert_raise StandardError do
+    err = assert_raise StandardError do
       sc.classB = ca
     end
+    assert_match /In (\w+::)+HasOneTestClass : Can not use a (\w+::)+ClassA where a (\w+::)+ClassB is expected/, err.message
     
     assert_equal [], mm::ClassA.ecore.eReferences
     assert_equal [], mm::ClassB.ecore.eReferences
@@ -335,9 +343,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal [ca1, ca2], o.classA
     o.removeClassA(ca2)
     assert_equal [ca1], o.classA
-    assert_raise StandardError do
+    err = assert_raise StandardError do
       o.addClassA(mm::ClassB.new)
     end
+    assert_match /In (\w+::)+HasManyTestClass : Can not use a (\w+::)+ClassB where a (\w+::)+ClassA is expected/, err.message
     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
@@ -543,9 +552,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert ac.bClasses.include?(bc)
     
     # put something else into the BClass
-    assert_raise StandardError do
+    err = assert_raise StandardError do
       bc.addAClasses :notaaclass
     end
+    assert_match /In (\w+::)+BClassMM : Can not use a Symbol\(:notaaclass\) where a (\w+::)+AClassMM is expected/, err.message
     
     # remove the AClass from the BClass
     bc.removeAClasses ac
@@ -558,9 +568,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert bc.aClasses.include?(ac)
     
     # put something else into the AClass
-    assert_raise StandardError do
+    err = assert_raise StandardError do
       ac.addBClasses :notabclass
     end
+    assert_match /In (\w+::)+AClassMM : Can not use a Symbol\(:notabclass\) where a (\w+::)+BClassMM is expected/, err.message
     
     # remove the BClass from the AClass
     ac.removeBClasses bc
@@ -789,9 +800,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
   end
 
   def test_abstract
-    assert_raise StandardError do
+    err = assert_raise StandardError do
       mm::AbstractClass.new
     end
+    assert_match /Class (\w+::)+AbstractClass is abstract/, err.message
   end
 
   module BadDefaultValueLiteralContainer
@@ -835,27 +847,34 @@ class MetamodelBuilderTest < Test::Unit::TestCase
   end
 
   def test_bad_default_value_literal
-    assert_raise StandardError do
+    err = assert_raise StandardError do
       BadDefaultValueLiteralContainer::Test1.call
     end
-    assert_raise StandardError do
+    assert_equal "Property integerWithDefault can not take value 1.1, expected an Integer", err.message
+    err = assert_raise StandardError do
       BadDefaultValueLiteralContainer::Test2.call
     end
-    assert_raise StandardError do
+    assert_equal "Property integerWithDefault can not take value x, expected an Integer", err.message
+    err = assert_raise StandardError do
       BadDefaultValueLiteralContainer::Test3.call
     end
-    assert_raise StandardError do
+    assert_equal "Property boolWithDefault can not take value 1, expected true or false", err.message
+    err = assert_raise StandardError do
       BadDefaultValueLiteralContainer::Test4.call
     end
-    assert_raise StandardError do
+    assert_equal "Property floatWithDefault can not take value 1, expected a Float", err.message
+    err = assert_raise StandardError do
       BadDefaultValueLiteralContainer::Test5.call
     end
-    assert_raise StandardError do
+    assert_equal "Property floatWithDefault can not take value true, expected a Float", err.message
+    err = assert_raise StandardError do
       BadDefaultValueLiteralContainer::Test6.call
     end
-    assert_raise StandardError do
+    assert_equal "Property enumWithDefault can not take value xxx, expected one of :simple, :extended", err.message
+    err = assert_raise StandardError do
       BadDefaultValueLiteralContainer::Test7.call
     end
+    assert_equal "Property enumWithDefault can not take value 7, expected one of :simple, :extended", err.message
   end
 
   def test_isset_set_to_nil

data/test/qualified_name_provider_test.rb

@@ -0,0 +1,48 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/metamodel_builder'
+require 'rgen/serializer/qualified_name_provider'
+
+class QualifiedNameProviderTest < Test::Unit::TestCase
+
+  class AbstractTestNode < RGen::MetamodelBuilder::MMBase
+    contains_many 'children', AbstractTestNode, "parent"
+  end
+
+  class NamedNode < AbstractTestNode
+    has_attr 'n', String
+  end
+
+  class UnnamedNode < AbstractTestNode
+  end
+
+  def test_simple
+    root = NamedNode.new(:n => "root", :children => [
+      NamedNode.new(:n => "a", :children => [
+        NamedNode.new(:n => "a1")
+      ]),
+      UnnamedNode.new(:children => [
+        NamedNode.new(:n => "b1")
+      ])
+    ])
+
+    qnp = RGen::Serializer::QualifiedNameProvider.new(:attribute_name => "n")
+
+    assert_equal "/root", qnp.identifier(root)
+    assert_equal "/root/a", qnp.identifier(root.children[0])
+    assert_equal "/root/a/a1", qnp.identifier(root.children[0].children[0])
+    assert_equal "/root", qnp.identifier(root.children[1])
+    assert_equal "/root/b1", qnp.identifier(root.children[1].children[0])
+  end
+
+  def test_unnamed_root
+    root = UnnamedNode.new
+
+    qnp = RGen::Serializer::QualifiedNameProvider.new(:attribute_name => "n")
+
+    assert_equal "/", qnp.identifier(root)
+  end
+
+end
+

data/test/rgen_test.rb

@@ -22,4 +22,5 @@ require 'metamodel_order_test'
 require 'metamodel_from_ecore_test'
 require 'util_test'
 require 'model_fragment_test'
+require 'qualified_name_provider_test'