rgen 0.4.6 → 0.5.0

data/lib/rgen/model_builder/reference_resolver.rb

@@ -0,0 +1,156 @@
+require 'rgen/array_extensions'
+
+module RGen
+  
+module ModelBuilder
+
+class ReferenceResolver
+  ResolverJob = Struct.new(:receiver, :reference, :namespace, :string)
+  
+  class ResolverException < Exception
+  end
+
+  class ToplevelNamespace
+    def initialize(ns)
+      raise "Namespace must be an Enumerable" unless ns.is_a?(Enumerable)
+      @ns = ns
+    end
+    def elements
+      @ns
+    end
+  end
+  
+  def initialize
+    @jobs = []
+    @elementName = {}
+  end
+
+  def addJob(job)
+    @jobs << job
+  end
+  
+  def setElementName(element, name)
+    @elementName[element] = name
+  end
+
+  def resolve(ns=[])
+    @toplevelNamespace = ToplevelNamespace.new(ns)
+    (@jobs || []).each_with_index do |job, i|
+      target = resolveReference(job.namespace || @toplevelNamespace, job.string.split("."))
+      raise ResolverException.new("Can not resolve reference #{job.string}") unless target
+      if job.reference.many
+        job.receiver.addGeneric(job.reference.name, target)
+      else
+        job.receiver.setGeneric(job.reference.name, target)
+      end
+    end
+  end
+  
+  private
+  
+  # TODO: if a reference can not be fully resolved, but a prefix can be found,
+  # the exception reported is that its first path element can not be found on
+  # toplevel
+  def resolveReference(namespace, nameParts)
+    element = resolveReferenceDownwards(namespace, nameParts)
+    if element.nil? && parentNamespace(namespace)
+      element = resolveReference(parentNamespace(namespace), nameParts)
+    end
+    element
+  end
+  
+  def resolveReferenceDownwards(namespace, nameParts)
+    firstPart, *restParts = nameParts
+    element = namespaceElementByName(namespace, firstPart)
+    return nil unless element
+    if restParts.size > 0
+      resolveReferenceDownwards(element, restParts)
+    else
+      element
+    end
+  end
+  
+  def namespaceElementByName(namespace, name)
+    @namespaceElementsByName ||= {}
+    return @namespaceElementsByName[namespace][name] if @namespaceElementsByName[namespace]
+    hash = {}
+    namespaceElements(namespace).each do |e|
+      raise ResolverException.new("Multiple elements named #{elementName(e)} found in #{nsToS(namespace)}") if hash[elementName(e)]
+      hash[elementName(e)] = e if elementName(e)
+    end
+    @namespaceElementsByName[namespace] = hash
+    hash[name]
+  end
+  
+  def parentNamespace(namespace)
+    if namespace.class.respond_to?(:ecore)
+      parents = elementParents(namespace)
+      raise ResolverException.new("Element #{nsToS(namespace)} has multiple parents") \
+        if parents.size > 1
+      parents.first || @toplevelNamespace
+    else
+      nil
+    end
+  end
+  
+  def namespaceElements(namespace)
+    if namespace.is_a?(ToplevelNamespace)
+      namespace.elements
+    elsif namespace.class.respond_to?(:ecore)
+      elementChildren(namespace)
+    else
+      raise ResolverException.new("Element #{nsToS(namespace)} can not be used as a namespace")
+    end
+  end
+  
+  def nsToS(namespace)
+    if namespace.is_a?(ToplevelNamespace)
+      "toplevel namespace"
+    else
+      result = namespace.class.name    
+      result += ":\"#{elementName(namespace)}\"" if elementName(namespace)
+      result
+    end
+  end
+  
+  def elementName(element)
+    @elementName[element]
+  end
+  
+  def elementChildren(element)
+    @elementChildren ||= {}
+    return @elementChildren[element] if @elementChildren[element]
+    children = containmentRefs(element).collect do |r|
+      element.getGeneric(r.name)
+    end.flatten.compact
+    @elementChildren[element] = children
+  end
+  
+  def elementParents(element)
+    @elementParents ||= {}
+    return @elementParents[element] if @elementParents[element]
+    parents = parentRefs(element).collect do |r|
+      element.getGeneric(r.name)
+    end.flatten.compact
+    @elementParents[element] = parents
+  end  
+  
+  def containmentRefs(element)
+    @containmentRefs ||= {}
+    @containmentRefs[element.class] ||= eAllReferences(element).select{|r| r.containment}
+  end
+  
+  def parentRefs(element)
+    @parentRefs ||= {}
+    @parentRefs[element.class] ||= eAllReferences(element).select{|r| r.eOpposite && r.eOpposite.containment}
+  end
+
+  def eAllReferences(element)
+    @eAllReferences ||= {}
+    @eAllReferences[element.class] ||= element.class.ecore.eAllReferences
+  end
+end
+
+end
+
+end

