codemodels 0.2.2-java

data/lib/codemodels/query_serialized.rb

@@ -0,0 +1,81 @@
+# This module permits to manipulate Objects serialized
+# as Hash
+
+module CodeModels
+
+module QuerySerialized
+
+	def self.rel_conts(root)
+		root.keys.select {|k| k.start_with? 'relcont_'}
+	end
+
+	def self.rel_non_conts(root)
+		root.keys.select {|k| k.start_with? 'relnoncont_'}
+	end
+
+	def self.attrs(root)
+		root.keys.select {|k| k.start_with? 'attr_'}
+	end
+
+	def self.print_tree(root,depth=0)
+		traverse(root) do |n,d|
+			s = ""
+			d.times { s = s + "  " }
+			s = s + n['type'] if n
+			s = s + '<NIL>' unless n
+			puts s
+		end
+	end	
+
+	def self.values(root,feat)
+		raw = root[feat]
+		return [] if raw==nil
+		return raw if raw.is_a? Array
+		return [raw]
+	end
+
+	def self.traverse(root,depth=0,&op)
+		return traverse(root['root'],depth,&op) if root and (root.key? 'root')
+		op.call(root,depth)
+		return unless root		
+		rel_conts(root).each do |r|
+			if root[r].is_a? Array
+				root[r].each do |c|
+					raise "expected an object but it is a #{c.class} (relation: #{r})" unless c.is_a? Hash
+					traverse(c,depth+1,&op)
+				end
+			else
+				traverse(root[r],depth+1,&op)
+			end
+		end
+	end
+
+	# the set of values appearing in the object and its children
+	def self.collect_values(el)
+		values = Set.new
+		rel_conts(el).each do |r|
+			values(el,r).each {|c| values.merge(collect_values(c))}
+		end
+		attrs(el).each do |a|
+			values(el,a).each {|v| values.add(v)}
+		end
+		values
+	end
+
+	# a counting map values appearing in the object and its children
+	def self.collect_values_with_count(el)
+		values = Hash.new {|h,k| h[k]=0}
+		rel_conts(el).each do |r|
+			values(el,r).each do |ch| 
+				collect_values_with_count(ch).each {|v,count| values[v]+=count}
+			end
+		end
+		attrs(el).each do |a|
+			values(el,a).each {|v| values[v]+=1 }
+		end
+		values
+	end
+
+end
+
+end

data/lib/codemodels/rgen_ext.rb

