rgen 0.5.1 → 0.5.2

data/lib/rgen/instantiator/json_parser.y

@@ -0,0 +1,89 @@
+class JsonParser
+
+rule
+
+  json: value { result = val[0] }
+
+  array: "[" valueList "]" { result = val[1] }
+    | "[" "]" { result = [] }
+
+  valueList: value { result = [ val[0] ] }
+    | value "," valueList { result = [ val[0] ] + val[2] }
+
+  object: "{" memberList "}" { result = @instantiator.createObject(val[1]) }
+    | "{" "}" { result = nil }
+
+  memberList: member { result = val[0] }
+    | member "," memberList { result = val[0].merge(val[2]) } 
+
+  member: STRING ":" value { result = {val[0].value => val[2]} }
+
+  value: array { result = val[0] }
+    | object { result = val[0] }
+    | STRING { result = val[0].value }
+    | INTEGER { result = val[0].value.to_i }
+    | FLOAT { result = val[0].value.to_f }
+    | "true" { result = true }
+    | "false" { result = false }
+
+end
+
+---- header
+
+module RGen
+
+module Instantiator
+
+---- inner
+
+	ParserToken = Struct.new(:line, :file, :value)
+
+  def initialize(instantiator)
+    @instantiator = instantiator
+  end
+     	
+	def parse(str, file=nil)
+		@q = []
+		line = 1
+		
+		until str.empty?
+			case str
+				when /\A\n/
+					str = $'
+					line +=1
+				when /\A\s+/
+					str = $'
+				when /\A([-+]?\d+\.\d+)/
+					str = $'
+					@q << [:FLOAT, ParserToken.new(line, file, $1)]
+				when /\A([-+]?\d+)/
+					str = $'
+					@q << [:INTEGER, ParserToken.new(line, file, $1)]
+				when /\A"((?:[^"\\]|\\"|\\\\|\\[^"\\])*)"/
+					str = $'
+          sval = $1
+          sval.gsub!('\\\\','\\')
+          sval.gsub!('\\"','"')
+					@q << [:STRING, ParserToken.new(line, file, sval)]
+				when /\A(\{|\}|\[|\]|,|:|true|false)/
+					str = $'
+					@q << [$1, ParserToken.new(line, file, $1)]
+        else
+          raise "parse error in line #{line} on "+str[0..20].inspect+"..."
+			end
+		end
+		@q.push [false, ParserToken.new(line, file, '$end')]
+		do_parse
+	end
+	
+	def next_token
+		r = @q.shift
+    r
+	end
+	
+---- footer
+
+end
+
+end
+

data/lib/rgen/instantiator/qualified_name_resolver.rb

@@ -0,0 +1,93 @@
+require 'rgen/instantiator/reference_resolver'
+
+module RGen
+
+module Instantiator
+
+# This is a resolver resolving element identifiers which are qualified names.
+class QualifiedNameResolver
+  include ReferenceResolver
+
+  attr_reader :nameAttribute
+  attr_reader :separator
+  attr_reader :leadingSeparator
+
+  def initialize(rootElements, options={})
+    @rootElements = rootElements
+    @nameAttribute = options[:nameAttribute] || "name"
+    @separator = options[:separator] || "/"
+    @leadingSeparator = options.has_key?(:leadingSeparator) ? options[:leadingSeparator] : true
+    @elementByQName = {}
+    @visitedQName = {}
+    @childReferences = {}
+  end
+
+  def resolveIdentifier(qualifiedName)
+    return @elementByQName[qualifiedName] if @elementByQName.has_key?(qualifiedName)
+    path = qualifiedName.split(separator).reject{|s| s == ""}
+    if path.size > 1
+      parentQName = (leadingSeparator ? separator : "") + path[0..-2].join(separator)
+      parents = resolveIdentifier(parentQName)
+      parents = [parents].compact unless parents.is_a?(Array)
+      children = parents.collect{|p| allNamedChildren(p)}.flatten
+    elsif path.size == 1
+      parentQName = ""
+      children = allRootNamedChildren
+    else
+      return @elementByQName[qualifiedName] = nil
+    end
+    # if the parent was already visited all matching elements are the hash 
+    if !@visitedQName[parentQName]
+      children.each do |c|
+        name = c.send(nameAttribute)
+        if name
+          qname = parentQName + ((parentQName != "" || leadingSeparator) ? separator : "") + name
+          existing = @elementByQName[qname]
+          if existing 
+            @elementByQName[qname] = [existing] unless existing.is_a?(Array)
+            @elementByQName[qname] << c
+          else
+            @elementByQName[qname] = c 
+          end
+        end
+      end
+      # all named children of praent have been checked and hashed
+      @visitedQName[parentQName] = true
+    end
+    @elementByQName[qualifiedName] ||= nil
+  end
+
+  private
+
+  def allNamedChildren(element)
+    childReferences(element.class).collect do |r|
+      element.getGenericAsArray(r.name).collect do |c|
+        if c.respond_to?(nameAttribute)
+          c
+        else
+          allNamedChildren(c)
+        end
+      end
+    end.flatten
+  end
+
+  def allRootNamedChildren
+    @rootElements.collect do |e|
+      if e.respond_to?(nameAttribute)
+        e
+      else
+        allNamedChildren(e)
+      end
+    end.flatten
+  end
+
+  def childReferences(clazz)
+    @childReferences[clazz] ||= clazz.ecore.eAllReferences.select{|r| r.containment}
+  end
+
+end
+
+end
+
+end
+

