activerdf_net7 1.6.16 → 1.7.0

data/lib/active_rdf/objectmanager/property.rb

@@ -0,0 +1,345 @@
+require 'digest'
+require 'set'
+
+module RDF
+  # Represents an RDF property.
+  # If an optional subject is provided on instatiation, provides access to values of this property belonging to the
+  # associated subject. Property objects are +Enumerable+. Values are returned as copies with no order garunteed
+  # and may be accessed individually by key.
+  #
+  # == Usage
+  #  age = RDF::Property.new('http://activerdf.org/test/age')
+  #  age.domain => [#<RDFS::Resource @uri="http://activerdf.org/test/Person">]
+  #  age.range => [#<RDFS::Resource @uri="http://www.w3.org/1999/02/22-rdf-syntax-ns#Literal">]
+  #  age.type => [#<RDFS::Resource @uri="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property">]
+  #  age.to_a => ActiveRdfError: http://activerdf.org/test/age: no associated subject
+  #
+  #  email = RDF::Property.new('http://activerdf.org/test/email', 'http://activerdf.org/test/eyal')
+  #  email.replace("eyal@cs.cu.nl")                                 # replace any existing values
+  #  email.add("eyal.oren@deri.com")                                # add new value to this property
+  #  email += ("eyal.oren@deri.net")                                # alternative way to add new value
+  #  email.clear                                                    # delete any existing values
+  #  email.add(["eyal@cs.cu.nl","eyal.oren@deri.com"])              # add array containing values
+  #  email["eyal.oren@deri.com"] = "eyal.oren@deri.net"             # replace existing value
+  #  email[p.index("eyal.oren@deri.net")] = "eyal.oren@deri.org"    # replace existing value by key
+  #  email.include?("eyal.oren@deri.org") => true                   # check for existing value
+  #  email == ["eyal.oren@deri.org","eyal@cs.cu.nl"] => true        # compare value(s) to array (order is ignored)
+  #  email.delete("eyal@cs.cu.nl")                                  # delete specific value
+  #  email == "eyal.oren@deri.org" => true                          # compare value(s) to single value
+  #  email.collect!{|val| val.gsub(/@/,' at ').gsub(/\./,' dot ')}  # update value(s) with result of block
+  class Property < RDFS::Resource
+    attr_reader :subject
+
+    def initialize(property, subject = nil)
+      super(property)
+      @subject = subject
+      @lang = nil
+      @exact_lang = true
+      @datatype = nil
+      @context = nil
+
+      if @subject
+        class<<self
+          include AssociatedProperty
+        end
+      end
+    end
+
+    self.class_uri = ActiveRDF::Namespace.lookup(:rdf, :Property)
+
+    def initialize_copy(property)
+      if @subject
+        class<<self
+          include AssociatedProperty
+        end
+      end
+    end
+
+    # Returns the property object for this property without @subject set
+    def property
+      RDF::Property.new(self)
+    end
+  end
+
+  # Provides methods for accessing property values when @subject is set
+  module AssociatedProperty
+    include Enumerable
+    # Value reference. Retrieves a copy of the value by the key or value. Returns nil if not found.
+    def [](md5_or_value)
+      unless md5_or_value.nil?
+        arr = to_a
+        arr.find{|value| value == md5_or_value} || arr.find{|value| get_key(value) == md5_or_value}
+      end
+    end
+    alias :at :[]
+
+    # Selective value replacement. Replaces the value given by key or value. Raises IndexError if value not found.
+    def []=(md5_or_value,new_value)
+      value = self[md5_or_value]
+      raise IndexError, "Couldn't find existing value to replace: #{md5_or_value}" unless value
+      ActiveRDF::FederationManager.delete(@subject, self.property, value)
+      add(new_value)
+    end
+
+    # Returns a new array with the object appended, or the objects values if obj.respond_to? :to_ary
+    def +(obj)
+      to_a + [*obj]
+    end
+
+    # Returns a new array with the object removed
+    def -(obj)
+      to_a - [*obj]
+    end
+
+    def ==(other)
+      if other.respond_to?(:to_ary)
+        Set.new(other) == Set.new(to_a)
+      else
+        arr = to_a
+        if arr.size == 1
+          other == arr[0] || super
+        else
+          super
+        end
+      end
+    end
+    alias :eql? :==
+
+    # Append. Adds the given object(s) to the values for this property belonging to @subject
+    # This expression returns the property itself, so several appends may be chained together.
+    def add(*args)
+      args.each do |arg|
+        if arg.respond_to?(:to_ary)
+          arg.to_ary.each {|item| ActiveRDF::FederationManager.add(@subject, self.property, item)}
+        else
+          ActiveRDF::FederationManager.add(@subject, self.property, arg)
+        end
+      end
+      self
+    end
+
+    # Removes all values
+    def clear
+      ActiveRDF::FederationManager.delete(@subject, self.property)
+      self
+    end
+
+    # Invokes the block once for each value, replacing the value with the value returned by block
+    def collect!(&block)
+      to_a.each do |item|
+        new_item = yield(item)
+        delete(item)
+        add(new_item)
+      end
+      self
+    end
+    alias :map! :collect!
+
+    # Returns the context for the property if context is nil.
+    # Returns a new RDF::Property object with the @context value set if context is provided
+    # see also #lang, #datatype
+    def context(context = nil)
+      if context.nil?
+        @context
+      else
+        property_with_context = self.dup
+        property_with_context.context = context
+        property_with_context
+      end
+    end
+
+    # Sets context for this property
+    def context=(context)
+      @context = context
+    end
+
+    # Returns the datatype if type is nil.
+    # Returns a new RDF::Property object with the @datatype set if type is provided
+    # see also #context, #lang
+    def datatype(type = nil)
+      if type.nil?
+        @datatype
+      else
+        property_with_datatype = dup
+        property_with_datatype.datatype = type
+        property_with_datatype
+      end
+    end
+
+    # Sets datatype for this property
+    def datatype=(type)
+      @datatype = type
+    end
+
+    # Deletes value given by key or value. If the item is not found, returns nil.
+    # If the optional code block is given, returns the result of block if the item is not found
+    def delete(md5_or_value)
+      value = self[md5_or_value]
+      if value
+        ActiveRDF::FederationManager.delete(@subject, self.property, value)
+        value
+      elsif block_given?
+        yield
+      end
+    end
+
+    # Deletes every value for which block evaluates to true
+    def delete_if(&block)  # :yields: key, value
+      reject!(&block)
+      self
+    end
+
+    # Calls block once for each value, passing a copy of the value as a parameter
+    def each(&block)  # :yields: value
+      q = ActiveRDF::Query.new.distinct(:o).where(@subject,self,:o,@context)
+      if @lang and !@datatype
+        q.lang(:o,@lang,@exact_lang)
+      elsif @datatype and !@lang
+        q.datatype(:o, @datatype)
+      elsif @lang and @datatype
+        raise ActiveRdfError, "@datatype and @lang may not both be set"
+      end
+      q.execute(&block)
+      self
+    end
+    alias :each_value :each
+
+    # Calls block once for each value, passing the key as a parameter
+    def each_key(&block)  # :yields: key
+      keys.each(&block)
+      self
+    end
+
+    # Calls block once for each value, passing the key and value as a parameters
+    # See also #to_h
+    def each_pair(&block)  # :yields: key, value
+      each{|value| yield get_key(value), value}
+      self
+    end
+
+    # Returns true if the property contains no values
+    def empty?
+      to_a.empty?
+    end
+    alias :blank? :empty?
+
+    # Returns a value from the property for the given key. If the key can't be found, there are several options:
+    # With no other arguments, it will raise an IndexError exception; if default is given, then that will be returned;
+    # if the optional code block is specified, then that will be run and its result returned.
+    def fetch(md5, default = nil, &block)
+      val = self[md5]
+      if val
+        val
+      else
+        if block_given?
+          yield md5
+        elsif default
+          default
+        else
+          raise IndexError, "could not find #{md5}"
+        end
+      end
+    end
+
+    # Returns true if the given key or value is present
+    def include?(obj)
+      !!self[obj]
+    end
+    alias :value? :include?
+    alias :has_value? :include?
+
+    # Returns the key for a given value. If not found, returns nil.
+    def index(obj)
+      value = to_a.find{|val| obj == val}
+      get_key(value) if value
+    end
+
+    # Return the value(s) of this property as a string.
+    def inspect
+      "#<RDF::Property #{abbr} [#{to_a.collect{|obj| obj.inspect}.join(", ")}]>"
+    end
+
+    # Returns a new array populated with the keys to the values
+    def keys
+      collect{|value| get_key(value)}
+    end
+
+    # Returns the language tag and the match settings for the property if tag is nil.
+    # Returns a new RDF::Property object with the @lang value set if tag is provided
+    # see also #context, #datatype
+    def lang(tag = nil, exact = true)
+      if tag.nil?
+        [@lang,@exact_lang]
+      else
+        property_with_lang = RDF::Property.new(self, @subject)
+        property_with_lang.lang = tag, exact
+        property_with_lang
+      end
+    end
+
+    # Sets lang and match settings
+    def lang=(*args)
+      args.flatten!
+      @lang = args[0].sub(/^@/,'')
+      @exact_lang = truefalse(args[1],true)
+    end
+
+    # Returns the number of values assigned to this property for this @subject
+    def length
+      to_a.length
+    end
+    alias :size :length
+
+    # Ensure the return of only one value assigned to this property for this @subject.
+    # If more than 1 value is found, ActiveRdfError is thrown.
+    def only
+      entries = self.entries
+      raise ActiveRDF::ActiveRdfError if entries.size > 1
+      entries[0]
+    end
+
+    # Equivalent to Property#delete_if, but returns nil if no changes were made
+    def reject!(&block)  # :yields: key, value
+      change = false
+      each_pair do |key, value|
+        if yield(key, value)
+          delete(value)
+          change = true
+        end
+      end
+      self if change
+    end
+
+    # Value replacement. Replaces all current value(s) with the new value
+    def replace(new)
+      clear
+      add(new)
+      self
+    end
+    alias :size :length
+
+    # Allow this Property to be automatically converted to array
+    alias :to_ary :to_a
+
+    # Returns a hash of copies of all values with indexes.
+    # Changes to this hash will not effect the underlying values. Use #add or #replace to persist changes.
+    # See also #each_pair
+    def to_h
+      hash = {}
+      to_a.each do |value|
+        hash[get_key(value)] = value
+      end
+      hash
+    end
+
+    # Return an array containing the values for the given keys.
+    def values_at(*args)
+      args.collect{|md5| self[md5]}
+    end
+
+    private
+    def get_key(value)
+      Digest::MD5.hexdigest(value.to_s)
+    end
+  end
+end

