rgen 0.8.0 → 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5091748f0290a5b0c82cf66e3bf2fea91ac774f6
+  data.tar.gz: db0663f172064272ed0bcd037e6715c12729429b
+SHA512:
+  metadata.gz: 1355aa9282e5c3a18a93b65788f4fb5a4f92b26bb5cf89fa50e7ec71bd63dad090af06b73e292e959a7750fe08d75a5e0e4a5f0010fe84bb162c6eed1af338d1
+  data.tar.gz: 3f8755a969d35c22d4d8b3bcabeb6c75799b48b416d242a83530afbdc8b7364e682ba59750eddc375a454b450ef1ed5d32941951d7397430f4172d37aa1841a7

data/CHANGELOG

@@ -205,3 +205,24 @@
 * 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.
+
+=0.9.0
+
+* Update to support Ruby 2.7, drop support for older Rubies

data/Project.yaml

@@ -0,0 +1,22 @@
+name: rgen
+gemspec: rgen.gemspec
+git: https://github.com/mthiede/rgen.git
+version: 0.9.0
+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.11.2', '< 1.12'],    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}
+    - {name: andand,             version: '1.3.3',                    development: true}

data/Rakefile

@@ -1,41 +1,37 @@
 require 'rubygems/package_task'
 require 'rdoc/task'
+require 'rake/testtask'
 
-RGenGemSpec = Gem::Specification.new do |s|
-  s.name = %q{rgen}
-  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}
-  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

@@ -12,9 +12,11 @@ module RGen
     extend RGen::MetamodelBuilder::ModuleExtension
     
     class EObject < RGen::MetamodelBuilder::MMBase
+      abstract
     end
     
     class EModelElement < RGen::MetamodelBuilder::MMBase
+      abstract
     end
     
     class EAnnotation < RGen::MetamodelBuilder::MMMultiple(EModelElement, EObject)
@@ -22,10 +24,12 @@ module RGen
     end
     
     class ENamedElement < EModelElement
+      abstract
       has_attr 'name', String
     end
     
     class ETypedElement < ENamedElement
+      abstract
       has_attr 'lowerBound', Integer, :defaultValueLiteral => "0"
       has_attr 'ordered', Boolean, :defaultValueLiteral => "true"
       has_attr 'unique', Boolean, :defaultValueLiteral => "true"
@@ -43,6 +47,7 @@ module RGen
     end
     
     class EStructuralFeature < ETypedElement
+      abstract
       has_attr 'changeable', Boolean, :defaultValueLiteral => "true"
       has_attr 'defaultValue', Object, :derived=>true
       has_attr 'defaultValueLiteral', String
@@ -76,6 +81,7 @@ module RGen
     end
     
     class EClassifier < ENamedElement
+      abstract
       has_attr 'defaultValue', Object, :derived=>true
       has_attr 'instanceClass', Object, :derived=>true
       has_attr 'instanceClassName', String
