rgen 0.3.0 → 0.4.0

data/lib/rgen/template_language/template_container.rb

@@ -2,152 +2,195 @@
 # (c) Martin Thiede, 2006
 
 require 'erb'
+require 'fileutils'
 require 'rgen/template_language/output_handler'
 require 'rgen/template_language/template_helper'
 
 module RGen
+  
+  module TemplateLanguage
+    
+    class TemplateContainer
+      include TemplateHelper
+      
+      def initialize(metamodels, output_path, parent, filename)
+        @templates = {}
+        @parent = parent
+        @filename = filename
+        @indent = 0
+        @output_path = output_path
+        raise StandardError.new("Can not set metamodel, dup class first") if self.class == TemplateContainer
+        @@metamodels = metamodels
+        @@metamodels = [ @@metamodels ] unless @@metamodels.is_a?(Array)
+      end
+      
+      def load
+        #print "Loading templates in #{@filename} ...\n"
+        File.open(@filename) { |f|
+          begin
+            ERB.new(f.read,nil,nil,'@output').result(binding)
+          rescue Exception => e
+            processAndRaise(e)
+          end
+        }
+      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 @@metamodels
+        @@metamodels.each do |mm|
+          return mm.const_get(name) rescue NameError
+        end
+        super
+      end
+      
+      private
+      
+      def nonl
+        @output.ignoreNextNL
+      end
+      
+      def nows
+        @output.ignoreNextWS
+      end
+      
+      def nl
+        _direct_concat("\n")
+      end
+      
+      def ws
+        _direct_concat(" ")
+      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)
+        begin
+          yield
+        rescue Exception => e
+          processAndRaise(e)
+        end
+        path = ""
+        path += @output_path+"/" if @output_path
+        dirname = File.dirname(path+name)
+        FileUtils.makedirs(dirname) unless File.exist?(dirname)
+        File.open(path+name,"w") { |f| f.write(@output) }
+        @output = old_output
+      end
+      
+      # private private
+      
+      def _expand_foreach(template, args, params)
+        sep = params[:separator]
+        params[:foreach].each_with_index {|e,i|
+          single_params = params.dup
+          single_params[:for] = e
+          _direct_concat(sep.to_s) if sep && i > 0 
+          _expand(template, args, single_params)
+        }
+      end
+      
+      LOCAL_TEMPLATE_REGEX = /^:*(\w+)$/
+      
+      def _expand(template, args, params)
+        context = params[:for]
+        @indent = params[:indent] || @indent
+        # if this is the first call to expand within this container, @output is nil
+        noIndentNextLine = params[:noIndentNextLine]
+        noIndentNextLine = (@output.to_s =~ /[^\n]\z/ ? true : false) if noIndentNextLine.nil?
+        old_context, @context = @context, context if context
+        local_output = nil
+        if template =~ LOCAL_TEMPLATE_REGEX
+          tplname = $1
+          throw "Template not found: #{$1}" unless @templates[tplname]
+          old_output, @output = @output, OutputHandler.new(@indent)
+          @output.noIndentNextLine if noIndentNextLine
+          _call_template(tplname, @context, args)
+          local_output, @output = @output, old_output
+        else
+          local_output = @parent.expand(template, *(args.dup << {:for => @context, :indent => @indent, :noIndentNextLine => noIndentNextLine}))
+        end
+        _direct_concat(local_output)
+        @context = old_context if old_context
+        local_output
+      end
+      
+      def processAndRaise(e, tpl=nil)
+        bt = e.backtrace.dup
+        e.backtrace.each_with_index do |t,i|
+          if t =~ /\(erb\):(\d+):/
+            bt[i] = "#{@filename}:#{$1}"
+            bt[i] += ":in '#{tpl}'" if tpl
+            break
+          end
+        end
+        raise e, e.to_s, bt
+      end
 
-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} "+
+      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
+            if arity != args.size
+              begin
+                proc.call(*args) 
+              rescue Exception => e
+                processAndRaise(e, tpl)
+              end
+              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

data/lib/rgen/transformer.rb

@@ -198,16 +198,13 @@ class Transformer
 
 	# This class method specifies that all objects of class +from+ are to be copied
 	# into an object of class +to+. If +to+ is omitted, +from+ is used as target class.
-	# During copy, all attributes according to 
-	# MetamodelBuilder::BuilderExtensions.one_attributes and 
-	# MetamodelBuilder::BuilderExtensions.many_attributes of the target object
+	# During copy, all attributes and references of the target object
 	# are set to their transformed counterparts of the source object.
 	# 
 	def self.copy(from, to=nil)
 		transform(from, :to => to || from) do
