rgen 0.3.0 → 0.4.0

data/lib/rgen/instantiator/nodebased_xml_instantiator.rb

@@ -0,0 +1,157 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","..","..","redist","xmlscan","lib")
+
+require 'rgen/metamodel_builder'
+require 'rgen/instantiator/abstract_instantiator'
+require 'xmlscan/namespace'
+
+module RGen
+
+module Instantiator
+
+class NodebasedXMLInstantiator < AbstractInstantiator
+	
+	class << self
+
+		# The prune level is the number of parent/children associations which
+		# is kept when the instantiator ascents the XML tree.
+		# If the level is 2, information for the node's children and the childrens'
+		# children will be available as an XMLNodeDescriptor object.
+		# If the level is 0 no pruning will take place, i.e. the whole information
+		# is kept until the end of the instantiation process. 0 is default.
+		def set_prune_level(level)
+			@prune_level = level
+		end
+
+		def prune_level # :nodoc:
+			@prune_level ||= 0
+		end
+
+	end
+
+	class XMLNodeDescriptor
+		attr_reader :namespace, :qtag, :prefix, :tag, :parent, :attributes, :chardata
+		attr_accessor :object, :children
+		
+		def initialize(ns, qtag, prefix, tag, parent, children, attributes)
+			@namespace, @qtag, @prefix, @tag, @parent, @children, @attributes = 
+				ns, qtag, prefix, tag, parent, children, attributes
+			@parent.children << self if @parent
+			@chardata = []
+		end
+	end
+	
+	class XMLScanVisitor
+	    attr_reader :namespaces
+	    
+		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 on_stag_end_ns(qname, namespaces)
+		    @namespaces = namespaces
+			if qname =~ /^([^:]+):([^:]+)$/
+				prefix, tag = $1, $2
+			else
+				prefix, tag = nil, qname
+			end
+			@instantiator.start_element(namespaces[prefix], qname, prefix, tag, @current_attributes)
+			@current_attributes = {}
+		end
+		
+		def on_stag_end_empty_ns(qname, namespaces)
+			on_stag_end_ns(qname, namespaces)
+			@instantiator.end_element
+		end
+		
+		def on_etag(name)
+			@instantiator.end_element
+		end
+		
+		def on_chardata(str)
+			@instantiator.on_chardata(str)
+		end
+	end
+	
+	def initialize(env)
+		super
+		@env = env
+		@stack = []
+	end
+	
+	def instantiate_file(file)
+		File.open(file) { |f| parse(f.read)}
+		resolve
+	end
+	
+	def instantiate(text)
+		parse(text)
+		resolve
+	end
+		
+	def parse(src)
+	    @visitor = XMLScanVisitor.new(self)
+		parser = XMLScan::XMLParserNS.new(@visitor)
+	    parser.parse(src)
+		@visitor = nil
+	end	
+		
+	def start_element(ns, qtag, prefix, tag, attributes)
+		node = XMLNodeDescriptor.new(ns, qtag, prefix, tag, @stack[-1], [], attributes)
+		@stack.push node
+		on_descent(node)
+	end
+	
+	def end_element
+		node = @stack.pop
+		on_ascent(node)
+		prune_children(node, self.class.prune_level - 1) if self.class.prune_level > 0
+	end
+	
+	def on_chardata(str)
+		node = @stack.last
+		node.chardata << str
+	end
+
+	# This method is called when the XML parser goes down the tree.
+	# An XMLNodeDescriptor +node+ describes the current node.
+	# Implementing classes must overwrite this method.
+	def on_descent(node)
+		raise "Overwrite this method !"
+	end
+	
+	# This method is called when the XML parser goes up the tree.
+	# An XMLNodeDescriptor +node+ describes the current node.
+	# Implementing classes must overwrite this method.
+	def on_ascent(node)
+		raise "Overwrite this method !"
+	end
+
+    def namespaces
+      @visitor.namespaces if @visitor
+    end
+    
+	private
+	
+	def prune_children(node, level)
+		if level == 0
+			node.children = nil
+		else
+			node.children.each { |c| prune_children(c, level-1) }
+		end
+	end					
+end
+
+end
+
+end