@@ -155,7 +161,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,189 @@
+require 'rgen/ecore/ecore'
+require 'json'
+require 'andand'
+
+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(enamedelement(l), {
+        :_class_ref => 'RGen.ECore.EEnumLiteral',
+        :value => l.value,
+      })
+    end      
+  })
+end
+
+def eannotation(e)
+  merge(emodelelement(e), {
+    :_class_ref => 'RGen.ECore.EAnnotation',
+    :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.andand.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,3 +1,4 @@
+require 'set'
 require 'rgen/ecore/ecore'
 
 module RGen
@@ -11,6 +12,7 @@ class ECoreToRuby
     @modules = {}
     @classifiers = {}
     @features_added = {}
+    @reserved = Set.new(Object.methods)
   end
 
   # Create a Ruby module representing +epackage+.
@@ -38,22 +40,35 @@ class ECoreToRuby
   # 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)
+    with_empty_constant_order_helper do
+      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
-    end
 
-    mod
+      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
+  end
+
   def create_module_internal(epackage, under, temp)
     return @modules[epackage] if @modules[epackage]
     
@@ -199,6 +214,27 @@ class ECoreToRuby
     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)

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/metamodel_builder/builder_extensions.rb

@@ -319,6 +319,10 @@ module BuilderExtensions
         end
         <% if name != "class" %>
           alias <%= name %> get<%= firstToUpper(name) %>
+        <% else %>
+          def getGeneric(role)
+            send("get\#{firstToUpper(role.to_s)}")
+          end
         <% end %>
 
       CODE
@@ -380,10 +384,14 @@ module BuilderExtensions
       @@many_read_builder ||= ERB.new <<-CODE
       
         def get<%= firstToUpper(name) %>
-          ( @<%= name %> ? @<%= name %>.dup : [] )
+          ( defined?(@<%= name %>) ? @<%= name %>.dup : [] )
         end
         <% if name != "class" %>
           alias <%= name %> get<%= firstToUpper(name) %>
+        <% else %>
+          def getGeneric(role)
+            send("get\#{firstToUpper(role.to_s)}")
+          end
         <% end %>
               
       CODE
@@ -394,7 +402,7 @@ module BuilderExtensions
       @@many_write_builder ||= ERB.new <<-CODE
     
         def add<%= firstToUpper(name) %>(val, index=-1)
-          @<%= name %> = [] unless @<%= name %>
+          @<%= name %> = [] unless defined?(@<%= name %>)
           return if val.nil? || (val.is_a?(MMBase) || val.is_a?(MMGeneric)) && @<%= name %>.any? {|e| e.equal?(val)}
           <%= type_check_code("val", props) %>
           @<%= name %>.insert(index, val)
@@ -407,7 +415,7 @@ module BuilderExtensions
         end
         
         def remove<%= firstToUpper(name) %>(val)
-          @<%= name %> = [] unless @<%= name %>
+          @<%= name %> = [] unless defined?(@<%= name %>)
           @<%= name %>.each_with_index do |e,i|
             if e.equal?(val)
               @<%= name %>.delete_at(i)
@@ -428,7 +436,7 @@ module BuilderExtensions
           get<%= firstToUpper(name) %>.each {|e|
             remove<%= firstToUpper(name) %>(e)
           }
-          @<%= name %> = [] unless @<%= name %>
+          @<%= name %> = [] unless defined?(@<%= name %>)
           <% if props.reference? %>
           val.uniq {|elem| elem.object_id }.each {|elem|
             next if elem.nil?
@@ -451,7 +459,7 @@ module BuilderExtensions
         alias <%= name %>= set<%= firstToUpper(name) %>
         
         def _register<%= firstToUpper(name) %>(val)
-          @<%= name %> = [] unless @<%= name %>
+          @<%= name %> = [] unless defined?(@<%= name %>)
           @<%= name %>.push val
           <% if props.reference? && props.value(:containment) %>
             val._set_container(self, :<%= name %>)
@@ -531,7 +539,7 @@ module BuilderExtensions
       code << "\n"
       expected = "Integer"
     elsif props.impl_type.is_a?(Class)
-      code << "unless #{varname}.nil? || #{varname}.is_a?(#{props.impl_type}) || #{varname}.is_a?(MMGeneric)"
+      code << "unless #{varname}.nil? || #{varname}.is_a?(ObjectSpace._id2ref(#{props.impl_type.object_id})) || #{varname}.is_a?(MMGeneric)"
       code << " || #{varname}.is_a?(BigDecimal)" if props.impl_type == Float && defined?(BigDecimal)
       code << "\n"
       expected = props.impl_type.to_s

data/lib/rgen/metamodel_builder/builder_runtime.rb

@@ -58,14 +58,17 @@ module BuilderRuntime
     end
   end
 
-	def getGeneric(role)
-		send("get#{firstToUpper(role.to_s)}")
-	end
+  alias getGeneric send
 
   def getGenericAsArray(role)
     result = getGeneric(role)
-    result = [result].compact unless result.is_a?(Array)
-    result
+    if result.nil?
+      []
+    elsif result.is_a?(Array)
+      result
+    else
+      [result]
+    end
   end
 
   def eIsSet(role)
@@ -100,6 +103,10 @@ module BuilderRuntime
 
   # if a block is given, calls the block on every contained element in depth first order. 
   # if the block returns :prune, recursion will stop at this point.
+  # 
+  # BEWARE of concurrent modification of contained elements while iterating!
+  # (adding/removing containers or contained elements)
+  # if you need to do such modifications, use the variant without a block instead.
   #
   # if no block is given builds and returns a list of all contained elements.
   #

data/lib/rgen/template_language/output_handler.rb

@@ -91,6 +91,16 @@ module TemplateLanguage
       @output.concat(s)
     end
     
+    def direct_concat_allow_indent(s)
+      unless @noIndentNextLine || (@output[-1] && @output[-1] != NL_CHAR)
+        @output.concat(@indent_string)
+      else
+        @noIndentNextLine = false
+      end
+      @state = :wait_for_nl
+      @output.concat(s)
+    end
+
     def ignoreNextNL
       @ignoreNextNL = true
     end

data/lib/rgen/template_language/template_container.rb

@@ -84,7 +84,7 @@ module RGen
       end
       
       def ws
-        _direct_concat(" ")
+        _direct_concat(" ", true)
       end
       
       def iinc
@@ -210,9 +210,13 @@ module RGen
         raise StandardError.new("Template class not matching: #{tpl} for #{context.class.name}") unless found
       end
         
-      def _direct_concat(s)
+      def _direct_concat(s, allow_indent=false)
         if @output.is_a? OutputHandler
-          @output.direct_concat(s)
+          if allow_indent
+            @output.direct_concat_allow_indent(s)
+          else
+            @output.direct_concat(s)
+          end
         else
           @output << s
         end

data/lib/rgen/template_language.rb

@@ -129,6 +129,7 @@ module RGen
 # Starting from this point one can add indentation and newlines as required by using
 # explicit formatting commands:
 # * <code><%nl%></code> (newline) starts a new line
+# * <code><%ws%></code> (whitespace) adds an explicit space
 # * <code><%iinc%></code> (indentation increment) increases the current indentation
 # * <code><%idec%></code> (indentation decrement) decreases the current indentation
 # * <code><%nonl%></code> (no newline) ignore next newline
@@ -294,4 +295,4 @@ module TemplateLanguage
 
 end
 
-end
+end