emf_jruby 0.1.7-java → 0.2.0-java

data/lib/emf/emf_nav.rb

@@ -1,57 +1,107 @@
-require 'json'
+# Utils methods to naviate real EMF objects
 
-module JSON
-	def self.load_file(path,max_nesting=100)
-		parse(File.read(path),{max_nesting: max_nesting})
-	end
-end
+java_import org.eclipse.emf.ecore.EObject
 
-# This module permits to manipulate EObjects serialized
-# as Hash
-module EMF
+module Java::OrgEclipseEmfEcore::EObject
 
-	def self.rel_conts(root)
-		root.keys.select {|k| k.start_with? 'relcont_'}
-	end
+	module NavigationMethods
 
-	def self.rel_non_conts(root)
-		root.keys.select {|k| k.start_with? 'relcont_'}
-	end
+		if not instance_methods.include? :contents
 
-	def self.attrs(root)
-		root.keys.select {|k| k.start_with? 'attr_'}
-	end
+		def contents
+			method = nil
+			method = :eContents if respond_to?(:eContents)
+			method = :old_contents if respond_to?(:old_contents)	
+			method = :getContents if respond_to?(:getContents)
+			raise "No method for getting contents, class: #{self.class}" unless method!=nil
+			send method
+		end
 
-	def self.values(root,feat)
-		raw = root[feat]
-		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)
+		def contents_deep
+			l = []
+			contents.each do |c|
+				l << c
+				begin
+					grand_children = c.contents_deep
+				rescue Exception => e
+					raise "Problem getting children of #{c} (#{c.class}): #{e}"
+				end
+				grand_children.each do |sc|
+					l << sc
 				end
+			end   
+			l
+		end
+
+		def only_content_of_eclass(eclass)
+			Java::OrgEclipseEmfEcore::EObject::NavigationMethods.only_of_class(contents,eclass)
+		end
+
+		def only_content_deep_of_eclass(eclass)
+			Java::OrgEclipseEmfEcore::EObject::NavigationMethods.only_of_class(contents_deep,eclass)
+		end
+
+		def self.only_of_class(collection,eclass)
+			selected = collection.select {|o| o.eClass.isSuperTypeOf eclass}
+			case selected.count
+			when 0
+				raise EMF::LessThanExpectedFound.new
+			when 1
+				return selected.first
 			else
-				traverse(root[r],depth+1,&op)
+				raise EMF::MoreThanExpectedFound.new
 			end
 		end
+
 	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
+	module ModificationMethods
+
+		def set_attr_value(attr_name,value)
+			a = get_attr(attr_name)
+			raise 'Attr not found' unless a
+			eSet(a,value)
+		end
+
+		def get_attr_value(attr_name)
+			eGet(get_attr(attr_name))
 		end
+
+		def get_attr(attr_name)
+			(eClass.getEAllAttributes.select {|a| a.name==attr_name}).first
+		end
+
+		def get_ref(name)
+			(eClass.getEAllReferences.select {|r| r.name==name}).first
+		end
+
+		def get_ref_value(name)
+			eGet(get_ref(name))
+		end
+
+		def add_to_ref(ref_name,el)
+			l = eGet(get_ref(ref_name))
+			l.add el
+		end
+
 	end
 
+	include NavigationMethods
+	include ModificationMethods
+
+end
+
+class Java::OrgEclipseEmfEcoreImpl::BasicEObjectImpl
+
+	include Java::OrgEclipseEmfEcore::EObject::NavigationMethods
+	include Java::OrgEclipseEmfEcore::EObject::ModificationMethods
+
+end
+
+class Java::OrgEclipseEmfEcoreResourceImpl::ResourceImpl
+
+	include Java::OrgEclipseEmfEcore::EObject::NavigationMethods
+
 end

data/lib/emf/emf_utils.rb

