rgen 0.2.0

data/lib/rgen/metamodel_builder/builder_runtime.rb

@@ -0,0 +1,67 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'rgen/name_helper'
+
+module RGen
+
+module MetamodelBuilder
+
+# This module is mixed into MetamodelBuilder::MMBase.
+# The methods provided by this module are used by the methods generated
+# by the class methods of MetamodelBuilder::BuilderExtensions
+module BuilderRuntime
+	include NameHelper
+	
+	def addGeneric(role, value)
+		send("add#{firstToUpper(role)}",value)
+	end
+	
+	def removeGeneric(role, value)
+		send("remove#{firstToUpper(role)}",value)
+	end
+	
+	def setGeneric(role, value)
+		send("#{role}=",value)
+	end
+
+	def getGeneric(role)
+		send("#{role}")
+	end
+
+	def _unregister(element, target, target_role, kind)
+		return unless element and target and target_role
+		if kind == 'one'
+			target.send("#{target_role}=",nil)
+		elsif kind == 'many'
+			target.send("remove#{firstToUpper(target_role)}",element)
+		end
+	end
+			
+	def _register(element, target, target_role, kind)
+		return unless element and target and target_role
+		if kind == 'one'
+			target.send("#{target_role}=",element)
+		elsif kind == 'many'
+			target.send("add#{firstToUpper(target_role)}",element)
+		end
+	end
+
+	def _assignmentTypeError(target, value, expected)
+		text = ""
+		if target
+			targetId = target.class.name
+			targetId += "(" + target.name + ")" if target.respond_to?(:name) and target.name
+			text += "In #{targetId} : "
+		end
+		valueId = value.class.name
+		valueId += "(" + value.name + ")" if value.respond_to?(:name) and value.name
+		text += "Can not put a #{valueId} where a #{expected} is expected"
+		StandardError.new(text)
+	end
+
+end
+
+end
+
+end

data/lib/rgen/name_helper.rb

@@ -0,0 +1,18 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+module RGen
+
+module NameHelper
+	def normalizeName(name)
+		name.gsub(/[\.:]/,'_')
+	end
+	def className(object)
+		object.class.name =~ /::(\w+)$/; $1
+	end
+	def firstToUpper(str)
+		str[0..0].upcase + ( str[1..-1] || "" )
+	end
+end
+
+end

data/lib/rgen/template_language.rb

