rgen 0.3.0 → 0.4.0

data/lib/rgen/ecore/ecore_instantiator.rb

@@ -0,0 +1,25 @@
+module RGen
+
+module ECore
+
+# Mixin to provide access to the ECore model describing a Ruby class or module
+# built using MetamodelBuilder.
+# The module should be used to +extend+ a class or module, i.e. to make its
+# methods class methods.
+# 
+module ECoreInstantiator
+	
+	# This method will lazily build to ECore model element belonging to the calling
+	# class or module using ECoreTransformer.
+	# 
+	def ecore
+		require 'rgen/ecore/ecore_transformer'
+		@@transformer ||= ECoreTransformer.new
+		@@transformer.trans(self)
+	end	
+	
+end
+
+end
+
+end

data/lib/rgen/ecore/ecore_transformer.rb

@@ -0,0 +1,85 @@
+require 'rgen/transformer'
+require 'rgen/ecore/ecore'
+
+module RGen
+  
+module ECore
+  
+# This transformer creates an ECore model from Ruby classes built
+# by RGen::MetamodelBuilder.
+# 
+class ECoreTransformer < Transformer
+  
+  transform Class, :to => EClass, :if => :convert? do
+    { :name => name.gsub(/.*::(\w+)$/,'\1'),
+      :abstract => false,
+      :interface => false,
+      :eStructuralFeatures => trans(_metamodel_description),
+      :ePackage =>  trans(name =~ /(.*)::\w+$/ ? eval($1) : nil),
+      :eSuperTypes => trans(superclasses),
+      :instanceClassName => name,
+      :eAnnotations => trans(_annotations)
+    }
+  end
+  
+  method :superclasses do
+    if superclass.respond_to?(:multiple_superclasses) && superclass.multiple_superclasses
+      superclass.multiple_superclasses
+    else
+      [ superclass ]
+    end
+  end
+  
+  transform Module, :to => EPackage, :if => :convert?  do
+    { :name => name.gsub(/.*::(\w+)$/,'\1'),
+      :eClassifiers => trans(constants.collect{|c| const_get(c)}.select{|c| c.is_a?(Class)}),
+      :eSuperPackage => trans(name =~ /(.*)::\w+$/ ? eval($1) : nil),
+      :eSubpackages => trans(constants.collect{|c| const_get(c)}.select{|c| c.is_a?(Module) && !c.is_a?(Class)}),
+      :eAnnotations => trans(_annotations)
+    }
+  end
+  
+  method :convert? do
+    @current_object.respond_to?(:ecore) && @current_object != RGen::MetamodelBuilder::MMBase
+  end
+  
+  transform MetamodelBuilder::AttributeDescription, :to => EAttribute do
+    Hash[*MetamodelBuilder::AttributeDescription.propertySet.collect{|p| [p, value(p)]}.flatten].merge({
+      :eType => (etype == :EEnumerable ? trans(impl_type) : RGen::ECore.const_get(etype)),
+      :eAnnotations => trans(annotations)
+    })
+  end
+  
+  transform MetamodelBuilder::ReferenceDescription, :to => EReference do
+    Hash[*MetamodelBuilder::ReferenceDescription.propertySet.collect{|p| [p, value(p)]}.flatten].merge({
+      :eType => trans(impl_type),
+      :eOpposite => trans(opposite),
+      :eAnnotations => trans(annotations)
+    })
+  end
+  
+  transform MetamodelBuilder::Intermediate::Annotation, :to => EAnnotation do
+    { :source => source,
+      :details => details.keys.collect do |k|
+        e = EStringToStringMapEntry.new
+        e.key = k
+        e.value = details[k]
+        e
+      end
+    }
+  end
+  
+  transform MetamodelBuilder::DataTypes::Enum, :to => EEnum do
+    { :name => name, 
+      :eLiterals => literals.collect do |l|
+        lit = EEnumLiteral.new
+        lit.name = l.to_s
+        lit
+      end }
+  end
+  
+end
+  
+end
+  
+end

