rgen 0.7.0 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe212a74ff9c45d6fcd848596acb527d6def24f5
-  data.tar.gz: 3c99d2170dab24b922a30a5a5420f03aaa05779e
+  metadata.gz: d1c27a6cc15f063ebc9483cb56253ebd20721cd2
+  data.tar.gz: b30dfcf5b91d19a8d26b0cc66a5dec9d3c0471c9
 SHA512:
-  metadata.gz: a70a59af207fcf7d3c35c0f8785a9bcceebb370b9a0f41e07a2103bc563256acd6e5160d256c1e8c786d52f48f9e540ed62e2105348b9b9a520a57f9d0a99c0b
-  data.tar.gz: eae33d63df0964a0175917aa7efd711306e933a4ab56fa938976a5d28eb8fc53a3e7e18e984a4c89dd134d0421418f6d86ff02a60c1e7e011620a544a62b6edd
+  metadata.gz: 5b74eb0928f9e39911b25dddbff8c73b12a331d651d59fdb27672794c6f6477bcdf23b3e8ac17ca97c2b3138dc33a3788a48ae6100493a710ff06e5557093dc8
+  data.tar.gz: cfe2866c2692b7a408cd460205cdc105f2cf792262104adfb6a0f0aa55bf917c26193766abebf43ccfd2f218f74e78910f20b82fa17d585beaca5345301bf985

data/CHANGELOG

@@ -195,3 +195,26 @@
 * 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)
+
+=0.8.1
+
+* Improved performance of ECoreToRuby
+* Fixed <%ws%> command to trigger indentation if starting a new line
+
+=0.8.2
+
+* Added helper methods
+
+=0.8.3
+
+* Performance improvement: getGeneric made a lot faster
+ 

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

@@ -1,39 +1,29 @@
 require 'rubygems/package_task'
 require 'rdoc/task'
+require 'bundler/setup'
+require 'rake/testtask'
 
