activerdf 1.2 → 1.2.1

data/Rakefile

@@ -30,7 +30,7 @@ desc 'test and package gem'
 task :default => :install
 
 # get ActiveRdfVersion from commandline
-ActiveRdfVersion = '1.2'
+ActiveRdfVersion = '1.2.1'
 NAME="activerdf"
 GEMNAME="#{NAME}-#{ActiveRdfVersion}.gem"
 

data/lib/active_rdf/objectmanager/resource.rb

@@ -23,6 +23,7 @@ module RDFS
     def initialize uri
       raise ActiveRdfError, "creating resource <#{uri}>" unless uri.is_a?(String)
       @uri = uri
+			@predicates = Hash.new
     end
 
     # setting our own class uri to rdfs:resource
@@ -144,6 +145,10 @@ module RDFS
       # 4. eyal.age is a custom-written method in class Person
       # evidence: eyal type ?c, ?c.methods includes age
       # action: inject age into eyal and invoke
+			#
+			# 5. eyal.age is registered abbreviation 
+			# evidence: age in @predicates
+			# action: return object from triple (eyal, @predicates[age], ?o)
 
       # maybe change order in which to check these, checking (4) is probably
       # cheaper than (1)-(2) but (1) and (2) are probably more probable (getting
@@ -151,8 +156,8 @@ module RDFS
 
       $activerdflog.debug "RDFS::Resource: method_missing on instance: called with method name #{method}"
 
-      # are we doing an update or not?
-      # checking if method ends with '='
+      # are we doing an update or not? 
+			# checking if method ends with '='
 
       if method.to_s[-1..-1] == '='
         methodname = method.to_s[0..-2]
@@ -162,161 +167,175 @@ module RDFS
         update = false
       end
 
+			# check possibility (5)
+			if @predicates.include?(methodname)
+				return predicate_invocation(@predicates[methodname], args, update)
+			end
+
       candidates = if update
                       (class_level_predicates + direct_predicates).compact.uniq
                     else
                       direct_predicates
                     end
-    
-    # checking possibility (1) and (3)
-    candidates.each do |pred|
-      if Namespace.localname(pred) == methodname
-        # found a property invocation of eyal: option 1) or 2)
-        # query execution will return either the value for the predicate (1)
-        # or nil (2)
-        if update
-          # TODO: delete old value if overwriting
-          # FederiationManager.delete(self, pred, nil)
-
-          # handling eyal.friends = [armin, andreas] --> expand array values
-          args.each do |value|
-            FederationManager.add(self, pred, value)
-          end
-          return args
-        else
-          # look into args, if it contains a hash with {:array => true} then
-          # we should not flatten the query results
-          return get_property_value(pred, args)
-        end
-      end
-    end
-    
-		raise ActiveRdfError, "could not set #{methodname} to #{args}: no suitable 
-		predicate found. Maybe you are missing some schema information?" if update
-
-    # get/set attribute value did not succeed, so checking option (2) and (4)
-    
-    # checking possibility (2), it is not handled correctly above since we use
-    # direct_predicates instead of class_level_predicates. If we didn't find
-    # anything with direct_predicates, we need to try the
-    # class_level_predicates. Only if we don't find either, we
-    # throw "method_missing"
-    candidates = class_level_predicates
-
-    # if any of the class_level candidates fits the sought method, then we
-    # found situation (2), so we return nil or [] depending on the {:array =>
-    # true} value
-    if candidates.any?{|c| Namespace.localname(c) == methodname}
-      return_ary = args[0][:array] if args[0].is_a? Hash
-      if return_ary
-        return []
-      else
-        return nil
 
-      end
-    end
+			# checking possibility (1) and (3)
+			candidates.each do |pred|
+				if Namespace.localname(pred) == methodname
+					return predicate_invocation(pred, args, update)
+				end
+			end
+			
+			raise ActiveRdfError, "could not set #{methodname} to #{args}: no suitable 
+			predicate found. Maybe you are missing some schema information?" if update
+
+			# get/set attribute value did not succeed, so checking option (2) and (4)
+			
+			# checking possibility (2), it is not handled correctly above since we use
+			# direct_predicates instead of class_level_predicates. If we didn't find
+			# anything with direct_predicates, we need to try the
+			# class_level_predicates. Only if we don't find either, we
+			# throw "method_missing"
+			candidates = class_level_predicates
+
+			# if any of the class_level candidates fits the sought method, then we
+			# found situation (2), so we return nil or [] depending on the {:array =>
+			# true} value
+			if candidates.any?{|c| Namespace.localname(c) == methodname}
+				return_ary = args[0][:array] if args[0].is_a? Hash
+				if return_ary
+					return []
+				else
+					return nil
+				end
+			end
+
+			# checking possibility (4)
+			# TODO: implement search strategy to select in which class to invoke
+			# e.g. if to_s defined in Resource and in Person we should use Person
+			$activerdflog.debug "RDFS::Resource: method_missing option 4: custom class method"
+			self.type.each do |klass|
+				if klass.instance_methods.include?(method.to_s)
+					_dup = klass.new(uri)
+					return _dup.send(method,*args)
+				end
+			end
+
+			# if none of the three possibilities work out, we don't know this method
+			# invocation, but we don't want to throw NoMethodError, instead we return
+			# nil, so that eyal.age does not raise error, but returns nil. (in RDFS,
+			# we are never sure that eyal cannot have an age, we just dont know the
+			# age right now)
+			nil
+		end
 