@@ -0,0 +1,65 @@
+# Generic utilities related to real EMF objects
+
+java_import org.eclipse.emf.ecore.EcoreFactory
+java_import org.eclipse.emf.ecore.impl.DynamicEObjectImpl
+java_import org.eclipse.emf.ecore.EcorePackage
+
+module EMF
+
+	EcoreLiterals = JavaUtilities.get_proxy_class('org.eclipse.emf.ecore.EcorePackage$Literals')
+
+	def self.create_eclass(p=nil)
+		if p
+			c = p.createEClass p.next_id
+			c
+		else
+			EcoreFactory.eINSTANCE.createEClass
+		end
+	end
+
+	def self.create_eattribute(name, datatype)
+		a = EcoreFactory.eINSTANCE.createEAttribute
+		a.name = name
+		a.etype = datatype
+		a
+	end
+
+	def self.create_eattribute_str(name)
+		create_eattribute(name,EcoreLiterals::ESTRING)
+	end
+
+	def self.create_ereference(type=nil, name=nil, params=[])
+		r = EcoreFactory.eINSTANCE.createEReference #(type, type.ePackage.next_id)
+		r.set_etype(type) 
+		r.name = name
+		raise 'Cannot be both single and many' if params.include? :many and params.include? :single
+		raise 'Cannot be both containment and not containment' if params.include? :containment and params.include? :not_containment
+		containment = params.include? :containment
+		many = params.include? :many
+		r.containment = containment
+		r.set_upper_bound(-1) if many
+		r.set_upper_bound(1) unless many
+		r
+	end
+
+	def self.create_eobject(eclass)
+		eo = EcoreFactory.eINSTANCE.createEObject
+		eo.eSetClass eclass
+		eo
+	end
+
+	def self.create_epackage(name, uri)
+		p = EcoreFactory.eINSTANCE.createEPackage
+		class << p
+			def next_id
+				@next_id = 0 unless @next_id
+				@next_id += 1
+				@next_id
+			end
+		end
+		p.setName name
+		p.setNsURI uri
+		p
+	end
+
+end

data/lib/emf/exceptions.rb

@@ -0,0 +1,33 @@
+# Various exceptions used in the lib
+
+module EMF
+
+	class MoreThanExpectedFound < Exception
+	end
+
+	class LessThanExpectedFound < Exception
+	end
+
+	class UnexistingFeature < Exception
+		attr_reader :feat_name
+		def initialize(feat_name)
+			@feat_name = feat_name
+		end
+		def to_s
+			"UnexistingFeature: '#{@feat_name}'"
+		end
+	end
+
+	class SingleAttributeRequired < Exception
+		def initialize(class_name,attributes)
+			@class_name = class_name
+			@attributes = attributes
+		end
+		def to_s
+			names = []
+			@attributes.each {|a| names << a.name}
+			"SingleAttributeRequired: '#{@class_name}', attributes: #{names.join(', ')}"
+		end
+	end
+
+end

data/lib/emf/rgen_ext.rb

@@ -0,0 +1,104 @@
+# 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|
+				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
+				#puts "ignore #{self.class.name}.#{ref.name}" if to_ignore
+				#puts "returning false on #{attrib.name}" unless self_value.eql?(other_value)
+				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)
+								return false unless self_value[i].shallow_eql?(other_value[i])
+							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
+
+	end
+
+	class << self
+		include ClassAddOn
+	end
+
+	include SingletonAddOn
+end

data/lib/emf/rgen_to_emf.rb

@@ -1,24 +1,27 @@
-java_import org.eclipse.emf.ecore.EcoreFactory
-java_import org.eclipse.emf.ecore.impl.DynamicEObjectImpl
-java_import org.eclipse.emf.ecore.EcorePackage
+# Conversion of RGen object to real EMF objects
 
-module EMF
+require 'rgen/metamodel_builder'
 
-	EcoreLiterals = JavaUtilities.get_proxy_class('org.eclipse.emf.ecore.EcorePackage$Literals')
+module EMF
 
-	def self.create_eclass
-		EcoreFactory.eINSTANCE.createEClass
-	end
+	# Track already converted classes
+	# Known the namespace and the URI
+	class ConversionContext
+		def initialize
+			@classes_cache = {}
+		end
 
