activerdf_net7 1.6.11

data/lib/active_rdf/objectmanager/property_list.rb

@@ -0,0 +1,76 @@
+# Simple class which will contain all values of a specified property related to a subject.
+# It provides some useful shortcut methods to work with properties and related values.
+
+class PropertyList < Array
+  
+  # Add reader accessor
+  attr_reader :s, :p
+  attr_accessor :writeable
+  
+  # Initialize a new list of properties' values
+  # * p           the original property
+  # * pv_list     the list of properties' values
+  # * s           the sobject which property is related to
+  # * writeable   if set to false, the list will be write-protected
+  def initialize(p, pv_list, s, writeable = true)
+    super pv_list
+    @s, @p = s, p
+    @writeable = writeable
+  end
+
+  # add a new property value realated to @p property and @s subject
+  alias :add :<<
+  def <<(pv)
+    check_writeable!
+    # update the array list
+    add pv
+    
+    # insert the new statment into the store
+    FederationManager.add(@s, @p, pv)
+  end
+  
+  # delete a statment which contains old_p_value
+  # and insert a new statment (@s, @p, new_p_value)
+  def replace(old_p_value, new_p_value)
+    check_writeable!
+    # delete the old statment
+    self.delete(old_p_value)
+    FederationManager.delete(@s, @p, old_p_value)
+    
+    # insert the new statment
+    self << new_p_value
+  end
+
+  # if no papameters will be specified, delete every
+  # triple related to :s and p: otherwise delete the
+  # triples whose values are specified by params
+  def remove(*params)
+    check_writeable!
+    if params.length >= 1
+      # delete only triples whose values is specified by parameters
+      params.each{|param|
+        if self.delete(param)
+          return FederationManager.delete(@s, @p, param)
+        end
+      }
+    else
+      # delete every triple related to :s and :p whose values is contained by self...
+      self.each{|value|
+        if FederationManager.delete(@s, @p, value) == false
+          return false
+        end
+      }
+      # ...and clear the array Poperty_list array
+      self.clear
+      return true
+    end
+  end
+    
+  private
+  
+  # Checks if the list is writeable, raise an error otherwise
+  def check_writeable!
+    raise(RuntimeError, "List is not writeable!") unless(@writeable)
+  end
+
+end

data/lib/active_rdf/objectmanager/resource.rb