data/lib/rgen/environment.rb

@@ -1,8 +1,11 @@
+require 'rgen/find_helper'
+
 module RGen
 
 # An Environment is used to hold model elements.
 #
 class Environment
+	include RGen::FindHelper
 
 	def initialize
 		@elements = []
@@ -15,28 +18,10 @@ class Environment
 		self
 	end
 	
-	# Finds and returns model elements in the environment.
-	# 
-	# The search description argument must be a hash specifying attribute/value pairs.
-	# Only model elements are returned which respond to the specified attribute methods
-	# and return the specified values as result of these attribute methods.
-	# 
-	# As a special hash key :class can be used to look for model elements of a specific
-	# class. In this case an array of possible classes can optionally be given.
-	# 
-	def find(desc)
-		result = []
-		classes = desc[:class] if desc[:class] and desc[:class].is_a?(Array)
-		classes = [ desc[:class] ] if !classes and desc[:class]
-		elements.each {|e|
-			failed = false
-			failed = true if classes and !classes.any?{ |c| e.is_a?(c) }
-			desc.each_pair { |k,v|
-				failed = true if k != :class and ( !e.respond_to?(k) or e.send(k) != v )
-			}
-			result << e unless failed
-		}
-		result
+	# Iterates each element
+	#
+	def each(&b)
+		@elements.each(&b)
 	end
 	
 	# Return the elements of the environment as an array
@@ -48,8 +33,8 @@ class Environment
 	# This method can be used to instantiate a class and automatically put it into
 	# the environment. The new instance is returned.
 	#
-	def new(clazz)
-		@elements << clazz.new
+	def new(clazz, *args)
+		@elements << clazz.new(*args)
 		@elements[-1]
 	end
 end

data/lib/rgen/find_helper.rb

@@ -0,0 +1,68 @@
+module RGen
+
+module FindHelper
+	
+	# Finds and returns model elements in the environment.
+	# 
+	# The search description argument must be a hash specifying attribute/value pairs.
+	# Only model elements are returned which respond to the specified attribute methods
+	# and return the specified values as result of these attribute methods.
+	# 
+	# As a special hash key :class can be used to look for model elements of a specific
+	# class. In this case an array of possible classes can optionally be given.
+	# 
+	def find(desc)
+		result = []
+		classes = desc[:class] if desc[:class] and desc[:class].is_a?(Array)
+		classes = [ desc[:class] ] if !classes and desc[:class]
+		each {|e|
+			failed = false
+			failed = true if classes and !classes.any?{ |c| e.is_a?(c) }
+			desc.each_pair { |k,v|
+				failed = true if k != :class and ( !e.respond_to?(k) or e.send(k) != v )
+			}
+			result << e unless failed
+		}
+		result
+	end
+	
+	def findIndex(index_method)
+		index = FindIndex.new(index_method)
+		each { |e|
+			index.add(e)
+		}
+		index
+	end
+
+	class FindIndex
+	
+		def initialize(index_method)
+			@index_method = index_method.to_sym
+			@index = {}
+			@non_indexed = [].extend(FindHelper)
+		end
+		
+		def add(element)
+			if element.respond_to?(@index_method)
+				val = element.send(@index_method)
+				@index[val] ||= [].extend(FindHelper)
+				@index[val] << element
+			end
+			@non_indexed << element
+		end
+		
+		def find(desc)
+			if (desc.keys.include?(@index_method))
+				val = desc.delete(@index_method)		
+				return [] unless @index[val]
+				return @index[val].find(desc)
+			else
+				return @non_indexed.find(desc)
+			end
+		end
+		
+	end
+	
+end
+
+end

data/lib/rgen/{instantiator.rb → instantiator/abstract_instantiator.rb}

@@ -1,6 +1,8 @@
 module RGen
 
