rgen 0.2.0

data/lib/mmgen/mmgen.rb

@@ -0,0 +1,21 @@
+require 'ea/xmi_instantiator'
+require 'mmgen/metamodel_generator'
+
+include XMIClassInstantiator
+include MMGen::MetamodelGenerator
+
+unless ARGV.length == 1
+	puts "Usage: mmgen.rb <xmi_class_model_file>"
+	exit
+else
+	file_name = ARGV.shift
+	out_file = file_name.gsub(/\.\w+$/,'')
+	puts out_file
+end
+
+envUML = RGen::Environment.new
+File.open(file_name) { |f|
+	instantiateUMLClassModel(envUML, f.read)
+}
+
+generateMetamodel(envUML, out_file)

data/lib/mmgen/templates/uml_classmodel.tpl

@@ -0,0 +1,63 @@
+
+<% define 'GenerateClassModel', :for => UMLPackage do |filename, modules| %>
+	<% file filename do %>
+		require 'rgen/metamodel_builder'
+		
+		<% expand 'GeneratePackage', modules %>
+		<%nl%>
+		<% expand 'GenerateAssocs' %>
+	<% end %>
+<% end %>
+		
+<% define 'GeneratePackage', :for => UMLPackage do |modules| %>
+	module <%= moduleName %><% iinc %>
+		<% for c in sortedClasses %><%nl%>
+			<% expand 'ModuleHeader', modules, :for => c %><%iinc%>
+				<% (c.superclasses.name & modules).each do |n| %>
+					include <%= n %>
+				<% end %>
+				<% if modules.include?(c.className) %>
+					extend RGen::MetamodelBuilder::BuilderExtensions
+				<% end %>
+				has_one 'name', String
+				<% for a in c.attributes %>
+					has_one '<%= a.name %>', <%= a.RubyType %>
+				<% end %><%idec%>
+			end
+		<% end %><%nl%>
+		<% for p in subpackages %>
+			<%nl%><% expand 'GeneratePackage', modules, :for => p %>
+		<% end %><%idec%>
+	end
+<% end %>
+
+<% define 'GenerateAssocs', :for => UMLPackage do %>
+	<% for a in allClasses.assocEnds>>:assoc %>
+		<% if a.endA.one? %>
+			<% if a.endB.one? %>
+				<%= a.endA.clazz.qualifiedName(this) %>.one_to_one '<%= a.endB.MName %>', <%= a.endB.clazz.qualifiedName(this) %>, '<%= a.endA.MName %>'
+			<% elsif a.endB.many? %>
+				<%= a.endA.clazz.qualifiedName(this) %>.one_to_many '<%= a.endB.MName %>', <%= a.endB.clazz.qualifiedName(this) %>, '<%= a.endA.MName %>'
+			<% end %>
+		<% elsif a.endA.many? %>
+			<% if a.endB.one? %>
+				<%= a.endB.clazz.qualifiedName(this) %>.one_to_many '<%= a.endA.MName %>', <%= a.endA.clazz.qualifiedName(this) %>, '<%= a.endB.MName %>'
+			<% elsif a.endB.many? %>
+				<%= a.endB.clazz.qualifiedName(this) %>.many_to_many '<%= a.endA.MName %>', <%= a.endA.clazz.qualifiedName(this) %>, '<%= a.endB.MName %>'
+			<% end %>
+		<% end %>
+	<% end %>
+<% end %>
+
+<% define 'ModuleHeader' do |modules| %>
+	<% if modules.include?(name) %>
+		module <%= className %>
+	<% else %>
+		class <%= className %> < <% nows %>
+		<% if rsc=RubySuperclass(modules) %><% nows %>
+			<%= rsc.className %>
+		<% else %><% nows %>
+			RGen::MetamodelBuilder::MMBase
+		<% end %>
+	<% end %>
+<% end %>

data/lib/rgen/array_extensions.rb

@@ -0,0 +1,23 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+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}
+		compact.inject([]) { |r,e|
+			if e.is_a? RGen::MetamodelBuilder::MMBase				
+				r | ( (o=e.send(m)).is_a?(Array) ? o : [o] ) 
+			else
+				raise StandardError.new("Trying to call a method on an array element not a RGen MMBase")
+			end
+		}.compact
+	end
+
+end

data/lib/rgen/auto_class_creator.rb

