active-fedora 3.1.0.pre2 → 3.1.0.pre3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active-fedora (3.1.0.pre1)
+    active-fedora (3.1.0.pre2)
       activeresource (~> 3.0.0)
       activesupport (~> 3.0.0)
       equivalent-xml
@@ -11,6 +11,8 @@ PATH
       multipart-post (= 1.1.2)
       nokogiri
       om (>= 1.0)
+      rdf
+      rdf-rdfxml
       rubydora (~> 0.1.6)
       solr-ruby (>= 0.0.6)
       solrizer (> 1.0.0)
@@ -28,6 +30,7 @@ GEM
       activemodel (= 3.0.10)
       activesupport (= 3.0.10)
     activesupport (3.0.10)
+    addressable (2.2.6)
     akami (1.0.0)
       gyoku (>= 0.4.0)
     builder (2.1.2)
@@ -69,6 +72,11 @@ GEM
     rake (0.9.2)
     rbx-require-relative (0.0.5)
     rcov (0.9.10)
+    rdf (0.3.4.1)
+      addressable (>= 2.2.6)
+    rdf-rdfxml (0.3.5)
+      nokogiri (>= 1.4.4)
+      rdf (>= 0.3.4)
     rest-client (1.6.7)
       mime-types (>= 1.16)
     rsolr (1.0.2)

data/active-fedora.gemspec

@@ -28,6 +28,8 @@ Gem::Specification.new do |s|
   s.add_dependency("equivalent-xml")
   s.add_dependency("facets")
   s.add_dependency("rubydora", '~>0.1.6')
+  s.add_dependency("rdf")
+  s.add_dependency("rdf-rdfxml")
   s.add_development_dependency("yard")
   s.add_development_dependency("RedCloth") # for RDoc formatting
   s.add_development_dependency("rake")

data/lib/active_fedora.rb

@@ -79,15 +79,13 @@ module ActiveFedora #:nodoc:
   # 2. If it does not find a solr.yml and the fedora.yml contains a solr url, it will raise an configuration error 
   # 3. If it does not find a solr.yml and the fedora.yml does not contain a solr url, it will look in: +Rails.root+/config, +current working directory+/config, then the solr.yml shipped with gem
   def self.init( options={} )
-    logger.level = Logger::ERROR if logger.respond_to? :level ###MediaShelf StubLogger doesn't have a level= method
     # Make config_options into a Hash if nil is passed in as the value
     options = {} if options.nil?
 
     # For backwards compatibility, handle cases where config_path (a String) is passed in as the argument rather than a config_options hash
     # In all other cases, set config_path to config_options[:config_path], which is ok if it's nil
     if options.is_a? String
-      logger.warn "DEPRECATION WARNING: Calling ActiveFedora.init with a path as an argument is deprecated.  Use ActiveFedora.init(:fedora_config_path=>#{options})"
-      @config_options = {:fedora_config_path=>options}
+      raise ArgumentError, "Calling ActiveFedora.init with a path as an argument has been removed.  Use ActiveFedora.init(:fedora_config_path=>#{options})"
     else
       @config_options = options
     end
@@ -290,6 +288,7 @@ module ActiveFedora
   class UnknownAttributeError < NoMethodError; end; # :nodoc:
   class ActiveFedoraConfigurationException < Exception; end # :nodoc:
   class AssociationTypeMismatch < RuntimeError; end # :nodoc:
+  class UnregisteredPredicateError < RuntimeError; end
 
 end
 

data/lib/active_fedora/base.rb

@@ -199,7 +199,8 @@ module ActiveFedora
         if (ds_spec)
           klass = ds_spec.first
           datastreams[dsid] = klass.new(inner_object, dsid, true)
-          #datastreams[dsid].dsLabel = ds_spec[1]   #this shouldn't cause it to be dirty
+          datastreams[dsid].model = self if klass == RelsExtDatastream
+
           if ds_spec.last.class == Proc
             ds_spec.last.call(datastreams[dsid])
           end
@@ -286,7 +287,9 @@ module ActiveFedora
     # Failing that, creates a new RelsExtDatastream and adds it to the object
     def rels_ext
       if !datastreams.has_key?("RELS-EXT") 