data/lib/rgen/instantiator/xmi11_instantiator.rb

@@ -0,0 +1,164 @@
+require 'rgen/ecore/ecore'
+require 'rgen/instantiator/abstract_xml_instantiator'
+require 'rgen/array_extensions'
+
+class XMI11Instantiator < AbstractXMLInstantiator
+  
+  include RGen::ECore
+
+  ResolverDescription = Struct.new(:object, :attribute, :value, :many)
+  
+  INFO = 0
+  WARN = 1
+  ERROR = 2
+  
+  def initialize(env, fix_map={}, loglevel=ERROR)
+    @env = env
+    @fix_map = fix_map
+    @loglevel = loglevel
+    @rolestack = []
+    @elementstack = []
+  end
+   
+  def add_metamodel(ns, mod)
+    @ns_module_map ||={}
+    @ns_module_map[ns] = mod
+  end  
+
+  def instantiate(str)
+    @resolver_descs = []
+    @element_by_id = {}
+    super(str)
+    @resolver_descs.each do |rd|
+      if rd.many
+        newval = rd.value.split(" ").collect{|v| @element_by_id[v]}
+      else
+        newval = @element_by_id[rd.value]
+      end
+      log WARN, "Could not resolve reference #{rd.attribute} on #{rd.object}" unless newval
+      rd.object.setGeneric(rd.attribute,newval)
+    end
+  end
+
+  def start_tag(prefix, tag, namespaces, attributes)
+    if tag =~ /\w+\.(\w+)/
+      # XMI role
+      role_name = map_feature_name($1) || $1
+      eRef = @elementstack.last && eAllReferences(@elementstack.last).find{|r|r.name == role_name}
+      log WARN, "No reference found for #{role_name} on #{@elementstack.last}" unless eRef
+      @rolestack.push eRef
+    elsif attributes["xmi.idref"]
+      # reference
+      rd = ResolverDescription.new
+      rd.object = @elementstack.last
+      rd.attribute = @rolestack.last.name
+      rd.value = attributes["xmi.idref"]
+      rd.many = @rolestack.last.many      
+      @resolver_descs << rd
+      @elementstack.push nil
+    else
+      # model element
+      value = map_tag(tag, attributes) || tag
+      if value.is_a?(String)
+        mod = @ns_module_map[namespaces[prefix]]
+        unless mod
+          log WARN, "Ignoring tag #{tag}"
+          return
+        end
+        value = mod.const_get(value).new
+      end
+      @env << value
+      eRef = @rolestack.last
+      if eRef && eRef.many
+        @elementstack.last.addGeneric(eRef.name, value)
+      elsif eRef
+        @elementstack.last.setGeneric(eRef.name, value)
+      end
+      @elementstack.push value
+    end
+  end
+  
+  def end_tag(prefix, tag)
+    if tag =~ /\w+\.(\w+)/
+      @rolestack.pop
+    else
+      @elementstack.pop
+    end
+  end  
+  
+  def set_attribute(attr, value)
+    return unless @elementstack.last
+    if attr == "xmi.id"
+      @element_by_id[value] = @elementstack.last
+    else
+      attr_name = map_feature_name(attr) || attr
+      eFeat = eAllStructuralFeatures(@elementstack.last).find{|a| a.name == attr_name}
+      unless eFeat
+        log WARN, "No structural feature found for #{attr_name} on #{@elementstack.last}"
+        return
+      end
+      if eFeat.is_a?(RGen::ECore::EReference)
+        if map_feature_value(attr_name, value).is_a?(eFeat.eType.instanceClass)
+          @elementstack.last.setGeneric(attr_name, map_feature_value(attr_name, value))
+        else
+          rd = ResolverDescription.new
+          rd.object = @elementstack.last
+          rd.attribute = attr_name
+          rd.value = value
+          rd.many = eFeat.many
+          @resolver_descs << rd
+        end
+      else
+        value = map_feature_value(attr_name, value) || value
+        value = true if value == "true" && eFeat.eType == EBoolean
+        value = false if value == "false" && eFeat.eType == EBoolean
+        value = value.to_i if eFeat.eType == EInt
+        value = value.to_f if eFeat.eType == EFloat
+        value = value.to_sym if eFeat.eType.is_a?(EEnum)
+        @elementstack.last.setGeneric(attr_name, value)
+      end
+    end
+  end
+  
+  private
+  
+  def map_tag(tag, attributes)
+    tag_map = @fix_map[:tags] || {}
+    value = tag_map[tag]
+    if value.is_a?(Proc)
+      value.call(tag, attributes)
+    else
+      value
+    end 
+  end
+        
+  def map_feature_name(name)
+    name_map = @fix_map[:feature_names] || {}
+    name_map[name]
+  end
+  
+  def map_feature_value(attr_name, value)
+    value_map = @fix_map[:feature_values] || {}
+    map = value_map[attr_name]
+    if map.is_a?(Hash)
+      map[value]
+    elsif map.is_a?(Proc)
+      map.call(value)
+    end
+  end
+  
+  def log(level, msg)
+    puts %w(INFO WARN ERROR)[level] + ": " + msg if level >= @loglevel
+  end
+
+  def eAllReferences(element)
+    @eAllReferences ||= {}
+    @eAllReferences[element.class] ||= element.class.ecore.eAllReferences
+  end
+    
+  def eAllStructuralFeatures(element)
+    @eAllStructuralFeatures ||= {}
+    @eAllStructuralFeatures[element.class] ||= element.class.ecore.eAllStructuralFeatures
+  end
+  
+end