-	def self.create_eattribute
-		EcoreFactory.eINSTANCE.createEAttribute
+		def convert(rgen_class)
+			unless @classes_cache[rgen_class]
+				emf_class = EMF.rgen_to_eclass(rgen_class,self)
+				@classes_cache[rgen_class] = emf_class
+			end
+			@classes_cache[rgen_class]
+		end
 	end
 
-	def self.create_eobject(eclass)
-		DynamicEObjectImpl.new eclass
-	end
 
-	def self.rgen_to_eobject(rgen_obj)
+	def self.rgen_to_eobject(rgen_obj,context=ConversionContext.new)
 	end
 
 	def self.rgen_to_edatatype(rgen_datatype)
@@ -29,15 +32,52 @@ module EMF
 		end
 	end
 
-	def self.rgen_to_eclass(rgen_class)
+	def self.rgen_to_eclass(rgen_class,context=ConversionContext.new)
+		if rgen_class.respond_to? :ecore
+			ecore = rgen_class.ecore
+		else
+			ecore = rgen_class
+		end
 		emf_eclass = create_eclass
-		rgen_class.ecore.getEAttributes.each do |a|			
-			emf_a = create_eattribute
-			emf_a.name = a.name
-			emf_a.setEType(rgen_to_edatatype(a.eType))
+		ecore.getEAttributes.each do |a|			
+			emf_a = create_eattribute(a.name,rgen_to_edatatype(a.eType))
 			emf_eclass.getEStructuralFeatures.add emf_a
 		end
+		ecore.getEReferences.each do |r|
+			#puts "Ref #{r} #{r.name}"
+			emf_r = create_ereference
+			emf_r.name = r.name
+			emf_r.containment = r.containment
+			#emf_r.resolve_proxies = r.getResolveProxies
+			#emf_r.setEType(context.convert r.getEType)
+			emf_eclass.getEStructuralFeatures.add emf_r
+		end
 		emf_eclass
 	end
 
+	class RGen::MetamodelBuilder::MMBase
+
+		module EmfConversionClassMethods
+
+			def to_eclass(context=ConversionContext.new)
+				EMF.rgen_to_eclass(self,context)
+			end
+
+		end
+
+		module EmfConversionInstanceMethods
+
+			def to_eobject(context=ConversionContext.new)
+				EMF.rgen_to_eobject(self,context)
+			end
+
+		end
+
+		class << self
+			include EmfConversionClassMethods
+		end
+
+		include EmfConversionInstanceMethods
+	end
+
 end

data/lib/emf/xmi.rb

@@ -1,28 +1,55 @@
-# java_import org.eclipse.emf.ecore.resource.URIConverter
+# Methods to managa XMI serialization of real EMF objects
+
+require 'rgen/metamodel_builder'
+
 java_import org.eclipse.emf.ecore.resource.ResourceSet
 java_import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
-java_import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl
-# java_import import org.eclipse.emf.common.util.URI
 java_import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl
 java_import org.eclipse.emf.ecore.EObject
 java_import org.eclipse.emf.ecore.resource.Resource
 
 module EMF	
 
-	def self.to_xmi_str(data)
-		if data.is_a? EObject
+	module XmiConversion
+
+		def self.to_xmi(data)
+			if data.is_a? EObject
+				eobject_to_xmi(data)			
+			elsif data.is_a? Resource
+				resource_to_xmi(data)
+			else
+				raise "I do not know how to save a #{data.class}"
+			end
+		end
+
+		def self.eobject_to_xmi(eobject)
 			resource_set = ResourceSetImpl.new 
 			resource = XMIResourceImpl.new
 			resource_set.resources.add resource
-			resource.contents.add data
-			to_xmi_str(resource)			
-		elsif data.is_a? Resource
+			resource.contents.add eobject
+			to_xmi(resource)
+		end
+
+		def self.resource_to_xmi(res)
 			writer = java.io.StringWriter.new
-			data.save(writer,nil)
+			res.save(writer,nil)
 			writer.to_s
