rgen 0.3.0 → 0.4.0

data/lib/rgen/metamodel_builder/build_helper.rb

@@ -11,16 +11,38 @@ class BuildHelper
 	include NameHelper
 	
 	def self.build(mod,bnd,tpl)
-		mod.module_eval ERB.new(tpl).result(BuildHelper.new(bnd).bnd)
+		mod.module_eval ERB.new(tpl).result(BuildHelper.new(mod, bnd).bnd)
 	end
-	def initialize(bnd)
+	def initialize(mod, bnd)
 		@outer_binding = bnd
+		@mod = mod
 	end
 	def bnd
 		binding
 	end
-	def method_missing(m)
-		eval("#{m}",@outer_binding)
+	def method_missing(m, *args)
+		if args.empty?
+			eval("#{m}",@outer_binding)
+		else
+			@mod.instance_eval do
+				send(m,*args)
+			end
+		end
+	end
+	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"
+			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"
+		    expected = "["+props.impl_type.literals_as_strings.join(',')+"]"
+		else
+			raise StandardError.new("Unkown type "+props.impl_type.to_s)
+		end
+		code << "raise _assignmentTypeError(self,#{varname},\"#{expected}\")\n"
+		code << "end"
+		code		
 	end
 end
 

data/lib/rgen/metamodel_builder/builder_extensions.rb

@@ -3,6 +3,7 @@
 
 require 'erb'
 require 'rgen/metamodel_builder/build_helper'
+require 'rgen/metamodel_builder/metamodel_description.rb'
 
 module RGen
 
@@ -16,19 +17,50 @@ module MetamodelBuilder
 # See MetamodelBuilder for an example.
 # 
 module BuilderExtensions
+	include NameHelper
 
+    class FeatureBlockEvaluator
+      def self.eval(block, props1, props2=nil)
+        return unless block
+        e = self.new(props1, props2)
+        e.instance_eval(&block)
+      end
+      def initialize(props1, props2)
+        @props1, @props2 = props1, props2
+      end
+      def annotation(hash)
+        @props1.annotations << Intermediate::Annotation.new(hash)
+      end
+      def opposite_annotation(hash)
+        raise "No opposite available" unless @props2
+        @props2.annotations << Intermediate::Annotation.new(hash)
+      end
+    end
+    
+	def has_attr(role, target_class=nil, raw_props={}, &block)
+		props = AttributeDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>role, :upperBound=>1}))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
+	end
+	
 	# Add a single attribute or unidirectional association.
 	# 'role' specifies the name which is used to access the attribute.
-	# 'target_class' is optional and can be used to fix the type of objects which
-	# can be held by this 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_one(role, target_class=nil)
-		has_one_internal(role, target_class)
+	def has_one(role, target_class=nil, raw_props={}, &block)
+		props = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>role, :upperBound=>1, :containment=>false}))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
 	end
 
 	# Add an unidirectional _many_ association.
@@ -44,8 +76,28 @@ module BuilderExtensions
 	# Note that the first letter of the role name is turned into an uppercase 
 	# for the add and remove methods.
 	# 
-	def has_many(role, target_class=nil)
-		has_many_internal(role, target_class)
+	def has_many(role, target_class=nil, raw_props={}, &block)
+		props = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>role, :upperBound=>-1,	:containment=>false}))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
+	end
+	
+	def contains_one_uni(role, target_class=nil, raw_props={}, &block)
+		props = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>role, :upperBound=>1, :containment=>true}))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
+	end
+
+	def contains_many_uni(role, target_class=nil, raw_props={}, &block)
+		props = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>role, :upperBound=>-1, :containment=>true}))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
 	end
 	
 	# Add a bidirectional one-to-many association between two classes.
@@ -69,15 +121,32 @@ module BuilderExtensions
 	# When an element is added/set on either side, this element also receives the element
 	# is is added to as a new element.
 	# 