-        add_datastream(ActiveFedora::RelsExtDatastream.new(@inner_object,'RELS-EXT'))
+        ds = ActiveFedora::RelsExtDatastream.new(@inner_object,'RELS-EXT')
+        ds.model = self
+        add_datastream(ds)
       end
       return datastreams["RELS-EXT"]
     end
@@ -719,35 +722,11 @@ module ActiveFedora
     # Rely on rels_ext datastream to track relationships array
     # Overrides accessor for relationships array used by SemanticNode.
     # If outbound_only is false, inbound relationships will be included.
-    def relationships(outbound_only=true)
-      outbound_only ? rels_ext.relationships : rels_ext.relationships.merge(:inbound=>inbound_relationships)
-    end
+    # def relationships(outbound_only=true)
+    #   outbound_only ? rels_ext.relationships : rels_ext.relationships.merge(:inbound=>inbound_relationships)
+    # end
 
-    # Add a Rels-Ext relationship to the Object.
-    # @param predicate
-    # @param object Either a string URI or an object that responds to .pid 
-    def add_relationship(predicate, obj, literal=false)
-      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj, :is_literal=>literal)
-      unless relationship_exists?(r.subject, r.predicate, r.object)
-        rels_ext.add_relationship(r)
-        #need to call here to indicate update of named_relationships
-        @relationships_are_dirty = true
-        rels_ext.dirty = true
-      end
-    end
     
-    # ** EXPERIMENTAL **
-    #
-    # Remove a Rels-Ext relationship from the Object.
-    # @param predicate
-    # @param object Either a string URI or an object that responds to .pid 
-    def remove_relationship(predicate, obj, literal=false)
-      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj, :is_literal=>literal)
-      rels_ext.remove_relationship(r)
-      #need to call here to indicate update of named_relationships
-      @relationships_are_dirty = true
-      rels_ext.dirty = true
-    end
 
     def inner_object # :nodoc
       @inner_object
@@ -1007,6 +986,7 @@ module ActiveFedora
             #attributes = self.datastreams[name].attributes
           else
             ds = ar.first.new(inner_object, name)
+            ds.model = self if ar.first == RelsExtDatastream
             ds.dsLabel = ar[1]
             # If you called has_metadata with a block, pass the block into the Datastream class
             if ar.last.class == Proc

data/lib/active_fedora/content_model.rb

@@ -24,7 +24,7 @@ module ActiveFedora
       else
         namespace = klass.pid_namespace
       end
-      return "#{namespace}:#{sanitized_class_name}#{pid_suffix}" 
+      return "info:fedora/#{namespace}:#{sanitized_class_name}#{pid_suffix}" 
     end
     
     def self.models_asserted_by(obj)

data/lib/active_fedora/relationships_helper.rb

@@ -86,14 +86,7 @@ module ActiveFedora
     # @param [Boolean] if false it will include inbound relationships (defaults to true)
     # @return [Hash] Returns a hash of subject name (:self or :inbound) mapped to nested hashs of each relationship name mapped to an Array of objects linked via the relationship
     def relationships_by_name(outbound_only=true)
-      #make sure to update if relationships have been updated
-      if @relationships_are_dirty == true
-        @relationships_by_name = relationships_by_name_from_class()
-        @relationships_are_dirty = false
-      end
-      
-      #this will get called normally on first fetch if relationships are not dirty
-      @relationships_by_name ||= relationships_by_name_from_class()
+      @relationships_by_name = relationships_by_name_from_class()
       outbound_only ? @relationships_by_name : @relationships_by_name.merge(:inbound=>inbound_relationships_by_name)      
     end
 
@@ -105,11 +98,23 @@ module ActiveFedora
     def relationships_by_name_from_class()
       rels = {}
       relationship_predicates.each_pair do |subj, names|
-        if relationships.has_key?(subj)
-          rels[subj] = {}
+        case subj
+        when :self
+          rels[:self] = {}
           names.each_pair do |name, predicate|
-            rels[subj][name] = (relationships[subj].has_key?(predicate) ? relationships[subj][predicate] : [])
+            set = []
+            res = relationships.query(:predicate => find_graph_predicate(predicate))
+            res.each_object do |o|
+              set << o.to_s
+            end
+            rels[:self][name] = set
           end