data/lib/active_rdf/objectmanager/property_list.rb

@@ -26,7 +26,7 @@ class PropertyList < Array
     add pv
     
     # insert the new statment into the store
-    FederationManager.add(@s, @p, pv)
+    ActiveRDF::FederationManager.add(@s, @p, pv)
   end
   
   # delete a statment which contains old_p_value
@@ -35,7 +35,7 @@ class PropertyList < Array
     check_writeable!
     # delete the old statment
     self.delete(old_p_value)
-    FederationManager.delete(@s, @p, old_p_value)
+    ActiveRDF::FederationManager.delete(@s, @p, old_p_value)
     
     # insert the new statment
     self << new_p_value
@@ -50,13 +50,13 @@ class PropertyList < Array
       # delete only triples whose values is specified by parameters
       params.each{|param|
         if self.delete(param)
-          return FederationManager.delete(@s, @p, param)
+          return ActiveRDF::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
+        if ActiveRDF::FederationManager.delete(@s, @p, value) == false
           return false
         end
       }

data/lib/active_rdf/objectmanager/property_lookup.rb

@@ -0,0 +1,57 @@
+module ActiveRDF
+  class PropertyLookup
+
+    # not directly chainable like ResourceQuery
+    def initialize(subject)
+      @ns = nil
+      @subject = subject
+    end
+
+    # Searches for property belonging to @subject. Returns RDF::Property.
+    # Replaces any existing values if method is an assignment: resource.prop=(new_value)
+    def method_missing(ns_or_property, *args)
+      # check registered namespace
+      # foaf::name, where foaf is a registered abbreviation
+      # evidence: foaf in Namespace
+      # action: return self with @ns set
+      if !@ns and Namespace.include?(ns_or_property)
+        @ns = ns_or_property
+        return self
+      end
+
+      property_name = ns_or_property.to_s
+      # are we doing an update or not?
+      # checking if method ends with '='
+      update = property_name[-1..-1] == '='
+      property_name = update ? property_name[0..-2] : property_name
+
+      property =
+        if @ns
+          # seen registered namespace, lookup property
+          RDF::Property.new(Namespace.lookup(@ns, property_name), @subject)
+        elsif (registered_predicates = @subject.instance_eval{@predicates}) and registered_predicates.include?(property_name)
+          # check for registered abbreviation
+          # eyal.age is registered abbreviation
+          # evidence: age in @predicates
+          # action: return RDF::Property(age,self) and store value if assignment
+          warn "Registered predicates is deprecated. Please use registered namespaces instead."
+          RDF::Property.new(@predicates[property_name],@subject)
+        else
+          # search for known property
+          @subject.properties.find{|prop| Namespace.localname(prop) == property_name}
+        end
+
+      if property
+        property.replace(*args) if update
+        return property
+      end
+
+      raise ActiveRdfError, "could not set #{methodname} to #{args}: no suitable predicate found. Maybe you are missing some schema information?" if update
+
+      # If property can't be found, return nil instead of throwing NoMethodError.
+      # In RDFS, we can't be sure that eyal cannot have an age, we just dont know the
+      # age right now)
+      nil
+    end
+  end
+end