data/lib/rgen/metamodel_builder.rb

@@ -3,6 +3,10 @@
 
 require 'rgen/metamodel_builder/builder_runtime'
 require 'rgen/metamodel_builder/builder_extensions'
+require 'rgen/metamodel_builder/module_extension'
+require 'rgen/metamodel_builder/data_types'
+require 'rgen/metamodel_builder/mm_multiple'
+require 'rgen/ecore/ecore_instantiator'
 
 module RGen
 
@@ -23,12 +27,12 @@ module RGen
 # Here is an example:
 # 
 # 	class Person < RGen::MetamodelBuilder::MMBase
-# 		has_one 'name', String
-# 		has_one 'age', Integer
+# 		has_attr 'name', String
+# 		has_attr 'age', Integer
 # 	end
 # 
 # 	class House < RGen::MetamodelBuilder::MMBase
-# 		has_one 'address'
+# 		has_attr 'address' # String is default
 # 	end
 # 
 # 	Person.many_to_many 'homes', House, 'inhabitants'
@@ -53,8 +57,7 @@ module RGen
 # 
 # 	p.name = :myName	# => exception: can not put a Symbol where a String is expected
 # 
-# If the type of an attribute should be left undefined, just leave away the
-# second argument of 'has_one' as show at the attribute 'address' for House.
+# If the type of an attribute should be left undefined, use Object as type.
 #
 # =Associations
 # 
@@ -81,11 +84,92 @@ module RGen
 # exception:
 # 
 # 	p.addHomes(:justASymbol) # => exception: can not put a Symbol where a House is expected