@@ -0,0 +1,56 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'rgen/metamodel_builder'
+
+module RGen
+
+class Base
+	extend MetamodelBuilder
+	def initialize(env=nil)
+		env << self if env
+	end
+end
+
+class AutoCreatedClass < Base
+	def method_missing(m,*args)
+		return super unless self.class.parent.accEnabled
+		if m.to_s =~ /(.*)=$/ 
+			self.class.has_one($1)
+			send(m,args[0])
+		elsif args.size == 0
+			self.class.has_many(m)
+			send(m)
+		end
+	end
+end
+
+# will be "extended" to the auto created class
+module ParentAccess
+	def parent=(p)
+		@parent = p
+	end
+	def parent
+		@parent
+	end
+end
+
+module AutoClassCreator
+	attr_reader :accEnabled
+	def const_missing(className)
+		return super unless @accEnabled
+		module_eval("class "+className.to_s+" < RGen::AutoCreatedClass; end")
+		c = const_get(className)
+		c.extend(ParentAccess)
+		c.parent = self
+		c
+	end
+	def enableACC
+		@accEnabled = true
+	end
+	def disableACC
+		@accEnabled = false
+	end
+end
+
+end

data/lib/rgen/environment.rb

@@ -0,0 +1,57 @@
+module RGen
+
+# An Environment is used to hold model elements.
+#
+class Environment
+
+	def initialize
+		@elements = []
+	end
+	
+	# Add a model element. Returns the environment so <code><<</code> can be chained.
+	# 
+	def <<(el)
+		@elements << el
+		self
+	end
+	
+	# Finds and returns model elements in the environment.
+	# 
+	# The search description argument must be a hash specifying attribute/value pairs.
+	# Only model elements are returned which respond to the specified attribute methods
+	# and return the specified values as result of these attribute methods.
+	# 
+	# As a special hash key :class can be used to look for model elements of a specific
+	# class. In this case an array of possible classes can optionally be given.
+	# 
+	def find(desc)
+		result = []
+		classes = desc[:class] if desc[:class] and desc[:class].is_a?(Array)
+		classes = [ desc[:class] ] if !classes and desc[:class]
+		elements.each {|e|
+			failed = false
+			failed = true if classes and !classes.any?{ |c| e.is_a?(c) }
+			desc.each_pair { |k,v|
+				failed = true if k != :class and ( !e.respond_to?(k) or e.send(k) != v )
+			}
+			result << e unless failed
+		}
+		result
+	end
+	
+	# Return the elements of the environment as an array
+	#
+	def elements
+		@elements.dup
+	end
+	
+	# This method can be used to instantiate a class and automatically put it into
+	# the environment. The new instance is returned.
+	#
+	def new(clazz)
+		@elements << clazz.new
+		@elements[-1]
+	end
+end
+	
+end

data/lib/rgen/metamodel_builder.rb

@@ -0,0 +1,102 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'rgen/metamodel_builder/builder_runtime'
+require 'rgen/metamodel_builder/builder_extensions'
+
+module RGen
+
+# MetamodelBuilder can be used to create a metamodel, i.e. Ruby classes which
+# act as metamodel elements.
+# 
+# To create a new metamodel element, create a Ruby class which inherits from
+# MetamodelBuilder::MMBase
+# 
+# 	class Person < RGen::MetamodelBuilder::MMBase
+# 	end
+# 
+# This way a couple of class methods are made available to the new class.
+# These methods can be used to:
+# * add attributes to the class
+# * add associations with other classes
+# 
+# Here is an example:
+# 
+# 	class Person < RGen::MetamodelBuilder::MMBase
+# 		has_one 'name', String
+# 		has_one 'age', Integer
+# 	end
+# 
+# 	class House < RGen::MetamodelBuilder::MMBase
+# 		has_one 'address'
+# 	end
+# 
+# 	Person.many_to_many 'homes', House, 'inhabitants'
+# 
+# See BuilderExtensions for details about the available class methods.
+# 
+# =Attributes
+# 
+# The example above creates two classes 'Person' and 'House'. Person has the attributes
+# 'name' and 'age', House has the attribute 'address'. The attributes can be 
+# accessed on instances of the classes in the following way:
+# 
+# 	p = Person.new
+# 	p.name = "MyName"
+# 	p.age = 22
+# 	p.name	# => "MyName"
+# 	p.age 	# => 22
+# 
+# Note that the class Person takes care of the type of its attributes. As 
+# declared above, a 'name' can only be a String, an 'age' must be an Integer.
+# So the following would return an exception:
+# 
+# 	p.name = :myName	# => exception: can not put a Symbol where a String is expected
+# 
+# If the type of an attribute should be left undefined, just leave away the
+# second argument of 'has_one' as show at the attribute 'address' for House.
+#
+# =Associations
+# 
+# As well as attributes show up as instance methods, associations bring their own
+# accessor methods. For the Person-to-House association this would be:
+# 
+# 	h1 = House.new
+# 	h1.address = "Street1"
+# 	h2 = House.new
+# 	h2.address = "Street2"
+# 	p.addHomes(h1)
+# 	p.addHomes(h2)
+# 	p.removeHomes(h1)
+# 	p.homes	# => [ h2 ]
+# 
+# The Person-to-House association is _bidirectional_. This means that with the 
+# addition of a House to a Person, the Person is also added to the House. Thus:
+# 
+# 	h1.inhabitants	# => []
+# 	h2.inhabitants	# => [ p ]
+# 	
+# Note that the association is defined between two specific classes, instances of
+# different classes can not be added. Thus, the following would result in an 
+# exception:
+# 
+# 	p.addHomes(:justASymbol) # => exception: can not put a Symbol where a House is expected
+# 
+# _Unidirectional_ associations can be thought of as attributes as shown above. This means 
+# that 'has_one' or 'has_many' can be used to define such associations. Again, the
+# type of the attribute/association can be specified as a second argument.
+# 
+module MetamodelBuilder	
+
+	# Use this class as a start for new metamodel elements (i.e. Ruby classes)
+	# by inheriting for it.
+	# 
+	# See MetamodelBuilder for an example.
+	class MMBase
+		include BuilderRuntime
+		extend BuilderExtensions
+	end
+
+end
+
+end

