rgen 0.4.2 → 0.4.3

data/lib/rgen/template_language/directory_template_container.rb

@@ -51,6 +51,17 @@ class DirectoryTemplateContainer
     end
   end
   
+  # Set indentation string.
+  # Every generated line will be prependend with n times this string at an indentation level of n.
+  # Defaults to "   " (3 spaces)
+  def indentString=(str)
+    @indentString = str
+  end
+  
+  def indentString
+    @indentString || (@parent && @parent.indentString) || "   "
+  end
+  
   private
   
   def _expand(template, *all_args)

data/lib/rgen/template_language/directory_template_container.rb.bak

@@ -0,0 +1,69 @@
+# 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,qf)).load
+      elsif File.directory?(qf) && f != "." && f != ".."
+       (@containers[f] = DirectoryTemplateContainer.new(@metamodel, @output_path, self)).load(qf)
+      end
+    }
+  end
+  
+  def expand(template, *all_args)
+    if template =~ /^\//
+      if @parent
+        # pass to parent
+        @parent.expand(template, *all_args)
+      else
+        # this is root
+        _expand(template, *all_args)
+      end
+    elsif template =~ /^\.\.\/(.*)/
+      if @parent
+        # pass to parent
+        @parent.expand($1, *all_args)
+      else
+        raise "No parent directory for root"
+      end
+    else
+      _expand(template, *all_args)
+    end
+  end
+  
+  private
+  
+  def _expand(template, *all_args)
+    if template =~ /^\/?([^:\/]+)(?:::|\/)([^:\/].*)/ 
+      raise "Template not found: #{$1}" unless @containers[$1]
+      @containers[$1].expand($2, *all_args)
+    else
+      raise "Invalid template name: #{template}"
+    end
+  end
+  
+end
+
+end
+    
+end

data/lib/rgen/template_language/output_handler.rb

@@ -8,9 +8,10 @@ module TemplateLanguage
   class OutputHandler
     attr_writer :indent
     
-    def initialize(indent=0, mode=:explicit)
+    def initialize(indent=0, indentString="   ", mode=:explicit)
       self.mode = mode
       @indent = indent
+      @indentString = indentString
       @state = :wait_for_nonws
       @output = ""
     end
@@ -42,7 +43,7 @@ module TemplateLanguage
             if s =~ /\A\s*(\S+.*)/m
               s = $1 || ""
               if !@noIndentNextLine && !(@output.to_s.size > 0 && @output.to_s[-1] != "\n"[0])
-                @output.concat("   "*@indent)
+                @output.concat(@indentString * @indent)
               else
                 @noIndentNextLine = false
               end

data/lib/rgen/template_language/output_handler.rb.bak

@@ -0,0 +1,88 @@
+# 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
+    
+    # ERB will call this method for every string s which is part of the
+    # template file in between %> and <%. If s contains a newline, it will
+    # call this method for every part of s which is terminated by a \n
+    # 
+    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
+          if @state == :wait_for_nl
+            if s =~ /\A([^\r\n]*\r?\n)(.*)/m
+              rest = $2
+              @output.concat($1.gsub(/[\t ]+(?=\r|\n)/,''))
+              s = rest || ""
+              @state = :wait_for_nonws
+            else
+              @output.concat(s)
+              s = ""
+            end
+          elsif @state == :wait_for_nonws
+            if s =~ /\A\s*(\S+.*)/m
+              s = $1 || ""
+              if !@noIndentNextLine && !(@output.to_s.size > 0 && @output.to_s[-1] != "\n"[0])
+                @output.concat("   "*@indent)
+              else
+                @noIndentNextLine = false
+              end
+              @state = :wait_for_nl
+            else
+              s = ""
+            end
+          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 noIndentNextLine
+      @noIndentNextLine = 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

@@ -96,8 +96,8 @@ module RGen
         @templates[template][cls] = block
       end
       
-      def file(name)
-        old_output, @output = @output, OutputHandler.new(@indent)
+      def file(name, indentString=nil)
+        old_output, @output = @output, OutputHandler.new(@indent, indentString || @parent.indentString)
         begin
           yield
         rescue Exception => e
@@ -126,6 +126,7 @@ module RGen
       LOCAL_TEMPLATE_REGEX = /^:*(\w+)$/
       
       def _expand(template, args, params)
+        raise StandardError.new("expand :for argument evaluates to nil") if params.has_key?(:for) && params[:for].nil?
         context = params[:for]
         @indent = params[:indent] || @indent
         # if this is the first call to expand within this container, @output is nil
@@ -135,8 +136,8 @@ module RGen
         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)
