rgen 0.3.0 → 0.4.0

data/lib/rgen/metamodel_builder/builder_runtime.rb

@@ -13,6 +13,11 @@ module MetamodelBuilder
 module BuilderRuntime
 	include NameHelper
 	
+	def is_a?(c)
+	   return super unless c.respond_to?(:_class_module)
+	   kind_of?(c._class_module)
+	end
+	
 	def addGeneric(role, value)
 		send("add#{firstToUpper(role)}",value)
 	end
@@ -56,7 +61,8 @@ module BuilderRuntime
 		end
 		valueId = value.class.name
 		valueId += "(" + value.name + ")" if value.respond_to?(:name) and value.name
-		text += "Can not put a #{valueId} where a #{expected} is expected"
+		valueId += "(:" + value.to_s + ")" if value.is_a?(Symbol)
+		text += "Can not use a #{valueId} where a #{expected} is expected"
 		StandardError.new(text)
 	end
 

data/lib/rgen/metamodel_builder/data_types.rb

@@ -0,0 +1,67 @@
+module RGen
+
+module MetamodelBuilder
+
+module DataTypes
+
+  # An enum object is used to describe possible attribute values within a 
+  # MetamodelBuilder attribute definition. An attribute defined this way can only
+  # take the values specified when creating the Enum object. 
+  # Literal values can only be symbols or true or false.
+  # Optionally a name may be specified for the enum object.
+  # 
+  # Examples:
+  # 
+  # 	Enum.new(:name => "AnimalEnum", :literals => [:cat, :dog])
+  # 	Enum.new(:literals => [:cat, :dog])
+  # 	Enum.new([:cat, :dog])
+  # 
+	class Enum
+	  attr_reader :name, :literals
+	  
+	  # Creates a new named enum type object consisting of the elements passed as arguments.
+	  def initialize(params)
+	  	if params.is_a?(Array)
+		    @literals = params
+	  		@name = "anonymous"
+	  	elsif params.is_a?(Hash)
+	  		raise StandardError.new("Hash entry :literals is missing") unless params[:literals]
+	  		@literals = params[:literals]
+	  		@name = params[:name] || "anonymous"
+	  	else
+	  		raise StandardError.new("Pass an Array or a Hash")
+	  	end
+	  end
+
+		# This method can be used to check if an object can be used as value for
+		# variables having this enum object as type.	  
+	  def validLiteral?(l)
+	    literals.include?(l)
+	  end
+	  
+	  def literals_as_strings
+	  	literals.collect do |l|
+	  		if l.is_a?(Symbol)
+	  			":"+l.to_s
+	  		elsif l.is_a?(TrueClass) || l.is_a?(FalseClass)
+	  			l.to_s
+	  		else
+	  			raise StandardError.new("Literal values can only be symbols or true/false")
+	  		end
+	  	end
+	  end
+	  
+	  def to_s # :nodoc:
+	  	name
+	  end
+	end
+	
+	# Boolean is a predefined enum object having Ruby's true and false singletons
+	# as possible values.
+	Boolean = Enum.new(:name => "Boolean", :literals => [true, false])
+
+end
+
+end
+
+end

data/lib/rgen/metamodel_builder/intermediate/annotation.rb

@@ -0,0 +1,30 @@
+module RGen
+
+module MetamodelBuilder
+
+module Intermediate
+
+class Annotation
+  attr_reader :details, :source
+  
+  def initialize(hash)
+    if hash[:source] || hash[:details]
+      restKeys = hash.keys - [:source, :details]
+      raise "Hash key #{restKeys.first} not allowed." unless restKeys.empty?
+      raise "Details not provided, key :details is missing" unless hash[:details]
+      raise "Details must be provided as a hash" unless hash[:details].is_a?(Hash)
+      @details = hash[:details]
+      @source = hash[:source]
+    else
+      raise "Details must be provided as a hash" unless hash.is_a?(Hash)
+      @details = hash
+    end
+  end
+  
+end
+
+end
+
+end
+
+end

data/lib/rgen/metamodel_builder/metamodel_description.rb