-			Hash[*(@current_object.class.one_attributes + 
-			@current_object.class.many_attributes).inject([]) {|l,a|
-				l + [a.to_sym, trans(@current_object.send(a))]
+			Hash[*@current_object.class.ecore.eAllStructuralFeatures.inject([]) {|l,a|
+				l + [a.name.to_sym, trans(@current_object.send(a.name))]
 			}]
 		end
 	end
@@ -221,9 +218,10 @@ class Transformer
 	end
 	
 
-	# Creates a new transformer with the specified input and output Environment.
+	# Creates a new transformer
+	# Optionally an input and output Environment can be specified.
 	# 
-	def initialize(env_in, env_out)
+	def initialize(env_in=nil, env_out=nil)
 		@env_in = env_in
 		@env_out = env_out
 		@transformer_results = {}
@@ -236,7 +234,9 @@ class Transformer
 	# The transformation result element is created in the output environment and returned.
 	# In addition, the result is cached, i.e. a second invocation with the same parameter
 	# object will return the same result object without any further evaluation of the 
-	# transformation rules. Nil will be transformed into nil.
+	# transformation rules. Nil will be transformed into nil. Ruby "singleton" objects
+	# +true+, +false+, numerics and symbols will be return without any change. Ruby strings
+	# will be duplicated with the result being cached.
 	# 
 	# The transformation input can be given as:
 	# * a single object
@@ -244,7 +244,10 @@ class Transformer
 	# * a hash used as input to Environment#find with the result being transformed
 	# 
 	def trans(obj)
-		obj = @env_in.find(obj) if obj.is_a?(Hash)
+		if obj.is_a?(Hash)
+			raise StandardError.new("No input environment available to find model element.") unless @env_in
+			obj = @env_in.find(obj) 
+		end
 		return nil if obj.nil?
 		return obj if obj.is_a?(TrueClass) or obj.is_a?(FalseClass) or obj.is_a?(Numeric) or obj.is_a?(Symbol)
 		return @transformer_results[obj] if @transformer_results[obj]
@@ -266,11 +269,11 @@ class Transformer
 	# If that object also does not respond to the call, it is treated as a transformer
 	# method call (see Transformer.method).
 	# 
-	def method_missing(m) #:nodoc:
+	def method_missing(m, *args) #:nodoc:
 		if @current_object.respond_to?(m)
-			@current_object.send(m)
+			@current_object.send(m, *args)
 		else
-			_invokeMethod(m)
+			_invokeMethod(m, *args)
 		end
 	end
 
@@ -313,7 +316,9 @@ class Transformer
 			target_class = target_desc
 		end
 		@current_object = old_object
-		@env_out.new target_class
+		result = target_class.new
+		@env_out << result if @env_out
+		result
 	end
 	
 	def _invokeMethod(m) # :nodoc:

data/lib/transformers/uml13_to_ecore.rb

@@ -0,0 +1,75 @@
+require 'metamodels/uml13_metamodel'
+require 'rgen/transformer'
+require 'rgen/ecore/ecore'
+require 'rgen/array_extensions'
+
+class UML13ToECore < RGen::Transformer
+	include RGen::ECore
+
+	def transform
+		trans(:class => UML13::Class)
+	end
+
+	transform UML13::Model, :to => EPackage do
+	    trans(ownedClassOrPackage)
+		{ :name => name && name.strip }
+	end
+		
+	transform UML13::Package, :to => EPackage do
+	    trans(ownedClassOrPackage)
+		{ :name => name && name.strip, 
+		  :eSuperPackage => trans(namespace.is_a?(UML13::Package) ? namespace : nil) }
+	end
+	
+	method :ownedClassOrPackage do
+	 ownedElement.select{|e| e.is_a?(UML13::Package) || e.is_a?(UML13::Class)}
+	end
+	
+	transform UML13::Class, :to => EClass do
+		{ :name => name && name.strip,
+			:ePackage => trans(namespace.is_a?(UML13::Package) ? namespace : nil),
+			:eStructuralFeatures => trans(feature.select{|f| f.is_a?(UML13::Attribute)} + associationEnd),
+			:eOperations => trans(feature.select{|f| f.is_a?(UML13::Operation)}),
+			:eSuperTypes =>  trans(generalization.parent + clientDependency.select{|d| d.stereotype.name == "implements"}.supplier),
+            :eAnnotations => [ EAnnotation.new(:details => trans(taggedValue)) ] }
+	end
+
+	transform UML13::Interface, :to => EClass do
+		{ :name => name && name.strip,
+			:ePackage => trans(namespace.is_a?(UML13::Package) ? namespace : nil),
+			:eStructuralFeatures => trans(feature.select{|f| f.is_a?(UML13::Attribute)} + associationEnd),
+			:eOperations => trans(feature.select{|f| f.is_a?(UML13::Operation)}),
+			:eSuperTypes =>  trans(generalization.parent)}
+	end
+
+	transform UML13::Attribute, :to => EAttribute do
+		typemap = { "string" => EString, "boolean" => EBoolean, "int" => EInt, "float" => EFloat }
+		typetv = taggedValue.find{|tv| tv.tag == "type"}
+		{	:name => name && name.strip, :eType => (typetv && typetv.value && typemap[typetv.value.downcase]),
+            :eAnnotations => [ EAnnotation.new(:details => trans(taggedValue)) ] }
+	end
+	
+	transform UML13::Operation, :to => EOperation do
+		{ :name => name && name.strip }
+	end
+	
+	transform UML13::AssociationEnd, :to => EReference, :if => :isReference do
+	    otherEnd = association.connection.find{|ae| ae != @current_object}
+		{ :eType => trans(otherEnd.type),
+			:name => otherEnd.name && otherEnd.name.strip,
+			:eOpposite => trans(otherEnd),
+			:lowerBound => otherEnd.multiplicity ? otherEnd.multiplicity.range.first.lower.to_i : 0,
+			:upperBound => otherEnd.multiplicity ? otherEnd.multiplicity.range.first.upper.gsub('*','-1').to_i : 1,
+			:containment => (aggregation == :composite),
+            :eAnnotations => [ EAnnotation.new(:details => trans(association.taggedValue)) ] }
+	end
+	
+	method :isReference do
+	  otherEnd = association.connection.find{|ae| ae != @current_object}
+      otherEnd.name && otherEnd.name.size > 0
+	end			
+
+	transform UML13::TaggedValue, :to => EStringToStringMapEntry do
+	 { :key => tag, :value => value}
+	end
+end