-    # checking possibility (4)
-    # TODO: implement search strategy to select in which class to invoke
-    # e.g. if to_s defined in Resource and in Person we should use Person
-    $activerdflog.debug "RDFS::Resource: method_missing option 4: custom class method"
-    self.type.each do |klass|
-      if klass.instance_methods.include?(method.to_s)
-        _dup = klass.new(uri)
-        return _dup.send(method,*args)
-      end
-    end
+		# saves instance into datastore
+		def save
+			db = ConnectionPool.write_adapter
+			rdftype = Namespace.lookup(:rdf, :type)
+			types.each do |t|
+				db.add(self, rdftype, t)
+			end
+
+			Query.new.distinct(:p,:o).where(self, :p, :o).execute do |p, o|
+				db.add(self, p, o)
+			end
+		end
 
-    # if none of the three possibilities work out, we don't know this method
-    # invocation, but we don't want to throw NoMethodError, instead we return
-    # nil, so that eyal.age does not raise error, but returns nil. (in RDFS,
-    # we are never sure that eyal cannot have an age, we just dont know the
-    # age right now)
-    nil
-  end
-
-	# saves instance into datastore
-	def save
-		db = ConnectionPool.write_adapter
-		rdftype = Namespace.lookup(:rdf, :type)
-		types.each do |t|
-			db.add(self, rdftype, t)
+		def type
+			types.collect do |type|
+				ObjectManager.construct_class(type)
+			end
 		end
 
-		Query.new.distinct(:p,:o).where(self, :p, :o).execute do |p, o|
-			db.add(self, p, o)
+		def add_predicate localname, fulluri
+			localname = localname.to_s
+			fulluri = RDFS::Resource.new(fulluri) if fulluri.is_a? String
+
+			# predicates is a hash from abbreviation string to full uri resource
+			@predicates[localname] = fulluri
 		end
-	end
 
-  def type
-    types.collect do |type|
-      ObjectManager.construct_class(type)
-    end
-  end
-
-  # overrides built-in instance_of? to use rdf:type definitions
-  def instance_of?(klass)
-    self.type.include?(klass)
-  end
-
-  # returns all predicates that fall into the domain of the rdf:type of this
-  # resource
-  def class_level_predicates
-    type = Namespace.lookup(:rdf, 'type')
-    domain = Namespace.lookup(:rdfs, 'domain')
-    Query.new.distinct(:p).where(self,type,:t).where(:p, domain, :t).execute || []
-  end
-
-  # returns all predicates that are directly defined for this resource
-  def direct_predicates(distinct = true)
-    if distinct
-      q = Query.new.distinct(:p)
-    else
-      q = Query.new.select(:p)
-    end
-    q.where(self,:p, :o).execute
-  end
-
-  def property_accessors
-    direct_predicates.collect {|pred| Namespace.localname(pred) }
-  end
-
-  # alias include? to ==, so that you can do paper.creator.include?(eyal)
-  # without worrying whether paper.creator is single- or multi-valued
-  alias include? ==
-
-  # returns uri of resource, can be overridden in subclasses
-  def to_s
-    "<#{uri}>"
-  end
-
-#	# label of resource (rdfs:label if available, uri otherwise)
-#  def label
-#    get_property_value(Namespace.lookup(:rdfs,:label)) || uri
-#  end
-
-  private
-  def get_property_value(predicate, args=[])
-    return_ary = args[0][:array] if args[0].is_a?(Hash)
-    flatten_results = !return_ary
-    query = Query.new.distinct(:o).where(self, predicate, :o)
-		query.execute(:flatten => flatten_results)
-  end  
-
-  # returns all rdf:types of this resource
-  def types
-    type = Namespace.lookup(:rdf, :type)
-
-    # we lookup the type in the database
-    types = Query.new.distinct(:t).where(self,type,:t).execute
-
-    # we are also always of type rdfs:resource and of our own class (e.g. foaf:Person)
-		defaults = []
-		defaults << Namespace.lookup(:rdfs,:Resource)
-		defaults << self.class.class_uri
-
-    (types + defaults).uniq
-  end
 