data/lib/rgen/instantiator/reference_resolver.rb

@@ -0,0 +1,44 @@
+module RGen
+
+module Instantiator
+
+# This module is meant to be mixed into a resolver class providing the method +resolveIdentifier+
+module ReferenceResolver
+ 
+  # Instances of this class represent information about not yet resolved references.
+  # This consists of the +element+ and metamodel +featureName+ which hold/is to hold the reference
+  # and the proxy object which is the placeholder for the reference.
+  UnresolvedReference = Struct.new(:element, :featureName, :proxy)
+
+  # tries to resolve the given +unresolvedReferences+
+  # if resolution is successful, the proxy object will be removed
+  # otherwise there will be an error description in +problems+
+  # returns an array of the references which are still unresolved
+  def resolveReferences(unresolvedReferences, problems=[])
+    stillUnresolvedReferences = []
+    unresolvedReferences.each do |ur|
+      target = resolveIdentifier(ur.proxy.targetIdentifier)
+      if target && !target.is_a?(Array)
+        if ur.element.hasManyMethods(ur.featureName)
+          ur.element.removeGeneric(ur.featureName, ur.proxy)
+          ur.element.addGeneric(ur.featureName, target)
+        else
+          # this will replace the proxy
+          ur.element.setGeneric(ur.featureName, target)
+        end
+      elsif target
+        problems << "identifier #{ur.proxy.targetIdentifier} not uniq"
+        stillUnresolvedReferences << ur
+      else
+        problems << "identifier #{ur.proxy.targetIdentifier} not found"
+        stillUnresolvedReferences << ur
+      end
+    end
+    stillUnresolvedReferences
+  end   
+
+end
+
+end
+
+end

data/lib/rgen/metamodel_builder.rb

@@ -192,6 +192,17 @@ module MetamodelBuilder
 	  end
 	end
 	
+  # Instances of the proxy class can be used as values in any reference feature
+  # They can be used instead of the real target elements in case references should be resolved later on
+  class MMProxy
+    # The +targetIdentifer+ is an object identifying the element the proxy represents
+    attr_accessor :targetIdentifier
+
+    def initialize(ident=nil)
+      @targetIdentifier = ident
+    end
+  end
+
 end
 
-end
+end

data/lib/rgen/metamodel_builder/builder_extensions.rb

@@ -36,6 +36,15 @@ module BuilderExtensions
       end
     end
     
+	# Add an attribute which can hold a single value.
+	# 'role' specifies the name which is used to access the attribute.
+	# 'target_class' specifies the type of objects which can be held by this attribute.
+	# If no target class is given, String will be default.
+	# 
+	# This class method adds the following instance methods, where 'role' is to be 
+	# replaced by the given role name:
+	# 	class#role	# getter
+	# 	class#role=(value)	# setter
 	def has_attr(role, target_class=nil, raw_props={}, &block)
 		props = AttributeDescription.new(target_class, _ownProps(raw_props).merge({
 			:name=>role, :upperBound=>1}))
@@ -43,14 +52,34 @@ module BuilderExtensions
 		FeatureBlockEvaluator.eval(block, props)
 		_build_internal(props)
 	end
-	
-	# Add a single attribute or unidirectional association.
+  
+ 	# Add an attribute which can hold multiple values.
 	# 'role' specifies the name which is used to access the attribute.
 	# 'target_class' specifies the type of objects which can be held by this attribute.
 	# If no target class is given, String will be default.
 	# 
 	# This class method adds the following instance methods, where 'role' is to be 
 	# replaced by the given role name:
