rgen 0.2.0

data/test/metamodel_generator_test.rb

@@ -0,0 +1,45 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'ea/xmi_class_instantiator'
+require 'mmgen/metamodel_generator'
+
+class MetamodelGeneratorTest < Test::Unit::TestCase
+
+	MODEL_DIR = File.join(File.dirname(__FILE__),"xmi_instantiator_test")
+	OUTPUT_DIR = File.dirname(__FILE__)+"/metamodel_generator_test"
+	MM_FILE = OUTPUT_DIR+"/TestModel.rb"
+	
+	include XMIClassInstantiator
+	include MMGen::MetamodelGenerator
+		
+	def test_generator
+		envUML = RGen::Environment.new
+		File.open(MODEL_DIR+"/testmodel.xml") { |f|
+			instantiateUMLClassModel(envUML, f.read)
+		}
+
+		rootPackage = envUML.find(:class => UMLClassModel::UMLPackage).select{|p| p.name == "HouseMetamodel"}.first
+		assert_not_nil rootPackage
+		
+		assert_raise StandardError do
+			# this will raise an exception because multiple inheritance is not resolved
+			generateMetamodel(rootPackage, MM_FILE)
+		end
+		
+		# resolve multiple inheritance by specifying which class should be a module
+		modules = ['MeetingPlace']
+		generateMetamodel(rootPackage, MM_FILE, modules)
+		
+		# try to use the generated metamodel
+		File.open(MM_FILE) { |f|
+			eval(f.read)
+		}
+		assert HouseMetamodel::House.new
+
+		result = expected = ""
+		File.open(MM_FILE) {|f| result = f.read}
+		File.open(OUTPUT_DIR+"/expected_result.txt") {|f| expected = f.read}
+		assert_equal expected, result
+	end
+end

data/test/metamodel_generator_test/TestModel.rb

@@ -0,0 +1,40 @@
+require 'rgen/metamodel_builder'
+module HouseMetamodel
+
+   class Person < RGen::MetamodelBuilder::MMBase
+      has_one 'name', String
+   end
+
+   class House < RGen::MetamodelBuilder::MMBase
+      has_one 'name', String
+      has_one 'address', String
+   end
+
+   module MeetingPlace
+      extend RGen::MetamodelBuilder::BuilderExtensions
+      has_one 'name', String
+   end
+
+
+   module Rooms
+
+      class Room < RGen::MetamodelBuilder::MMBase
+         has_one 'name', String
+      end
+
+      class Bathroom < Room
+         has_one 'name', String
+      end
+
+      class Kitchen < Room
+         include MeetingPlace
+         has_one 'name', String
+      end
+
+   end
+end
+
+HouseMetamodel::Person.one_to_many 'home', HouseMetamodel::House, 'person'
+HouseMetamodel::House.one_to_one 'bathroom', HouseMetamodel::Rooms::Bathroom, 'house'
+HouseMetamodel::Rooms::Kitchen.one_to_one 'house', HouseMetamodel::House, 'kitchen'
+HouseMetamodel::House.one_to_many 'room', HouseMetamodel::Rooms::Room, 'house'

data/test/metamodel_generator_test/expected_result.txt

@@ -0,0 +1,40 @@
+require 'rgen/metamodel_builder'
+module HouseMetamodel
+
+   class Person < RGen::MetamodelBuilder::MMBase
+      has_one 'name', String
+   end
+
+   class House < RGen::MetamodelBuilder::MMBase
+      has_one 'name', String
+      has_one 'address', String
+   end
+
+   module MeetingPlace
+      extend RGen::MetamodelBuilder::BuilderExtensions
+      has_one 'name', String
+   end
+
+
+   module Rooms
+
+      class Room < RGen::MetamodelBuilder::MMBase
+         has_one 'name', String
+      end
+
+      class Bathroom < Room
+         has_one 'name', String
+      end
+
+      class Kitchen < Room
+         include MeetingPlace
+         has_one 'name', String
+      end
+
+   end
+end
+
+HouseMetamodel::Person.one_to_many 'home', HouseMetamodel::House, 'person'
+HouseMetamodel::House.one_to_one 'bathroom', HouseMetamodel::Rooms::Bathroom, 'house'
+HouseMetamodel::Rooms::Kitchen.one_to_one 'house', HouseMetamodel::House, 'kitchen'
+HouseMetamodel::House.one_to_many 'room', HouseMetamodel::Rooms::Room, 'house'

