rgen 0.7.0 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe212a74ff9c45d6fcd848596acb527d6def24f5
-  data.tar.gz: 3c99d2170dab24b922a30a5a5420f03aaa05779e
+  metadata.gz: e58b57346e1f7e95fcaa15f29112706c911d20ed
+  data.tar.gz: 6551cb4e9579f7e76582018876973edd9a58d0e6
 SHA512:
-  metadata.gz: a70a59af207fcf7d3c35c0f8785a9bcceebb370b9a0f41e07a2103bc563256acd6e5160d256c1e8c786d52f48f9e540ed62e2105348b9b9a520a57f9d0a99c0b
-  data.tar.gz: eae33d63df0964a0175917aa7efd711306e933a4ab56fa938976a5d28eb8fc53a3e7e18e984a4c89dd134d0421418f6d86ff02a60c1e7e011620a544a62b6edd
+  metadata.gz: 1e82e58dd4eaf95de47ef1714a778558a6bd3cb76f8229fb43e029a98f9e03c6234ee2fab831adde1d7de1b953665afab031f27f39b0ad7a060a91c4ed7c7328
+  data.tar.gz: 47b73a00783a82d630b0771fb55b01c4da6adffe73a459cd35828dd5040644b8b0f6cd00a565a4abf257d8c4d2e97ca17db2c072cbe05e8ae44fe9b2b3a2637e

data/CHANGELOG

@@ -195,3 +195,30 @@
 * 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
+
+=0.8.4
+
+* Add early loading for types which have attributes conflicting with Ruby reserved words.
+* Change type checking code to use ObjectSpace to find class objects. This is to find classes with an unbound name.

data/Project.yaml

@@ -0,0 +1,21 @@
+name: rgen
+gemspec: rgen.gemspec
+git: https://github.com/mthiede/rgen.git
+version: 0.8.4
+summary: Ruby Modelling and Generator Framework
+email: martin dot thiede at gmx de
+homepage: http://ruby-gen.org
+rubyforge_project: rgen
+description: 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.
+authors: [Martin Thiede]
+rdoc_options: [--main, README.rdoc, -x, test, -x, metamodels, -x, ea_support/uml13*]
+extra_rdoc_files: [README.rdoc, CHANGELOG, MIT-LICENSE]
+include_files: ['lib/**/*', 'test/**/*', README.rdoc, CHANGELOG, MIT-LICENSE, Rakefile]
+exclude_files: ['**/*.bak']
+encrypt_sources: false
+dependencies:
+  https://rubygems.org:
+    - {name: nokogiri,           version: ['~> 1.6.0', '>= 1.6.8.1'], development: true}
+    - {name: rake,               version: '~> 12.0',                development: true}
+    - {name: minitest,           version: ['~> 5.0', '>= 5.10.1'], development: true}
+    - {name: minitest-fail-fast, version: '~> 0.1.0',               development: true}

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,41 +1,38 @@
 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]
 
 task :clobber => [:clobber_rdoc, :clobber_package]
+
+task :ecore_to_json do
+  require 'rgen/ecore/ecore_to_json'
+
+  exporter = RGen::ECore::ECoreToJson.new
+  File.write('ecore.json', exporter.epackage_to_json_string(RGen.ecore, exporter.ecore_datatypes))
+end

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_json.rb