-	def one_to_many(own_role, target_class, target_role)
-		has_many_internal(own_role,target_class,target_role,:one)
-		target_class.has_one_internal(target_role,self,own_role,:many)
+	def one_to_many(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>target_role, :upperBound=>-1, :containment=>false}))
+		props2 = ReferenceDescription.new(self, _oppositeProps(raw_props).merge({
+			:name=>own_role, :upperBound=>1, :containment=>false}))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
+	end
+
+	def contains_many(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>target_role, :upperBound=>-1, :containment=>true}))
+		props2 = ReferenceDescription.new(self, _oppositeProps(raw_props).merge({
+			:name=>own_role, :upperBound=>1, :containment=>false}))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
 	end
 	
 	# This is the inverse of one_to_many provided for convenience.
-	def many_to_one(own_role, target_class, target_role)
-		has_one_internal(own_role,target_class,target_role,:many)
-		target_class.has_many_internal(target_role,self,own_role,:one)
+	def many_to_one(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>target_role, :upperBound=>1, :containment=>false}))
+		props2 = ReferenceDescription.new(self, _oppositeProps(raw_props).merge({
+			:name=>own_role, :upperBound=>-1, :containment=>false}))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
 	end
 	
 	# Add a bidirectional many-to-many association between two classes.
@@ -102,9 +171,13 @@ module BuilderExtensions
 	# When an element is added on either side, this element also receives the element
 	# is is added to as a new element.
 	# 
-	def many_to_many(own_role, target_class, target_role)
-		has_many_internal(own_role,target_class,target_role,:many)
-		target_class.has_many_internal(target_role,self,own_role,:many)
+	def many_to_many(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>target_role, :upperBound=>-1, :containment=>false}))
+		props2 = ReferenceDescription.new(self, _oppositeProps(raw_props).merge({
+			:name=>own_role, :upperBound=>-1, :containment=>false}))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
 	end
 	
 	# Add a bidirectional one-to-one association between two classes.
@@ -125,93 +198,217 @@ module BuilderExtensions
 	# When an element is set on either side, this element also receives the element
 	# is is added to as the new element.
 	# 
-	def one_to_one(own_role, target_class, target_role)
-		has_one_internal(own_role,target_class,target_role,:one)
-		target_class.has_one_internal(target_role,self,own_role,:one)
+	def one_to_one(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>target_role, :upperBound=>1, :containment=>false}))
+		props2 = ReferenceDescription.new(self, _oppositeProps(raw_props).merge({
+			:name=>own_role, :upperBound=>1, :containment=>false}))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
 	end
 	
-	# Returns the names of the classes attributes pointing to a single object.
-	# The result includes this kind of attributes of the superclass.
-	def one_attributes
-		@one_attributes ||= []
-		result = @one_attributes.dup
-		result += superclass.one_attributes if superclass.respond_to?(:one_attributes)
-		result
+	def contains_one(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>target_role, :upperBound=>1, :containment=>true}))
+		props2 = ReferenceDescription.new(self, _oppositeProps(raw_props).merge({
+			:name=>own_role, :upperBound=>1, :containment=>false}))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
 	end
-	
-	# Returns the names of the classes attributes pointing to many other objects
-	# The result includes this kind of attributes of the superclass.
-	def many_attributes
-		@many_attributes ||= []
-		result = @many_attributes.dup
-		result += superclass.many_attributes if superclass.respond_to?(:many_attributes)
-		result
+		
+	def _metamodel_description # :nodoc:
+		@metamodel_description ||= []
 	end
 	
+	def inherited(c)
+	   c._class_module
+	end
+		
+	def _class_module # :nodoc:
+        unless const_defined?(:ClassModule)
+          const_set(:ClassModule, Module.new)
+          include const_get(:ClassModule)
+        end
+        const_get(:ClassModule)
+    end
+		
 	protected
