Class: ObjectManager

Inherits:
Object
  • Object
show all
Defined in:
lib/active_rdf/objectmanager/object_manager.rb

Overview

Constructs Ruby classes for RDFS classes (in the right namespace)

Class Method Summary collapse

Class Method Details

.construct_class(resource) ⇒ Object

constructs Ruby class for the given resource (and puts it into the module as defined by the registered namespace abbreviations)



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/active_rdf/objectmanager/object_manager.rb', line 39

def self.construct_class(resource)
   # get prefix abbreviation and localname from type
   # e.g. :foaf and Person
   localname = Namespace.localname(resource)
   prefix = Namespace.prefix(resource)

   # find (ruby-acceptable) names for the module and class
   # e.g. FOAF and Person
   if prefix.nil?
		# if the prefix is unknown, we create our own from the full URI
     modulename = create_module_name(resource)
     $activerdflog.debug "ObjectManager: construct_class: constructing modulename #{modulename} from URI #{resource}"
	else
		# otherwise we convert the registered prefix into a module name
		modulename = prefix_to_module(prefix)
		$activerdflog.debug "ObjectManager: construct_class: constructing modulename #{modulename} from registered prefix #{prefix}"
   end
   klassname = localname_to_class(localname)

   # look whether module defined
   # else: create it
   _module = if Object.const_defined?(modulename.to_sym)
       $activerdflog.debug "ObjectManager: construct_class: module name #{modulename} previously defined"
			Object.const_get(modulename.to_sym)
		else
       $activerdflog.debug "ObjectManager: construct_class: defining module name #{modulename} now"
			Object.const_set(modulename, Module.new)
		end

	# look whether class defined in that module
	if _module.const_defined?(klassname.to_sym)
     $activerdflog.debug "ObjectManager: construct_class: given class #{klassname} defined in the module"
		# if so, return the existing class
		_module.const_get(klassname.to_sym)
	else
     $activerdflog.debug "ObjectManager: construct_class: creating given class #{klassname}"
		# otherwise: create it, inside that module, as subclass of RDFS::Resource
		# (using toplevel Class.new to prevent RDFS::Class.new from being called)
		klass = _module.module_eval("#{klassname} = Object::Class.new(RDFS::Resource)")
		klass.class_uri = resource
		klass
	end
end

.construct_classes ⇒ Object

before so no class was created for it)



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/active_rdf/objectmanager/object_manager.rb', line 10

def self.construct_classes
  # find all rdf:types and construct class for each of them
  #q = Query.new.select(:t).where(:s,Namespace.lookup(:rdf,:type),:t)

# find everything defined as rdfs:class or owl:class
type = Namespace.lookup(:rdf,:type)
rdfsklass = Namespace.lookup(:rdfs,:Class)

# TODO: we should not do this, we should not support OWL
# instead, owl:Class is defined as subclass-of rdfs:Class, so if the 
# reasoner has access to owl definition it should work out fine.
owlklass = Namespace.lookup(:owl,:Class)

klasses = []
  klasses << Query.new.distinct(:s).where(:s,type,rdfsklass).execute
  klasses << Query.new.distinct(:s).where(:s,type,owlklass).execute

# flattening to get rid of nested arrays
# compacting array to get rid of nil (if one of these queries returned nil)
klasses = klasses.flatten.compact
$activerdflog.debug "ObjectManager: construct_classes: classes found: #{klasses}"

# then we construct a Ruby class for each found rdfs:class
# and return the set of all constructed classes
  klasses.collect { |t| construct_class(t) }
end