+        when :inbound
+          #nop
+          # inbound = inbound_relationships
+          # names.each_pair do |name, predicate|
+          #   rels[:inbound][name] = inbound[predicate]
+          # end
         end
       end
       return rels
@@ -325,12 +330,13 @@ module ActiveFedora
     def conforms_to?(model_class)
       if self.kind_of?(model_class)
         #check has model and class match
-        if relationships[:self].has_key?(:has_model)
-          r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:has_model, :object=>ActiveFedora::ContentModel.pid_from_ruby_class(self.class))
-          if relationships[:self][:has_model].first.to_s.eql?(r.object.to_s)
+        mod = relationships.first(:predicate=>find_graph_predicate(:has_model))
+        if mod
+          expected = ActiveFedora::ContentModel.pid_from_ruby_class(self.class)
+          if mod.object.to_s == expected
             return true
           else
-            raise "has_model relationship check failed for model #{model_class} raising exception, expected: '#{r.object.to_s}' actual: '#{relationships[:self][:has_model].to_s}'"
+            raise "has_model relationship check failed for model #{model_class} raising exception, expected: '#{expected}' actual: '#{mod.object.to_s}'"
           end
         else
           raise "has_model relationship does not exist for model #{model_class} check raising exception"
@@ -374,22 +380,12 @@ module ActiveFedora
     def relationship_query(relationship_name)
       query = ""
       if self.class.is_bidirectional_relationship?(relationship_name)
-        id_array = []
         predicate = outbound_relationship_predicates["#{relationship_name}_outbound"]
-        if !outbound_relationships[predicate].nil? 
-          outbound_relationships[predicate].each do |rel|
-            id_array << rel.gsub("info:fedora/", "")
-          end
-        end
+        id_array = ids_for_outbound(predicate)
         query = self.class.bidirectional_relationship_query(pid,relationship_name,id_array)
       elsif outbound_relationship_names.include?(relationship_name)
-        id_array = []
         predicate = outbound_relationship_predicates[relationship_name]
-        if !outbound_relationships[predicate].nil? 
-          outbound_relationships[predicate].each do |rel|
-            id_array << rel.gsub("info:fedora/", "")
-          end
-        end
+        id_array = ids_for_outbound(predicate)
         query = self.class.outbound_relationship_query(relationship_name,id_array)
       elsif inbound_relationship_names.include?(relationship_name)
         query = self.class.inbound_relationship_query(pid,relationship_name)

data/lib/active_fedora/rels_ext_datastream.rb

@@ -1,30 +1,28 @@
 require 'active_support/core_ext/class/inheritable_attributes'
 require 'solrizer/field_name_mapper'
 require 'uri'
+require 'rdf/rdfxml'
+require 'rdf'
 
 module ActiveFedora
   class RelsExtDatastream < Datastream
     
-    include ActiveFedora::SemanticNode
     include Solrizer::FieldNameMapper
+    attr_accessor :model
     
     
-    # def initialize(digital_object, dsid, exists_in_fedora=nil)
-    #   super(digital_object, 'RELS-EXT')
-    # end
-
     def changed?
-      relationships_are_dirty || super
+      (model && model.relationships_are_dirty) || super
     end
 
     def serialize!
-      self.content = to_rels_ext(self.pid) if relationships_are_dirty
-      relationships_are_dirty = false
+      self.content = to_rels_ext() if model.relationships_are_dirty
+      model.relationships_are_dirty = false
     end
     
 
     def to_xml(fields_xml) 
-      to_rels_ext(self.pid) 
+      to_rels_ext() 
     end
       
     # Populate a RelsExtDatastream object based on the "datastream" content 
@@ -35,38 +33,46 @@ module ActiveFedora
       if (xml.nil?)
         ### maybe put the template here?
       else