@@ -0,0 +1,232 @@
+require 'rgen/metamodel_builder'
+
+module RGen
+
+module MetamodelBuilder
+
+class MetamodelDescription
+
+	attr_reader :etype, :impl_type
+		
+	def self.default_value(prop)
+		checkProperty(prop)
+		defaultValues[prop]
+	end
+	
+	def self.has_default?(prop)
+		checkProperty(prop)
+		defaultValues.has_key?(prop)
+	end
+	
+	def initialize(props)
+		@props = props.dup
+	end
+
+	def value(prop)
+		self.class.checkProperty(prop)
+		@props[prop]
+	end
+	
+	def annotations
+	    @annotations ||= []
+	end
+	
+	def many?
+		value(:upperBound) > 1 || value(:upperBound) == -1
+	end
+
+protected
+	
+  def setupDefaults
+    self.class.propertySet.each do |p| 
+      @props[p] = self.class.default_value(p) unless @props.has_key?(p)   
+    end
+  end
+
+  def checkAllPropertiesSet
+    self.class.propertySet.each do |p| 
+      raise StandardError.new("'#{p}' property not set") if !self.class.optionalProperties.include?(p) && @props[p].nil?
+    end
+  end
+  
+  def checkForInvalidProperties
+    @props.keys.each do |p|
+      raise StandardError.new("invalid property #{p}") unless self.class.propertySet.include?(p)
+    end
+  end
+
+private
+
+	def descendent?(clazz1, clazz2)
+		return true if clazz1 == clazz2 || clazz1.superclass == clazz2
+		return false if clazz1.superclass.nil?
+		descendent?(clazz1.superclass, clazz2)
+	end
+
+	def self.checkProperty(prop)
+		raise ArgumentError.new("Not a valid property: #{prop}") unless propertySet.include?(prop)
+	end
+		
+	def to_s
+		self.class.to_s + ": " +
+			self.class.propertySet.collect{|p| "#{p}=>#{value(p)}"}.join(", ")
+	end
+	
+	def self.propertySet
+		[ :name ]
+	end
+	
+
+	def self.optionalProperties
+        []
+	end
+
+	def self.defaultValues
+		{ }
+	end
+	
+	def self.typeMap
+		{ :EString => String,
+			:EInt => Integer,
+			:EFloat => Float,
+			:EBoolean => RGen::MetamodelBuilder::DataTypes::Boolean,
+		  :EJavaObject => Object,
+		  :ERubyObject => Object,
+		  :EJavaClass => Class,
+		  :ERubyClass => Class }
+	end
+	
+end
+
+# DERIVED:	ordered = true, unique = false, lowerBound = 0/1, upperBound = 1
+# DERIVED: when :derived : changeable= false, :volatile=true, transient=true
+class AttributeDescription < MetamodelDescription
+
+	def initialize(type, props)
+		super(props)
+		# type default
+		type ||= :EString 
+		setupType(type)
+		# fixed values can not be changed by user
+    setupDefaults
+    checkForInvalidProperties
+		if @props[:derived]
+			@props[:changeable] = false
+			@props[:volatile] = true
+			@props[:transient] = true
+		end		
+    checkAllPropertiesSet
+	end
+	
+private
+
+	def setupType(type)
+		if self.class.typeMap.keys.include?(type)
+			@etype = type
+			@impl_type = self.class.typeMap[type]
+		elsif self.class.typeMap.invert.keys.include?(type)
+			@etype = self.class.typeMap.invert[type]
+			@impl_type = type
+		elsif type.is_a?(RGen::MetamodelBuilder::DataTypes::Enum)
+			@etype = :EEnumerable
+			@impl_type = type
+    else
+  		raise ArgumentError.new("Type invalid: " + type.to_s)
+    end
+	end
+
+	def self.propertySet
+		super | [ 
+			:ordered, 
+		  :unique,
+		  :changeable,
+		  :volatile,
+		  :transient,
+		  :unsettable,
+			:derived,
+			:lowerBound,
+			:upperBound,
+			:defaultValueLiteral ]
+	end
+	
+	def self.optionalProperties
+		super | [ 
+          :defaultValueLiteral
+        ]
+	end
+
+	def self.defaultValues 
+		super.merge(
+		{ :ordered => true,
+		  :unique => true,
+		  :changeable => true,
+		  :volatile => false,
+		  :transient => false,
+		  :unsettable => false,
+		  :derived => false,
+			:lowerBound => 0 })
+	end
+	
+end
+
+#  DERIVED default: lowerBound => 0/1 (required?), upperBound => 1/-1 (many?), containment (contains_xxx?), 
+#  DERIVED: when :derived : changeable= false, :volatile=true, transient=true
+class ReferenceDescription < MetamodelDescription
+	attr_accessor :opposite
+	
+	def initialize(type, props)
+		super(props)
+		setupType(type)
+    setupDefaults
+    checkForInvalidProperties
+		if @props[:derived]
+			@props[:changeable] = false
+			@props[:volatile] = true
+			@props[:transient] = true
+		end		
+    checkAllPropertiesSet
+	end
+
+private
+
+	def setupType(type)
+		if type.is_a?(Class) && descendent?(type, RGen::MetamodelBuilder::MMBase)
+			@etype = nil
+			@impl_type = type
+    else
+  		raise ArgumentError.new("Type is not a MMBase: " + type.to_s)
+    end
+	end
+
+	def self.propertySet
+		super | [ 
+			:ordered, 
+		  :unique,
+		  :changeable,
+		  :volatile,
+		  :transient,
+		  :unsettable,
+			:derived,
+			:lowerBound,
+			:upperBound,
+			:resolveProxies,
+			:containment ]
+	end
+
+	def self.defaultValues 
+		super.merge({ 
+			:ordered => true,
+		  :unique => true,
+		  :changeable => true,
+		  :volatile => false,
+		  :transient => false,
+		  :unsettable => false,
+		  :derived => false,
+		  :lowerBound => 0,
+		  :resolveProxies => true })
+	end
+end
+
+end
+
+end