-RGenGemSpec = Gem::Specification.new do |s|
-  s.name = %q{rgen}
-  s.version = "0.7.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}
-  s.homepage = %q{http://ruby-gen.org}
-  s.rubyforge_project = %q{rgen}
-  s.description = %q{RGen is a framework for Model Driven Software Development (MDSD) in Ruby. This means that it helps you build Metamodels, instantiate Models, modify and transform Models and finally generate arbitrary textual content from it.}
-  s.authors = ["Martin Thiede"]
-  gemfiles = Rake::FileList.new
-  gemfiles.include("{lib,test}/**/*")
-  gemfiles.include("README.rdoc", "CHANGELOG", "MIT-LICENSE", "Rakefile") 
-  gemfiles.exclude(/\b\.bak\b/)
-  s.files = gemfiles
-  s.rdoc_options = ["--main", "README.rdoc", "-x", "test", "-x", "metamodels", "-x", "ea_support/uml13*"]
-  s.extra_rdoc_files = ["README.rdoc", "CHANGELOG", "MIT-LICENSE"]
-end
+RGenGemSpec = eval(File.read('rgen.gemspec'))
 
 RDoc::Task.new do |rd|
-  rd.main = "README.rdoc"
-  rd.rdoc_files.include("README.rdoc", "CHANGELOG", "MIT-LICENSE", "lib/**/*.rb")
-  rd.rdoc_files.exclude("lib/metamodels/*")
-  rd.rdoc_files.exclude("lib/ea_support/uml13*")
-  rd.rdoc_dir = "doc"
+  rd.main = 'README.rdoc'
+  rd.rdoc_files.include('README.rdoc', 'CHANGELOG', 'MIT-LICENSE', 'lib/**/*.rb')
+  rd.rdoc_files.exclude('lib/metamodels/*')
+  rd.rdoc_files.exclude('lib/ea_support/uml13*')
+  rd.rdoc_dir = 'doc'
 end
 
 RGenPackageTask = Gem::PackageTask.new(RGenGemSpec) do |p|
   p.need_zip = false
-end	
+end
+
+::Rake::TestTask.new(:test) do |t|
+  t.test_files = ['test/rgen_test.rb']
+  t.warning = false
+end
 
 task :prepare_package_rdoc => :rdoc do
-  RGenPackageTask.package_files.include("doc/**/*")
+  RGenPackageTask.package_files.include('doc/**/*')
 end
 
 task :release => [:prepare_package_rdoc, :package]

data/lib/rgen/ecore/ecore.rb

@@ -155,7 +155,7 @@ module RGen
       has_many 'eAttributes', ECore::EAttribute, :derived=>true
       has_many 'eReferences', ECore::EReference, :derived=>true
       
-      module ClassModule		
+      module ClassModule
         def eAllAttributes_derived
           eAttributes + eSuperTypes.eAllAttributes
         end

data/lib/rgen/ecore/ecore_ext.rb

@@ -63,7 +63,15 @@ module RGen
       def eAllSubTypes
         eSubTypes + eSubTypes.eAllSubTypes
       end
+
+      def concrete
+        !(abstract || interface)
+      end
+
+      def isAssignableFrom(cls)
+        cls == self || cls.eAllSuperTypes.any? { |super_type| super_type == self }
+      end
       
-		end
+    end
   end
 end

data/lib/rgen/ecore/ecore_to_ruby.rb

@@ -4,63 +4,115 @@ 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
-    end
-    @modules[epackage] = m
-
-    epackage.eSubpackages.each{|p| create_module(p)}
-    m._set_ecore_internal(epackage)
-
-    create_module(epackage.eSuperPackage).const_set(epackage.name, m) if epackage.eSuperPackage
+  # 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)
+    with_empty_constant_order_helper do
+      temp = under.to_s.start_with?("#")
+      mod = create_module_internal(epackage, under, temp)
 
-    # 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)
+          create_class(c, temp)
         elsif c.is_a?(RGen::ECore::EEnum)
           create_enum(c)
         end
       end
-      @in_create_module = false
+
+      mod
+    end
+  end
+
+  private
+
+  def create_module_internal(epackage, under, temp)
+    return @modules[epackage] if @modules[epackage]
+    
+    if temp
+      mod = Module.new do
+        extend RGen::MetamodelBuilder::ModuleExtension
+      end
+      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 +127,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 +140,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 +177,53 @@ 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
+
+  class EmptyConstantOrderHelper
+    def classCreated(c); end
+    def moduleCreated(m); end
+    def enumCreated(e); end
+  end
+
+  def with_empty_constant_order_helper
+    orig_coh = RGen::MetamodelBuilder::ConstantOrderHelper
+    RGen::MetamodelBuilder.instance_eval { remove_const(:ConstantOrderHelper) }
+    RGen::MetamodelBuilder.const_set(:ConstantOrderHelper, EmptyConstantOrderHelper.new)
+
+    begin
+      result = yield
+    ensure
+      RGen::MetamodelBuilder.instance_eval { remove_const(:ConstantOrderHelper) }
+      RGen::MetamodelBuilder.const_set(:ConstantOrderHelper, orig_coh)
+    end
+
+    result
+  end
+
+  public
+
   def add_features(eclass)
     return false if @features_added[eclass]
     c = @classifiers[eclass]
@@ -147,18 +245,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/fragment/fragmented_model.rb

@@ -111,6 +111,8 @@ class FragmentedModel
   # This is a Hash mapping identifiers to model elements accessible via the identifier. 
   #
   def index
+    # Invalidate the cache when any fragment's local index changes.
+    # Assumption: If the local index content changes, there is a new index object.
     fragments.each do |f|
       if !@fragment_index[f] || (@fragment_index[f].object_id != f.index.object_id)
         @fragment_index[f] = f.index

data/lib/rgen/fragment/model_fragment.rb

@@ -117,6 +117,9 @@ class ModelFragment
   end
   
   # Returns the index of the element contained in this fragment.
+  # 
+  # FragmentedModel's index caching depends on the fact that any change 
+  # of a fragment's index contents implies a new index object.
   #
   def index
     build_index unless @index

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