ontomde-core 1.0.2

data/lib/ontomde-core/resource.rb

@@ -0,0 +1,272 @@
+# Core RDF resource management
+#:include: ../shared/license.rdoc
+
+RDF_TRUE="true"
+RDF_FALSE="false"
+
+module Mrdf_Resource
+	# Debug method 
+	# Dumps to screen the current object.
+	def dump	
+		log.debug("\n#{self} dump #{self.class}>\n")
+		instance_variables.each { 
+			|c| 
+				log.debug("-#{c}- #{instance_variable_get(c).to_s}\n" ) 
+		}
+		log.debug('methods: ( ')
+		#out.write('methods: ( ')
+		public_methods.each { |m|
+			log.debug( "#{m}, " )
+			}
+		log.debug('<\n')
+	end
+end
+
+class Crdf_Resource #< Crdfs_Resource
+	include Mrdf_Resource
+	attr_reader :uri
+	attr_reader :nbrItem 
+	attr_reader :rdf_model 
+	@@nbrItem=0
+
+	# Utiliser pour un hack
+	def force_rdf_model=(m)
+		@rdf_model=m
+	end
+
+	# Returns a new empty attribute array
+	def createEmptyAttributeValue
+		return  ArrayOrSingleElement.new()
+	end
+
+	#initialize a new resource and adds it to the current model.
+	#if uri is nil, a temporary uri is automaticaly generated.
+	#NOTE:
+	#  This uri is not suitable for use by mtk_protected.
+	#TODO: ??? add a detection for prexisting uri ???
+	def initialize(model,uri)
+		uri="_transient_#{object_id}" if uri.nil?
+		model[uri]=self
+		@rdf_model=model
+		@uri=uri
+		@@nbrItem=@@nbrItem+1 
+	end	
+
+	#List of non restable variables
+	@@NonResetableVariables=['@rdf_model','@rdf_type','@uri']
+
+	#Return true if v is a restable property.
+	def isResetable?(v)
+		return ! @@NonResetableVariables.include?(v)
+	end
+
+	# Force reset of this object properties
+	# Every resetable property is set to nil.
+	def forceReset!
+		#log.debug "forceReset #{self}"
+		instance_variables.each { |v|
+			if(isResetable?(v))
+				#log.debug "reset #{v}"
+				instance_variable_set(v,nil)
+			end
+		}
+	end
+
+	#suppress warning
+	alias :nbrItem_org :nbrItem
+	#Number of item loaded since the initilization of the program
+	#Used for monitoring.
+	def nbrItem
+		@@nbrItem
+	end
+
+	#Internal use
+	#
+	def set(var,val)
+		#TODO:  cout: 65s   -> 82    sur CRX
+		#TODO:        21.8s -> 25,8s -> 19,5s (19/6) sur SID 
+		raise Warning.new,'null val in set' if val.nil? 
+		raise Warning.new,'null var in set' if var.nil?
+		core_set(:"@#{var}",val)
+		val.core_set(:@ext_isReferencedBy,self) if(val.kind_of?(Crdf_Resource))
+	end
+
+
+	#Internal use
+	#
+	def core_set(ivar,val)
+		old=instance_variable_get(ivar)
+		if old.nil?
+			old=createEmptyAttributeValue  
+			instance_variable_set(ivar,old)
+		end
+		old.push(val)
+	end
+end
+
+class Crdf_Resource
+	attr_reader :rdf_type, :rdfs_label
+	rdf_safe_attr_reader_many :rdfs_subClassOf
+	attr_writer :rdf_type, :rdfs_label
+
+	rdf_safe_attr_reader_many :ext_isReferencedBy
+
+	#TODO: use ??
+	#@rubyName
+
+	def to_yaml
+		'empty'
+	end
+
+	def set_rdfIsRelated(rel)
+	end
+
+	# Internal use
+	#
+	# sets resource uri
+	def rdf_uri=(new_uri)
+		@uri=new_uri
+	end
+
+	#returns resource uri
+	def rdf_uri
+		return @uri
+	end
+
+	#default string converter. Returns uri
+	def to_s
+		return @uri.to_s #"#{@uri}"
+	end
+
+	#Internal use
+	#
+	#Returns the ruby module name corresponding to this ressource
+	def getRubyModuleName
+		return "M#{getRubyName}"
+	end
+	
+	#Internal use
+	#
+	#Returns the ruby class name corresponding to this ressource
+	def getRubyClassName
+		return "C#{getRubyName}"
+	end
+
+	#Retrieves a uri from a ruby identifier
+	def getRubyNameInverse(identifier)
+		found=nil
+		rdf_model.each { |k,c|
+			next if c.getRubyName!=identifier.to_s
+			log.error("Ruby name clash for #{identifier} and #{k}") unless found.nil?
+			found=k
+		}
+		log.error("No uri found for ruby identifier #{identifier} ") if found.nil?
+		return found
+	end
+
+	#Transforms a uri to a valid ruby identifier.
+	#cf. getRubyNameInverse
+	def getRubyName
+		return @uri.tr('^a-zA-Z0-9','_')
+		#return @rdf_label if @rdf_label
+		#return self.class.to_s # bootstrap
+	end
+	
+	#Internal use
+	def isBootstrap?
+		return self.class.to_s==self.getRubyClassName
+	end
+
+	#Internal use
+	def getRubyAttributeDefinition(model)
+		#todo qqchos pour renvoyer valeur non nil
+		cmd1=''
+		sep1=' rdf_safe_attr_reader_many :'
+		cmd2=''
+		sep2=' rdf_safe_attr_reader_one :'
+
+		model.each { |tbl,prop|
+			next unless prop.kind_of?(Crdf_Property)
+			next if prop.rdfs_domain.nil?
+			next unless prop.rdfs_domain.include?(self)
+			
+			#log.debug "res2=#{prop.uri} #{prop}"
+			#res.instance_variables.each { |var| log.debug "   > #{var} #{res.instance_variable_get(var)}" }
+			if(true)
+				#toujours disponible
+				cmd1+=sep1+prop.getRubyName
+				sep1=', :'
+			end
+			if(false)
+				#TODO
+				cmd2+=sep2+prop.getRubyName
+				sep2=', :'
+			end
+		}
+		cmd1+="\n"
+		cmd2+="\n"
+		return cmd1+cmd2
+	end
+
+	# Internal use
+	#
+	# Creates a skeleton minimal ruby class for immediate use.
+	def createRubyClassMinimal(model)
+		return if @mtk_rubyClassGenerated
+		return if isBootstrap?
+		eval("class ::#{getRubyClassName} < ::Crdfs_Class\nend\n")
+	end
+
+	# Liste des classes dont la classe courante d�rive (directe et indirecte)
+	def rdfs_subClassOfRecursive(ret=Array.new)
+		rdfs_subClassOf.each { |sub|
+			next if ret.contains(sub)
+			ret.push(sub)
+			sub.rdfs_subClassOfRecursive(ret)
+			}
+		return ret 
+	end	
+
+	# Creates a ruby structure for this element.
+	# NOTE:
+	#   generates ruby class   named getRubyClassName
+	#   generates ruby modules named getRubyModuleName
+	#   multiple inheritance is handled trough multiple module inclusion.
+	def createRubyClass(model)
+		cmd=''
+		return cmd if @mtk_rubyClassGenerated
+		return cmd if isBootstrap?
+		@mtk_rubyClassGenerated=true
+
+		rdfs_subClassOf.each { |sub|
+			cmd+=sub.createRubyClass(model) 
+		}
+
+		cmd+="module ::#{self.getRubyModuleName}\n"  
+		cmd+=getRubyAttributeDefinition(model)
+		rdfs_subClassOf.each { |sub|
+			cmd+='  include ::' +(sub.getRubyModuleName)+"\n"
+		}
+		cmd+="end\n\n"
+		cmd+="class ::#{getRubyClassName} < ::Crdfs_Class\n"  
+		cmd+='  include ' +self.getRubyModuleName+"\n"
+
+		#rdfs_subClassOfRecursive.uniq.each { |c|
+		#	cmd+='  include ' +(c.getRubyModuleName)+'\n'
+		#}
+		cmd+="end\n\n"	
+		
+		#log.debug "cmd -->#---------\n#{cmd}\n#---------------"
+		eval(cmd)
+
+		return cmd
+	end
+end
+
+module Mrdf_Resource
+	# returns this object uri converted to a dot/graphviz compatible identifier.
+	def dotId
+		return  rdf_uri.tr('^a-zA-Z0-9','_')
+	end
+end
+