-		else
-			raise "I do not know how to save a #{data.class}"
-		end			
+		end
+
+	end
+
+	class Java::OrgEclipseEmfEcoreImpl::BasicEObjectImpl
+
+		module XmiMethods
+
+			def to_xmi
+				EMF::XmiConversion::eobject_to_xmi(self)			
+			end
+
+		end
+
+		include XmiMethods
+
 	end
 
 end

data/lib/emf_jruby.rb

@@ -3,10 +3,6 @@ Dir[curr_dir+"/jars/*.jar"].each do |jar|
 	require jar
 end
 
-require 'emf/ast_serialization'
-require 'emf/emf_to_json'
-require 'emf/eobject_util'
-require 'emf/model'
-require 'emf/xmi'
-require 'emf/stats'
-require 'emf/rgen_to_emf'
+Dir[curr_dir+"/emf/*.rb"].each do |rb|
+	require rb
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: emf_jruby
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
   prerelease:
 platform: java
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-08-03 00:00:00.000000000 Z
+date: 2013-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -34,18 +34,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/emf_jruby.rb
-- lib/emf/emf_to_json.rb
-- lib/emf/emf_nav.rb
-- lib/emf/ast_serialization.rb
-- lib/emf/eobject_util.rb
-- lib/emf/model.rb
-- lib/emf/xmi.rb
-- lib/emf/stats.rb
-- lib/emf/rgen_to_emf.rb
-- lib/jars/org.antlr.runtime_3.0.0.v200803061811.jar
-- lib/jars/org.eclipse.emf.common_2.8.0.v20130125-0546.jar
-- lib/jars/org.eclipse.emf.ecore.xmi_2.8.1.v20130125-0546.jar
-- lib/jars/org.eclipse.emf.ecore_2.8.3.v20130125-0546.jar
+- ./lib/emf/xmi.rb
+- ./lib/emf/rgen_to_emf.rb
+- ./lib/emf/emf_nav.rb
+- ./lib/emf/exceptions.rb
+- ./lib/emf/emf_utils.rb
+- ./lib/emf/rgen_ext.rb
+- ./lib/jars/org.eclipse.emf.ecore_2.8.3.v20130125-0546.jar
+- ./lib/jars/org.eclipse.emf.ecore.xmi_2.8.1.v20130125-0546.jar
+- ./lib/jars/org.antlr.runtime_3.0.0.v200803061811.jar
+- ./lib/jars/org.eclipse.emf.common_2.8.0.v20130125-0546.jar
 homepage: http://federico-tomassetti.it
 licenses: []
 post_install_message:

data/lib/emf/ast_serialization.rb

@@ -1,10 +0,0 @@
-$serialization_ids = {}
-$next_serialization_id = 1
-
-def serialization_id(obj)
-	unless $serialization_ids[obj]		
-		$serialization_ids[obj] = $next_serialization_id
-		$next_serialization_id += 1
-	end
-	$serialization_ids[obj]
-end

data/lib/emf/emf_to_json.rb

@@ -1,68 +0,0 @@
-# This code permit to transform EObjects in Hash objects
-# containing lists and single values
-
-require 'emf/ast_serialization'
-
-def qname(e_object)
-	e_class = e_object.eClass
-	e_package = e_class.ePackage
-	"#{e_package.nsURI}##{e_class.name}"
-end
-
-def jsonize_attr_value(map,e_object,e_attr)
-	value = e_object.eGet e_attr
-	if e_attr.upperBound==1
-		map["attr_#{e_attr.name}"] = value
-	else
-		l = []
-		(0..(value.size-1)).each do |i|
-			l << value.get(i)
-		end
-		map["attr_#{e_attr.name}"] = l
-	end
-end
-
-def jsonize_ref_single_el(single_value,containment,adapters)
-	if containment
-		jsonize_obj(single_value,adapters)
-	else
-		serialization_id(single_value)
-	end
-end
-
-def jsonize_ref_value(map,e_object,e_ref,adapters)
-	value = e_object.eGet e_ref
-
-	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)
-	else
-		l = []
-		(0..(value.size-1)).each do |i|
-			l << jsonize_ref_single_el(value.get(i),e_ref.containment,adapters)
-		end
-		map[propname] = l
-	end
-end
-
-def jsonize_obj(e_object, adapters={})
-	if not e_object
-		nil
-	else 
-		map = { 'type' => qname(e_object), 'id' => serialization_id(e_object) }
-		e_class = e_object.eClass
-		e_class.eAllAttributes.each do |a|		
-			jsonize_attr_value(map,e_object,a)
-		end
-		e_class.eAllReferences.each do |r|
-			#puts "ref #{r.name} #{r.containment}"
-			jsonize_ref_value(map,e_object,r,adapters)
-		end
-		if adapters.has_key? qname(e_object)
-			adapters[qname(e_object)].adapt(e_object,map)
-		end
-		map
-	end
-end