@@ -0,0 +1,169 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'rgen/template_language/directory_template_container'
+require 'rgen/template_language/template_container'
+
+module RGen
+
+# The RGen template language has been designed to build complex generators.
+# It is very similar to the EXPAND language of the Java based
+# OpenArchitectureWare framework.
+# 
+# =Templates
+# 
+# The basic idea is to allow "templates" not only being template files
+# but smaller parts. Those parts can be expanded from other parts very 
+# much like Ruby methods are called from other methods.
+# Thus the term "template" refers to such a part within a "template file".
+# 
+# Template files used by the RGen template language should have a 
+# filename with the postfix ".tpl". Those files can reside within (nested)
+# template file directories.
+# 
+# As an example a template directory could look like the following:
+# 
+# 	templates/root.tpl
+# 	templates/dbaccess/dbaccess.tpl
+# 	templates/dbaccess/schema.tpl
+# 	templates/headers/generic_headers.tpl
+# 	templates/headers/specific/component.tpl
+# 
+# A template is always called for a <i>context object</i>. The context object
+# serves as the receiver of methods called within the template. Details are given
+# below.
+# 
+# 
+# =Defining Templates
+# 
+# One or more templates can be defined in a template file using the +define+
+# keyword as in the following example:
+# 
+# 	<% define 'GenerateDBAdapter', :for => DBDescription do |dbtype| %>
+# 		Content to be generated; use ERB syntax here
+# 	<% end %>
+# 
+# The template definition takes three kinds of parameters:
+# 1. The name of the template within the template file as a String or Symbol
+# 2. An optional class object describing the class of context objects for which
+#    this template is valid.
+# 3. An arbitrary number of template parameters
+# See RGen::TemplateLanguage::TemplateContainer for details about the syntax of +define+.
+# 
+# Within a template, regular ERB syntax can be used. This is
+# * <code><%</code> and <code>%></code> are used to embed Ruby code
+# * <code><%=</code> and <code>%></code> are used to embed Ruby expressions with
+#   the expression result being written to the template output
+# * <code><%#</code> and <code>%></code> are used for comments
+# All content not within these tags is written to the template output verbatim.
+# See below for details about output files and output formatting.
+# 
+# All methods which are called from within the template are sent to the context
+# object.
+#
+# 
+# =Expanding Templates
+# 
+# Templates are normally expanded from within other templates. The only
+# exception is the root template, which is expanded from the surrounding code.
+# 
+# Template names can be specified in the following ways:
+# * Non qualified name: use the template with the given name in the current template file
+# * Relative qualified name: use the template within the template file specified by the relative path
+# * Absolute qualified name: use the template within the template file specified by the absolute path
+# 
+# The +expand+ keyword is used to expand templates. 
+# 
+# Here are some examples:
+# 
+# 	<% expand 'GenerateDBAdapter', dbtype, :for => dbDesc %>
+# 
+# <i>Non qualified</i>. Must be called within the file where 'GenerateDBAdapter' is defined.
+# There is one template parameter passed in via variable +dbtype+.
+# The context object is provided in variable +dbDesc+.
+#  
+# 	<% expand 'dbaccess::ExampleSQL' %>
+# 
+# <i>Qualified with filename</i>. Must be called from a file in the same directory as 'dbaccess.tpl'
+# There are no parameters. The current context object will be used as the context 
+# object for this template expansion.
+# 
+# 	<% expand '../headers/generic_headers::CHeader', :foreach => modules %>
+# 
+# <i>Relatively qualified</i>. Must be called from a location from which the file
+# 'generic_headers.tpl' is accessible via the relative path '../headers'.
+# The template is expanded for each module in +modules+ (which has to be an Array).
+# Each element of +modules+ will be the context object in turn.
+# 
+# 	<% expand '/headers/generic_headers::CHeader', :foreach => modules %>
+# 
+# Absolutely qualified: The same behaviour as before but with an absolute path from
+# the template directory root (which in this example is 'templates', see above)
+# 
+# 
+# =Output Files and Formatting
+# 
+# Normally the generated content is to be written into one or more output files.
+# The RGen template language facilitates this by means of the +file+ keyword.
+# 
+# When the +file+ keyword is used to define a block, all output generated
+# from template code within this block will be written to the specified file.
+# This includes output generated from template expansions.
+# Thus all output from templates expanded within this block is written to
+# the same file as long as those templates do not use the +file+ keyword to 
+# define a new file context.
+# 
+# Here is an example:
+# 
+# 	<% file 'dbadapter/'+adapter.name+'.c' do %>
+# 		all content within this block will be written to the specified file
+# 	<% end %>
+# 
+# Note that the filename itself can be calculated dynamically by an arbitrary
+# Ruby expression.
+# 
+# The absolute position where the output file is created depends on the output
+# root directory passed to DirectoryTemplateContainer as described below.
+# 
+# =Setting up the Generator
+# 
+# Setting up the generator consists of 3 steps:
+# * Instantiate DirectoryTemplateContainer passing the metamodel and the output 
+#   directory to the constructor.
+# * Load the templates into the template container
+# * Expand the root template to start generation
+# 
+# Here is an example:
+#
+# 	module MyMM
+# 		# metaclasses are defined here, e.g. using RGen::MetamodelBuilder
+# 	end
+# 
+# 	OUTPUT_DIR = File.dirname(__FILE__)+"/output"
+# 	TEMPLATES_DIR = File.dirname(__FILE__)+"/templates"
+# 
+# 	tc = RGen::TemplateLanguage::DirectoryTemplateContainer.new(MyMM, OUTPUT_DIR)
+# 	tc.load(TEMPLATES_DIR)
+# 	# testModel should hold an instance of the metamodel class expected by the root template
+# 	# the following line starts generation
+# 	tc.expand('root::Root', :for => testModel, :indent => 1)
+# 
+# The metamodel is the Ruby module which contains the metaclasses.
+# This information is required for the template container in order to resolve the
+# metamodel classes used within the template file. 
+# 
+# The output path is prepended to the relative paths provided to the +file+ 
+# definitions in the template files.
+#
+# The template directory should contain template files as described above.
+#
+# Finally the generation process is started by calling +expand+ in the same way as it
+# is used from within templates.
+# 
+# Also see the unit tests for more examples.
+# 
+module TemplateLanguage
+
+end
+
+end