data/lib/ontomde-core/resourceSet.rb

@@ -0,0 +1,173 @@
+#:include: ../shared/license.rdoc
+
+module Mrdf_Model
+end
+
+class Crdf_Resource
+	#True if resource is a bootstrap resource.
+	#A bootstrap resource is a resource existing prior to model creation (not loaded from external configuration file).
+	#Loaded resources are built using bootstrap resouces as references.
+	rdf_safe_attr_reader_many :ext_isBootstrap
+end
+
+#Class meant to store every element of a model.
+class Crdf_Model  #< Hash
+	include Mrdf_Model
+	attr_reader :updateCount
+	def length
+		@resourceSet.length
+	end
+	def empty?
+		return @resourceSet.empty?
+	end
+	def to_s
+		log.debug  'Model'
+	end
+	
+	# Returns the ressource associated to the uri key. 
+	def [](key)
+		return @resourceSet[key]
+	end
+
+	# Internal use
+	def []=(key,res)
+		@resourceSet[key]=res
+	end
+
+	# Standard each iterator
+	def each(&block_expr)
+		@resourceSet.each &block_expr
+	end
+	
+	# Standard find_all iterator
+	def find_all(&block_expr)
+		@resourceSet.find_all &block_expr
+	end 
+	
+	# Standard each_value iterator
+	def each_value(&block_expr)
+		@resourceSet.each_value &block_expr
+	end
+	#
+	# Standard reject iterator
+	def reject(&block_expr)
+		@resourceSet.reject &block_expr
+	end
+
+	# Initialize model internal structures.
+	def initialize
+		super
+		@resourceSet=Hash.new
+		#@fileGenerated=Array.new
+		@updateCount=0
+		#@@mtk_out=nil
+			
+		#bootstrap
+		Crdf_Resource.new(self,'rdf_Resource');
+		Crdf_Resource.new(self,'rdfs_Resource'); # le p�re des h�ritages
+		Crdf_Resource.new(self,'rdfs_Class');
+		Crdf_Resource.new(self,'rdf_Property');
+		Crdf_Resource.new(self,'rdfs_Literal');
+		
+		#bootstrap pour module kb
+		Crdf_Resource.new(self,'kb_UML_METACLASS');
+		Crdf_Resource.new(self,'kb_UML_SLOT');
+
+		self.each {|k,c| c.ext_isBootstrap='true'}
+	end
+
+	#returns ressource associated to uri stored in model
+	def getRes(uri) 
+		raise Warning.new,'nil uri' if uri.nil?
+		obj=self[uri]
+		raise WarningURIundefined.new(uri),"--uri undefined \"#{uri}\" "  if obj.nil?
+		return obj
+	end
+
+	# internal use
+	def parse(nt,modeData)
+		if modeData 
+			parseModeData(nt)
+		else
+			parseModeResource(nt)
+		end
+	end
+
+	# internal use
+	@@RDF_type=['rdf_type']
+	 
+	# internal use
+	def predicat_isRDFTYPE(predicat)
+		return @@RDF_type.include?(predicat)
+	end
+
+	# internal use
+	def dynNewInstance(value_res,about_uri)
+		cmd=value_res.getRubyClassName+'.new(self,about_uri)'
+		return eval(cmd)
+	end
+
+	# internal use
+	def parseModeResource(nt)
+		return if !predicat_isRDFTYPE(nt.predicat_uri)
+
+		about_res=self[nt.about_uri]
+		if about_res 
+			about_res.forceReset!()
+		else	
+			value_res=self.getRes(nt.value_uri)
+			begin
+				self[nt.about_uri]=about_res=dynNewInstance(value_res,nt.about_uri)
+				about_res.rdf_type=value_res
+				#about_res.set(rubyIdentifier(predicat_uri),value_res) # ref 
+			rescue  => e
+				log.debug "e-->#{e}"
+				#TODO: cause probable
+				raise WarningRubyTypeUndefined.new(nt.about_uri,value_res),"Ruby Type #{value_res.getRubyClassName} Undefined (cause probable!)"
+			end
+			return
+		end
+	end
+
+	# internal use
+	def parseModeData(nt)
+		return if predicat_isRDFTYPE(nt.predicat_uri)
+		subject=self.getRes(nt.about_uri)
+		if nt.valueIsReference?
+			subject.set(rubyIdentifier(nt.predicat_uri),self.getRes(nt.value_uri))
+		else
+			subject.set(rubyIdentifier(nt.predicat_uri),nt.value_litteral) 
+		end
+
+	end
+
+	# internal use
+	def rubyIdentifier(str)
+		return str.tr('^a-zA-Z0-9','_')
+	end
+
+	# internal use
+	def generateClassesFromMetamodel(outRubyModelFileName)
+		log.info("ecriture du metamodele dans: #{outRubyModelFileName}")
+		#f=File.open(outRubyModelFileName,File::CREAT|File::TRUNC|File::RDWR, 0644) 
+		mtk_default_context(:logFileWrite => false) { mtk_writeSession(outRubyModelFileName) {
+		f=self
+		f.write("# Debut du fichier #{outRubyModelFileName}\n")
+		f.write("# Ce fichier a ete genere automatiquement\n")
+		f.write("# Genere le:#{Time.now}\n")
+		self.
+			find_all { |a,x| 
+			x.kind_of?(Crdfs_Class)
+			}.
+			each  { |a,x|
+			#log.debug "gen -> #{x} #{x.class}" 
+			cmd=x.createRubyClass(self)
+			f.write(cmd)
+			}
+		f.write("# Fin du fichier #{outRubyModelFileName}\n")
+		}} #f.close
+
+	end
+
+	
+end