@@ -0,0 +1,609 @@
+# require 'active_rdf'
+require 'objectmanager/object_manager'
+require 'objectmanager/namespace'
+require 'objectmanager/property_list'
+require 'instance_exec'
+
+module RDFS
+  # Represents an RDF resource and manages manipulations of that resource,
+  # including data lookup (e.g. eyal.age), data updates (e.g. eyal.age=20),
+  # class-level lookup (Person.find_by_name 'eyal'), and class-membership
+  # (eyal.class ...Person).
+
+  class Resource
+    
+    include ResourceLike
+    
+    # adding accessor to the class uri:
+    # the uri of the rdf resource being represented by this class
+    class << self
+      attr_accessor :class_uri
+    end
+
+    # uri of the resource (for instances of this class: rdf resources)
+    attr_reader :uri
+
+    # creates new resource representing an RDF resource
+    def initialize uri
+      @uri = case uri
+        # allow Resource.new(other_resource)
+      when RDFS::Resource
+        uri.uri
+        # allow Resource.new('<uri>') by stripping out <>
+      when /^<([^>]*)>$/
+        $1
+        # allow Resource.new('uri')
+      when String
+        uri
+      else 
+        raise ActiveRdfError, "cannot create resource <#{uri}>"
+      end
+      @predicates = Hash.new
+    end
+
+    # setting our own class uri to rdfs:resource
+    # (has to be done after defining our RDFS::Resource.new
+    # because it cannot be found in Namespace.lookup otherwise)
+    self.class_uri = Namespace.lookup(:rdfs, :Resource)
+
+    def self.uri; class_uri.uri; end
+    def self.==(other)
+      other.respond_to?(:uri) ? other.uri == self.uri : false
+    end
+    def self.localname; Namespace.localname(self); end
+
+    #####                        ######
+    ##### start of instance-level code
+    #####                        ######
+
+    def abbreviation; [Namespace.prefix(uri).to_s, localname]; end
+    # a resource is same as another if they both represent the same uri
+    def ==(other);
+      other.respond_to?(:uri) ? other.uri == self.uri : false
+    end
+    alias_method 'eql?','=='
+
+    # overriding hash to use uri.hash
+    # needed for array.uniq
+    def hash; uri.hash; end
+
+    def self.to_ntriple; "<#{class_uri.uri}>"; end
+
+    def to_xml
+      base = Namespace.expand(Namespace.prefix(self),'').chop
+
+      xml = "<?xml version=\"1.0\"?>\n"
+      xml += "<rdf:RDF xmlns=\"#{base}\#\"\n"
+      Namespace.abbreviations.each { |p| uri = Namespace.expand(p,''); xml += "  xmlns:#{p.to_s}=\"#{uri}\"\n" if uri != base + '#' }
+      xml += "  xml:base=\"#{base}\">\n"
+
+      xml += "<rdf:Description rdf:about=\"\##{localname}\">\n"
+      direct_predicates.each do |p|
+        objects = Query.new.distinct(:o).where(self, p, :o).execute
+        objects.each do |obj|
+          prefix, localname = Namespace.prefix(p), Namespace.localname(p)
+          pred_xml = if prefix
+            "%s:%s" % [prefix, localname]
+          else
+            p.uri
+          end
+
+          case obj
+          when RDFS::Resource
+            xml += "  <#{pred_xml} rdf:resource=\"#{obj.uri}\"/>\n"
+          when LocalizedString
+            xml += "  <#{pred_xml} xml:lang=\"#{obj.lang}\">#{obj}</#{pred_xml}>\n"
+          else
+            xml += "  <#{pred_xml} rdf:datatype=\"#{obj.xsd_type.uri}\">#{obj}</#{pred_xml}>\n"
+          end
+        end
+      end
+      xml += "</rdf:Description>\n"
+      xml += "</rdf:RDF>"
+    end
+
+    #####                   	#####
+    ##### class level methods	#####
+    #####                    	#####
+
+    # returns the predicates that have this resource as their domain (applicable
+    # predicates for this resource)
+    def Resource.predicates
+      domain = Namespace.lookup(:rdfs, :domain)
+      Query.new.distinct(:p).where(:p, domain, class_uri).execute || []
+    end
+
+    # quick fix for "direct" getting of a property
+    # return a PropertyCollection (see PropertyCollection class)
+    def [](property)
+      if !property.instance_of?(RDFS::Resource)
+        property = RDFS::Resource.new(property)
+      end
+
+      plv = Query.new.distinct(:o).where(self, property, :o).execute
+
+      # make and return new propertis collection
+      PropertyList.new(property, plv, self)
+    end
+
+    # manages invocations such as Person.find_by_name, 
+    # Person.find_by_foaf::name, Person.find_by_foaf::name_and_foaf::knows, etc.
+    def Resource.method_missing(method, *args)
+      if /find_by_(.+)/.match(method.to_s)
+        ActiveRdfLogger::log_debug "Constructing dynamic finder for #{method}", self
+
+        # construct proxy to handle delayed lookups 
+        # (find_by_foaf::name_and_foaf::age)
+        proxy = DynamicFinderProxy.new($1, nil, *args)
+
+        # if proxy already found a value (find_by_name) we will not get a more 
+        # complex query, so return the value. Otherwise, return the proxy so that 
+        # subsequent lookups are handled
+        return proxy.value || proxy
+      end
+    end
+
+    # returns array of all instances of this class (e.g. Person.find_all)
+    # (always returns collection)
+    def Resource.find_all(*args)
+      find(:all, *args)
+    end
+
+    def Resource.find(*args)
+      class_uri.find(*args)
+    end
+
+    #####                         #####
+    ##### instance level methods	#####
+    #####                         #####
+    def find(*args)
+      # extract sort options from args
+      options = args.last.is_a?(Hash) ? args.pop : {}
+
+      query = Query.new.distinct(:s)
+      query.where(:s, Namespace.lookup(:rdf,:type), self)
+
+      if options.include? :order
+        sort_predicate = options[:order]
+        query.sort(:sort_value)
+        query.where(:s, sort_predicate, :sort_value)
+      end
+
+      if options.include? :reverse_order
+        sort_predicate = options[:reverse_order]
+        query.reverse_sort(:sort_value)
+        query.where(:s, sort_predicate, :sort_value)
+      end
+
+      if options.include? :where
+        raise ActiveRdfError, "where clause should be hash of predicate => object" unless options[:where].is_a? Hash
+        options[:where].each do |p,o|
+          if options.include? :context
+            query.where(:s, p, o, options[:context])
+          else
+            query.where(:s, p, o)
+          end
+        end
+      else
+        if options[:context]
+          query.where(:s, :p, :o, options[:context])
+        end
+      end
+
+      query.limit(options[:limit]) if options[:limit]
+      query.offset(options[:offset]) if options[:offset]
+
+      if block_given?
+        query.execute do |resource|
+          yield resource
+        end
+      else
+        query.execute(:flatten => false)
+      end
+    end
+
+    def localname
+      Namespace.localname(self)
+    end
+
+    # Simple query shortcut which return a special object created on-the-fly by which is
+    # possible to directly obtain every distinct resources where:
+    # property ==> specified by the user by [] operator
+    # object   ==> current Ruby object representing an RDF resource
+    def inverse
+      inverseobj = Object.new
+      inverseobj.instance_variable_set(:@obj_uri, self)
+
+      class <<inverseobj     
+
+        def [](property_uri)
+          property = RDFS::Resource.new(property_uri)
+          Query.new.distinct(:s).where(:s, property, @obj_uri).execute
+        end
+        private(:type)
+      end
+
+      return inverseobj
+    end
+
+    # manages invocations such as eyal.age
+    def method_missing(method, *args,&block)
+      # possibilities:
+      # 1. eyal.age is a property of eyal (triple exists <eyal> <age> "30")
+      # evidence: eyal age ?a, ?a is not nil (only if value exists)
+      # action: return ?a
+      #
+      # 2. eyal's class is in domain of age, but does not have value for eyal
+      # explain: eyal is a person and some other person (not eyal) has an age
+      # evidence: eyal type ?c, age domain ?c
+      # action: return nil
+      #
+      # 3. eyal.age = 30 (setting a value for a property)
+      # explain: eyal has (or could have) a value for age, and we update that value
+      # complication: we need to find the full URI for age (by looking at
+      # possible predicates to use
+      # evidence: eyal age ?o  (eyal has a value for age now, we're updating it)
+      # evidence: eyal type ?c, age domain ?c (eyal could have a value for age, we're setting it)
+      # action: add triple (eyal, age, 30), return 30
+      #
+      # 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)
+      #
+      # 6. eyal.foaf::name, where foaf is a registered abbreviation
+      # evidence: foaf in Namespace.
+      # action: return namespace proxy that handles 'name' invocation, by 
+      # rewriting into predicate lookup (similar to case (5)
+
+      ActiveRdfLogger.log_debug(self) { "Method_missing: #{method}" }
+
+      # are we doing an update or not? 
+      # checking if method ends with '='
+
+      update = method.to_s[-1..-1] == '='
+      methodname = if update 
+        method.to_s[0..-2]
+      else
+        method.to_s
+      end
+
+      # extract single values from array unless user asked for eyal.all_age
+      flatten = true
+      if method.to_s[0..3] == 'all_'
+        flatten = false
+        methodname = methodname[4..-1]
+      end
+
+      # check possibility (5)
+      if @predicates.include?(methodname)
+        if update
+          return set_predicate(@predicates[methodname], args)
+        else
+          return get_predicate(@predicates[methodname], false, &block)
+        end
+      end
+
+      # check possibility (6)
+      if Namespace.abbreviations.include?(methodname.to_sym)
+        namespace = Object.new	
+        namespace.instance_variable_set(:@uri, methodname)
+        namespace.instance_variable_set(:@subject, self)
+        namespace.instance_variable_set(:@flatten, flatten)
+
+        # catch the invocation on the namespace
+        class <<namespace
+          def method_missing(localname, *values, &block)
+            update = localname.to_s[-1..-1] == '='
+            predicate = if update 
+              Namespace.lookup(@uri, localname.to_s[0..-2])
+            else
+              Namespace.lookup(@uri, localname)
+            end
+
+            if update
+              @subject.set_predicate(predicate, values)
+            else
+              @subject.get_predicate(predicate, @flatten, &block)
+            end
+          end
+          private(:type)
+        end
+        return namespace
+      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
+          if update
+            return set_predicate(pred, args)
+          else
+            return get_predicate(pred, flatten,  &block)
+          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 (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
+      ActiveRdfLogger::log_debug(self){ "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
+
+    # 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
+
+    # returns all rdf:type of this instance, e.g. [RDFS::Resource, 
+    # FOAF::Person]
+    #
+    # Note: this method performs a database lookup for { self rdf:type ?o }. For 
+    # simple type-checking (to know if you are handling an ActiveRDF object, use 
+    # self.class, which does not do a database query, but simply returns 
+    # RDFS::Resource.
+    def type
+      types.collect do |type|
+        ObjectManager.construct_class(type)
+      end
+    end
+
+    # define a localname for a predicate URI
+    #
+    # localname should be a Symbol or String, fulluri a Resource or String, e.g. 
+    # add_predicate(:name, FOAF::lastName)
+    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
+
+
+    # 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
+        Query.new.distinct(:p).where(self, :p, :o).execute
+      else
+        Query.new.select(:p).where(self, :p, :o).execute
+      end
+    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? ==
+
+    def set_predicate(predicate, values)
+      FederationManager.delete(self, predicate, nil)
+      values.flatten.each {|v| FederationManager.add(self, predicate, v) }
+      values
+    end
+
+    def get_predicate(predicate, flatten=false,&block)
+      query = Query.new.distinct(:o).where(self, predicate, :o)
+      if block_given?
+        yield query, :o
+      end
+      values = query.execute(:flatten => flatten)
+
+      # TODO: fix '<<' for Fixnum values etc (we cannot use values.instance_eval 
+      # because Fixnum cannot do instace_eval, they're not normal classes)
+      if values.is_a?(RDFS::Resource) and !values.nil?
+        # prepare returned values for accepting << later, eg. in
+        # eyal.foaf::knows << knud
+        #
+        # store @subject, @predicate in returned values
+        values.instance_exec(self, predicate) do |s,p|
+          @subj = s
+          @pred = p
+        end
+
+        # overwrite << to add triple to db
+        values.instance_eval do
+          def <<(value)
+            FederationManager.add(@subj, @pred, value)
+          end
+        end
+      end
+
+      values
+    end
+
+    private
+    #		def ancestors(predicate)
+    #			subproperty = Namespace.lookup(:rdfs,:subPropertyOf)
+    #			Query.new.distinct(:p).where(predicate, subproperty, :p).execute
+    #		end
+
+
+    # returns all rdf:types of this resource but without a conversion to 
+    # Ruby classes (it returns an array of RDFS::Resources)
+    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
+
+# proxy to manage find_by_ invocations
+class DynamicFinderProxy
+  @ns = nil
+  @where = nil
+  @value = nil
+  attr_reader :value
+  private(:type)
+
+  # construct proxy from find_by text
+  # foaf::name
+  def initialize(find_string, where, *args)
+    @where = where || []
+    parse_attributes(find_string, *args)
+  end
+
+  def method_missing(method, *args)
+    # we store the ns:name for later (we need to wait until we have the 
+    # arguments before actually constructing the where clause): now we just 
+    # store that a where clause should appear about foaf:name
+
+    # if this method is called name_and_foaf::age we add ourself to the query
+    # otherwise, the query is built: we execute it and return the results
+    if method.to_s.include?('_and_')
+      parse_attributes(method.to_s, *args)
+    else
+      @where << Namespace.lookup(@ns, method.to_s)
+      query(*args)
+    end
+  end
+
+  private 
+  # split find_string by occurrences of _and_
+  def parse_attributes string, *args
+    attributes = string.split('_and_')
+    attributes.each do |atr|
+      # attribute can be:
+      # - a namespace prefix (foaf): store prefix in @ns to prepare for method_missing
+      # - name (attribute name): store in where to prepare for method_missing
+      if Namespace.abbreviations.include?(atr.to_sym)
+        @ns = atr.to_s.downcase.to_sym
+      else
+        # found simple attribute label, e.g. 'name'
+        # find out candidate (full) predicate for this localname: investigate 
+        # all possible predicates and select first one with matching localname
+        candidates = Query.new.distinct(:p).where(:s,:p,:o).execute
+        @where << candidates.select {|cand| Namespace.localname(cand) == atr}.first
+      end
+    end
+
+    # if the last attribute was a prefix, return this dynamic finder (we'll 
+    # catch the following method_missing and construct the real query then)
+    # if the last attribute was a localname, construct the query now and return 
+    # the results
+    if Namespace.abbreviations.include?(attributes.last.to_sym)
+      return self
+    else
+      return query(*args)
+    end
+  end
+
+  # construct and execute finder query
+  def query(*args)
+    # extract options from args or use an empty hash (no options given)
+    options = args.last.is_a?(Hash) ? args.last : {}
+
+    # build query 
+    query = Query.new.distinct(:s)
+    @where.each_with_index do |predicate, i|
+      # specify where clauses, use context if given
+      if options[:context]
+        query.where(:s, predicate, args[i], options[:context])
+      else
+        query.where(:s, predicate, args[i])
+      end
+    end
+
+    # use sort order if given
+    if options.include? :order
+      sort_predicate = options[:order]
+      query.sort(:sort_value)
+      # add sort predicate where clause unless we have it already
+      query.where(:s, sort_predicate, :sort_value) unless @where.include? sort_predicate
+    end
+
+    if options.include? :reverse_order
+      sort_predicate = options[:reverse_order]
+      query.reverse_sort(:sort_value)
+      query.where(:s, sort_predicate, :sort_value) unless @where.include? sort_predicate
+    end
+
+    query.limit(options[:limit]) if options[:limit]
+    query.offset(options[:offset]) if options[:offset]
+
+    ActiveRdfLogger::log_debug(self) { "Executing dynamic finder: #{query.to_sp}" }
+
+    # store the query results so that caller (Resource.method_missing) can 
+    # retrieve them (we cannot return them here, since we were invoked from 
+    # the initialize method so all return values are ignored, instead the proxy 
+    # itself is returned)
+    @value = query.execute
+    return @value
+  end
+end