@@ -0,0 +1,186 @@
+# Extensions to RGen objects
+
+require 'rgen/metamodel_builder'
+
+class RGen::MetamodelBuilder::MMBase
+
+	module ClassAddOn
+
+		def build(values={})
+			instance = self.new
+			if values.is_a? Hash
+				values.each do |k,v|
+					attribute = self.ecore.eAllAttributes.find {|x| x.name==k.to_s}
+					reference = self.ecore.eAllReferences.find {|x| x.name==k.to_s}
+					raise EMF::UnexistingFeature.new(k.to_s) unless (attribute or reference)
+					setter = (k.to_s+'=').to_sym
+					instance.send setter, v
+				end
+			else
+				has_dynamic = false
+				self.ecore.eAllAttributes.each {|a| has_dynamic|=a.name=='dynamic'}
+				d = 0
+				d = 1 if has_dynamic
+
+				raise EMF::SingleAttributeRequired.new(self.ecore.name,self.ecore.eAllAttributes) if self.ecore.eAllAttributes.count!=1+d
+				attribute = self.ecore.eAllAttributes[0]
+				set_attr(instance,attribute,values)
+			end
+			instance
+		end
+
+		private
+
+		def set_attr(instance,attribute,value)
+			setter = (attribute.name+'=').to_sym
+			instance.send setter, value
+		end
+	end
+
+	module SingletonAddOn
+
+		# It does not check references, it is needed to avoid infinite recursion
+		def shallow_eql?(other)
+			return false if other==nil
+			return false unless self.class==other.class
+			self.class.ecore.eAllAttributes.each do |attrib|
+				raise "Attrib <nil> for class #{self.class.ecore.name}" unless attrib
+				if attrib.name != 'dynamic' # I have to understand this...
+					self_value  = self.get(attrib)
+					other_value = other.get(attrib)
+					#puts "returning false on #{attrib.name}" unless self_value.eql?(other_value)
+					return false unless self_value == other_value
+				end
+			end
+			true
+		end
+
+		def eql?(other)
+			# it should ignore relations which has as opposite a containement
+			return false unless self.shallow_eql?(other)
+			self.class.ecore.eAllReferences.each do |ref|
+				self_value = self.get(ref)
+				other_value = other.get(ref)
+				to_ignore = ref.getEOpposite and ref.getEOpposite.containment
+				unless to_ignore
+					if ref.containment
+						return false unless self_value == other_value
+					else
+						if (self_value.is_a? Array) or (other_value.is_a? Array)
+							return false unless self_value.count==other_value.count
+							for i in 0..(self_value.count-1)
+								unless self_value[i].shallow_eql?(other_value[i])
+									return false 
+								end
+							end
+						else  
+							if self_value==nil
+								return false unless other_value==nil
+							else
+								return false unless self_value.shallow_eql?(other_value)
+							end
+						end
+					end
+				end						
+			end
+			true
+		end
+
+		def ==(other)
+			eql? other
+		end
+	
+		def get(attr_or_ref)
+			getter = (attr_or_ref.name).to_sym
+			send getter
+		end
+
+		def all_children
+			arr = []
+			ecore = self.class.ecore
+			ecore.eAllReferences.select {|r| r.containment}.each do |ref|
+				res = self.send(ref.name.to_sym)
+				if ref.many
+					d = arr.count
+					res.each do |el|
+						arr << el unless res==nil
+					end
+				elsif res!=nil
+					d = arr.count
+					arr << res
+				end
+			end
+			arr
+		end
+
+		def all_children_deep
+			arr = []
+			all_children.each do |c|
+				arr << c
+				c.all_children_deep.each do |cc|
+					arr << cc
+				end
+			end			
+			arr
+		end
+
+		def traverse(&op)
+			op.call(self)
+			all_children_deep.each do |c|
+				op.call(c)
+			end
+		end
+
+		def collect_values_with_count
+			values = Hash.new {|h,k| h[k]=0}
+			self.class.ecore.eAllAttributes.each do |a|
+				v = self.send(:"#{a.name}")
+				if v!=nil
+					if a.many
+						v.each {|el| values[el]+=1}
+					else
+						values[v]+=1
+					end
+				end
+			end
+			values			
+		end
+
+		def collect_values_with_count_subtree
+			values = collect_values_with_count
+			all_children_deep.each do |c|
+				c.collect_values_with_count.each do |k,v|
+					values[k]+=v
+				end
+			end
+			values
+		end		
+
+		def all_children_of_type(type)
+			all_children.select {|c| c and c.is_a?(type)}
+		end
+
+		def all_children_deep_of_type(type)
+			all_children_deep.select {|c| c and c.is_a?(type)}
+		end
+
+		def only_child_of_type(type)
+			selected = all_children_of_type(type)
+			raise "Exactly one child of type #{type} expected, #{selected.count} found on #{self}" unless selected.count==1
+			selected[0]
+		end
+
+		def only_child_deep_of_type(type)
+			selected = all_children_deep_of_type(type)
+			raise "Exactly one child of type #{type} expected, #{selected.count} found on #{self}" unless selected.count==1
+			selected[0]
+		end
+
+	end
+
+	class << self
+		include ClassAddOn
+	end
+
+	include SingletonAddOn
+end

data/lib/codemodels/serialization.rb