-        node = Nokogiri::XML::Document.parse(xml)
-        node.xpath("rdf:RDF/rdf:Description/*", {"rdf"=>"http://www.w3.org/1999/02/22-rdf-syntax-ns#"}).each do |f|
-            if f.namespace
-              ns_mapping = self.predicate_mappings[f.namespace.href]
-              predicate = ns_mapping ?  ns_mapping.invert[f.name] : nil
-              predicate = "#{f.namespace.prefix}_#{f.name}" if predicate.nil?
-            else
-              logger.warn "You have a predicate without a namespace #{f.name}. Verify your rels-ext is correct."
-              predicate = "#{f.name}"
-            end
-            is_obj = f["resource"]
-            object = is_obj ? f["resource"] : f.inner_text
-            r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>object, :is_literal=>!is_obj)
-            tmpl.add_relationship(r)
+        RDF::RDFXML::Reader.new(xml) do |reader|
+          reader.each_statement do |statement|
+            literal = statement.object.kind_of?(RDF::Literal)
+            predicate = self.short_predicate(statement.predicate)
+            object = literal ? statement.object.value : statement.object.to_str
+            tmpl.model.add_relationship(predicate, object)
+          end
         end
-        tmpl.relationships_are_dirty = false
-        #tmpl.send(:dirty=, false)
+        tmpl.model.relationships_are_dirty = false
         tmpl
       end
     end
+
+    # Creates a RELS-EXT datastream for insertion into a Fedora Object
+    # @param [String] pid
+    # @param [Hash] relationships (optional) @default self.relationships
+    # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
+    def to_rels_ext()
+      xml = RDF::RDFXML::Writer.buffer do |writer|
+        model.relationships.each_statement do |statement|
+          writer << statement
+        end
+      end
+
+      xml
+
+    end
+
+    def self.short_predicate(predicate)
+      predicate.to_str.gsub(/^[^#]+#/, '').underscore.to_sym
+    end
     
     # Serialize the datastream's RDF relationships to solr
     # @param [Hash] solr_doc @deafult an empty Hash
     def to_solr(solr_doc = Hash.new)
-      self.relationships.each_pair do |subject, predicates|
-        if subject == :self || subject == "info:fedora/#{self.pid}"
-          predicates.each_pair do |predicate, values|
-            values.each do |val|
-              ::Solrizer::Extractor.insert_solr_field_value(solr_doc, solr_name(predicate, :symbol), val )
-            end
-          end
-        end
+      model.relationships.each_statement do |statement|
+        predicate = self.class.short_predicate(statement.predicate)
+        literal = statement.object.kind_of?(RDF::Literal)
+        val = literal ? statement.object.value : statement.object.to_str
+        ::Solrizer::Extractor.insert_solr_field_value(solr_doc, solr_name(predicate, :symbol), val )
       end
       return solr_doc
     end
@@ -82,22 +88,22 @@ module ActiveFedora
     #  Solr must be synchronized with RELS-EXT data in Fedora.
     def from_solr(solr_doc)
       #cycle through all possible predicates
-      self.class.predicate_mappings[self.class.default_predicate_namespace].keys.each do |predicate|
+      ActiveFedora::Base.predicate_mappings[ActiveFedora::Base.default_predicate_namespace].keys.each do |predicate|
         predicate_symbol = ActiveFedora::SolrService.solr_name(predicate, :symbol)
         value = (solr_doc[predicate_symbol].nil? ? solr_doc[predicate_symbol.to_s]: solr_doc[predicate_symbol]) 
         unless value.nil? 
           if value.is_a? Array
             value.each do |obj|
-              o_uri = URI.parse(obj)
-              literal = o_uri.scheme.nil?
-              r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj, :is_literal=>literal)
-              add_relationship(r)
+              #o_uri = URI.parse(obj)
+              #literal = o_uri.scheme.nil?
+              #r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj, :is_literal=>literal)
+              model.add_relationship(predicate, obj)
             end
           else
-            o_uri = URI.parse(value)
-            literal = o_uri.scheme.nil?
-            r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>value, :is_literal=>literal)
-            add_relationship(r)
+            #o_uri = URI.parse(value)
+            #literal = o_uri.scheme.nil?
+            #r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>value, :is_literal=>literal)
+            model.add_relationship(predicate, value)
           end
         end
       end

data/lib/active_fedora/semantic_node.rb

@@ -1,3 +1,5 @@
+require 'rdf'
+require 'active_support/core_ext/class/inheritable_attributes'
 module ActiveFedora
   module SemanticNode 
     extend ActiveSupport::Concern
@@ -6,67 +8,116 @@ module ActiveFedora
       self.class_relationships = {}
       self.class_named_relationships_desc = {}
     end
