rgen 0.4.6 → 0.5.0

data/lib/rgen/method_delegation.rb

@@ -0,0 +1,99 @@
+module RGen
+  
+module MethodDelegation
+
+class << self
+  
+  def registerDelegate(delegate, object, method)
+    method = method.to_sym
+    createDelegateStore(object)
+    if object._methodDelegates[method]
+      object._methodDelegates[method] << delegate
+    else
+      object._methodDelegates[method] = [delegate]
+      createDelegatingMethod(object, method)
+    end
+  end
+  
+  def unregisterDelegate(delegate, object, method)
+    method = method.to_sym
+    return unless object.respond_to?(:_methodDelegates)
+    return unless object._methodDelegates[method]
+    object._methodDelegates[method].delete(delegate)
+    if object._methodDelegates[method].empty?
+      object._methodDelegates[method] = nil
+      removeDelegatingMethod(object, method)
+      removeDelegateStore(object)
+    end
+  end
+
+  private
+  
+  def createDelegateStore(object)
+    return if object.respond_to?(:_methodDelegates)
+    class << object
+      def _methodDelegates
+        @_methodDelegates ||= {}
+      end
+    end
+  end
+  
+  def removeDelegateStore(object)
+    return unless object.respond_to?(:_methodDelegates)
+    class << object
+      remove_method(:_methodDelegates)
+    end
+  end
+  
+  def createDelegatingMethod(object, method)
+    if object.methods.include?(method.to_s)
+      object.instance_eval <<-END
+        class << self
+          alias #{aliasMethodName(method)} #{method}
+        end
+      END
+    end
+    
+    # define the delegating method
+    object.instance_eval <<-END
+      class << self
+        def #{method}(*args, &block)
+          @_methodDelegates[:#{method}].each do |d|
+            catch(:continue) do
+              return d.#{method}_delegated(self, *args, &block)
+            end
+          end
+          # if aliased method does not exist, we want an exception
+          #{aliasMethodName(method)}(*args, &block)
+        end
+      end
+    END
+  end
+
+  def removeDelegatingMethod(object, method)
+    if object.methods.include?(aliasMethodName(method))
+      # there is an aliased original, restore it
+      object.instance_eval <<-END
+        class << self
+          alias #{method} #{aliasMethodName(method)}
+          remove_method(:#{aliasMethodName(method)})
+        end
+      END
+    else
+      # just delete the delegating method
+      object.instance_eval <<-END
+        class << self
+          remove_method(:#{method})
+        end
+      END
+    end
+  end
+  
+  def aliasMethodName(method)
+    "#{method}_delegate_original"
+  end    
+end
+
+end
+
+end

data/lib/rgen/model_builder.rb

@@ -0,0 +1,27 @@
+require 'rgen/model_builder/builder_context'
+require 'rgen/method_delegation'
+#require 'ruby-prof'
+
+module RGen
+  
+module ModelBuilder
+
+  def self.build(package, env=nil, builderMethodsModule=nil, &block)
+    resolver = ReferenceResolver.new
+    bc = BuilderContext.new(package, builderMethodsModule, resolver, env)
+    contextModule = eval("Module.nesting", block.binding).first
+    MethodDelegation.registerDelegate(bc, contextModule, "const_missing")
+    #RubyProf.start
+    bc.instance_eval(&block)
+    #prof = RubyProf.stop
+    #File.open("profile_flat.txt","w+") do |f|
+    #  RubyProf::FlatPrinter.new(prof).print(f, 0)
+    # end
+    MethodDelegation.unregisterDelegate(bc, contextModule, "const_missing")
+    #puts "Resolving..."
+    resolver.resolve(bc.toplevelElements)
+    bc.toplevelElements
+  end    
+end
+
+end

data/lib/rgen/model_builder/builder_context.rb

@@ -0,0 +1,318 @@
+require 'rgen/ecore/ecore_ext'
+require 'rgen/model_builder/reference_resolver'
+
+module RGen
+  
+module ModelBuilder
+  
+class BuilderContext
+  attr_reader :toplevelElements
+  
+  def initialize(package, extensionsModule, resolver, env=nil)
+    package = package.ecore unless package.is_a?(RGen::ECore::EPackage)
+    raise "First argument must be a metamodel package" \
+      unless package.is_a?(RGen::ECore::EPackage)
+    @rootPackage, @env = package, env
+    @commandResolver = CommandResolver.new(package, extensionsModule, self)
+    @package = @rootPackage
+    @resolver = resolver
+    @contextStack = []
+    @toplevelElements = []
+    @helperNames = {}
+  end
+  
+  def const_missing_delegated(delegator, const)
+    ConstPathElement.new(const, self)
+  end
+  
+  class CommandResolver
+    def initialize(rootPackage, extensionsModule, builderContext)
+      @extensionFactory = ExtensionContainerFactory.new(rootPackage, extensionsModule, builderContext)
+      @packageResolver = PackageResolver.new(rootPackage, @extensionFactory)
+      @resolveCommand = {}
+    end
+    
+    def resolveCommand(cmd, parentPackage)
+      return @resolveCommand[[parentPackage, cmd]] if @resolveCommand.has_key?([parentPackage, cmd])
+      package = @packageResolver.packageByCommand(parentPackage, cmd)
+      result = nil
+	    if package
+  	    extensionContainer = @extensionFactory.extensionContainer(package)
+  	    if extensionContainer.respond_to?(cmd)
+          result = extensionContainer
+        else
+    	    className = cmd.to_s[0..0].upcase + cmd.to_s[1..-1]
+    	    result = package.eClasses.find{|c| c.name == className}
+        end
+      end
+      @resolveCommand[[parentPackage, cmd]] = [package, result]
+	  end
+  end
+  
+  def method_missing(m, *args, &block)
+    package, classOrContainer = @commandResolver.resolveCommand(m, @package)
+    return super if package.nil?
+    return classOrContainer.send(m, *args, &block) if classOrContainer.is_a?(ExtensionContainerFactory::ExtensionContainer)
+    eClass = classOrContainer
+    nameArg, argHash = self.class.processArguments(args)
+    internalName = nameArg || argHash[:name]
+    argHash[:name] ||= nameArg if nameArg && self.class.hasNameAttribute(eClass)
+    resolverJobs, asRole, helperName = self.class.filterArgHash(argHash, eClass)
+    element = eClass.instanceClass.new(argHash)
+    @resolver.setElementName(element, internalName)
+    @env << element if @env
+    contextElement = @contextStack.last
+    if contextElement
+      self.class.associateWithContextElement(element, contextElement, asRole)
+    else
+      @toplevelElements << element
+    end
+    resolverJobs.each do |job|
+      job.receiver = element
+      job.namespace = contextElement
+      @resolver.addJob(job)
+    end
+    # process block
+    if block
+      @contextStack.push(element)
+      @package, oldPackage = package, @package
+      instance_eval(&block)
+      @package = oldPackage
+      @contextStack.pop
+    end
+    element
+  end
+  
+  def _using(constPathElement, &block)
+    @package, oldPackage = 
+      self.class.resolvePackage(@package, @rootPackage, constPathElement.constPath), @package
+    instance_eval(&block)
+    @package = oldPackage
+  end
+  
+  def _context(depth=1)
+    @contextStack[-depth]
+  end
+
+  class ExtensionContainerFactory
+    
+    class ExtensionContainer
+      def initialize(builderContext)
+        @builderContext = builderContext
+      end
+      def method_missing(m, *args, &block)
+        @builderContext.send(m, *args, &block)
+      end
+    end
+    
+    def initialize(rootPackage, extensionsModule, builderContext)
+      @rootPackage, @extensionsModule, @builderContext = rootPackage, extensionsModule, builderContext
+      @extensionContainer = {}
+    end
+    
+    def moduleForPackage(package)
+      qName = package.qualifiedName
+      rqName = @rootPackage.qualifiedName
+      raise "Package #{qName} is not contained within #{rqName}" unless qName.index(rqName) == 0
+      path = qName.sub(rqName,'').split('::')
+      path.shift if path.first == ""
+      mod = @extensionsModule
+      path.each do |p|
+        if mod && mod.const_defined?(p)
+          mod = mod.const_get(p)
+        else
+          mod = nil
+          break
+        end
+      end
+      mod
+    end
+    
+    def extensionContainer(package)
+      return @extensionContainer[package] if @extensionContainer[package]
+      container = ExtensionContainer.new(@builderContext)
+      extensionModule = moduleForPackage(package)
+      container.extend(extensionModule) if extensionModule
+      @extensionContainer[package] = container
+    end
+  end
+  
+  class PackageResolver
+    def initialize(rootPackage, extensionFactory)
+      @rootPackage = rootPackage
+      @extensionFactory = extensionFactory
+      @packageByCommand = {}
+    end
+    
+    def packageByCommand(contextPackage, name)
+      return @packageByCommand[[contextPackage, name]] if @packageByCommand.has_key?([contextPackage, name])
+      if @extensionFactory.extensionContainer(contextPackage).respond_to?(name)
+        result = contextPackage
+      else
+        className = name.to_s[0..0].upcase + name.to_s[1..-1]
+        eClass = contextPackage.eClasses.find{|c| c.name == className}
+        if eClass
+          result = contextPackage
+        elsif contextPackage != @rootPackage
+          result = packageByCommand(contextPackage.eSuperPackage, name)
+        else
+          result = nil
+        end
+      end
+      @packageByCommand[[contextPackage, name]] = result
+    end
+  end
+  
+  class ConstPathElement < Module
+    def initialize(name, builderContext, parent=nil)
+      @name = name.to_s
+      @builderContext = builderContext
+      @parent = parent
+    end
+    
+    def const_missing(const)
+      ConstPathElement.new(const, @builderContext, self)
+    end
+    
+    def method_missing(m, *args, &block)
+      @builderContext._using(self) do
+        send(m, *args, &block)
+      end
+    end
+    
+    def constPath
+      if @parent
+        @parent.constPath << @name
+      else
+        [@name]
+      end
+    end
+  end
+
+  # helper methods put in the class object to be out of the way of 
+  # method evaluation in the builder context
+  class << self
+    class PackageNotFoundException < Exception
+    end
+  
+    def resolvePackage(contextPackage, rootPackage, path)
+      begin
+        return resolvePackageDownwards(contextPackage, path)
+      rescue PackageNotFoundException
+        if contextPackage.eSuperPackage && contextPackage != rootPackage
+          return resolvePackage(contextPackage.eSuperPackage, rootPackage, path)
+        else
+          raise
+        end
+      end
+    end
+  
+    def resolvePackageDownwards(contextPackage, path)
+      first, *rest = path
+      package = contextPackage.eSubpackages.find{|p| p.name == first}
+      raise PackageNotFoundException.new("Could not resolve package: #{first} is not a subpackage of #{contextPackage.name}") unless package
+      if rest.empty?
+        package 
+      else
+        resolvePackageDownwards(package, rest)
+      end
+    end
+    
+    def processArguments(args)
+      unless (args.size == 2 && args.first.is_a?(String) && args.last.is_a?(Hash)) ||
+        (args.size == 1 && (args.first.is_a?(String) || args.first.is_a?(Hash))) ||
+        args.size == 0
+        raise "Provide a Hash to set feature values, " +
+          "optionally the first argument may be a String specifying " + 
+          "the value of the \"name\" attribute."
+      end
+      if args.last.is_a?(Hash)
+        argHash = args.last
+      else
+        argHash = {}
+      end
+      nameArg = args.first if args.first.is_a?(String)
+      [nameArg, argHash]
+    end
+    
+    def filterArgHash(argHash, eClass)
+      resolverJobs = []
+      asRole, helperName = nil, nil
+      refByName = {}
+      eAllReferences(eClass).each {|r| refByName[r.name] = r}
+      argHash.each_pair do |k,v|
+        if k == :as
+          asRole = v
+          argHash.delete(k)
+        elsif k == :name && !hasNameAttribute(eClass)
+          helperName = v          
+          argHash.delete(k)
+        elsif v.is_a?(String)
+          ref = refByName[k.to_s]#eAllReferences(eClass).find{|r| r.name == k.to_s}
+          if ref
+            argHash.delete(k)
+            resolverJobs << ReferenceResolver::ResolverJob.new(nil, ref, nil,  v)
+          end
+        elsif v.is_a?(Array)
+          ref = refByName[k.to_s] #eAllReferences(eClass).find{|r| r.name == k.to_s}
+          ref && v.dup.each do |e|
+            if e.is_a?(String)
+              v.delete(e)
+              resolverJobs << ReferenceResolver::ResolverJob.new(nil, ref, nil, e)
+            end
+          end
+        end
+      end
+      [ resolverJobs, asRole, helperName ]
+    end
+    
+    def hasNameAttribute(eClass)
+      @hasNameAttribute ||= {}
+      @hasNameAttribute[eClass] ||= eClass.eAllAttributes.any?{|a| a.name == "name"}
+    end
+  
+    def eAllReferences(eClass)
+      @eAllReferences ||= {}
+      @eAllReferences[eClass] ||= eClass.eAllReferences
+    end
+    
+    def containmentRefs(contextClass, eClass)
+      @containmentRefs ||= {}
+      @containmentRefs[[contextClass, eClass]] ||=
+        eAllReferences(contextClass).select do |r| 
+          r.containment && (eClass.eAllSuperTypes << eClass).include?(r.eType)
+        end
+    end
+  
+    def associateWithContextElement(element, contextElement, asRole)
+      return unless contextElement
+      contextClass = contextElement.class.ecore
+      if asRole
+        asRoleRef = eAllReferences(contextClass).find{|r| r.name == asRole.to_s}
+        raise "Context class #{contextClass.name} has no reference named #{asRole}" unless asRoleRef
+        ref = asRoleRef
+      else
+        possibleContainmentRefs = containmentRefs(contextClass, element.class.ecore)
+        if possibleContainmentRefs.size == 1
+          ref = possibleContainmentRefs.first
+        elsif possibleContainmentRefs.size == 0
+          raise "Context class #{contextClass.name} can not contain a #{element.class.ecore.name}"
+        else
+          raise "Context class #{contextClass.name} has several containment references to a #{element.class.ecore.name}." +
+            " Clearify using \":as => <role>\""
+        end
+      end
+      if ref.many
+        contextElement.addGeneric(ref.name, element)
+      else
+        contextElement.setGeneric(ref.name, element)
+      end
+    end
+    
+  end
+  
+end
+
+end
+  
+end

data/lib/rgen/model_builder/model_serializer.rb

@@ -0,0 +1,201 @@
+require 'rgen/array_extensions'
+require 'rgen/ecore/ecore_ext'
+
+module RGen
+  
+module ModelBuilder
+
+class ModelSerializer
+  
+  def initialize(writable, rootPackage)
+    @writable = writable
+    @currentPackage = rootPackage
+    @qualifiedElementName = {}
+    @internalElementName = {}
+    @relativeQualifiedElementName = {}
+  end
+  
+  def serialize(elements)
+    calcQualifiedElementNames(elements)
+    unifyQualifiedElementNames
+    elements = [elements] unless elements.is_a?(Enumerable)
+    elements.each do |e|
+      serializeElement(e)
+    end
+  end
+  
+  private
+  
+  def serializeElement(element, viaRef=nil, namePath=[], indent=0)
+    className = element.class.ecore.name
+    cmd = className[0..0].downcase+className[1..-1]
+    args = ["\"#{@internalElementName[element]}\""]
+    namePath = namePath + [@internalElementName[element]]
+    childs = {}
+    eAllStructuralFeatures(element).each do |f|
+      next if f.derived
+      if f.is_a?(RGen::ECore::EAttribute)
+        next if f.name == "name" && element.name == @internalElementName[element]
+        val = element.getGeneric(f.name)
+        #puts f.defaultValue.inspect if f.name == "isRoot"
+        args << ":#{f.name} => #{serializeAttribute(val)}" unless val == f.defaultValue || val.nil?
+      elsif !f.containment
+        next if f.eOpposite && f.eOpposite == viaRef
+        val = element.getGeneric(f.name)
+        refString = serializeReference(element, f, val)
+        args << ":#{f.name} => #{refString}" if refString
+      else
+        cs = element.getGeneric(f.name)
+        refString = nil
+        if cs.is_a?(Array)
+          cs.compact!
+          rcs = cs.select{|c| serializeChild?(c, namePath)}
+          childs[f] = rcs unless rcs.empty?
+          refString = serializeReference(element, f, cs-rcs)
+        else
+          if cs && serializeChild?(cs, namePath)
+            childs[f] = [cs]
+          else
+            refString = serializeReference(element, f, cs)
+          end
+        end
+        args << ":#{f.name} => #{refString}" if refString
+      end
+    end
+    cmd = elementPackage(element)+"."+cmd if elementPackage(element).size > 0
+    @writable.write "  " * indent + cmd + " " + args.join(", ")
+    if childs.size > 0
+      @writable.write " do\n"
+      oldPackage, @currentPackage = @currentPackage, element.class.ecore.ePackage
+      childs.each_pair do |f,cs|
+        cs.each {|c| serializeElement(c, f, namePath, indent+1) }
+      end
+      @currentPackage = oldPackage
+      @writable.write "  " * indent + "end\n"
+    else
+      @writable.write "\n"
+    end
+  end
+  
+  def serializeChild?(child, namePath)
+    @qualifiedElementName[child][0..-2] == namePath
+  end
+
+  def serializeAttribute(value)
+    if value.is_a?(String)
+      "\"#{value.gsub("\"","\\\"")}\""
+    elsif value.is_a?(Symbol)
+      ":#{value}"
+    elsif value.nil?
+      "nil"
+    else
+      value.to_s
+    end
+  end
+  
+  def serializeReference(element, ref, value)
+    if value.is_a?(Array)
+      value = value.compact
+      value = value.select{|v| compareWithOppositeReference(element, v) > 0} if ref.eOpposite
+      qualNames = value.collect do |v|
+        relativeQualifiedElementName(v, element).join(".")
+      end
+      !qualNames.empty? && ("[" + qualNames.collect { |v| "\"#{v}\"" }.join(", ") + "]")
+    elsif value && (!ref.eOpposite || compareWithOppositeReference(element, value) > 0)
+      qualName = relativeQualifiedElementName(value, element).join(".")
+      ("\"#{qualName}\"")        
+    end
+  end
+  
+  def compareWithOppositeReference(element, target)
+    result = relativeQualifiedElementName(element, target).size <=> 
+      relativeQualifiedElementName(target, element).size
+    return result if result != 0
+    result = element.class.name <=> target.class.name
+    return result if result != 0
+    element.object_id <=> target.object_id    
+  end
+
+  def elementPackage(element)
+    @elementPackage ||= {}
+    return @elementPackage[element] if @elementPackage[element]
+    eNames = element.class.ecore.ePackage.qualifiedName.split("::")
+    rNames = @currentPackage.qualifiedName.split("::")
+    while eNames.first == rNames.first && !eNames.first.nil?
+      eNames.shift
+      rNames.shift
+    end
+    @elementPackage[element] = eNames.join("::")
+  end
+  
+  def relativeQualifiedElementName(element, context)
+    return @relativeQualifiedElementName[[element, context]] if @relativeQualifiedElementName[[element, context]]
+    # elements which are not in the @qualifiedElementName Hash are not in the scope
+    # of this serialization and will be ignored
+    return [] if element.nil? || @qualifiedElementName[element].nil?
+    return [] if context.nil? || @qualifiedElementName[context].nil?
+    eNames = @qualifiedElementName[element].dup
+    cNames = @qualifiedElementName[context].dup
+    while eNames.first == cNames.first && eNames.size > 1
+      eNames.shift
+      cNames.shift
+    end
+    @relativeQualifiedElementName[[element, context]] = eNames
+  end
+
+  def calcQualifiedElementNames(elements, prefix=[], takenNames=[])
+    elements = [elements] unless elements.is_a?(Array)
+    elements.compact!
+    elements.each do |element|
+      qualifiedNamePath = prefix + [calcInternalElementName(element, takenNames)]
+      @qualifiedElementName[element] ||= []
+      @qualifiedElementName[element] << qualifiedNamePath
+      takenChildNames = []
+      eAllStructuralFeatures(element).each do |f|
+        if f.is_a?(RGen::ECore::EReference) && f.containment
+          childs = element.getGeneric(f.name)
+          calcQualifiedElementNames(childs, qualifiedNamePath, takenChildNames)
+        end
+      end
+    end
+  end
+  
+  def unifyQualifiedElementNames
+    @qualifiedElementName.keys.each do |k|
+      @qualifiedElementName[k] = @qualifiedElementName[k].sort{|a,b| a.size <=> b.size}.first    
+    end
+  end
+
+  def calcInternalElementName(element, takenNames)
+    return @internalElementName[element] if @internalElementName[element]
+    name = if element.respond_to?(:name) && element.name && !element.name.empty?
+        element.name
+      else
+        nextElementHelperName(element)
+      end
+    while takenNames.include?(name)
+      name = nextElementHelperName(element)
+    end
+    takenNames << name
+    @internalElementName[element] = name 
+  end
+  
+  def nextElementHelperName(element)
+    eClass = element.class.ecore
+    @nextElementNameId ||= {}
+    @nextElementNameId[eClass] ||= 1
+    result = "_#{eClass.name}#{@nextElementNameId[eClass]}"
+    @nextElementNameId[eClass] += 1
+    result
+  end
+
+  def eAllStructuralFeatures(element)
+    @eAllStructuralFeatures ||= {}
+    @eAllStructuralFeatures[element.class] ||= element.class.ecore.eAllStructuralFeatures
+  end
+    
+end
+
+end
+
+end