@@ -0,0 +1,142 @@
+# This code permit to transform RGen-Objects in Hash objects
+# containing lists and single values
+
+require 'json'
+require 'fileutils'
+require 'rgen/metamodel_builder'
+
+module CodeModels
+module Serialization
+
+module SerializationFunctionalities
+
+	# It could be a simple hash with a block passed to the
+	# constructor...
+	class SerializationMemory
+
+		def initialize
+			@next_id = 1
+			@id_map = {}
+		end
+
+		def id(rgen_object)
+			unless @id_map[rgen_object]
+				@id_map[rgen_object] = @next_id
+				@next_id += 1
+			end
+			@id_map[rgen_object]
+		end
+
+	end
+
+	def to_json(serialization_memory=SerializationMemory.new,adapters={},with_source_info=true)
+		e_object = self
+		map = { 'type' => qname, 'id' => serialization_memory.id(e_object) }
+		if with_source_info
+			if self.respond_to?(:source) && self.source
+				source_map = {}
+				if self.source.begin_pos
+					source_map['begin_pos'] = {'line'=> self.source.begin_pos.line, 'column'=>self.source.begin_pos.column}
+				end				
+				if self.source.end_pos
+					source_map['end_pos'] = {'line'=> self.source.end_pos.line, 'column'=>self.source.end_pos.column}
+				end								
+				map['source'] = source_map
+			end
+		end
+		e_class = e_object.class.ecore
+		e_class.eAllAttributes.each do |a|		
+			jsonize_attr_value(map,a)
+		end
+		e_class.eAllReferences.each do |r|
+			id = jsonize_ref_value(map,r,adapters,serialization_memory)
+		end
+		if adapters.has_key? qname
+			adapters[qname].adapt(self,map)
+		end
+		map
+	end
+
+	private
+
+	def qname
+		self.class.to_s
+	end
+
+	def jsonize_attr_value(map,e_attr)
+		value = self.send(e_attr.name.to_sym)
+		if e_attr.upperBound==1
+			map["attr_#{e_attr.name}"] = value
+		else
+			l = []
+			value.each do |e|
+				l << e
+			end
+			map["attr_#{e_attr.name}"] = l
+		end
+	end
+
+	def jsonize_ref_value(map,e_ref,adapters,serialization_memory)
+		value = self.send e_ref.name.to_sym
+
+		propname = "relcont_#{e_ref.name}" if e_ref.containment
+		propname = "relnoncont_#{e_ref.name}" if not e_ref.containment
+
+		if e_ref.upperBound==1		
+			map[propname] = jsonize_ref_single_el(value,e_ref.containment,adapters,serialization_memory)
+		else
+			l = []
+			(0...(value.size)).each do |i|				
+				l << jsonize_ref_single_el(value.at(i),e_ref.containment,adapters,serialization_memory)
+			end
+			map[propname] = l
+		end
+	end
+
+	def jsonize_ref_single_el(single_value,containment,adapters,serialization_memory)
+		if containment
+			single_value.to_json(serialization_memory,adapters)
+		else
+			serialization_memory.id(single_value)
+		end
+	end
+
+end
+
+class ::RGen::MetamodelBuilder::MMBase
+	include SerializationFunctionalities
+end
+
+def self.load_file(path,max_nesting=500)
+	JSON.parse(File.read(path),{max_nesting: max_nesting})
+end
+
+def self.save_model(model,model_path, max_nesting=500)
+	dir = File.dirname(model_path)
+	FileUtils.mkdir_p(dir) 
+
+	File.open(model_path, 'w') do |file| 		
+		file.write(JSON.pretty_generate(model, :max_nesting => max_nesting))
+	end
+end
+
+def self.rgenobject_to_model(root,adapters={})
+	model = {}
+	external_elements = []
+
+	sm = SerializationFunctionalities::SerializationMemory.new
+	model['root'] = root.to_json(sm,adapters)
+	model['external_elements'] = []
+	external_elements.each do |ee|
+		model['external_elements'] << ee.to_json(sm,adapters)
+	end
+	model
+end
+
+def self.save_as_model(root,model_path)
+	model = to_model(root)
+	save_model(model,model_path)
+end
+
+end # module
+end # module

data/lib/codemodels/version.rb

@@ -0,0 +1,3 @@
+module CodeModels
+  VERSION = "0.2.2"
+end

data/lib/codemodels.rb

@@ -0,0 +1,5 @@
+curr_dir = File.dirname(__FILE__)
+
+Dir[curr_dir+"/codemodels/*.rb"].each do |rb|
+	require rb
+end