data/lib/emf/eobject_util.rb

@@ -1,15 +0,0 @@
-module EObjectUtil
-
-	def self.all_contents(root)
-		contents = []
-		root.getAllContents.each {|e| contents << e}
-		contents
-	end
-
-	def self.only_content_of_eclass(root,eclass)
-		selected = all_contents(root).select {|o| o.eClass.isSuperTypeOf eclass}
-		raise "One expected, #{selected.count} found" unless selected.count == 1
-		selected.first
-	end
-
-end

data/lib/emf/model.rb

@@ -1,5 +0,0 @@
-class Model
-	attr_accessor :root
-	attr_accessor :name
-	attr_accessor :external_objects
-end

data/lib/emf/stats.rb

@@ -1,97 +0,0 @@
-require 'emf/emf_nav'
-
-module CodeModels
-
-class CountingMap
-
-	def initialize
-		@map = {}
-		@sum_values = 0
-	end
-
-	def inc(key)
-		@map[key] = 0 unless @map[key]
-		@map[key] = @map[key]+1
-		@sum_values += 1
-	end
-
-	def value(key)
-		@map[key] = 0 unless @map[key]
-		@map[key]
-	end
-
-	# number of times the value appeared divived by total frequency
-	def p(key)
-		@map[key].to_f/total_frequency.to_f
-	end
-
-	def each(&block)
-		@map.each(&block)
-	end
-
-	def total_frequency
-		@sum_values
-	end
-
-	def n_values
-		@map.count
-	end
-
-end
-
-def self.entropy(counting_map)
-	s = 0.0	
-	counting_map.each do |k,v|
-		p = counting_map.p(k)
-		s += p*Math.log(p)
-	end
-	-s
-end
-
-def idf(n,n_docs)
-	Math.log(n_docs.to_f/n.to_f)
-end
-
-def combine_self(arr,&op)
-	for i in 0..(arr.count-2)
-		for j in (i+1)..(arr.count-1)
-			op.call(arr[i],arr[j])
-		end
-	end
-end
-
-def combine(arr1,arr2,&op)
-	arr1.each do |el1|
-		arr2.each {|el2| op.call(el1,el2)}
-	end
-end
-
-
-def self.load_models_from_dir(dir,verbose=false,max=-1)
-	per_type_values_map = Hash.new do |pt_hash,pt_key|	
-		pt_hash[pt_key] = Hash.new do |pa_hash,pa_key|
-			pa_hash[pa_key] = CountingMap.new
-		end
-	end
-
-	n = 0
-	files = Dir[dir+'/**/*.json']
-	files = files[0..(max-1)] if max!=-1
-	files.each do |f|
-		n+=1
-		puts "...#{n}) #{f}" if verbose
-		model = ::JSON.load_file(f,max_nesting=500)
-		EMF.traverse(model) do |n|
-			if n
-				puts "\tnode: #{n['type']}" if verbose
-				EMF.attrs(n).each do |a|
-					puts "\t\tattr: #{a}" if verbose
-					per_type_values_map[n['type']][a].inc(n[a])
-				end
-			end
-		end
-	end
-	per_type_values_map
-end
-
-end