-end
+		# overrides built-in instance_of? to use rdf:type definitions
+		def instance_of?(klass)
+			self.type.include?(klass)
+		end
+
+		# returns all predicates that fall into the domain of the rdf:type of this
+		# resource
+		def class_level_predicates
+			type = Namespace.lookup(:rdf, 'type')
+			domain = Namespace.lookup(:rdfs, 'domain')
+			Query.new.distinct(:p).where(self,type,:t).where(:p, domain, :t).execute || []
+		end
+
+		# returns all predicates that are directly defined for this resource
+		def direct_predicates(distinct = true)
+			if distinct
+				q = Query.new.distinct(:p)
+			else
+				q = Query.new.select(:p)
+			end
+			direct = q.where(self,:p, :o).execute
+			return (direct + direct.collect {|d| ancestors(d)}).flatten.uniq
+		end
+
+		def property_accessors
+			direct_predicates.collect {|pred| Namespace.localname(pred) }
+		end
+
+		# alias include? to ==, so that you can do paper.creator.include?(eyal)
+		# without worrying whether paper.creator is single- or multi-valued
+		alias include? ==
+
+		# returns uri of resource, can be overridden in subclasses
+		def to_s
+			"<#{uri}>"
+		end
+
+	#	# label of resource (rdfs:label if available, uri otherwise)
+	#  def label
+	#    get_property_value(Namespace.lookup(:rdfs,:label)) || uri
+	#  end
+
+		private
+
+		def ancestors(predicate)
+			subproperty = Namespace.lookup(:rdfs,:subPropertyOf)
+			Query.new.distinct(:p).where(predicate, subproperty, :p).execute
+		end
+
+		def predicate_invocation(predicate, args, update)
+			if update
+				args.each do |value|
+					FederationManager.add(self, predicate, value)
+				end
+				args
+			else
+				get_property_value(predicate, args)
+			end
+		end
+
+		def get_property_value(predicate, args=[])
+			return_ary = args[0][:array] if args[0].is_a?(Hash)
+			flatten_results = !return_ary
+			query = Query.new.distinct(:o).where(self, predicate, :o)
+			query.execute(:flatten => flatten_results)
+		end  
+
+		# returns all rdf:types of this resource
+		def types
+			type = Namespace.lookup(:rdf, :type)
+
+			# we lookup the type in the database
+			types = Query.new.distinct(:t).where(self,type,:t).execute
+
+			# we are also always of type rdfs:resource and of our own class (e.g. foaf:Person)
+			defaults = []
+			defaults << Namespace.lookup(:rdfs,:Resource)
+			defaults << self.class.class_uri
+
+			(types + defaults).uniq
+		end
+	end
 end

data/lib/active_rdf.rb

@@ -27,20 +27,20 @@ def load_adapter s
 end
 
 require 'rubygems'
-#determine if we are installed as a gem right now:
-if Gem::cache().search("activerdf").empty?
-   #we are not running as a gem
-   $activerdflog.info 'ActiveRDF is NOT installed as a Gem'
-   load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/rdflite'
-   load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/fetching'
-   load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/suggesting'
-   load_adapter this_dir + '/../activerdf-redland/lib/activerdf_redland/redland'
-   load_adapter this_dir + '/../activerdf-sparql/lib/activerdf_sparql/sparql'
-   load_adapter this_dir + '/../activerdf-yars/lib/activerdf_yars/jars2'
+# determine whether activerdf is installed as a gem:
+if Gem::cache.search(/^activerdf$/).empty?
+	# we are not running as a gem
+	$activerdflog.info 'ActiveRDF is NOT installed as a Gem'
+	load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/rdflite'
+	load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/fetching'
+	load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/suggesting'
+	load_adapter this_dir + '/../activerdf-redland/lib/activerdf_redland/redland'
+	load_adapter this_dir + '/../activerdf-sparql/lib/activerdf_sparql/sparql'
+	load_adapter this_dir + '/../activerdf-yars/lib/activerdf_yars/jars2'
 else
-   #we are indeed running as a gem
-   require 'gem_plugin'
-   $activerdflog.info 'ActiveRDF is installed as a Gem'
-   GemPlugin::Manager.instance.load "activerdf" => GemPlugin::INCLUDE
+	# we are running as a gem
+	require 'gem_plugin'
+	$activerdflog.info 'ActiveRDF is installed as a Gem'
+	GemPlugin::Manager.instance.load "activerdf" => GemPlugin::INCLUDE
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: activerdf
 version: !ruby/object:Gem::Version 
-  version: "1.2"
-date: 2006-12-21 00:00:00 +01:00
+  version: 1.2.1
+date: 2007-01-30 00:00:00 +00:00
 summary: Offers object-oriented access to RDF (with adapters to several datastores).
 require_paths: 
 - lib