data/test/output_handler_test.rb

@@ -0,0 +1,40 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/template_language/output_handler'
+
+class MetamodelBuilderTest < Test::Unit::TestCase
+	def test_direct_nl
+		h = RGen::TemplateLanguage::OutputHandler.new
+		h.mode = :direct
+		h << "Test"
+		h.ignoreNextNL
+		h << "\nContent"
+		assert_equal "TestContent", h.to_s
+	end
+	def test_direct_ws
+		h = RGen::TemplateLanguage::OutputHandler.new
+		h.mode = :direct
+		h << "Test"
+		h.ignoreNextWS
+		h << " \n       Content"
+		assert_equal "TestContent", h.to_s
+	end
+	def test_explicit_indent
+		h = RGen::TemplateLanguage::OutputHandler.new
+		h.mode = :explicit
+		h.indent = 1
+		h << "Start"
+		h << "   \n "
+		h << "Test"
+		h << "      \n   \n    Content"
+		assert_equal "   Start\n   Test\n   Content", h.to_s
+	end
+	def test_explicit_endswithws
+		h = RGen::TemplateLanguage::OutputHandler.new
+		h.mode = :explicit
+		h.indent = 1
+		h << "Start   \n\n"
+		assert_equal "   Start\n", h.to_s
+	end
+end

data/test/rgen_test.rb

@@ -0,0 +1,13 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'test/unit'
+
+require 'array_extensions_test'
+require 'environment_test'
+require 'metamodel_builder_test'
+require 'output_handler_test'
+require 'template_language_test'
+require 'xmi_class_instantiator_test'
+require 'xmi_object_instantiator_test'
+require 'metamodel_generator_test'
+require 'transformer_test'

data/test/template_language_test.rb

@@ -0,0 +1,46 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/template_language'
+
+class TemplateContainerTest < Test::Unit::TestCase
+
+	TEMPLATES_DIR = File.dirname(__FILE__)+"/template_language_test/templates"
+	OUTPUT_DIR = File.dirname(__FILE__)+"/template_language_test"
+	
+	module MyMM
+	
+	class Chapter
+		attr_reader :title
+		def initialize(title)
+			@title = title
+		end
+	end
+
+	class Document
+		attr_reader :title, :author, :chapters
+		def initialize(title, author)
+			@title, @author = title, author
+			@chapters = []
+		end
+	end
+	
+	end
+	
+	TEST_MODEL = MyMM::Document.new("SomeDocument","MyName")
+	TEST_MODEL.chapters << MyMM::Chapter.new("Intro")
+	TEST_MODEL.chapters << MyMM::Chapter.new("MainPart")
+	TEST_MODEL.chapters << MyMM::Chapter.new("Summary")
+	
+	def test_with_model
+		tc = RGen::TemplateLanguage::DirectoryTemplateContainer.new(MyMM, OUTPUT_DIR)
+		tc.load(TEMPLATES_DIR)
+		File.delete(OUTPUT_DIR+"/testout.txt") if File.exists? OUTPUT_DIR+"/testout.txt"
+		tc.expand('root::Root', :for => TEST_MODEL, :indent => 1)
+		result = expected = ""
+		File.open(OUTPUT_DIR+"/testout.txt") {|f| result = f.read}
+		File.open(OUTPUT_DIR+"/expected_result.txt") {|f| expected = f.read}
+		assert_equal expected, result
+	end
+	
+end

data/test/template_language_test/expected_result.txt

