rgen 0.7.0 → 0.8.0

data/CHANGELOG

@@ -195,3 +195,13 @@
 * Added setNilOrRemoveGeneric and setNilOrRemoveAllGeneric methods
 * Added disconnectContainer method
 
+=0.8.0
+
+* Fixed missing indentation when template file is not terminated by a newline
+* Fixed missing indentation when expand in same line expands sub templates
+* Fixed DefaultXMLInstantiator naming error with a tag named 'File' (issue #19, pull request #21 from jkugs)
+* Simplified ECoreToRuby and optionally let it create modules with non-temporary names
+* Improved performance of output handler
+* Improved performance of setXXX and addXXX methods (pull request #22 from thallgren)
+* Use a value larger than Fixnum max to test Bignum support (pull request #18 from graaff)
+

data/README.rdoc

@@ -5,7 +5,7 @@ This means that it helps you build Metamodels, instantiate Models, modify
 and transform Models and finally generate arbitrary textual content from it.
 
 RGen features include:
-* Supporting Ruby 1.8.6, 1.8.7 and 1.9.x
+* Supporting Ruby 1.8.7, 1.9.x, 2.0, 2.1, 2.2
 * Metamodel definition language (internal Ruby DSL)
 * ECore Meta-metamodel with an ECore instance available for every Metamodel
 * Generator creating the Ruby metamodel definition from an ECore instance

data/Rakefile

@@ -3,7 +3,7 @@ require 'rdoc/task'
 
 RGenGemSpec = Gem::Specification.new do |s|
   s.name = %q{rgen}
-  s.version = "0.7.0"
+  s.version = "0.8.0"
   s.date = Time.now.strftime("%Y-%m-%d")
   s.summary = %q{Ruby Modelling and Generator Framework}
   s.email = %q{martin dot thiede at gmx de}

data/lib/rgen/ecore/ecore_to_ruby.rb

@@ -4,63 +4,113 @@ module RGen
   
 module ECore
 
+# ECoreToRuby can turn ECore models into their Ruby metamodel representations
 class ECoreToRuby
   
   def initialize
     @modules = {}
     @classifiers = {}
     @features_added = {}
-    @in_create_module = false
   end
 
-  def create_module(epackage)
-    return @modules[epackage] if @modules[epackage]
-    
-    top = (@in_create_module == false)
-    @in_create_module = true
-
-    m = Module.new do
-      extend RGen::MetamodelBuilder::ModuleExtension
+  # Create a Ruby module representing +epackage+.
+  # This includes all nested modules/packages, classes and enums.
+  #
+  # If a parent module is provided with the "under" parameter, 
+  # the new module will be nested under the parent module.
+  #
+  # If the parent module has a non-temporary name,
+  # (more precisely: a non-temporary classpath) i.e. if it is reachable
+  # via a path of constant names from the root, then the nested
+  # modules and classes will also have non-temporary names.
+  # In particular, this means that they will keep their names even
+  # if they are assigned to new constants.
+  # 
+  # If no parent module is provided or the parent module has a
+  # temporary name by itself, then the nested modules and classes will
+  # also have temporary names. This means that their name will stay
+  # 'volatile' until they are assigned to constants reachable from
+  # the root and the Module#name method is called for the first time.
+  #
+  # While the second approach is more flexible, it can come with a major
+  # performance impact. The reason is that Ruby searches the space of
+  # all known non-temporary classes/modules every time the name
+  # of a class/module with a temporary name is queried.
+  #
+  def create_module(epackage, under=Module.new)
+    temp = under.to_s.start_with?("#")
+    mod = create_module_internal(epackage, under, temp)
+
+    epackage.eAllClassifiers.each do |c| 
+      if c.is_a?(RGen::ECore::EClass)
+        create_class(c, temp)
+      elsif c.is_a?(RGen::ECore::EEnum)
+        create_enum(c)
+      end
     end
-    @modules[epackage] = m
 
-    epackage.eSubpackages.each{|p| create_module(p)}
-    m._set_ecore_internal(epackage)
+    mod
+  end
 
-    create_module(epackage.eSuperPackage).const_set(epackage.name, m) if epackage.eSuperPackage
+  private
 
-    # create classes only after all modules have been created
-    # otherwise classes may be created multiple times
-    if top
-      epackage.eAllClassifiers.each do |c| 
-        if c.is_a?(RGen::ECore::EClass)
-          create_class(c)
-        elsif c.is_a?(RGen::ECore::EEnum)
-          create_enum(c)
-        end
+  def create_module_internal(epackage, under, temp)
+    return @modules[epackage] if @modules[epackage]
+    
+    if temp
+      mod = Module.new do
+        extend RGen::MetamodelBuilder::ModuleExtension
       end
-      @in_create_module = false
+      under.const_set(epackage.name, mod)
+    else
+      under.module_eval <<-END
+        module #{epackage.name}
+          extend RGen::MetamodelBuilder::ModuleExtension
+        end
+      END
+      mod = under.const_get(epackage.name)
     end
-    m
+    @modules[epackage] = mod
+
+    epackage.eSubpackages.each{|p| create_module_internal(p, mod, temp)}
+    mod._set_ecore_internal(epackage)
+
+    mod
   end
 
-  def create_class(eclass)
+  def create_class(eclass, temp)
     return @classifiers[eclass] if @classifiers[eclass]
 
-    c = Class.new(super_class(eclass)) do
-      abstract if eclass.abstract
-      class << self
-        attr_accessor :_ecore_to_ruby
+    mod = @modules[eclass.ePackage]
+    if temp
+      cls = Class.new(super_class(eclass, temp)) do
+        abstract if eclass.abstract
+        class << self
+          attr_accessor :_ecore_to_ruby
+         end
       end
+      mod.const_set(eclass.name, cls)
+    else
+      mod.module_eval <<-END
+        class #{eclass.name} < #{super_class(eclass, temp)}
+          #{eclass.abstract ? 'abstract' : ''}
+          class << self
+            attr_accessor :_ecore_to_ruby
+          end
+        end
+      END
+      cls = mod.const_get(eclass.name)
     end
+
     class << eclass
       attr_accessor :instanceClass
       def instanceClassName
         instanceClass.to_s
       end
     end
-    eclass.instanceClass = c
-    c::ClassModule.module_eval do
+    eclass.instanceClass = cls
+
+    cls::ClassModule.module_eval do
       alias _method_missing method_missing
       def method_missing(m, *args)
         if self.class._ecore_to_ruby.add_features(self.class.ecore)
@@ -75,12 +125,11 @@ class ECoreToRuby
         _respond_to(m)
       end
     end
-    @classifiers[eclass] = c
-    c._set_ecore_internal(eclass)
-    c._ecore_to_ruby = self
+    @classifiers[eclass] = cls
+    cls._set_ecore_internal(eclass)
+    cls._ecore_to_ruby = self
 
-    create_module(eclass.ePackage).const_set(eclass.name, c)
-    c
+    cls
   end
 
   def create_enum(eenum)
@@ -89,7 +138,7 @@ class ECoreToRuby
     e = RGen::MetamodelBuilder::DataTypes::Enum.new(eenum.eLiterals.collect{|l| l.name.to_sym})
     @classifiers[eenum] = e
 
-    create_module(eenum.ePackage).const_set(eenum.name, e)
+    @modules[eenum.ePackage].const_set(eenum.name, e)
     e
   end
 
@@ -126,6 +175,32 @@ class ECoreToRuby
     end
   end
 
+  def super_class(eclass, temp)
+    super_types = eclass.eSuperTypes
+    if temp
+      case super_types.size
+      when 0
+        RGen::MetamodelBuilder::MMBase
+      when 1
+        create_class(super_types.first, temp)
+      else
+        RGen::MetamodelBuilder::MMMultiple(*super_types.collect{|t| create_class(t, temp)})
+      end
+    else
+      case super_types.size
+      when 0
+        "RGen::MetamodelBuilder::MMBase"
+      when 1
+        create_class(super_types.first, temp).name
+      else
+        "RGen::MetamodelBuilder::MMMultiple(" + 
+          super_types.collect{|t| create_class(t, temp).name}.join(",") + ")"
+      end
+    end
+  end
+
+  public
+
   def add_features(eclass)
     return false if @features_added[eclass]
     c = @classifiers[eclass]
@@ -147,18 +222,6 @@ class ECoreToRuby
     true
   end
 
-  def super_class(eclass)
-    super_types = eclass.eSuperTypes
-    case super_types.size
-    when 0
-      RGen::MetamodelBuilder::MMBase
-    when 1
-      create_class(super_types.first)
-    else
-      RGen::MetamodelBuilder::MMMultiple(*super_types.collect{|t| create_class(t)})
-    end
-  end
-
 end
 
 end

data/lib/rgen/instantiator/default_xml_instantiator.rb

@@ -8,107 +8,112 @@ module Instantiator
 # Derive your own instantiator from this class or use it as is.
 # 
 class DefaultXMLInstantiator < NodebasedXMLInstantiator
-	include Util::NameHelper
+  include Util::NameHelper
 
-	NamespaceDescriptor = Struct.new(:prefix, :target)
-	
-	class << self
-	
-		def map_tag_ns(from, to, prefix="")
-			tag_ns_map[from] = NamespaceDescriptor.new(prefix, to)
-		end
-		
-		def tag_ns_map # :nodoc:
-			@tag_ns_map ||={}
-			@tag_ns_map
-		end
-		
-	end	
-	
-	def initialize(env, default_module, create_mm=false)
-		super(env)
-		@default_module = default_module
-		@create_mm = create_mm
-	end
-		
-	def on_descent(node)
-		obj = new_object(node)
-		@env << obj unless obj.nil?
-		node.object = obj
-		node.attributes.each_pair { |k,v| set_attribute(node, k, v) }
-	end
+  NamespaceDescriptor = Struct.new(:prefix, :target)
+  
+  class << self
+  
+    def map_tag_ns(from, to, prefix="")
+      tag_ns_map[from] = NamespaceDescriptor.new(prefix, to)
+    end
+    
+    def tag_ns_map # :nodoc:
+      @tag_ns_map ||={}
+      @tag_ns_map
+    end
+    
+  end  
+  
+  def initialize(env, default_module, create_mm=false)
+    super(env)
+    @default_module = default_module
+    @create_mm = create_mm
+  end
+    
+  def on_descent(node)
+    obj = new_object(node)
+    @env << obj unless obj.nil?
+    node.object = obj
+    node.attributes.each_pair { |k,v| set_attribute(node, k, v) }
+  end
 
-	def on_ascent(node)
-		node.children.each { |c| assoc_p2c(node, c) }
-		node.object.class.has_attr 'chardata', Object unless node.object.respond_to?(:chardata)
-		set_attribute(node, "chardata", node.chardata)
-	end
-	
+  def on_ascent(node)
+    node.children.each { |c| assoc_p2c(node, c) }
+    node.object.class.has_attr 'chardata', Object unless node.object.respond_to?(:chardata)
+    set_attribute(node, "chardata", node.chardata)
+  end
+  
   def class_name(str)
     saneClassName(str)
   end
   
-	def new_object(node)
-		ns_desc = self.class.tag_ns_map[node.namespace]
-		class_name = class_name(ns_desc.nil? ? node.qtag : ns_desc.prefix+node.tag)
-		mod = (ns_desc && ns_desc.target) || @default_module		
-		build_on_error(NameError, :build_class, class_name, mod) do
-			mod.const_get(class_name).new
-		end
-	end
+  def new_object(node)
+    ns_desc = self.class.tag_ns_map[node.namespace]
+    class_name = class_name(ns_desc.nil? ? node.qtag : ns_desc.prefix+node.tag)
+    mod = (ns_desc && ns_desc.target) || @default_module
+    build_on_error(NameError, :build_class, class_name, mod) do
+      begin
+        mod.const_get(class_name, false).new
+      rescue ArgumentError
+        # Ruby 1.8
+        mod.const_get(class_name).new
+      end
+    end
+  end
   
-	def build_class(name, mod)
-		mod.const_set(name, Class.new(RGen::MetamodelBuilder::MMBase))
-	end
+  def build_class(name, mod)
+    mod.const_set(name, Class.new(RGen::MetamodelBuilder::MMBase))
+  end
   
   def method_name(str)
     saneMethodName(str)
   end
 
-	def assoc_p2c(parent, child)
-        return unless parent.object && child.object
-        method_name = method_name(className(child.object))
-		build_on_error(NoMethodError, :build_p2c_assoc, parent, child, method_name) do
-			parent.object.addGeneric(method_name, child.object)
-			child.object.setGeneric("parent", parent.object)
-		end
-	end
-	
-	def build_p2c_assoc(parent, child, method_name)
-		parent.object.class.has_many(method_name, child.object.class)
-		child.object.class.has_one("parent", RGen::MetamodelBuilder::MMBase)
-	end
-	
-	def set_attribute(node, attr, value)
-	   return unless node.object
-	   	build_on_error(NoMethodError, :build_attribute, node, attr, value) do
-			node.object.setGeneric(method_name(attr), value)
-		end
-	end
-	
-	def build_attribute(node, attr, value)
-		node.object.class.has_attr(method_name(attr))
-	end
+  def assoc_p2c(parent, child)
+    return unless parent.object && child.object
+    method_name = method_name(className(child.object))
+    build_on_error(NoMethodError, :build_p2c_assoc, parent, child, method_name) do
+      parent.object.addGeneric(method_name, child.object)
+      child.object.setGeneric("parent", parent.object)
+    end
+  end
+  
+  def build_p2c_assoc(parent, child, method_name)
+    parent.object.class.has_many(method_name, child.object.class)
+    child.object.class.has_one("parent", RGen::MetamodelBuilder::MMBase)
+  end
+  
+  def set_attribute(node, attr, value)
+    return unless node.object
+      build_on_error(NoMethodError, :build_attribute, node, attr, value) do
+      node.object.setGeneric(method_name(attr), value)
+    end
+  end
+  
+  def build_attribute(node, attr, value)
+    node.object.class.has_attr(method_name(attr))
+  end
 
-	protected
-	
-	# Helper method for implementing classes.
-	# This method yields the given block.
-	# If the metamodel should be create automatically (see constructor)
-	# rescues +error+ and calls +builder_method+ with +args+, then 
-	# yields the block again.
-	def build_on_error(error, builder_method, *args)
-		begin
-			yield
-		rescue error
-			if @create_mm
-				send(builder_method, *args)
-				yield
-			else
-				raise
-			end
-		end
-	end
+  protected
+  
+  # Helper method for implementing classes.
+  # This method yields the given block.
+  # If the metamodel should be create automatically (see constructor)
+  # rescues +error+ and calls +builder_method+ with +args+, then 
+  # yields the block again.
+  def build_on_error(error, builder_method, *args)
+    begin
+      yield
+    rescue error
+      if @create_mm
+        send(builder_method, *args)
+        yield
+      else
+        raise
+      end
+    end
+  end
 
 end