data/lib/rgen/template_language/directory_template_container.rb

@@ -13,6 +13,7 @@ class DirectoryTemplateContainer
   
   def initialize(metamodel=nil, output_path=nil, parent=nil)
     @containers = {}
+    @directoryContainers = {}
     @parent = parent
     @metamodel = metamodel
     @output_path = output_path
@@ -24,7 +25,7 @@ class DirectoryTemplateContainer
       if !File.directory?(qf) && f =~ /^(.*)\.tpl$/
        (@containers[$1] = TemplateContainer.new(@metamodel, @output_path, self,qf)).load
       elsif File.directory?(qf) && f != "." && f != ".."
-       (@containers[f] = DirectoryTemplateContainer.new(@metamodel, @output_path, self)).load(qf)
+       (@directoryContainers[f] = DirectoryTemplateContainer.new(@metamodel, @output_path, self)).load(qf)
       end
     }
   end
@@ -64,9 +65,12 @@ class DirectoryTemplateContainer
   private
   
   def _expand(template, *all_args)
-    if template =~ /^\/?([^:\/]+)(?:::|\/)([^:\/].*)/ 
+    if template =~ /^\/?(\w+)::(\w.*)/ 
       raise "Template not found: #{$1}" unless @containers[$1]
       @containers[$1].expand($2, *all_args)
+    elsif template =~ /^\/?(\w+)\/(\w.*)/ 
+      raise "Template not found: #{$1}" unless @directoryContainers[$1]
+      @directoryContainers[$1].expand($2, *all_args)
     else
       raise "Invalid template name: #{template}"
     end

data/lib/rgen/template_language/output_handler.rb

@@ -7,6 +7,7 @@ module TemplateLanguage
   
   class OutputHandler
     attr_writer :indent
+    attr_accessor :noIndentNextLine
     
     def initialize(indent=0, indentString="   ", mode=:explicit)
       self.mode = mode
@@ -22,6 +23,7 @@ module TemplateLanguage
     # 
     def concat(s)
       return @output.concat(s) if s.is_a? OutputHandler
+      #puts [object_id, noIndentNextLine, @state, @output.to_s, s].inspect
       s = s.to_str.gsub(/^[\t ]*\r?\n/,'') if @ignoreNextNL
       s = s.to_str.gsub(/^\s+/,'') if @ignoreNextWS
       @ignoreNextNL = @ignoreNextWS = false if s =~ /\S/
@@ -74,10 +76,6 @@ module TemplateLanguage
       @ignoreNextWS = true
     end
     
-    def noIndentNextLine
-      @noIndentNextLine = true
-    end  
-      
     def mode=(m)
       raise StandardError.new("Unknown mode: #{m}") unless [:direct, :explicit].include?(m)
       @mode = m

data/lib/rgen/template_language/template_container.rb

@@ -8,208 +8,225 @@ 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
-    @metamodels = metamodels
-    @metamodels = [ @metamodels ] unless @metamodels.is_a?(Array)
-  end
-  
-  def load
-    File.open(@filename,"rb") do |f|
-      begin
-        @@metamodels = @metamodels
-        fileContent = f.read
-        _detectNewLinePattern(fileContent)
-        ERB.new(fileContent,nil,nil,'@output').result(binding)
-      rescue Exception => e
-        processAndRaise(e)
+  module TemplateLanguage
+    
+    class TemplateContainer
+      include TemplateHelper
+      
+      def initialize(metamodels, output_path, parent, filename)
+        @templates = {}
+        @parent = parent
+        @filename = filename
+        @indent = 0
+        @output_path = output_path
+    		@metamodels = metamodels
+    		@metamodels = [ @metamodels ] unless @metamodels.is_a?(Array)
       end
-    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.has_key?(:foreach)
-      raise StandardError.new("expand :foreach argument is not enumerable") \
-        unless 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(@newLinePattern)
-  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, indentString=nil)
-    old_output, @output = @output, OutputHandler.new(@indent, indentString || @parent.indentString)
-    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,"wb") { |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)
-    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
-    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
-      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
-    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
+      
+      def load
+    		File.open(@filename,"rb") do |f|
+          begin
+  	      	@@metamodels = @metamodels
+    	    	fileContent = f.read
+      	  	_detectNewLinePattern(fileContent)
+        		ERB.new(fileContent,nil,nil,'@output').result(binding)
+          rescue Exception => e
+            processAndRaise(e)
+          end
+    		end
       end