data/lib/rgen/template_language/directory_template_container.rb

@@ -0,0 +1,51 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'rgen/template_language/template_container'
+require 'rgen/template_language/template_helper'
+
+module RGen
+
+module TemplateLanguage
+
+class DirectoryTemplateContainer
+	include TemplateHelper
+	
+	def initialize(metamodel=nil, output_path=nil, parent=nil)
+		@containers = {}
+		@parent = parent
+		@metamodel = metamodel
+		@output_path = output_path
+	end
+	
+	def load(dir)
+		#print "Loading templates in #{dir} ...\n"
+		Dir.foreach(dir) { |f|
+			qf = dir+"/"+f
+			if !File.directory?(qf) && f =~ /^(.*)\.tpl$/
+				(@containers[$1] = TemplateContainer.dup.new(@metamodel, @output_path, self)).load(qf)
+			elsif File.directory?(qf) && f != "." && f != ".."
+				(@containers[f] = DirectoryTemplateContainer.new(@metamodel, @output_path, self)).load(qf)
+			end
+		}
+	end
+	
+	def expand(template, *all_args)
+		args, params = _splitArgsAndOptions(all_args)
+		element = params[:for]
+		if template =~ /^\// && @parent
+			@parent.expand(template, *all_args)
+		elsif template =~ /^[\/]*(\w+)[:\/]+(.*)/ 
+			throw "Template not found: #{$1}" unless @containers[$1]
+			@containers[$1].expand($2, *all_args)
+		elsif @parent
+			@parent.expand(template, *all_args)
+		else
+			throw "Template not found: #{template}"
+		end
+	end
+end
+
+end
+
+end

data/lib/rgen/template_language/output_handler.rb

@@ -0,0 +1,84 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+module RGen
+
+module TemplateLanguage
+
+class OutputHandler
+	attr_writer :indent
+	
+	def initialize(indent=0, mode=:explicit)
+		self.mode = mode
+		@indent = indent
+		@state = :wait_for_nonws
+		@output = ""
+	end
+		
+	def concat(s)
+		return @output.concat(s) if s.is_a? OutputHandler
+		s = s.to_str.gsub(/^[\t ]*\r?\n/,'') if @ignoreNextNL
+		s = s.to_str.gsub(/^\s+/,'') if @ignoreNextWS
+		@ignoreNextNL = @ignoreNextWS = false if s =~ /\S/
+		if @mode == :direct
+			@output.concat(s)
+		elsif @mode == :explicit
+			while s.size > 0
+				#puts "DEGUB: #{@state} #{s.dump}"
+				# s starts with whitespace
+				if s =~ /\A(\s+)(.*)/m	
+					ws = $1; rest = $2
+					#puts "DEGUB: ws #{ws.dump} rest #{rest.dump}"
+					if @state == :wait_for_nl
+						# ws contains a newline
+						if ws =~ /\A[\t ]*(\r?\n)(\s*)/m
+							@output.concat($1)
+							@state = :wait_for_nonws
+							s = $2 + rest
+						else
+							@output.concat(ws)
+							s = rest
+						end
+					else
+						s = rest
+					end
+				# s starts with non-whitespace
+				elsif s =~ /\A(\S+)(.*)/m
+					nonws = $1; rest = $2
+					#puts "DEGUB: nonws #{nonws.dump} rest #{rest.dump}"
+					@output.concat("   "*@indent) if @state == :wait_for_nonws
+					@output.concat(nonws)
+					@state = :wait_for_nl
+					s = rest
+				end
+			end
+		end
+	end
+	alias << concat
+	
+	def to_str
+		@output
+	end
+	alias to_s to_str
+
+	def direct_concat(s)
+		@output.concat(s)
+	end
+			
+	def ignoreNextNL
+		@ignoreNextNL = true
+	end
+	
+	def ignoreNextWS
+		@ignoreNextWS = true
+	end
+	
+	def mode=(m)
+		raise StandardError.new("Unknown mode: #{m}") unless [:direct, :explicit].include?(m)
+		@mode = m
+	end
+end
+
+end
+
+end

