rgen 0.2.0

data/lib/uml/objectmodel_instantiator.rb

@@ -0,0 +1,53 @@
+module ObjectmodelInstantiator
+
+	def instantiateObjectModel(env_in, env_out, metamodel)
+		objectMap = {}
+		env_in.find(:class => UMLObjectModel::UMLObject).each do |o_in|
+			o_out = env_out.new metamodel.const_get(o_in.classname)
+			objectMap[o_in] = o_out
+			o_out.name = o_in.name
+			o_in.attributeSettings.each { |as|
+				conversions = ["to_s", "to_i", "to_f"]
+				conv = conversions.first
+				begin
+					o_out.send(as.name+"=",as.value.send(conv))
+				rescue StandardError
+					conv = conversions[conversions.index(conv)+1]
+					retry if conv
+					raise
+				end
+			}
+		end
+		env_in.find(:class => UMLObjectModel::UMLAssociation).each do |a_in|
+			begin
+				if a_in.roleA
+					begin
+						o_out = objectMap[a_in.objectB]
+						es = o_out.send(a_in.roleA)
+					rescue NoMethodError
+						raise StandardError.new("In #{o_out.class.name}(#{o_out.name}): method not found #{a_in.roleA}")
+					end
+					if es.is_a? RGen::MetamodelBuilder::ElementSet
+						es << objectMap[a_in.objectA]
+					else
+						objectMap[a_in.objectB].send(a_in.roleA+"=", objectMap[a_in.objectA])
+					end
+				elsif a_in.roleB
+					begin
+						o_out = objectMap[a_in.objectA]
+						es = o_out.send(a_in.roleB)
+					rescue NoMethodError
+						raise StandardError.new("In #{o_out.class.name}(#{o_out.name}): method not found #{a_in.roleB}")
+					end
+					if es.is_a? RGen::MetamodelBuilder::ElementSet
+						es << objectMap[a_in.objectB]
+					else
+						objectMap[a_in.objectA].send(a_in.roleB+"=", objectMap[a_in.objectB])
+					end
+				end
+			rescue StandardError => e
+				puts e.message
+			end
+		end
+	end
+end

data/lib/uml/uml_classmodel.rb

@@ -0,0 +1,92 @@
+require 'rgen/metamodel_builder'
+
+module UMLClassModel
+
+include RGen::MetamodelBuilder
+
+class UMLPackage < MMBase
+	has_one 'name', String
+	def allClasses
+		subpackages.inject(classes) {|r,p| r.concat(p.allClasses) }
+	end
+end
+
+class UMLClass < MMBase
+	has_one 'name', String
+	has_many 'stereotypes', String
+	def remoteNavigableEnds
+		assocEnds.otherEnd.select{|e| e.navigable}
+	end
+	def localNavigableEnds
+		assocEnds.select{|e| e.navigable}
+	end
+	def localCompositeEnds
+		assocEnds.select{|e| e.composite}
+	end
+	def remoteCompositeEnds
+		assocEnds.otherEnd.select{|e| e.composite}
+		# put constraint check here and return the container directly ?
+	end
+end
+
+class UMLOperation < MMBase
+	has_one 'name', String
+end
+
+class UMLAttribute < MMBase
+	has_one 'name', String
+	has_one 'type', String
+end
+
+class UMLTaggedValue < MMBase
+	has_one 'tag'
+	has_one 'value'
+end
+
+class UMLAssociation < MMBase
+end
+
+class UMLAggregation < UMLAssociation
+end	
+
+class UMLAssociationEnd < MMBase
+	has_one 'multiplicity', String
+	has_one 'navigable' # boolean
+	has_one 'composite' # boolean
+	has_one 'role', String
+	def assoc
+		assocA || assocB
+	end
+	def otherEnd
+		return unless assoc
+		assoc.endA == self ? assoc.endB : assoc.endA		
+	end
+	def lowerMult
+		return unless multiplicity
+		stringToMult(multiplicity.split("..")[0])
+	end
+	def upperMult
+		return unless multiplicity
+		ma = multiplicity.split("..")
+		stringToMult(ma[1] || ma[0])
+	end
+	private
+	def stringToMult(s)
+		return :many if s == "*"
+		return s.to_i
+	end
+end
+
+UMLPackage.one_to_many 'subpackages', UMLPackage, 'superpackage'
+UMLPackage.one_to_many 'classes', UMLClass, 'package'
+
+UMLClass.many_to_many 'superclasses', UMLClass, 'subclasses'
+UMLClass.one_to_many 'assocEnds', UMLAssociationEnd, 'clazz'
+UMLClass.one_to_many 'attributes', UMLAttribute, 'clazz'
+UMLClass.one_to_many 'operations', UMLOperation, 'clazz'
+UMLClass.one_to_many 'taggedvalues', UMLTaggedValue, 'clazz'
+
+UMLAssociation.one_to_one 'endA', UMLAssociationEnd, 'assocA'
+UMLAssociation.one_to_one 'endB', UMLAssociationEnd, 'assocB'
+
+end