@@ -0,0 +1,10 @@
+   Document: SomeDocument
+   Index:
+      1 Intro in SomeDocument
+      2 MainPart in SomeDocument
+      3 Summary in SomeDocument
+   by MyName
+   ----------------
+   *** Intro ***
+   *** MainPart ***
+   *** Summary ***

data/test/template_language_test/templates/content/chapter.tpl

@@ -0,0 +1,5 @@
+<% define 'Root', :for => Chapter do %>
+ *** <%= title %> ***
+ 
+
+<% end %>

data/test/template_language_test/templates/index/c/cmod.tpl

@@ -0,0 +1 @@
+<% define 'cmod' do %>Module C is special !<% end %>

data/test/template_language_test/templates/index/chapter.tpl

@@ -0,0 +1,3 @@
+<% define 'Root' do |idx, doc| %>
+	<%= idx%> <%= title %> in <%= doc.title %>
+<% end %>

data/test/template_language_test/templates/root.tpl

@@ -0,0 +1,22 @@
+<% define 'Root' do %>
+	<% file 'testout.txt' do %>
+		Document: <%= title %>
+	
+		Index:<%iinc%>
+		<% for c in chapters %>
+			<% nr = (nr || 0); nr += 1 %>
+			<% expand 'index/chapter::Root', nr, this, :for => c %>
+		<% end %><%idec%>
+	
+		by <%= author %>
+		
+		----------------
+	
+		<% expand 'content/chapter::Root', :foreach => chapters %>
+	
+	<% end %>
+<% end %>
+
+<% def MyNewMethod(arg1, arg2, arg3) %>
+<% end %>
+

data/test/template_language_test/testout.txt

@@ -0,0 +1,10 @@
+   Document: SomeDocument
+   Index:
+      1 Intro in SomeDocument
+      2 MainPart in SomeDocument
+      3 Summary in SomeDocument
+   by MyName
+   ----------------
+   *** Intro ***
+   *** MainPart ***
+   *** Summary ***

data/test/transformer_test.rb