-    attr_accessor :internal_uri, :named_relationship_desc, :relationships_are_dirty, :load_from_solr
+    attr_accessor :named_relationship_desc, :relationships_are_dirty, :load_from_solr, :subject #:internal_uri
+
     #TODO I think we can remove named_relationship_desc from attr_accessor  - jcoyne
 
     def assert_kind_of(n, o,t)
       raise "Assertion failure: #{n}: #{o} is not of type #{t}" unless o.kind_of?(t)
     end
     
-    def add_relationship(relationship)
-      # Only accept ActiveFedora::Relationships as input arguments
-      assert_kind_of 'relationship',  relationship, ActiveFedora::Relationship
-      register_triple(relationship.subject, relationship.predicate, relationship.object)
+    # Add a relationship to the Object.
+    # @param predicate
+    # @param object Either a string URI or an object that is a kind of ActiveFedora::Base 
+    def add_relationship(predicate, obj, literal=false)
+      unless relationship_exists?(internal_uri, predicate, obj)
+        register_triple(internal_uri, predicate, obj)
+        #need to call here to indicate update of named_relationships
+        @relationships_are_dirty = true
+        rels_ext.dirty = true
+      end
     end
-    
-    def register_triple(subject, predicate, object)
+
+    # Add a RDF triple to the relationship graph
+    # @param pid a string represending the pid of the subject
+    # @param predicate a predicate symbol
+    # @param target an object to store
+    def register_triple(pid, predicate, target)
       self.relationships_are_dirty = true
-      register_subject(subject)
-      register_predicate(subject, predicate)
-      relationships[subject][predicate] << object
+      relationships.insert build_statement(pid, predicate, target)
+
+      # register_subject(subject)
+      # register_predicate(subject, predicate)
+      # relationships[subject][predicate] << object
     end
-    
-    def register_subject(subject)
-      if !relationships.has_key?(subject) 
-          relationships[subject] = {} 
+
+    # Create an RDF statement
+    # @param pid a string represending the pid of the subject
+    # @param predicate a predicate symbol
+    # @param target an object to store
+    def build_statement(pid, predicate, target)
+      raise "Not allowed anymore" if pid == :self
+      target = target.internal_uri if target.respond_to? :internal_uri
+      subject =  RDF::URI.new(pid)  #TODO cache
+      begin
+        literal = URI.parse(target).scheme.nil?
+      rescue URI::InvalidURIError
+        literal = false
       end
+      object = literal ? RDF::Literal.new(target) : RDF::URI.new(target)
+
+       RDF::Statement.new(subject, find_graph_predicate(predicate), object)
+    
     end
-  
-    def register_predicate(subject, predicate)
-      register_subject(subject)
-      if !relationships[subject].has_key?(predicate) 
-        relationships[subject][predicate] = []
-      end
+                  
+    def find_graph_predicate(predicate)
+        #TODO, these could be cached
+        case predicate
+        when :has_model, "hasModel", :hasModel
+          xmlns="info:fedora/fedora-system:def/model#"
+          begin
+            rel_predicate = ActiveFedora::Base.predicate_lookup(predicate,xmlns)
+          rescue UnregisteredPredicateError
+            xmlns = nil
+            rel_predicate = nil
+          end
+        else
+          xmlns="info:fedora/fedora-system:def/relations-external#"
+          begin
+            rel_predicate = ActiveFedora::Base.predicate_lookup(predicate,xmlns)
+          rescue UnregisteredPredicateError
+            xmlns = nil
+            rel_predicate = nil
+          end
+        end
+        
+        unless xmlns && rel_predicate
+          rel_predicate, xmlns = ActiveFedora::Base.find_predicate(predicate)
+        end
+        self.class.vocabularies[xmlns][rel_predicate] 
     end
+    
+    # def register_subject(subject)
+    #   if !relationships.has_key?(subject) 
+    #       relationships[subject] = {} 
+    #   end
+    # end
+  
+    # def register_predicate(subject, predicate)
+    #   register_subject(subject)
+    #   if !relationships[subject].has_key?(predicate) 
+    #     relationships[subject][predicate] = []
+    #   end
+    # end
 
     # ** EXPERIMENTAL **