data/lib/uml/uml_objectmodel.rb

@@ -0,0 +1,65 @@
+require 'rgen/metamodel_builder'
+
+module UMLObjectModel
+
+include RGen::MetamodelBuilder
+
+class UMLPackage < MMBase
+	has_one 'name', String
+	def allObjects
+		subpackages.inject(objects) {|r,p| r.concat(p.allObjects) }
+	end
+end
+
+class UMLObject < MMBase
+	has_one 'name', String
+	has_one 'classname', String
+	def remoteNavigableEnds
+		assocEnds.otherEnd.select{|e| e.navigable}
+	end
+	def localNavigableEnds
+		assocEnds.select{|e| e.navigable}
+	end
+	def localCompositeEnds
+		assocEnds.select{|e| e.composite}
+	end
+	def remoteCompositeEnds
+		assocEnds.otherEnd.select{|e| e.composite}
+		# put constraint check here and return the container directly ?
+	end
+end
+
+class UMLAttributeSetting < MMBase
+	has_one 'name', String
+	has_one 'value', String
+end
+
+class UMLAssociation < MMBase
+end
+
+class UMLAggregation < UMLAssociation
+end	
+
+class UMLAssociationEnd < MMBase
+	has_one 'navigable' # boolean
+	has_one 'composite' # boolean
+	has_one 'role', String
+	def assoc
+		assocA || assocB
+	end
+	def otherEnd
+		return unless assoc
+		assoc.endA == self ? assoc.endB : assoc.endA		
+	end
+end
+
+UMLPackage.one_to_many 'subpackages', UMLPackage, 'superpackage'
+UMLPackage.one_to_many 'objects', UMLObject, 'package'
+
+UMLObject.one_to_many 'assocEnds', UMLAssociationEnd, 'object'
+UMLObject.one_to_many 'attributeSettings', UMLAttributeSetting, 'object'
+
+UMLAssociation.one_to_one 'endA', UMLAssociationEnd, 'assocA'
+UMLAssociation.one_to_one 'endB', UMLAssociationEnd, 'assocB'
+
+end

data/test/array_extensions_test.rb

@@ -0,0 +1,54 @@
+$:.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_one 'name'
+		has_one 'age'
+	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
+	
+end

data/test/environment_test.rb

@@ -0,0 +1,47 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/environment'
+
+class EnvironmentTest < Test::Unit::TestCase
+
+	class Model
+		attr_accessor :name
+	end
+	
+	class ModelSub < Model
+	end
+
+	def test_find
+		m1 = Model.new
+		m1.name = "M1"
+		m2 = ModelSub.new
+		m2.name = "M2"
+		m3 = "justAString"
+		env_in = RGen::Environment.new << m1 << m2 << m3
+
+		result = env_in.find(:class => Model, :name => "M1")
+		assert result.is_a?(Array)
+		assert_equal 1, result.size
+		assert_equal m1, result.first
+
+		result = env_in.find(:class => Model)
+		assert result.is_a?(Array)
+		assert_equal 2, result.size
+		assert_equal m1, result[0]
+		assert_equal m2, result[1]
+		
+		result = env_in.find(:name => "M2")
+		assert result.is_a?(Array)
+		assert_equal 1, result.size
+		assert_equal m2, result[0]		
+		
+		result = env_in.find(:class => [Model, String])
+		assert result.is_a?(Array)
+		assert_equal 3, result.size
+		assert_equal m1, result[0]
+		assert_equal m2, result[1]
+		assert_equal m3, result[2]
+	end
+	
+end

data/test/metamodel_builder_test.rb