@@ -0,0 +1,176 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/transformer'
+require 'rgen/environment'
+
+class TransformerTest < Test::Unit::TestCase
+
+	class ModelIn
+		attr_accessor :name
+	end
+	
+	class ModelAIn
+		attr_accessor :name
+		attr_accessor :modelB
+	end
+
+	class ModelBIn
+		attr_accessor :name
+		attr_accessor :modelA
+	end
+
+	class ModelCIn
+		attr_accessor :number
+	end
+	
+	class ModelOut
+		attr_accessor :name
+	end
+	
+	class ModelAOut
+		attr_accessor :name
+		attr_accessor :modelB
+	end
+	
+	class ModelBOut
+		attr_accessor :name
+		attr_accessor :modelA
+	end
+	
+	class ModelCOut
+		attr_accessor :number
+	end
+	
+	class MyTransformer < RGen::Transformer
+		attr_reader :modelInTrans_count
+		attr_reader :modelAInTrans_count
+		attr_reader :modelBInTrans_count
+		
+		transform ModelIn, :to => ModelOut do
+			# aribitrary ruby code may be placed before the hash creating the output element
+			@modelInTrans_count ||= 0; @modelInTrans_count += 1
+			{ :name => name }
+		end
+		
+		transform ModelAIn, :to => ModelAOut do
+			@modelAInTrans_count ||= 0; @modelAInTrans_count += 1
+			{ :name => name, :modelB => trans(modelB) }
+		end
+		
+		transform ModelBIn, :to => ModelBOut do
+			@modelBInTrans_count ||= 0; @modelBInTrans_count += 1
+			{ :name => name, :modelA => trans(modelA) }
+		end
+		
+		transform ModelCIn, :to => ModelCOut, :if => :largeNumber do
+			# a method can be called anywhere in a transformer block
+			{ :number => duplicateNumber }
+		end
+
+		transform ModelCIn, :to => ModelCOut, :if => :smallNumber do
+			{ :number => number / 2 }
+		end
+		
+		method :largeNumber do
+			number > 1000
+		end
+		
+		method :smallNumber do
+			number < 500
+		end
+		
+		method :duplicateNumber do
+			number * 2;
+		end
+		
+	end
+	
+	class MyTransformer2 < RGen::Transformer
+		# check that subclasses are independent (i.e. do not share the rules)
+		transform ModelIn, :to => ModelOut do
+			{ :name => name }
+		end
+	end	
+	
+	def test_transformer
+		from = ModelIn.new
+		from.name = "TestName"
+		env_out = RGen::Environment.new
+		t = MyTransformer.new(:env_in, env_out)
+		assert t.trans(from).is_a?(ModelOut)
+		assert_equal "TestName", t.trans(from).name
+		assert_equal 1, env_out.elements.size
+		assert_equal env_out.elements.first, t.trans(from)
+		assert_equal 1, t.modelInTrans_count
+	end
+	
+	def test_transformer_array
+		froms = [ModelIn.new, ModelIn.new]
+		froms[0].name = "M1"
+		froms[1].name = "M2"
+		env_out = RGen::Environment.new
+		t = MyTransformer.new(:env_in, env_out)
+		assert t.trans(froms).is_a?(Array)
+		assert t.trans(froms)[0].is_a?(ModelOut)
+		assert_equal "M1", t.trans(froms)[0].name
+		assert t.trans(froms)[1].is_a?(ModelOut)
+		assert_equal "M2", t.trans(froms)[1].name
+		assert_equal 2, env_out.elements.size
+		assert (t.trans(froms)-env_out.elements).empty?
+		assert_equal 2, t.modelInTrans_count
+	end
+	
+	def test_transformer_cyclic
+		# setup a cyclic dependency between fromA and fromB
+		fromA = ModelAIn.new
+		fromB = ModelBIn.new
+		fromA.modelB = fromB
+		fromA.name = "ModelA"
+		fromB.modelA = fromA
+		fromB.name = "ModelB"
+		env_out = RGen::Environment.new
+		t = MyTransformer.new(:env_in, env_out)
+		# check that trans resolves the cycle correctly (no endless loop)
+		# both elements, fromA and fromB will be transformed with the transformation
+		# of the first element, either fromA or fromB
+		assert t.trans(fromA).is_a?(ModelAOut)
+		assert_equal "ModelA", t.trans(fromA).name
+		assert t.trans(fromA).modelB.is_a?(ModelBOut)
+		assert_equal "ModelB", t.trans(fromA).modelB.name
+		assert_equal t.trans(fromA), t.trans(fromA).modelB.modelA
+		assert_equal t.trans(fromB), t.trans(fromA).modelB
+		assert_equal 2, env_out.elements.size
+		assert (env_out.elements - [t.trans(fromA), t.trans(fromB)]).empty?
+		assert_equal 1, t.modelAInTrans_count
+		assert_equal 1, t.modelBInTrans_count
+	end
+	
+	def test_transformer_conditional
+		froms = [ModelCIn.new, ModelCIn.new, ModelCIn.new]
+		froms[0].number = 100
+		froms[1].number = 1000
+		froms[2].number = 2000
+
+		env_out = RGen::Environment.new
+		t = MyTransformer.new(:env_in, env_out)
+
+		assert t.trans(froms).is_a?(Array)
+		assert_equal 2, t.trans(froms).size
+		
+		# this one matched the smallNumber rule
+		assert t.trans(froms[0]).is_a?(ModelCOut)
+		assert_equal 50, t.trans(froms[0]).number
+		
+		# this one did not match any rule
+		assert t.trans(froms[1]).nil?
+
+		# this one matched the largeNumber rule
+		assert t.trans(froms[2]).is_a?(ModelCOut)
+		assert_equal 4000, t.trans(froms[2]).number
+		
+		# elements in environment are the same as the ones returned
+		assert_equal 2, env_out.elements.size
+		assert (t.trans(froms)-env_out.elements).empty?
+	end
+end