data/lib/rgen/metamodel_builder/mm_multiple.rb

@@ -0,0 +1,23 @@
+
+module RGen
+
+module MetamodelBuilder
+
+def self.MMMultiple(*superclasses)
+  c = Class.new(MMBase)
+  class << c
+    attr_reader :multiple_superclasses
+  end
+  c.instance_variable_set(:@multiple_superclasses, superclasses)
+  superclasses.collect{|sc| sc.ancestors}.flatten.
+    reject{|m| m.is_a?(Class)}.each do |arg|
+      c.instance_eval do
+        include arg
+      end
+  end
+  return c
+end
+
+end
+
+end

data/lib/rgen/metamodel_builder/module_extension.rb

@@ -0,0 +1,33 @@
+require 'rgen/ecore/ecore_instantiator'
+require 'rgen/metamodel_builder/intermediate/annotation'
+
+module RGen
+
+module MetamodelBuilder
+
+# This module is used to extend modules which should be
+# part of RGen metamodels
+module ModuleExtension
+  include RGen::ECore::ECoreInstantiator
+  
+  def annotation(hash)
+    _annotations << Intermediate::Annotation.new(hash)
+  end
+  
+  def _annotations
+    @_annotations ||= []
+  end
+  
+  def final_method(m)
+    @final_methods ||= []
+    @final_methods << m
+  end
+  
+  def method_added(m)
+    raise "Method #{m} can not be redefined" if @final_methods && @final_methods.include?(m)
+  end
+end
+
+end
+
+end

data/lib/rgen/model_comparator.rb

@@ -0,0 +1,56 @@
+require 'rgen/ecore/ecore'
+
+module RGen
+
+module ModelComparator
+
+# This method compares to models regarding equality
+# For this the identity of a model element is defined based on identity
+# of all attributes and referenced elements.
+# Arrays are sorted before comparison if possible (if <=> is provided).
+# 
+def modelEqual?(a, b, featureIgnoreList=[])
+  @modelEqual_visited = {}
+  _modelEqual_internal(a, b, featureIgnoreList, [])
+end
+  
+def _modelEqual_internal(a, b, featureIgnoreList, path)
+  return true if @modelEqual_visited[[a,b]]
+  @modelEqual_visited[[a,b]] = true
+  return true if a.nil? && b.nil?
+  unless a.class == b.class
+    puts "#{path.inspect}\n  Classes differ: #{a} vs. #{b}"
+    return false 
+  end
+  if a.is_a?(Array)
+    unless a.size == b.size
+      puts "#{path.inspect}\n  Array size differs: #{a.size} vs. #{b.size}"
+      return false 
+    end
+    as = a
+    as = a.sort if a.all?{|o| o.respond_to?('<=>')}
+    bs = b
+    bs = b.sort if b.all?{|o| o.respond_to?('<=>')}
+    a.each_index do |i|
+      return false unless _modelEqual_internal(as[i], bs[i], featureIgnoreList, path+[i])
+    end
+  else
+    a.class.ecore.eAllStructuralFeatures.reject{|f| f.derived}.each do |feat|
+      next if featureIgnoreList.include?(feat.name)
+      if feat.eType.is_a?(RGen::ECore::EDataType)
+        unless a.getGeneric(feat.name) == b.getGeneric(feat.name)
+          puts "#{path.inspect}\n  Value '#{feat.name}' differs: #{a.getGeneric(feat.name)} vs. #{b.getGeneric(feat.name)}"
+          return false
+        end
+      else
+        return false unless _modelEqual_internal(a.getGeneric(feat.name), b.getGeneric(feat.name), featureIgnoreList, path+["#{a.respond_to?(:name) && a.name}:#{feat.name}"])
+      end
+    end
+  end
+  return true
+end
+
+end
+
+end
+