data/lib/rgen/metamodel_builder/build_helper.rb

@@ -0,0 +1,29 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'rgen/name_helper'
+
+module RGen
+
+module MetamodelBuilder
+
+class BuildHelper
+	include NameHelper
+	
+	def self.build(mod,bnd,tpl)
+		mod.module_eval ERB.new(tpl).result(BuildHelper.new(bnd).bnd)
+	end
+	def initialize(bnd)
+		@outer_binding = bnd
+	end
+	def bnd
+		binding
+	end
+	def method_missing(m)
+		eval("#{m}",@outer_binding)
+	end
+end
+
+end
+
+end

data/lib/rgen/metamodel_builder/builder_extensions.rb

@@ -0,0 +1,191 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'erb'
+require 'rgen/metamodel_builder/build_helper'
+
+module RGen
+
+module MetamodelBuilder
+
+# This module provides methods which can be used to setup a metamodel element.
+# The module is used to +extend+ MetamodelBuilder::MMBase, i.e. add the module's 
+# methods as class methods.
+# 
+# MetamodelBuilder::MMBase should be used as a start for new metamodel elements.
+# See MetamodelBuilder for an example.
+# 
+module BuilderExtensions
+
+	# Add a single attribute or unidirectional association.
+	# 'role' specifies the name which is used to access the attribute.
+	# 'target_class' is optional and can be used to fix the type of objects which
+	# can be held by this attribute.
+	# 
+	# This class method adds the following instance methods, where 'role' is to be 
+	# replaced by the given role name:
+	# 	class#role	# getter
+	# 	class#role=(value)	# setter
+	# 
+	def has_one(role, target_class=nil)
+		has_one_internal(role, target_class)
+	end
+
+	# Add an unidirectional _many_ association.
+	# 'role' specifies the name which is used to access the attribute.
+	# 'target_class' is optional and can be used to fix the type of objects which
+	# can be referenced by this association.
+	# 
+	# This class method adds the following instance methods, where 'role' is to be 
+	# replaced by the given role name:
+	# 	class#addRole(value)	
+	# 	class#removeRole(value)
+	# 	class#role	# getter, returns an array
+	# Note that the first letter of the role name is turned into an uppercase 
+	# for the add and remove methods.
+	# 
+	def has_many(role, target_class=nil)
+		has_many_internal(role, target_class)
+	end
+	
+	# Add a bidirectional one-to-many association between two classes.
+	# The class this method is called on is refered to as _own_class_ in 
+	# the following.
+	# 
+	# Instances of own_class can use 'own_role' to access _many_ associated instances
+	# of type 'target_class'. Instances of 'target_class' can use 'target_role' to
+	# access _one_ associated instance of own_class.
+	# 
+	# This class method adds the following instance methods where 'ownRole' and
+	# 'targetRole' are to be replaced by the given role names:
+	# 	own_class#addOwnRole(value)
+	# 	own_class#removeOwnRole(value)
+	# 	own_class#ownRole
+	# 	target_class#targetRole
+	# 	target_class#targetRole=(value)
+	# Note that the first letter of the role name is turned into an uppercase 
+	# for the add and remove methods.
+	# 
+	# When an element is added/set on either side, this element also receives the element
+	# is is added to as a new element.
+	# 
+	def one_to_many(own_role, target_class, target_role)
+		has_many_internal(own_role,target_class,target_role,:one)
+		target_class.has_one_internal(target_role,self,own_role,:many)
+	end
+	
+	# Add a bidirectional many-to-many association between two classes.
+	# The class this method is called on is refered to as _own_class_ in 
+	# the following.
+	# 
+	# Instances of own_class can use 'own_role' to access _many_ associated instances
+	# of type 'target_class'. Instances of 'target_class' can use 'target_role' to
+	# access _many_ associated instances of own_class.
+	# 
+	# This class method adds the following instance methods where 'ownRole' and
+	# 'targetRole' are to be replaced by the given role names:
+	# 	own_class#addOwnRole(value)
+	# 	own_class#removeOwnRole(value)
+	# 	own_class#ownRole
+	# 	target_class#addTargetRole
+	# 	target_class#removeTargetRole=(value)
+	# 	target_class#targetRole
+	# Note that the first letter of the role name is turned into an uppercase 
+	# for the add and remove methods.
+	# 
+	# When an element is added on either side, this element also receives the element
+	# is is added to as a new element.
+	# 
+	def many_to_many(own_role, target_class, target_role)
+		has_many_internal(own_role,target_class,target_role,:many)
+		target_class.has_many_internal(target_role,self,own_role,:many)
+	end
+	
+	# Add a bidirectional one-to-one association between two classes.
+	# The class this method is called on is refered to as _own_class_ in 
+	# the following.
+	# 
+	# Instances of own_class can use 'own_role' to access _one_ associated instance
+	# of type 'target_class'. Instances of 'target_class' can use 'target_role' to
+	# access _one_ associated instance of own_class.
+	# 
+	# This class method adds the following instance methods where 'ownRole' and
+	# 'targetRole' are to be replaced by the given role names:
+	# 	own_class#ownRole
+	# 	own_class#ownRole=(value)
+	# 	target_class#targetRole
+	# 	target_class#targetRole=(value)
+	# 
+	# When an element is set on either side, this element also receives the element
+	# is is added to as the new element.
+	# 
+	def one_to_one(own_role, target_class, target_role)
+		has_one_internal(own_role,target_class,target_role,:one)
+		target_class.has_one_internal(target_role,self,own_role,:one)
+	end
+	
+	protected
+	
+	def has_one_internal(name, cls=nil, role=nil, kind=nil)
+		BuildHelper.build self, binding, <<-CODE
+			@@one_assocs ||= []
+			@@one_assocs << name
+			def #{name}=(val)
+				return if val == @#{name}
+				<% if cls %>
+					raise _assignmentTypeError(self,val,#{cls}) unless val.nil? or val.is_a? #{cls}
+				<% end %>
+				oldval = @#{name}
+				@#{name} = val
+				_unregister(self,oldval,"#{role}","#{kind}")
+				_register(self,val,"#{role}","#{kind}")
+			end 
+			def #{name}
+				@#{name}
+			end
+			alias get<%= firstToUpper(name) %> #{name}
+			alias set<%= firstToUpper(name) %> #{name}=
+		CODE
+	end
+	
+	def has_many_internal(name, cls=nil, role=nil, kind = nil)
+		BuildHelper.build self, binding, <<-CODE
+			@@many_assocs ||= []
+			@@many_assocs << name
+			def add<%= firstToUpper(name) %>(val)
+				@#{name} = [] unless @#{name}
+				return if val.nil? or @#{name}.include?(val) 
+				<% if cls %>
+					raise _assignmentTypeError(self,val,#{cls}) unless val.nil? or val.is_a? #{cls}
+				<% end %>
+				@#{name}.push val
+				_register(self, val, "#{role}", "#{kind}")
+			end
+			def remove<%= firstToUpper(name) %>(val)
+				@#{name} = [] unless @#{name}
+				return unless @#{name}.include?(val)
+				@#{name}.delete val
+				_unregister(self, val, "#{role}", "#{kind}")
+			end
+			def #{name}
+				( @#{name} ? @#{name}.dup : [] )
+			end
+			def #{name}=(val)
+				return if val.nil?
+				raise _assignmentTypeError(self, val, Array) unless val.is_a? Array
+				#{name}.each {|e|
+					remove<%= firstToUpper(name) %>(e)
+				}
+				val.each {|v|
+					add<%= firstToUpper(name) %>(v)
+				}
+			end
+			alias get<%= firstToUpper(name) %> #{name}
+			alias set<%= firstToUpper(name) %> #{name}=
+		CODE
+	end	
+
+end
+end
+
+end