-    end
-    raise e, e.to_s, bt
-  end
-
-  def _call_template(tpl, context, args)
-    found = false
-    @templates[tpl].each_pair do |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
+      
+      def expand(template, *all_args)
+        args, params = _splitArgsAndOptions(all_args)
+    		if params.has_key?(:foreach)
+      		raise StandardError.new("expand :foreach argument is not enumerable") \
+        		unless params[:foreach].is_a?(Enumerable)
+          _expand_foreach(template, args, params)
+        else
+          _expand(template, args, params)
+        end
+      end
+      
+      def evaluate(template, *all_args)
+        args, params = _splitArgsAndOptions(all_args)
+        raise StandardError.new(":foreach can not be used with evaluate") if params[:foreach]
+        _expand(template, args, params.merge({:_evalOnly => true}))
+      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(@newLinePattern)
+      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
+      
+      TemplateDesc = Struct.new(:block, :local)
+      
+      def define(template, params={}, &block)
+        _define(template, params, &block)
+      end
+      
+      def define_local(template, params={}, &block)
+        _define(template, params.merge({:local => true}), &block)
+      end
+      
+      def file(name, indentString=nil)
+        old_output, @output = @output, OutputHandler.new(@indent, indentString || @parent.indentString)
         begin
-          @@metamodels = @metamodels
-          proc.call(*args) 
+          yield
         rescue Exception => e
-          processAndRaise(e, tpl)
+          processAndRaise(e)
         end
-        found = true
+        path = ""
+        path += @output_path+"/" if @output_path
+        dirname = File.dirname(path+name)
+        FileUtils.makedirs(dirname) unless File.exist?(dirname)
+    		File.open(path+name,"wb") { |f| f.write(@output) }
+        @output = old_output
       end
+      
+      # private private
+      
+      def _define(template, params={}, &block)
+        @templates[template] ||= {}
+        cls = params[:for] || Object
+        @templates[template][cls] = TemplateDesc.new(block, params[:local])
+      end
+      
+      def _expand_foreach(template, args, params)
+        sep = params[:separator]
+        params[:foreach].each_with_index {|e,i|
+          _direct_concat(sep.to_s) if sep && i > 0 
+          output = _expand(template, args, params.merge({:for => e}))
+        }
+      end
+      
+      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
+        noIndentNextLine = params[:_noIndentNextLine] || 
+          (@output.is_a?(OutputHandler) && @output.noIndentNextLine) || 
+          (@output.to_s.size > 0 && @output.to_s[-1] != "\n"[0]) 
+        caller = params[:_caller] || self
+        old_context, @context = @context, context if context
+        local_output = nil
+        if template =~ LOCAL_TEMPLATE_REGEX
+          tplname = $1
+          raise StandardError.new("Template not found: #{$1}") unless @templates[tplname]
+          old_output, @output = @output, OutputHandler.new(@indent, @parent.indentString)
+          @output.noIndentNextLine = noIndentNextLine
+          _call_template(tplname, @context, args, caller == self)
+          old_output.noIndentNextLine = false if old_output.is_a?(OutputHandler) && !old_output.noIndentNextLine
+          local_output, @output = @output, old_output
+        else
+          local_output = @parent.expand(template, *(args.dup << {:for => @context, :indent => @indent, :_noIndentNextLine => noIndentNextLine, :_evalOnly => true, :_caller => caller}))
+        end
+        _direct_concat(local_output) unless params[:_evalOnly]
+        @context = old_context if old_context
+        local_output.to_s
+      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, localCall)
+        found = false
+        @templates[tpl].each_pair do |key, value| 
+          if context.is_a?(key)
+            templateDesc = @templates[tpl][key]
+            proc = templateDesc.block
+            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
+            raise StandardError.new("Template can only be called locally: #{tpl}") \
+              if templateDesc.local && !localCall
+            begin
+             	@@metamodels = @metamodels
+              proc.call(*args) 
+            rescue Exception => e
+              processAndRaise(e, tpl)
+            end
+            found = true
+          end
+        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
 
+      def _detectNewLinePattern(text)
+        tests = 0
+        rnOccurances = 0
+        text.scan(/(\r?)\n/) do |groups|
+          tests += 1
+          rnOccurances += 1 if groups[0] == "\r"
+          break if tests >= 10
+        end
+        if rnOccurances > (tests / 2)
+          @newLinePattern = "\r\n"
+        else
+          @newLinePattern = "\n"
+        end
+      end
+              
     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
-  
-  def _detectNewLinePattern(text)
-    tests = 0
-    rnOccurances = 0
-    text.scan(/(\r?)\n/) do |groups|
-      tests += 1
-      rnOccurances += 1 if groups[0] == "\r"
-      break if tests >= 10
-    end
-    if rnOccurances > (tests / 2)
-      @newLinePattern = "\r\n"
-    else
-      @newLinePattern = "\n"
-    end
+    
   end
-end
-  
-end
   
 end