-	
-	def has_one_internal(name, cls=nil, role=nil, kind=nil)
-		@one_attributes ||= []
-		return if @one_attributes.include?(name)
-		@one_attributes << name
-		BuildHelper.build self, binding, <<-CODE
-			def #{name}=(val)
-				return if val == @#{name}
-				<% if cls %>
-					raise _assignmentTypeError(self,val,#{cls}) unless val.nil? or val.is_a? #{cls}
-				<% end %>
-				oldval = @#{name}
-				@#{name} = val
-				_unregister(self,oldval,"#{role}","#{kind}")
-				_register(self,val,"#{role}","#{kind}")
-			end 
-			def #{name}
-				@#{name}
+		
+	# Central builder method
+	# 
+	def _build_internal(props1, props2=nil)
+		_metamodel_description << props1
+		if props1.is_a?(ReferenceDescription) && props1.many?
+			_build_many_methods(props1, props2)
+		else
+			_build_one_methods(props1, props2)
+		end
+		if props2
+			# this is a bidirectional reference
+			props1.opposite, props2.opposite = props2, props1
+			other_class = props1.impl_type			
+			other_class._metamodel_description << props2
+			raise "Internal error: second description must be a ReferenceDescription" \
+				unless props2.is_a?(ReferenceDescription)
+			if props2.many?
+				other_class._build_many_methods(props2, props1)
+			else
+				other_class._build_one_methods(props2, props1)
 			end
-			alias get<%= firstToUpper(name) %> #{name}
-			alias set<%= firstToUpper(name) %> #{name}=
-		CODE
+		end
 	end
 	
-	def has_many_internal(name, cls=nil, role=nil, kind = nil)
-		@many_attributes ||= []
-		return if @many_attributes.include?(name)
-		@many_attributes << name
-		BuildHelper.build self, binding, <<-CODE
-			def add<%= firstToUpper(name) %>(val)
-				@#{name} = [] unless @#{name}
-				return if val.nil? or @#{name}.include?(val) 
-				<% if cls %>
-					raise _assignmentTypeError(self,val,#{cls}) unless val.nil? or val.is_a? #{cls}
-				<% end %>
-				@#{name}.push val
-				_register(self, val, "#{role}", "#{kind}")
-			end
-			def remove<%= firstToUpper(name) %>(val)
-				@#{name} = [] unless @#{name}
-				return unless @#{name}.include?(val)
-				@#{name}.delete val
-				_unregister(self, val, "#{role}", "#{kind}")
-			end
+	# To-One association methods
+	# 
+	def _build_one_methods(props, other_props=nil)
+		name = props.value(:name)
+		other_role = other_props && other_props.value(:name)
+		other_kind = other_props && ( other_props.many? ? :many : :one )
+
+		if props.value(:derived)
+			build_derived_method(name, props, :one)
+		else
+			BuildHelper.build _class_module, binding, <<-CODE
+			
+				def #{name}
+				  <% if props.is_a?(AttributeDescription) && props.value(:defaultValueLiteral) %>
+					<% defVal = props.value(:defaultValueLiteral) %>
+                    <% defVal = '"'+defVal+'"' if props.impl_type == String %>
+                    <% defVal = ':'+defVal if props.impl_type.is_a?(DataTypes::Enum) %>
+					@#{name}.nil? ? <%= defVal %> : @#{name}
+				  <% else %>
+				    @#{name}
+				  <% end %>
+				end
+				alias get<%= firstToUpper(name) %> #{name}
+
+			CODE
+		end
+		
+		if props.value(:changeable)
+			BuildHelper.build _class_module, binding, <<-CODE
+				
+				def #{name}=(val)
+					return if val == @#{name}
+					<%= type_check_code("val", props) %>
+					oldval = @#{name}
+					@#{name} = val
+					<% if other_role && other_kind %>
+						_unregister(self,oldval,"#{other_role}","#{other_kind}")
+						_register(self,val,"#{other_role}","#{other_kind}")
+					<% end %>
+				end 
+				alias set<%= firstToUpper(name) %> #{name}=
+				
+			CODE
+
+		end
+	end
+	
+	# To-Many association methods
+	# 
+	def _build_many_methods(props, other_props=nil)
+		name = props.value(:name)
+		other_role = other_props && other_props.value(:name)
+		other_kind = other_props && ( other_props.many? ? :many : :one )
+
+		if props.value(:derived)
+			build_derived_method(name, props, :many)
+		else
+			BuildHelper.build _class_module, binding, <<-CODE
+			
+				def #{name}
+					( @#{name} ? @#{name}.dup : [] )
+				end
+				alias get<%= firstToUpper(name) %> #{name}
+							
+			CODE
+		end
+		
+		if props.value(:changeable)
+			BuildHelper.build _class_module, binding, <<-CODE
+		
+				def add<%= firstToUpper(name) %>(val)
+					@#{name} = [] unless @#{name}
+					return if val.nil? or @#{name}.include?(val) 
+					<%= type_check_code("val", props) %>
+					@#{name}.push val
+					<% if other_role && other_kind %>
+						_register(self, val, "#{other_role}", "#{other_kind}")
+					<% end %>
+				end
+				
+				def remove<%= firstToUpper(name) %>(val)
+					@#{name} = [] unless @#{name}
+					return unless @#{name}.include?(val)
+					@#{name}.delete val
+					<% if other_role && other_kind %>
+						_unregister(self, val, "#{other_role}", "#{other_kind}")
+					<% end %>
+				end
+				
+				def #{name}=(val)
+					return if val.nil?
+					raise _assignmentTypeError(self, val, Array) unless val.is_a? Array
+					getGeneric(:#{name}).each {|e|
+						remove<%= firstToUpper(name) %>(e)
+					}
+					val.each {|v|
+						add<%= firstToUpper(name) %>(v)
+					}
+				end
+				alias set<%= firstToUpper(name) %> #{name}=
+				
+			CODE
+		end		
+				
+	end	
+	
+	private
+
+	def build_derived_method(name, props, kind)
+		raise "Implement method #{name}_derived instead of method #{name}" \
+			if (public_instance_methods+protected_instance_methods+private_instance_methods).include?(name)
+		BuildHelper.build _class_module, binding, <<-CODE
+		
 			def #{name}
-				( @#{name} ? @#{name}.dup : [] )
+				raise "Derived feature requires public implementation of method #{name}_derived" \
+					unless respond_to?(:#{name+"_derived"})
+				val = #{name}_derived
+				<% if kind == :many %>
+					raise _assignmentTypeError(self,val,Array) unless val && val.is_a?(Array)
+					val.each do |v|
+						<%= type_check_code("v", props) %>
+					end
+				<% else %>
+					<%= type_check_code("val", props) %>
+				<% end %>	
+				val
 			end
-			def #{name}=(val)
-				return if val.nil?
-				raise _assignmentTypeError(self, val, Array) unless val.is_a? Array
-				#{name}.each {|e|
-					remove<%= firstToUpper(name) %>(e)
-				}
-				val.each {|v|
-					add<%= firstToUpper(name) %>(v)
-				}
-			end
-			alias get<%= firstToUpper(name) %> #{name}
-			alias set<%= firstToUpper(name) %> #{name}=
+			alias get#{firstToUpper(name)} #{name}
+			#TODO final_method :#{name}
+			
 		CODE
-	end	
+	end
+	
+	private
+	
+	def _ownProps(props)
+	  Hash[*(props.select{|k,v| !(k.to_s =~ /^opposite_/)}.flatten)]
+    end
 
+	def _oppositeProps(props)
+	   r = {}
+	   props.each_pair do |k,v|
+	     if k.to_s =~ /^opposite_(.*)$/
+            r[$1.to_sym] = v
+         end
+       end
+       r
+    end
+    
 end
+
 end
 
 end