data/lib/rgen/template_language/template_container.rb

@@ -0,0 +1,153 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'erb'
+require 'rgen/template_language/output_handler'
+require 'rgen/template_language/template_helper'
+
+module RGen
+
+module TemplateLanguage
+
+class TemplateContainer
+	include TemplateHelper
+	
+	def initialize(metamodel, output_path, parent)
+		@templates = {}
+		@parent = parent
+		@indent = 0
+		@output_path = output_path
+		raise StandardError.new("Can not set metamodel, dup class first") if self.class == TemplateContainer
+		@@metamodel = metamodel
+	end
+
+	def load(filename)
+		#print "Loading templates in #{filename} ...\n"
+		File.open(filename) { |f|
+			ERB.new(f.read,nil,nil,'@output').result(binding)
+		}
+	end
+	
+	# if this container can handle the call, the expansion result is returned
+	# otherwise expand is called on the appropriate container and the result is added to @output
+	def expand(template, *all_args)
+		args, params = _splitArgsAndOptions(all_args)
+		if params[:foreach].is_a? Enumerable
+			_expand_foreach(template, args, params)
+		else
+			_expand(template, args, params)
+		end
+	end
+	
+	def this
+		@context
+	end
+	
+	def method_missing(name, *args)
+		@context.send(name, *args)
+	end
+	
+	def self.const_missing(name)
+		super unless @@metamodel
+		@@metamodel.const_get(name) 
+	end
+	
+	private
+
+	def nonl
+		@output.ignoreNextNL
+	end
+
+	def nows
+		@output.ignoreNextWS
+	end
+	
+	def nl
+		_direct_concat("\n")
+	end
+	
+	def iinc
+		@indent += 1
+		@output.indent = @indent
+	end
+	
+	def idec
+		@indent -= 1 if @indent > 0
+		@output.indent = @indent
+	end
+	
+	def define(template, params={}, &block)
+		@templates[template] ||= {}
+		cls = params[:for] || Object
+		@templates[template][cls] = block
+	end
+	
+	def file(name)
+		old_output, @output = @output, OutputHandler.new(@indent)
+		yield
+		path = ""
+		path += @output_path+"/" if @output_path
+		File.open(path+name,"w") { |f| f.write(@output) }
+		@output = old_output
+	end
+
+	# private private
+	
+	def _expand_foreach(template, args, params)
+		params[:foreach].each {|e|
+			single_params = params.dup
+			single_params[:for] = e
+			_expand(template, args, single_params)
+		}
+	end
+
+	LOCAL_TEMPLATE_REGEX = /^:*(\w+)$/
+
+	def _expand(template, args, params)
+		context = params[:for]
+		@indent = params[:indent] || @indent
+		old_context, @context = @context, context if context
+		local_output = nil
+		if template =~ LOCAL_TEMPLATE_REGEX
+			throw "Template not found: #{$1}" unless @templates[$1]
+			old_output, @output = @output, OutputHandler.new(@indent)
+			_call_template($1, @context, args)
+			local_output, @output = @output, old_output
+		else
+			local_output = @parent.expand(template, *(args.dup << {:for => @context, :indent => @indent}))
+		end
+		_direct_concat(local_output)
+		@context = old_context if old_context
+		local_output
+	end
+	
+	def _call_template(tpl, context, args)
+		found = false
+		@templates[tpl].each_pair { |key, value| 
+			if context.is_a?(key)
+				proc = @templates[tpl][key]
+				arity = proc.arity
+				arity = 0 if arity == -1	# if no args are given
+				raise StandardError.new("Wrong number of arguments calling template #{tpl}: #{args.size} for #{arity} "+
+					"(Beware: Hashes as last arguments are taken as options and are ignored)") \
+					if arity != args.size
+				proc.call(*args) 
+				found = true
+			end
+		}
+		raise StandardError.new("Template class not matching: #{tpl} for #{context.class.name}") unless found
+	end
+	
+	def _direct_concat(s)
+		if @output.is_a? OutputHandler
+			@output.direct_concat(s)
+		else
+			@output << s
+		end
+	end
+	
+end
+
+end
+
+end