@@ -0,0 +1,175 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/metamodel_builder'
+
+class MetamodelBuilderTest < Test::Unit::TestCase
+
+	class HasOneTestClass < RGen::MetamodelBuilder::MMBase
+		has_one 'name'
+		has_one 'an_array', Array
+	end
+	
+	def test_has_one
+		sc = HasOneTestClass.new
+		assert_respond_to sc, :name
+		assert_respond_to sc, :name=
+		sc.name = 'SomeName'
+		assert_equal 'SomeName', sc.name
+		sc.name = nil
+		assert_equal nil, sc.name
+
+		assert_respond_to sc, :an_array
+		assert_respond_to sc, :an_array=
+		aa = Array.new
+		sc.an_array = aa
+		assert_equal aa, sc.an_array
+		
+		assert_raise StandardError do
+			sc.an_array = "a string"
+		end
+	end
+	
+	class HasManyTestClass < RGen::MetamodelBuilder::MMBase
+		has_many 'string', String
+	end
+	
+	def test_has_many
+		o = HasManyTestClass.new
+		o.addString("s1")
+		o.addString("s2")
+		assert_equal ["s1","s2"], o.string
+		# make sure we get a copy
+		o.string.clear
+		assert_equal ["s1","s2"], o.string
+		o.removeString("s3")
+		assert_equal ["s1","s2"], o.string
+		o.removeString("s2")
+		assert_equal ["s1"], o.string
+		assert_raise StandardError do
+			o.addString(:notastring)
+		end
+	end
+
+	class OneClass < RGen::MetamodelBuilder::MMBase
+	end
+	class ManyClass < RGen::MetamodelBuilder::MMBase
+	end
+	OneClass.one_to_many 'manyClasses', ManyClass, 'oneClass'
+	
+	def test_one_to_many
+		oc = OneClass.new
+		assert_respond_to oc, :manyClasses
+		assert oc.manyClasses.empty?
+		
+		mc = ManyClass.new
+		assert_respond_to mc, :oneClass
+		assert_respond_to mc, :oneClass=
+		assert_nil mc.oneClass
+		
+		# put the OneClass into the ManyClass
+		mc.oneClass = oc
+		assert_equal oc, mc.oneClass
+		assert oc.manyClasses.include?(mc)
+		
+		# remove the OneClass from the ManyClass
+		mc.oneClass = nil
+		assert_equal nil, mc.oneClass
+		assert !oc.manyClasses.include?(mc)
+
+		# put the ManyClass into the OneClass
+		oc.addManyClasses mc
+		assert oc.manyClasses.include?(mc)
+		assert_equal oc, mc.oneClass
+		
+		# remove the ManyClass from the OneClass
+		oc.removeManyClasses mc
+		assert !oc.manyClasses.include?(mc)
+		assert_equal nil, mc.oneClass
+	end
+
+	class AClassOO < RGen::MetamodelBuilder::MMBase
+	end
+	class BClassOO < RGen::MetamodelBuilder::MMBase
+	end
+	AClassOO.one_to_one 'bClass', BClassOO, 'aClass'
+
+	def test_one_to_one
+		ac = AClassOO.new
+		assert_respond_to ac, :bClass
+		assert_respond_to ac, :bClass=
+		assert_nil ac.bClass
+		
+		bc = BClassOO.new
+		assert_respond_to bc, :aClass
+		assert_respond_to bc, :aClass=
+		assert_nil bc.aClass
+		
+		# put the AClass into the BClass
+		bc.aClass = ac
+		assert_equal ac, bc.aClass
+		assert_equal bc, ac.bClass
+		
+		# remove the AClass from the BClass
+		bc.aClass = nil
+		assert_equal nil, bc.aClass
+		assert_equal nil, ac.bClass
+
+		# put the BClass into the AClass
+		ac.bClass = bc
+		assert_equal bc, ac.bClass
+		assert_equal ac, bc.aClass
+		
+		# remove the BClass from the AClass
+		ac.bClass = nil
+		assert_equal nil, ac.bClass
+		assert_equal nil, bc.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
+		assert_respond_to ac, :bClasses
+		assert ac.bClasses.empty?
+
+		bc = BClassMM.new
+		assert_respond_to bc, :aClasses
+		assert bc.aClasses.empty?
+		
+		# put the AClass into the BClass
+		bc.addAClasses ac
+		assert bc.aClasses.include?(ac)
+		assert ac.bClasses.include?(bc)
+		
+		# put something else into the BClass
+		assert_raise StandardError do
+			bc.addAClasses :notaaclass
+		end
+		
+		# remove the AClass from the BClass
+		bc.removeAClasses ac
+		assert !bc.aClasses.include?(ac)
+		assert !ac.bClasses.include?(bc)
+
+		# put the BClass into the AClass
+		ac.addBClasses bc
+		assert ac.bClasses.include?(bc)
+		assert bc.aClasses.include?(ac)
+		
+		# put something else into the AClass
+		assert_raise StandardError do
+			ac.addBClasses :notabclass
+		end
+		
+		# remove the BClass from the AClass
+		ac.removeBClasses bc
+		assert !ac.bClasses.include?(bc)
+		assert !bc.aClasses.include?(ac)
+	end
+end