-class Instantiator
+module Instantiator
+
+class AbstractInstantiator
 
 	ResolverDescription = Struct.new(:from, :attribute, :block) # :nodoc:
 
@@ -8,7 +10,7 @@ class Instantiator
 		attr_accessor :resolver_descs
 	end
 
-	def initialize(env, mod)
+	def initialize(env)
 		@env = env
 	end
 
@@ -59,4 +61,6 @@ class Instantiator
 	
 end
 
+end
+
 end

data/lib/rgen/instantiator/abstract_xml_instantiator.rb

@@ -0,0 +1,59 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","..","..","redist","xmlscan","lib")
+
+require 'xmlscan/namespace'
+
+class AbstractXMLInstantiator
+    
+  class XMLScanVisitor
+    include XMLScan::NSVisitor
+    
+    def initialize(inst)
+      @current_attributes = {}
+      @instantiator = inst
+    end
+    
+    def on_attribute_ns(qname, prefix, localpart)
+      @current_attr_name = qname
+    end
+    
+    def on_attr_value(str)
+      @current_attributes[@current_attr_name] = str
+    end
+    
+    def split_qname(qname)
+      if qname =~ /^([^:]+):([^:]+)$/
+        prefix, tag = $1, $2
+      else
+        prefix, tag = nil, qname
+      end
+      return prefix, tag
+    end
+    
+    def on_stag_end_ns(qname, namespaces)
+      prefix, tag = split_qname(qname)
+      @instantiator.start_tag(prefix, tag, namespaces, @current_attributes)
+      @current_attributes.each_pair { |k,v| @instantiator.set_attribute(k, v) }
+      @current_attributes = {}
+    end
+    
+    def on_stag_end_empty_ns(qname, namespaces)
+      prefix, tag = split_qname(qname)
+      @instantiator.start_tag(prefix, tag, namespaces, @current_attributes)
+      @current_attributes.each_pair { |k,v| @instantiator.set_attribute(k, v) }
+      @current_attributes = {}
+      @instantiator.end_tag(prefix, tag)
+    end
+    
+    def on_etag(qname)
+      prefix, tag = split_qname(qname)
+      @instantiator.end_tag(prefix, tag)
+    end
+  end
+
+  def instantiate(str)
+    visitor = XMLScanVisitor.new(self)
+	parser = XMLScan::XMLParserNS.new(visitor)
+    parser.parse(str)
+  end
+  
+end

data/lib/rgen/instantiator/default_xml_instantiator.rb

@@ -0,0 +1,117 @@
+require 'rgen/instantiator/nodebased_xml_instantiator'
+
+module RGen
+
+module Instantiator
+
+# A default XML instantiator.
+# Derive your own instantiator from this class or use it as is.
+# 
+class DefaultXMLInstantiator < NodebasedXMLInstantiator
+	include 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
+
+	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 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
+
+	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
+
+end
+
+end

data/lib/rgen/instantiator/ecore_xml_instantiator.rb