-    # 
-    # Remove the given ActiveFedora::Relationship from this object
-    def remove_relationship(relationship)
+    #
+    # Remove a Rels-Ext relationship from the Object.
+    # @param predicate
+    # @param object Either a string URI or an object that responds to .pid 
+    def remove_relationship(predicate, obj, literal=false)
+      relationships.delete build_statement(internal_uri, predicate, obj)
       @relationships_are_dirty = true
-      unregister_triple(relationship.subject, relationship.predicate, relationship.object)
+      rels_ext.dirty = true
     end
 
-    # ** EXPERIMENTAL **
-    # 
-    # Remove the subject, predicate, and object triple from the relationships hash
-    def unregister_triple(subject, predicate, object)
-      if relationship_exists?(subject, predicate, object)
-        relationships[subject][predicate].delete_if {|curObj| curObj == object}
-        relationships[subject].delete(predicate) if relationships[subject][predicate].nil? || relationships[subject][predicate].empty? 
-      else
-        return false
-      end     
-    end
+
     
     # ** EXPERIMENTAL **
     # 
     # Returns true if a relationship exists for the given subject, predicate, and object triple
     def relationship_exists?(subject, predicate, object)
-      outbound_only = (subject != :inbound)
-      #cache the call in case it is retrieving inbound as well, don't want to hit solr too many times
-      cached_relationships = relationships(outbound_only)
-      cached_relationships.has_key?(subject)&&cached_relationships[subject].has_key?(predicate)&&cached_relationships[subject][predicate].include?(object)
+      relationships.has_statement? build_statement(subject, predicate, object)
     end
 
     def inbound_relationships(response_format=:uri)
@@ -92,17 +143,13 @@ module ActiveFedora
     end
     
     def outbound_relationships()
-      if !internal_uri.nil? && !relationships[internal_uri].nil?
-        return relationships[:self].merge(relationships[internal_uri]) 
-      else
-        return relationships[:self]
-      end
+      relationships.statements
     end
     
-    # If outbound_only is false, inbound relationships will be included.
-    def relationships(outbound_only=true)
-      @relationships ||= relationships_from_class
-      outbound_only ? @relationships : @relationships.merge(:inbound=>inbound_relationships)
+    def relationships
+#      @relationships ||= {:self=>{}}
+      @subject ||=  RDF::URI.new(internal_uri)
+      @relationships ||= RDF::Graph.new
     end
     
     def relationships_from_class
@@ -116,61 +163,6 @@ module ActiveFedora
       return rels
     end
     
-    # Creates a RELS-EXT datastream for insertion into a Fedora Object
-    # @param [String] pid
-    # @param [Hash] relationships (optional) @default self.relationships
-    # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
-    def to_rels_ext(pid, relationships=self.relationships)
-      starter_xml = <<-EOL
-      <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-        <rdf:Description rdf:about="info:fedora/#{pid}">
-        </rdf:Description>
-      </rdf:RDF>
-      EOL
-      xml = REXML::Document.new(starter_xml)
-    
-      # Iterate through the hash of predicates, adding an element to the RELS-EXT for each "object" in the predicate's corresponding array.
-      # puts ""
-      # puts "Iterating through a(n) #{self.class}"
-      # puts "=> whose relationships are #{self.relationships.inspect}"
-      # puts "=> and whose outbound relationships are #{self.outbound_relationships.inspect}"
-      self.outbound_relationships.each do |predicate, targets_array|
-        targets_array.each do |target|
-          xmlns=String.new
-          case predicate
-          when :has_model, "hasModel", :hasModel
-            xmlns="info:fedora/fedora-system:def/model#"
-            begin
-              rel_predicate = self.class.predicate_lookup(predicate,xmlns)
-            rescue UnregisteredPredicateError
-              xmlns = nil
-              rel_predicate = nil
-            end
-          else
-            xmlns="info:fedora/fedora-system:def/relations-external#"
-            begin
-              rel_predicate = self.class.predicate_lookup(predicate,xmlns)
-            rescue UnregisteredPredicateError
-              xmlns = nil
-              rel_predicate = nil
-            end
-          end
-          
-          unless xmlns && rel_predicate
-            rel_predicate, xmlns = self.class.find_predicate(predicate)
-          end
-          # puts ". #{predicate} #{target} #{xmlns}"
-          literal = URI.parse(target).scheme.nil?
-          if literal
-            xml.root.elements["rdf:Description"].add_element(rel_predicate, {"xmlns" => "#{xmlns}"}).add_text(target)
-          else
-            xml.root.elements["rdf:Description"].add_element(rel_predicate, {"xmlns" => "#{xmlns}", "rdf:resource"=>target})
-          end
-        end
-      end
-      xml.to_s
-    end
-
     def load_inbound_relationship(name, predicate, opts={})
       opts = {:rows=>25}.merge(opts)
       query = self.class.inbound_relationship_query(self.pid,"#{name}")