+#
+# =ECore Metamodel description
+# 
+# The class methods described above are used to create a Ruby representation of the metamodel
+# we have in mind in a very simple and easy way. We don't have to care about all the details
+# of a metamodel at this point (e.g. multiplicities, changeability, etc).
+# 
+# At the same time however, an instance of the ECore metametamodel (i.e. a ECore based
+# description of our metamodel) is provided for all the Ruby classes and modules we create.
+# Since we did not provide the nitty-gritty details of the metamodel, defaults are used to
+# fully complete the ECore metamodel description.
+#
+# In order to access the ECore metamodel description, just call the +ecore+ method on a
+# Ruby class or module object belonging to your metamodel.
+# 
+# Here is the example continued from above:
+# 
+# 	Person.ecore.eAttributes.name # => ["name", "age"]
+# 	h2pRef = House.ecore.eReferences.first
+# 	h2pRef.eType                  # => Person
+# 	h2pRef.eOpposite.eType        # => House
+# 	h2pRef.lowerBound             # => 0
+# 	h2pRef.upperBound             # => -1
+# 	h2pRef.many                   # => true
+# 	h2pRef.containment            # => false
+# 
+# Note that the use of array_extensions.rb is assumed here to make model navigation convenient.
+# 
+# The following metamodel builder methods are supported, see individual method description
+# for details:
+# 
+# Attributes:
+# * BuilderExtensions#has_attr
+# 
+# Unidirectional references:
+# * BuilderExtensions#has_one
+# * BuilderExtensions#has_many
+# * BuilderExtensions#contains_one_uni
+# * BuilderExtensions#contains_many_uni
+# 
+# Bidirectional references:
+# * BuilderExtensions#one_to_one
+# * BuilderExtensions#one_to_many
+# * BuilderExtensions#many_to_one
+# * BuilderExtensions#many_to_many
+# * BuilderExtensions#contains_one
+# * BuilderExtensions#contains_many
+# 
+# Every builder command can optionally take a specification of further ECore properties.
+# Additional properties for Attributes and References are (with defaults in brackets):
+# * :ordered (true), 
+# * :unique (true),
+# * :changeable (true),
+# * :volatile (false),
+# * :transient (false),
+# * :unsettable (false),
+# * :derived (false),
+# * :lowerBound (0),
+# * :resolveProxies (true) <i>references only</i>,
+# 
+# Using these additional properties, the above example can be refined as follows:
+# 
+# 	class Person < RGen::MetamodelBuilder::MMBase
+# 		has_attr 'name', String, :lowerBound => 1
+# 		has_attr 'yearOfBirth', Integer,
+# 		has_attr 'age', Integer, :derived => true
+# 		def age_derived
+# 			Time.now.year - yearOfBirth
+# 		end
+# 	end
 # 
-# _Unidirectional_ associations can be thought of as attributes as shown above. This means 
-# that 'has_one' or 'has_many' can be used to define such associations. Again, the
-# type of the attribute/association can be specified as a second argument.
+# 	Person.many_to_many 'homes', House, 'inhabitants', :upperBound => 5
 # 
+# 	Person.ecore.eReferences.find{|r| r.name == 'homes'}.upperBound # => 5
+# 
+# This way we state that there must be a name for each person, we introduce a new attribute
+# 'yearOfBirth' and make 'age' a derived attribute. We also say that a person can 
+# have at most 5 houses in our metamodel.
+# 
+# ==Derived attributes and references
+# 
+# If the attribute 'derived' of an attribute or reference is set to true, a method +attributeName_derived+
+# has to be provided. This method is called whenever the original attribute is accessed. The
+# original attribute can not be written if it is derived.
+# 
+#
 module MetamodelBuilder	
 
 	# Use this class as a start for new metamodel elements (i.e. Ruby classes)
@@ -94,9 +178,19 @@ module MetamodelBuilder
 	# See MetamodelBuilder for an example.
 	class MMBase
 		include BuilderRuntime
+		include DataTypes
 		extend BuilderExtensions
+		extend ModuleExtension
+		extend RGen::ECore::ECoreInstantiator
+		
+		def initialize(arg=nil)
+          arg.each_pair { |k,v| setGeneric(k, v) } if arg.is_a?(Hash)
+		end
+    	def self.method_added(m)
+    	  raise "Do not add methods to model classes directly, add them to the ClassModule instead"
+    	end
 	end
-
+	
 end
 
 end