@@ -0,0 +1,144 @@
+require 'rgen/ecore/ecore'
+require 'rgen/instantiator/abstract_xml_instantiator'
+require 'rgen/array_extensions'
+
+class ECoreXMLInstantiator < AbstractXMLInstantiator
+  
+  include RGen::ECore
+  
+  INFO = 0
+  WARN = 1
+  ERROR = 2
+  
+  def initialize(env, loglevel=ERROR)
+    @env = env
+    @rolestack = []
+    @elementstack = []
+    @loglevel = loglevel
+  end
+  
+  def start_tag(prefix, tag, namespaces, attributes)
+    eRef = nil
+    if @elementstack.last
+      eRef = eAllReferences(@elementstack.last).find{|r|r.name == tag}
+      if eRef
+        if attributes["xsi:type"] && attributes["xsi:type"] =~ /ecore:(\w+)/
+          class_name = $1
+          attributes.delete("xsi:type")
+        else 
+          class_name = eRef.eType.name
+        end
+      else
+        raise "Reference not found: #{tag} on #{@elementstack.last}"
+      end
+    else
+      class_name = tag
+    end
+    
+    eClass = RGen::ECore.ecore.eClassifiers.find{|c| c.name == class_name}
+    if eClass
+      obj = RGen::ECore.const_get(class_name).new
+      if eRef
+        if eRef.many
+          @elementstack.last.addGeneric(eRef.name, obj)
+        else
+          @elementstack.last.setGeneric(eRef.name, obj)
+        end
+      end
+      @env << obj
+      @elementstack.push obj
+    else
+      log WARN, "Class not found: #{class_name}"
+      @elementstack.push nil
+    end
+  end
+  
+  def end_tag(prefix, tag)
+    @elementstack.pop
+  end
+  
+  ResolverDescription = Struct.new(:object, :attribute, :value)
+  
+  def set_attribute(attr, value)
+    return unless @elementstack.last
+    eFeat = eAllStructuralFeatures(@elementstack.last).find{|a| a.name == attr}
+    if eFeat.is_a?(EReference)
+      rd = ResolverDescription.new
+      rd.object = @elementstack.last
+      rd.attribute = attr
+      rd.value = value
+      @resolver_descs << rd
+    elsif eFeat
+      value = true if value == "true" && eFeat.eType == EBoolean
+      value = false if value == "false" && eFeat.eType == EBoolean
+      value = value.to_i if eFeat.eType == EInt
+      @elementstack.last.setGeneric(attr, value)
+    else
+      log WARN, "Feature not found: #{attr} on #{@elementstack.last}"
+    end
+  end
+  
+  def instantiate(str)
+    @resolver_descs = []
+#    puts "Instantiating ..."
+    super
+    rootpackage = @env.find(:class => EPackage).first
+#    puts "Resolving ..."
+    @resolver_descs.each do |rd|
+      refed = find_referenced(rootpackage, rd.value)
+      feature = eAllStructuralFeatures(rd.object).find{|f| f.name == rd.attribute}
+      raise StandardError.new("StructuralFeature not found: #{rd.attribute}") unless feature
+      if feature.many
+        rd.object.setGeneric(feature.name, refed)
+      else
+        rd.object.setGeneric(feature.name, refed.first)
+      end
+    end
+  end
+  
+  def eAllReferences(element)
+    @eAllReferences ||= {}
+    @eAllReferences[element.class] ||= element.class.ecore.eAllReferences
+  end
+  
+  def eAllAttributes(element)
+    @eAllAttributes ||= {}
+    @eAllAttributes[element.class] ||= element.class.ecore.eAllAttributes
+  end
+  
+  def eAllStructuralFeatures(element)
+    @eAllStructuralFeatures ||= {}
+    @eAllStructuralFeatures[element.class] ||= element.class.ecore.eAllStructuralFeatures
+  end
+  
+  def find_referenced(context, desc)
+    desc.split(/\s+/).collect do |r|
+      if r =~ /^#\/\d*\/([\w\/]+)/
+        find_in_context(context, $1.split('/'))
+      end
+      end.compact
+    end
+    
+    def find_in_context(context, desc_elements)
+      if context.is_a?(EPackage)
+        r = (context.eClassifiers + context.eSubpackages).find{|c| c.name == desc_elements.first}
+      elsif context.is_a?(EClass)
+        r = context.eStructuralFeatures.find{|s| s.name == desc_elements.first}
+      else
+        raise StandardError.new("Don't know how to find #{desc_elements.join('/')} in context #{context}")
+      end
+      if r
+        if desc_elements.size > 1
+          find_in_context(r, desc_elements[1..-1])
+        else
+          r
+        end
+      else
+        log WARN, "Can not follow path, element #{desc_elements.first} not found within #{context}(#{context.name})"
+      end
+    end
+    
+    def log(level, msg)
+      puts %w(INFO WARN ERROR)[level] + ": " + msg if level >= @loglevel
+    end
+  end