+          raise StandardError.new("Template not found: #{$1}") unless @templates[tplname]
+          old_output, @output = @output, OutputHandler.new(@indent, @parent.indentString)
           @output.noIndentNextLine if noIndentNextLine
           _call_template(tplname, @context, args)
           local_output, @output = @output, old_output

data/lib/rgen/template_language/template_container.rb.bak

@@ -0,0 +1,196 @@
+# RGen Framework
+# (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.size > 0 && @output.to_s[-1] != "\n"[0]) 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
+
+      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
+              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.bak

@@ -0,0 +1,381 @@
+module RGen
+
+# The Transformer class can be used to specify model transformations.
+# 
+# Model transformations take place between a <i>source model</i> (located in the <i>source
+# environment</i> being an instance of the <i>source metamodel</i>) and a <i>target model</i> (located
+# in the <i>target environment</i> being an instance of the <i>target metamodel</i>).
+# Normally a "model" consists of several model elements associated with each other.
+# 
+# =Transformation Rules
+# 
+# The transformation is specified within a subclass of Transformer.
+# Within the subclass, the Transformer.transform class method can be used to specify transformation
+# blocks for specific metamodel classes of the source metamodel.
+# 
+# If there is no transformation rule for the current object's class, a rule for the superclass
+# is used instead. If there's no rule for the superclass, the class hierarchy is searched
+# this way until Object.
+# 
+# Here is an example:
+# 
+# 	class MyTransformer < RGen::Transformer
+# 
+# 		transform InputClass, :to => OutputClass do
+# 			{ :name => name, :otherClass => trans(otherClass) }
+# 		end
+# 
+# 		transform OtherInputClass, :to => OtherOutputClass do
+# 			{ :name => name }
+# 		end
+# 	end
+# 
+# In this example a transformation rule is specified for model elements of class InputClass
+# as well as for elements of class OtherInputClass. The former is to be transformed into
+# an instance of OutputClass, the latter into an instance of OtherOutputClass.
+# Note that the Ruby class objects are used to specifiy the classes.
+#
+# =Transforming Attributes
+# 
+# Besides the target class of a transformation, the attributes of the result object are
+# specified in the above example. This is done by providing a Ruby block with the call of
+# +transform+. Within this block arbitrary Ruby code may be placed, however the block
+# must return a hash. This hash object specifies the attribute assignment of the
+# result object using key/value pairs: The key must be a Symbol specifying the attribute
+# which is to be assigned by name, the value is the value that will be assigned.
+#
+# For convenience, the transformation block will be evaluated in the context of the
+# source model element which is currently being converted. This way it is possible to just
+# write <code>:name => name</code> in the example in order to assign the name of the source 
+# object to the name attribute of the target object.
+# 
+# =Transforming References
+# 
+# When attributes of elements are references to other elements, those referenced
+# elements have to be transformed as well. As shown above, this can be done by calling
+# the Transformer#trans method. This method initiates a transformation of the element
+# or array of elements passed as parameter according to transformation rules specified
+# using +transform+. In fact the +trans+ method is the only way to start the transformation
+# at all.
+#
+# For convenience and performance reasons, the result of +trans+ is cached with respect
+# to the parameter object. I.e. calling trans on the same source object a second time will 
+# return the same result object _without_ a second evaluation of the corresponding 
+# transformation rules.
+# 
+# This way the +trans+ method can be used to lookup the target element for some source
+# element without the need to locally store a reference to the target element. In addition
+# this can be useful if it is not clear if certain element has already been transformed
+# when it is required within some other transformation block. See example below.
+# 
+# Special care has been taken to allow the transformation of elements which reference 
+# each other cyclically. The key issue here is that the target element of some transformation
+# is created _before_ the transformation's block is evaluated, i.e before the elements 
+# attributes are set. Otherwise a call to +trans+ within the transformation's block
+# could lead to a +trans+ of the element itself.
+# 
+# Here is an example:
+# 
+# 	transform ModelAIn, :to => ModelAOut do
+# 		{ :name => name, :modelB => trans(modelB) }
+# 	end
+# 	
+# 	transform ModelBIn, :to => ModelBOut do
+# 		{ :name => name, :modelA => trans(modelA) }
+# 	end
+#
+# Note that in this case it does not matter if the transformation is initiated by calling
+# +trans+ with a ModelAIn element or ModelBIn element due to the caching feature described
+# above.
+# 
+# =Transformer Methods
+# 
+# When code in transformer blocks becomes more complex it might be useful to refactor
+# it into smaller methods. If regular Ruby methods within the Transformer subclass are
+# used for this purpose, it is necessary to know the source element being transformed.
+# This could be achieved by explicitly passing the +@current_object+ as parameter of the
+# method (see Transformer#trans).
+# 
+# A more convenient way however is to define a special kind of method using the
+# Transformer.method class method. Those methods are evaluated within the context of the
+# current source element being transformed just the same as transformer blocks are.
+# 
+# Here is an example:
+# 
+# 	transform ModelIn, :to => ModelOut do
+# 		{ :number => doubleNumber }
+# 	end
+#
+# 	method :doubleNumber do
+# 		number * 2;
+# 	end
+#
+# In this example the transformation assigns the 'number' attribute of the source element
+# multiplied by 2 to the target element. The multiplication is done in a dedicated method
+# called 'doubleNumber'. Note that the 'number' attribute of the source element is 
+# accessed without an explicit reference to the source element as the method's body
+# evaluates in the source element's context.
+# 
+# =Conditional Transformations
+# 
+# Using the transformations as described above, all elements of the same class are
+# transformed the same way. Conditional transformations allow to transform elements of
+# the same class into elements of different target classes as well as applying different
+# transformations on the attributes.
+# 
+# Conditional transformations are defined by specifying multiple transformer blocks for
+# the same source class and providing a condition with each block. Since it is important
+# to create the target object before evaluation of the transformation block (see above),
+# the conditions must also be evaluated separately _before_ the transformer block.
+# 
+# Conditions are specified using transformer methods as described above. If the return
+# value is true, the corresponding block is used for transformation. If more than one
+# conditions are true, only the first transformer block will be evaluated.
+# 
+# If there is no rule with a condition evaluating to true, rules for superclasses will
+# be checked as described above.
+# 
+# Here is an example:
+# 
+# 	transform ModelIn, :to => ModelOut, :if => :largeNumber do
+# 		{ :number => number * 2}
+# 	end
+#
+# 	transform ModelIn, :to => ModelOut, :if => :smallNumber do
+# 		{ :number => number / 2 }
+# 	end
+# 	
+# 	method :largeNumber do
+# 		number > 1000
+# 	end
+# 	
+# 	method :smallNumber do
+# 		number < 500
+# 	end
+# 
+# In this case the transformation of an element of class ModelIn depends on the value
+# of the element's 'number' attribute. If the value is greater than 1000, the first rule
+# as taken and the number is doubled. If the value is smaller than 500, the second rule
+# is taken and the number is divided by two.
+# 
+# Note that it is up to the user to avoid cycles within the conditions. A cycle could
+# occure if the condition are based on transformation target elements, i.e. if +trans+
+# is used within the condition to lookup or transform other elements.
+# 
+class Transformer
+	
+	TransformationDescription = Struct.new(:block, :target) # :nodoc:
+	
+	@@methods = {}
+	@@transformer_blocks = {}
+
+	def self._transformer_blocks # :nodoc:
+		@@transformer_blocks[self] ||= {}
+	end
+
+	def self._methods # :nodoc:
+		@@methods[self] ||= {}
+	end
+	
+	# This class method is used to specify a transformation rule.
+	#
+	# The first argument specifies the class of elements for which this rule applies.
+	# The second argument must be a hash including the target class
+	# (as value of key ':to') and an optional condition (as value of key ':if').
+	# 
+	# The target class is specified by passing the actual Ruby class object.
+	# The condition is either the name of a transformer method (see Transfomer.method) as
+	# a symbol or a proc object. In either case the block is evaluated at transformation
+	# time and its result value determines if the rule applies.
+	# 
+	def self.transform(from, desc=nil, &block)
+		to = (desc && desc.is_a?(Hash) && desc[:to])
+		condition = (desc && desc.is_a?(Hash) && desc[:if])
+		raise StandardError.new("No transformation target specified.") unless to
+		block_desc = TransformationDescription.new(block, to)
+		if condition
+			_transformer_blocks[from] ||= {}
+			raise StandardError.new("Multiple (non-conditional) transformations for class #{from.name}.") unless _transformer_blocks[from].is_a?(Hash)
+			_transformer_blocks[from][condition] = block_desc
+		else
+			raise StandardError.new("Multiple (non-conditional) transformations for class #{from.name}.") unless _transformer_blocks[from].nil?
+			_transformer_blocks[from] = block_desc
+		end
+	end
+
+	# 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 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.ecore.eAllStructuralFeatures.inject([]) {|l,a|
+				l + [a.name.to_sym, trans(@current_object.send(a.name))]
+			}]
+		end
+	end
+	
+	# Define a transformer method for the current transformer class.
+	# In contrast to regular Ruby methods, a method defined this way executes in the
+	# context of the object currently being transformed.
+	# 
+	def self.method(name, &block)
+		_methods[name.to_s] = block
+	end
+	
+
+	# Creates a new transformer
+	# Optionally an input and output Environment can be specified.
+	# 
+	def initialize(env_in=nil, env_out=nil)
+		@env_in = env_in
+		@env_out = env_out
+		@transformer_results = {}
+		@transformer_jobs = []
+	end
+
+
+	# Transforms a given model element according to the rules specified by means of
+	# the Transformer.transform	class method.
+	# 
+	# 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. Ruby "singleton" objects
+	# +true+, +false+, numerics and symbols will be returned without any change. Ruby strings
+	# will be duplicated with the result being cached.
+	# 
+	# The transformation input can be given as:
+	# * a single object
+	# * an array each element of which is transformed in turn
+	# * a hash used as input to Environment#find with the result being transformed
+	# 
+	def trans(obj)
+		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]
+		return @transformer_results[obj] = obj.dup if obj.is_a?(String)
+		return obj.collect{|o| trans(o)}.compact if obj.is_a? Array
+		raise StandardError.new("No transformer for class #{obj.class.name}") unless _transformerBlock(obj.class)
+		block_desc = _evaluateCondition(obj)
+		return nil unless block_desc
+		@transformer_results[obj] = _instantiateTargetClass(obj, block_desc.target)
+		# we will transform the properties later
+		@transformer_jobs << TransformerJob.new(self, obj, block_desc)
+		# if there have been jobs in the queue before, don't process them in this call
+		# this way calls to trans are not nested; a recursive implementation 
+		# may cause a "Stack level too deep" exception for large models
+		return @transformer_results[obj] if @transformer_jobs.size > 1
+		# otherwise this is the first call of trans, process all jobs here
+		# more jobs will be added during job execution
+		while @transformer_jobs.size > 0
+			@transformer_jobs.first.execute
+			@transformer_jobs.shift
+		end
+		@transformer_results[obj]
+	end
+	
+	def _transformProperties(obj, block_desc) #:nodoc:
+		old_object, @current_object = @current_object, obj
+		block_result = instance_eval(&block_desc.block)
+		raise StandardError.new("Transformer must return a hash") unless block_result.is_a? Hash
+		@current_object = old_object
+		_attributesFromHash(@transformer_results[obj], block_result)
+	end
+	
+	class TransformerJob #:nodoc:
+		def initialize(transformer, obj, block_desc)
+			@transformer, @obj, @block_desc = transformer, obj, block_desc
+		end
+		def execute
+			@transformer._transformProperties(@obj, @block_desc)
+		end
+	end
+
+	# Each call which is not handled by the transformer object is passed to the object
+	# currently being transformed.
+	# 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, *args) #:nodoc:
+		if @current_object.respond_to?(m)
+			@current_object.send(m, *args)
+		else
+			_invokeMethod(m, *args)
+		end
+	end
+
+	private
+	
+	# returns _transformer_blocks content for clazz or one of its superclasses 
+	def _transformerBlock(clazz) # :nodoc:
+		block = self.class._transformer_blocks[clazz]
+		block = _transformerBlock(clazz.superclass) if block.nil? && clazz != Object
+		block
+	end
+		
+	# returns the first TransformationDescription for clazz or one of its superclasses
+	# for which condition is true 
+	def _evaluateCondition(obj, clazz=obj.class) # :nodoc:
+		tb = self.class._transformer_blocks[clazz]
+		block_description = nil
+		if tb.is_a?(TransformationDescription)
+			# non-conditional
+			block_description = tb
+		elsif tb
+			old_object, @current_object = @current_object, obj
+			tb.each_pair {|condition, block|
+				if condition.is_a?(Proc)
+					result = instance_eval(&condition)
+				elsif condition.is_a?(Symbol)
+					result = _invokeMethod(condition)
+				else
+					result = condition
+				end
+				if result
+					block_description = block 
+					break
+				end
+			}
+			@current_object = old_object
+		end
+		block_description = _evaluateCondition(obj, clazz.superclass) if block_description.nil? && clazz != Object
+		block_description
+	end
+	
+	def _instantiateTargetClass(obj, target_desc) # :nodoc:
+		old_object, @current_object = @current_object, obj
+		if target_desc.is_a?(Proc)
+			target_class = instance_eval(&target_desc)
+		elsif target_desc.is_a?(Symbol)
+			target_class = _invokeMethod(target_desc)
+		else
+			target_class = target_desc
+		end
+		@current_object = old_object
+		result = target_class.new
+		@env_out << result if @env_out
+		result
+	end
+	
+	def _invokeMethod(m) # :nodoc:
+			raise StandardError.new("Method not found: #{m}") unless self.class._methods[m.to_s]
+			instance_eval(&self.class._methods[m.to_s])
+	end
+		
+	def _attributesFromHash(obj, hash) # :nodoc:
+		hash.delete(:class)
+		hash.each_pair{|k,v|
+			obj.send("#{k}=", v)
+		}
+		obj
+	end
+	
+end
+
+end