+	# 	class#addRole(value)	
+	# 	class#removeRole(value)
+	# 	class#role	# getter, returns an array
+	# 	class#role= # setter, sets multiple values at once
+	# Note that the first letter of the role name is turned into an uppercase 
+	# for the add and remove methods.
+	def has_many_attr(role, target_class=nil, raw_props={}, &block)
+		props = AttributeDescription.new(target_class, _setManyUpperBound(_ownProps(raw_props).merge({
+			:name=>role})))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
+	end
+	
+	# Add a single unidirectional association.
+	# 'role' specifies the name which is used to access the association.
+	# 'target_class' specifies the type of objects which can be held by this association.
+	# 
+	# This class method adds the following instance methods, where 'role' is to be 
+	# replaced by the given role name:
 	# 	class#role	# getter
 	# 	class#role=(value)	# setter
 	# 
@@ -245,7 +274,7 @@ module BuilderExtensions
 	# 
 	def _build_internal(props1, props2=nil)
 		_add_metamodel_description(props1)
-		if props1.is_a?(ReferenceDescription) && props1.many?
+		if props1.many?
 			_build_many_methods(props1, props2)
 		else
 			_build_one_methods(props1, props2)
@@ -301,15 +330,15 @@ module BuilderExtensions
 					oldval = @<%= name %>
 					@<%= name %> = val
 					<% if other_role %>
-						oldval._unregister<%= firstToUpper(other_role) %>(self) unless oldval.nil?
-						val._register<%= firstToUpper(other_role) %>(self) unless val.nil?
+						oldval._unregister<%= firstToUpper(other_role) %>(self) unless oldval.nil? || oldval.is_a?(MMProxy)
+						val._register<%= firstToUpper(other_role) %>(self) unless val.nil? || val.is_a?(MMProxy)
 					<% end %>
 				end 
 				alias set<%= firstToUpper(name) %> <%= name %>=
 
 				def _register<%= firstToUpper(name) %>(val)
 					<% if other_role %>
-						@<%= name %>._unregister<%= firstToUpper(other_role) %>(self) unless @<%= name %>.nil?
+						@<%= name %>._unregister<%= firstToUpper(other_role) %>(self) unless @<%= name %>.nil? || @<%= name %>.is_a?(MMProxy)
 					<% end %>
 					@<%= name %> = val
 				end
@@ -353,7 +382,7 @@ module BuilderExtensions
 					<%= type_check_code("val", props) %>
 					@<%= name %>.push val
 					<% if other_role %>
-						val._register<%= firstToUpper(other_role) %>(self)
+						val._register<%= firstToUpper(other_role) %>(self) unless val.is_a?(MMProxy)
 					<% end %>
 				end
 				
@@ -363,7 +392,7 @@ module BuilderExtensions
 						if e.object_id == val.object_id
 							@<%= name %>.delete_at(i)
     						<% if other_role %>
-								val._unregister<%= firstToUpper(other_role) %>(self)
+                  val._unregister<%= firstToUpper(other_role) %>(self) unless val.is_a?(MMProxy)
     						<% end %>
 							return
 						end
@@ -428,10 +457,10 @@ module BuilderExtensions
 	def type_check_code(varname, props)
 		code = ""
 		if props.impl_type.is_a?(Class)
-			code << "unless #{varname}.nil? or #{varname}.is_a? #{props.impl_type}\n"
+			code << "unless #{varname}.nil? || #{varname}.is_a?(#{props.impl_type}) || #{varname}.is_a?(MMProxy)\n"
 			expected = props.impl_type.to_s
 		elsif props.impl_type.is_a?(RGen::MetamodelBuilder::DataTypes::Enum)
-			code << "unless #{varname}.nil? or [#{props.impl_type.literals_as_strings.join(',')}].include?(#{varname})\n"
+			code << "unless #{varname}.nil? || [#{props.impl_type.literals_as_strings.join(',')}].include?(#{varname})\n"
 		    expected = "["+props.impl_type.literals_as_strings.join(',')+"]"
 		else
 			raise StandardError.new("Unkown type "+props.impl_type.to_s)
@@ -464,4 +493,4 @@ end
 
 end
 
-end
+end

data/lib/rgen/metamodel_builder/builder_runtime.rb

@@ -30,10 +30,28 @@ module BuilderRuntime
 		send("#{role}=",value)
 	end
 
+  def hasManyMethods(role)
+    respond_to?("add#{firstToUpper(role)}")
+  end
+
+  def setOrAddGeneric(role, value)
+    if hasManyMethods(role)
+      addGeneric(role, value)
+    else
+      setGeneric(role, value)
+    end
+  end
+
 	def getGeneric(role)
 		send("#{role}")
 	end
 