@@ -193,13 +185,18 @@ module ActiveFedora
       end
     end
 
-    def load_outbound_relationship(name, predicate, opts={})
+
+    def ids_for_outbound(predicate)
       id_array = []
-      if !outbound_relationships[predicate].nil? 
-        outbound_relationships[predicate].each do |rel|
-          id_array << rel.gsub("info:fedora/", "")
-        end
+      res = relationships.query(:predicate => find_graph_predicate(predicate))
+      res.each_object do |o|
+        id_array << o.to_s.gsub("info:fedora/", "")
       end
+      id_array
+    end
+
+    def load_outbound_relationship(name, predicate, opts={})
+      id_array = ids_for_outbound(predicate)
       if opts[:response_format] == :id_array  && !self.class.relationship_has_solr_filter_query?(:self,"#{name}")
         return id_array
       else
@@ -222,7 +219,10 @@ module ActiveFedora
     end
     
     module ClassMethods
-      #include ActiveFedora::RelationshipsHelper::ClassMethods
+      def vocabularies
+        @vocabularies ||= {"info:fedora/fedora-system:def/relations-external#" =>  RDF::Vocabulary.new("info:fedora/fedora-system:def/relations-external#"),
+        "info:fedora/fedora-system:def/model#" =>  RDF::Vocabulary.new("info:fedora/fedora-system:def/model#")}
+      end
 
       # Allows for a relationship to be treated like any other attribute of a model class. You define
       # relationships in your model class using this method.  You then have access to several
@@ -478,7 +478,6 @@ module ActiveFedora
       #   ds.relationships # => {:self=>{:has_model=>["afmodel:SimpleThing"],:has_part=>["demo:20"]},:inbound=>{:is_part_of=>["demo:6"]} 
       def relationships
         @class_relationships ||= Hash[:self => {}]
-        #class_relationships
       end
     
     
@@ -495,31 +494,6 @@ module ActiveFedora
         end
       end
 
-      #alias_method :register_target, :register_object
-    
-      # Creates a RELS-EXT datastream for insertion into a Fedora Object
-      # @param [String] pid of the object that the RELS-EXT datastream belongs to
-      # @param [Hash] relationships the relationships hash to transform into RELS-EXT RDF. @default the object's relationships hash
-      # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
-      def relationships_to_rels_ext(pid, relationships=self.relationships)
-        starter_xml = <<-EOL
-        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-          <rdf:Description rdf:about="info:fedora/#{pid}">
-          </rdf:Description>
-        </rdf:RDF>
-        EOL
-        xml = REXML::Document.new(starter_xml)
-      
-        # Iterate through the hash of predicates, adding an element to the RELS-EXT for each "object" in the predicate's corresponding array.
-        self.outbound_relationships.each do |predicate, targets_array|
-          targets_array.each do |target|
-            #puts ". #{predicate} #{target}"
-            xml.root.elements["rdf:Description"].add_element(predicate_lookup(predicate), {"xmlns" => "info:fedora/fedora-system:def/relations-external#", "rdf:resource"=>target})
-          end
-        end
-        xml.to_s
-      end
-    
       # If predicate is a symbol, looks up the predicate in the predicate_mappings
       # If predicate is not a Symbol, returns the predicate untouched
       # @raise UnregisteredPredicateError if the predicate is a symbol but is not found in the predicate_mappings
@@ -559,6 +533,5 @@ module ActiveFedora
     end
   end
 
-  class UnregisteredPredicateError < RuntimeError; end
 
 end