data/lib/ontomde-core/triplet.rb

@@ -0,0 +1,161 @@
+#:include: ../shared/license.rdoc
+
+require "singleton"
+
+class UriNamespace 
+	include Singleton
+	def initialize
+		# Les 1er sont prioritaire pour unalias ??
+		@urialiases=Hash.new(nil)
+		@urialiases["http:\/\/uml\/2"]="uml"
+		#@urialiases["http:\/\/uml\/1.4"]="uml"
+		@urialiases["http:\/\/www.w3.org\/2000\/01\/rdf-schema"]="rdfs"
+		@urialiases["http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns"]="rdf"
+		@urialiases["http:\/\/protege.stanford.edu\/system"]="sys"
+		@urialiases["http:\/\/protege.stanford.edu\/kb"]="kb"
+		@urialiases["http:\/\/ft\/uml\/2"]="umlx"
+		@urialiases["http:\/\/kb"]="ukb"
+		@urialiases["http:\/\/orange-ftgroup.com\/2007\/rd\/xmda\/bpm"]="bpm"
+	end
+	
+	# Returns unaliases uri for uri
+	# Used by magic draw export plugin
+	# NOTE:
+	#   raises an error if alias is unknown.
+	# Example:
+	#   unalias("rdf_XYZ") return @urialises("rdf")+"#"+"XYZ" 
+	def unalias(uri)
+		n=uri.split('_',2)
+		@urialiases.each {|k,v|
+			next if v!=n[0]
+			return k+"#"+n[1] 
+		}
+		# no alias is ok
+		return uri 
+		#raise "unalias failed for #{uri}"
+	end
+
+	# Returns the alias associated to ns.
+	# NOTE:
+	#    uri of the form http://orange-ft.com/[0-9]+/XyZ are aliases xyz 
+	def getNamespaceAlias(ns)
+		_alias=@urialiases[ns]
+		return _alias if _alias 
+
+		md=/^http:\/\/orange-ft.com\/[0-9]+\/([a-z0-9A-Z]+)$/.match(ns)
+		if md.nil?
+			_alias="ns_#{@urialiases.length.to_s}"
+		else
+			# La premi�re lettre doit �tre minuscule
+			_alias=md[1].downcase
+		end
+		addAliasHelp(_alias,ns)
+		addAlias(_alias,ns)
+		return _alias
+
+	end
+
+	def addAliasHelp(_alias,ns)
+		#return if context[:displayAddAliasHelp,true]
+		log.debug <<-ENDMSG
+
+**********************************************************
+** An unknown rdf namespace has been found and a random
+** alias has been generated for it : '#{_alias}'
+**
+** Using a random alias is OK if you do not need to
+** reference a namespace somewhere in your code.
+**
+** If, for example, you need to declare methods 
+** for elements of this namespace 
+** (for generating code for example), 
+** you will need a fix namespace alias.
+**
+** Run the following ruby code once in your ruby 
+** program to declare a new alias:
+**
+** YourCode.rb
+**   require 'ontomde-core'
+**   (...)
+**   UriNamespace.instance.addAlias('yourAlias',
+**       '#{ns.gsub(/\//,'\\\/')}'
+**       )
+**
+** Note: beware of \\/ ruby string escaping) 
+**********************************************************
+		ENDMSG
+	end
+	
+	#adds an alias to the predefined list of aliases.
+	def addAlias(_alias,ns)
+		log.debug { "Creation d'un alias de namespace xmlns:"+_alias+"=\""+ns+"#\"" }
+		@urialiases[ns]=_alias
+		return nil 
+	end
+	
+	#compute aliases name for given uri
+	#exemple alias('http://foo#bar') --> 'ns1:bar'
+	#Note:
+	# method added for uml2_kb which stores unaliased uri in kb text field for back reference to uml model.
+	def urialias(uri)
+		a=uri.split("#",2)
+		return uri if a[1].nil?
+		ns=getNamespaceAlias(a[0])
+		#puts "uri=#{ns}_#{a[1]}"
+		return "#{ns}_#{a[1]}"
+	end
+end
+
+#RDF triplet handling.
+class NTriple
+	attr_reader :about_uri, :predicat_uri,  :value_uri, :value_litteral
+	def valueIsReference?
+	end
+	
+	# Initialization of internal cache (performance enchancement)
+	def initialize
+		# Le cache est remis � z�ro � chaque fichier. 
+		# Les essais avec SID.nt montrent un gain de performance 
+		# de 10% sur la m�thode urialias, les fichiers �tant largement disjoints.
+		#@@cacheUse=1
+		#@@cacheMiss=100
+		#log.debug "initialize triplet"
+		@uriMappingCache=Hash.new(nil)
+	end
+	
+	# Returns an aliases uri
+	# uri is in ntriple format: '<http://foo#bar>'
+	# Optimize for ntriple file handling
+	def urialias(uri)
+		#log.debug "#{uri} ??"
+		#return nil if uri == nil
+		ret=@uriMappingCache[uri]
+		#log.debug "cache miss %=#{1.0*@@cacheMiss/@@cacheUse*100} cacheUse=#{@@cacheUse}"
+		#@@cacheUse=@@cacheUse+1
+		return ret unless ret.nil?
+		#log.debug "cache miss"
+		#@@cacheMiss=@@cacheMiss+1
+		@uriMappingCache[uri]=ret=compute_urialias(uri)
+		#log.debug "#{uri} -> #{ret}"
+		return ret
+	end
+	
+	# Internal use
+	def compute_urialias(uri)
+		#renvoi une uri apres avoir remplacer le chemin par son alias
+		raise Warning.new,"Bad NT URI (#{uri})" if uri.nil? || (uri[0] != 60)
+		#uri=uri[1,uri.length-2]
+		#log.debug "uri[0,1] -> '#{uri[0,1]}'"
+		uri=uri[1,uri.length].split(">",2)[0]
+		#log.debug "uri-->#{uri}"
+		return ::UriNamespace.instance.urialias(uri)
+
+		#a=uri.split("#",2)
+		#return uri if a[1].nil?
+		#r=::UriNamespace.instance.getNamespaceAlias(a[0])
+		#log.debug "urialias="+r+"_"+a[1] 
+		#return r+"_"+a[1] 
+		#return "#{r}_#{a[1]}"
+	end	
+
+end