+  def getGenericAsArray(role)
+    result = getGeneric(role)
+    result = [result].compact unless result.is_a?(Array)
+    result
+  end
+
 	def _assignmentTypeError(target, value, expected)
 		text = ""
 		if target
@@ -52,4 +70,4 @@ end
 
 end
 
-end
+end

data/lib/rgen/serializer/json_serializer.rb

@@ -0,0 +1,120 @@
+module RGen
+
+module Serializer
+
+class JsonSerializer
+
+  def initialize(writer, opts={})
+    @writer = writer
+    @elementIdentifiers = {}
+    @identAttrName = opts[:identAttrName] || "name"
+    @separator = opts[:separator] || "/"
+    @leadingSeparator = opts.has_key?(:leadingSeparator) ? opts[:leadingSeparator] : true 
+    @featureFilter = opts[:featureFilter]
+    @identifierProvider = opts[:identifierProvider]
+  end
+
+  def elementIdentifier(element)
+    ident = @identifierProvider && @identifierProvider.call(element)
+    ident || (element.is_a?(RGen::MetamodelBuilder::MMProxy) && element.targetIdentifier) || qualifiedElementName(element)
+  end
+
+  # simple identifier calculation based on qualified names
+  # prerequisits:
+  # * containment relations must be bidirectionsl
+  # * local name stored in single attribute +@identAttrName+ for all classes
+  #
+  def qualifiedElementName(element)
+    return @elementIdentifiers[element] if @elementIdentifiers[element]
+    localIdent = ((element.respond_to?(@identAttrName) && element.getGeneric(@identAttrName)) || "").strip
+    parentRef = element.class.ecore.eAllReferences.select{|r| r.eOpposite && r.eOpposite.containment}.first
+    parent = parentRef && element.getGeneric(parentRef.name)
+    if parent
+      if localIdent.size > 0
+        parentIdent = qualifiedElementName(parent)
+        result = parentIdent + @separator + localIdent
+      else
+        result = qualifiedElementName(parent)
+      end
+    else
+      result = (@leadingSeparator ? @separator : "") + localIdent
+    end
+    @elementIdentifiers[element] = result
+  end
+
+  def serialize(elements)
+    if elements.is_a?(Array)
+      write("[ ")
+      elements.each_with_index do |e, i| 
+        serializeElement(e)
+        write(",\n") unless i == elements.size-1 
+      end
+      write("]")
+    else
+      serializeElement(elements)
+    end
+  end
+
+  def serializeElement(element, indent="")
+    write(indent + "{ \"_class\": \""+element.class.ecore.name+"\"")
+    element.class.ecore.eAllStructuralFeatures.each do |f|
+      next if f.derived
+      value = element.getGeneric(f.name)
+      unless value == [] || value.nil? || 
+        (f.is_a?(RGen::ECore::EReference) && f.eOpposite && f.eOpposite.containment) || 
+        (@featureFilter && !@featureFilter.call(f)) 
+        write(", ")
+        writeFeature(f, value, indent)
+      end
+    end
+    write(" }")
+  end
+
+  def writeFeature(feat, value, indent)
+    write("\""+feat.name+"\": ")
+    if feat.is_a?(RGen::ECore::EAttribute)
+      if value.is_a?(Array)
+        write("[ "+value.collect{|v| attributeValue(v, feat)}.join(", ")+" ]")
+      else
+        write(attributeValue(value, feat))
+      end
+    elsif !feat.containment
+      if value.is_a?(Array)
+        write("[ "+value.collect{|v| "\""+elementIdentifier(v)+"\""}.join(", ")+" ]")
+      else
+        write("\""+elementIdentifier(value)+"\"")
+      end
+    else
+      if value.is_a?(Array)
+        write("[ \n")
+        value.each_with_index do |v, i|
+          serializeElement(v, indent+"  ")
+          write(",\n") unless i == value.size-1
+        end
+        write("]")
+      else
+        write("\n")
+        serializeElement(value, indent+"  ")
+      end
+    end
+  end
+
+  def attributeValue(value, a)
+    if a.eType == RGen::ECore::EString || a.eType.is_a?(RGen::ECore::EEnum)
+      "\""+value.to_s.gsub('"','\\"').gsub('\\','\\\\')+"\""
+    else
+      value.to_s
+    end
+  end
+   
+  private
+
+  def write(s)
+    @writer.write(s) 
+  end
+end
+
+end
+
+end
+