@@ -0,0 +1,188 @@
+require 'rgen/ecore/ecore'
+require 'json'
+
+module RGen
+
+module ECore
+
+# ECoreToJson can turn ECore models into their JSON metamodel representations
+class ECoreToJson
+
+def initialize
+
+end
+  
+def root_elements_to_json_string(root_elements)
+  JSON.pretty_generate(root_elements.map do |el|
+    if el.is_a?(RGen::ECore::EPackage)
+      epackage(el)
+    elsif el.is_a?(RGen::ECore::EClass)
+      eclass(el)
+    else
+      raise "Not implemented for #{el}"
+    end
+  end)
+end
+
+def epackage_to_json(package)
+  epackage(package)
+end
+
+def ecore_datatypes
+  [RGen::ECore::EString, RGen::ECore::EInt, RGen::ECore::ELong, RGen::ECore::EBoolean, RGen::ECore::EFloat,
+   RGen::ECore::ERubyObject, RGen::ECore::EJavaObject, RGen::ECore::ERubyClass, RGen::ECore::EJavaClass]
+      .map {|dt| edatatype(dt)}
+end
+
+def epackage_to_json_pretty_string(package, append = [])
+  JSON.pretty_generate([epackage_to_json(package)] + append)
+end
+
+def epackage_to_json_string(package, append = [])
+  JSON.generate([epackage_to_json(package)] + append)
+end
+  
+def emodelelement(me)
+  {
+    :eAnnotations => me.eAnnotations.map { |e| eannotation(e) }
+  }
+end
+
+
+def enamedelement(ne)
+  merge(emodelelement(ne), {:name => ne.name})
+end
+
+def epackage(package)
+  merge(enamedelement(package), {
+    :_class_ref => 'RGen.ECore.EPackage',
+    :eClassifiers => package.eClassifiers.map do |classifier|
+      if classifier.is_a?(RGen::ECore::EClass)
+        eclass(classifier)
+      elsif classifier.is_a?(RGen::ECore::EEnum)
+        eenum(classifier)
+      else
+        edatatype(classifier)
+      end
+    end,
+    :eSubpackages => package.eSubpackages.map { |sp| epackage(sp) },
+    :nsURI => package.nsURI,
+    :nsPrefix => package.nsPrefix
+  })
+end
+  
+def eclassifier(classifier)
+  enamedelement(classifier).merge({
+    # omit :instanceClassName => classifier.instanceClassName
+  })
+end
+  
+def eclass(_class)
+  merge(eclassifier(_class), {
+    :_class_ref => 'RGen.ECore.EClass',
+    :abstract => _class.abstract,
+    :interface => _class.interface,
+    :eStructuralFeatures => _class.eStructuralFeatures.map do |sf|
+      if sf.is_a?(RGen::ECore::EReference)
+        ereference(sf)
+      else
+        eattribute(sf)
+      end
+    end,
+    :eSuperTypes => _class.eSuperTypes.map { |st| {:_ref => ref_id(st)} }
+  })
+end
+  
+def edatatype(_datatype)
+  merge(eclassifier(_datatype), {
+    :_class_ref => 'RGen.ECore.EDataType',
+    :serializable => _datatype.serializable,
+    :instanceClassName => _datatype.instanceClassName
+  })
+end
+
+def eenum(enum)
+  merge(edatatype(enum), {
+    :_class_ref => 'RGen.ECore.EEnum',
+    :eLiterals => enum.eLiterals.map do |l|
+      merge({}, {
+        :_class_ref => 'RGen.ECore.EEnumLiteral',
+        :value => l.value,
+        :literal => l.literal
+      })
+    end      
+  })
+end
+
+def eannotation(e)
+  merge(emodelelement(e), {
+    :source => e.source,
+    :details => e.details.map do |d|
+      merge({}, {
+          :_class_ref => 'RGen.ECore.EStringToStringMapEntry',
+          :key => d.key,
+          :value => d.value
+      })
+    end
+  })
+end
+
+def etypedelement(te)
+  merge(enamedelement(te), {
+    :ordered => te.ordered,
+    :unique => te.unique,
+    :lowerBound => te.lowerBound,
+    :upperBound => te.upperBound,
+    :many => te.many,
+    :required => te.required,
+    :eType => {:_ref => te.eType ? ref_id(te.eType) : nil}
+  })
+end
+
+def estructuralfeature(sf)
+  merge(etypedelement(sf), {
+    :changeable => sf.changeable,
+    :volatile => sf.volatile,
+    :transient => sf.transient,
+    :defaultValueLiteral => sf.defaultValueLiteral,
+    :unsettable => sf.unsettable,
+    :derived => sf.derived,
+  })
+end
+  
+def eattribute(attr)
+  merge(estructuralfeature(attr), {
+    :_class_ref => 'RGen.ECore.EAttribute',
+    :iD => attr.iD
+  })
+end
+  
+def ereference(ref)
+  merge(estructuralfeature(ref), {
+    :_class_ref => 'RGen.ECore.EReference',
+    :containment => ref.containment,
+    :resolveProxies => ref.resolveProxies,
+    :eOpposite => ref.eOpposite ? {:_ref => "#{ref_id(ref.eOpposite.eContainer)}.#{ref.eOpposite.name}"} : nil
+  })
+end
+  
+def ref_id(obj)
+  res = ref_parts(obj)
+  res.join('.')
+end
+  
+def ref_parts(obj)
+  return [obj.name] unless obj&.eContainer
+  ref_parts(obj.eContainer) << obj.name 
+end
+  
+def merge(hash, values)
+  values.each { |k, v| hash[k] = v unless v.nil? }
+  hash
+end
+  
+end
+  
+end
+  
+end

data/lib/rgen/ecore/ecore_to_ruby.rb

@@ -1,66 +1,131 @@
+require 'set'
 require 'rgen/ecore/ecore'
 
 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
+    @reserved = Set.new(Object.methods)
   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
+
+      load_classes_with_reserved_keywords(epackage)
+      mod
+    end
+  end
+
+  private
+
+  def load_classes_with_reserved_keywords(epackage)
+    epackage.eAllClassifiers.each do |eclass|
+      # we early load classes which have ruby reserved keywords
+      if eclass.is_a?(RGen::ECore::EClass)
+        reserved_used = eclass.eStructuralFeatures.any? { |f| @reserved.include?(f.name.to_sym) }
+        add_features(eclass) if reserved_used
+      end
     end
-    m
   end
 
-  def create_class(eclass)
+  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
+    @modules[epackage] = mod
+
+    epackage.eSubpackages.each{|p| create_module_internal(p, mod, temp)}
+    mod._set_ecore_internal(epackage)
+
+    mod
+  end
+
+  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 +140,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 +153,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 +190,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 +258,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