active-fedora 1.1.13 → 1.2.0

data/lib/active_fedora/metadata_datastream.rb

@@ -42,11 +42,18 @@ module ActiveFedora
     # ds.update_attributes({:myfield=>{"0"=>"a","1"=>"b"},:myotherfield=>{"-1"=>"c"}})
     #
     def update_indexed_attributes(params={}, opts={})
+      
+      ##FIX this bug, it should delete it from a copy of params in case passed to another datastream for update since this will modify params
+      ##for subsequent calls if updating more than one datastream in a single update_indexed_attributes call
+      current_params = params.clone
       # remove any fields from params that this datastream doesn't recognize
-      params.delete_if {|field_name,new_values| !self.fields.include?(field_name.to_sym) }
+      current_params.delete_if {|field_name,new_values| !self.fields.include?(field_name.to_sym) }
       
-      result = params.dup
-      params.each do |field_name,new_values|
+      result = current_params.dup
+      current_params.each do |field_name,new_values|
+        ##FIX this bug, it should delete it from a copy of params in case passed to another datastream for update
+        #if field does not exist just skip it
+        next if !self.fields.include?(field_name.to_sym)
         field_accessor_method = "#{field_name}_values"
         
         if new_values.kind_of?(Hash)

data/lib/active_fedora/metadata_datastream_helper.rb

@@ -1,3 +1,5 @@
+require 'solrizer/field_name_mapper'
+
 #this class represents a MetadataDatastream, a special case of ActiveFedora::Datastream
 module ActiveFedora::MetadataDatastreamHelper 
   
@@ -16,7 +18,7 @@ module ActiveFedora::MetadataDatastreamHelper
   
   def self.included(klass)
     klass.extend(ClassMethods)
-    klass.send(:include, ActiveFedora::SolrMapper)
+    klass.send(:include, Solrizer::FieldNameMapper)
   end
   
   #constructor, calls up to ActiveFedora::Datastream's constructor
@@ -38,7 +40,7 @@ module ActiveFedora::MetadataDatastreamHelper
   def to_solr(solr_doc = Solr::Document.new) # :nodoc:
     fields.each do |field_key, field_info|
       if field_info.has_key?(:values) && !field_info[:values].nil?
-        field_symbol = generate_solr_symbol(field_key, field_info[:type])
+        field_symbol = solr_name(field_key, field_info[:type])
         field_info[:values].each do |val|             
           solr_doc << Solr::Field.new(field_symbol => val)
         end
@@ -48,6 +50,20 @@ module ActiveFedora::MetadataDatastreamHelper
     return solr_doc
   end
   
+  def from_solr(solr_doc)
+    fields.each do |field_key, field_info|
+      field_symbol = Solrizer::FieldNameMapper.solr_name(field_key, field_info[:type])
+      value = (solr_doc[field_symbol].nil? ? solr_doc[field_symbol.to_s]: solr_doc[field_symbol]) 
+      unless value.nil?
+        if value.is_a? Array
+          update_attributes({field_key=>value})
+        else
+          update_indexed_attributes({field_key=>{0=>value}})
+        end
+      end
+    end
+  end
+  
   def to_xml(xml = Nokogiri::XML::Document.parse("<fields />")) #:nodoc:
     if xml.instance_of?(Nokogiri::XML::Builder)
       xml_insertion_point = xml.doc.root 
@@ -71,10 +87,10 @@ module ActiveFedora::MetadataDatastreamHelper
   end
   
 
-  protected
-
-  def generate_solr_symbol(field_name, field_type) # :nodoc:
-    solr_name(field_name, field_type)
-  end
+  # protected
+  # 
+  # def generate_solr_symbol(field_name, field_type) # :nodoc:
+  #   solr_name(field_name, field_type)
+  # end
 
 end

data/lib/active_fedora/model.rb

@@ -56,7 +56,7 @@ module ActiveFedora
       def find(args)
         if args == :all
           escaped_class_name = self.name.gsub(/(:)/, '\\:')
-          q = "#{SolrMapper.solr_name(:active_fedora_model, :symbol)}:#{escaped_class_name}"
+          q = "#{Solrizer::FieldNameMapper.solr_name(:active_fedora_model, :symbol)}:#{escaped_class_name}"
         elsif args.class == String
           escaped_id = args.gsub(/(:)/, '\\:')
           q = "#{SOLR_DOCUMENT_ID}:#{escaped_id}"
@@ -89,13 +89,115 @@ module ActiveFedora
       def find_by_solr(query, args={})
         if query == :all
           escaped_class_name = self.name.gsub(/(:)/, '\\:')
-          SolrService.instance.conn.query("#{SolrMapper.solr_name(:active_fedora_model, :symbol)}:#{escaped_class_name}", args)
+          SolrService.instance.conn.query("#{Solrizer::FieldNameMapper.solr_name(:active_fedora_model, :symbol)}:#{escaped_class_name}", args)
         elsif query.class == String
           escaped_id = query.gsub(/(:)/, '\\:')          
           SolrService.instance.conn.query("#{SOLR_DOCUMENT_ID}:#{escaped_id}", args)
         end
       end
 
+      # Find all ActiveFedora objects for this model that match arguments
+      # passed in by querying Solr.  Like find_by_solr this returns a solr result.
+      #
+      # query_fields   a hash of object field names and values to filter on
+      # opts           specifies options for the solr query
+      #
+      #   options may include:
+      # 
+      #   :sort             => array of hash with one hash per sort by field... defaults to [{system_create=>:descending}]
+      #   :default_field, :rows, :filter_queries, :debug_query,
+      #   :explain_other, :facets, :highlighting, :mlt,
+      #   :operator         => :or / :and
+      #   :start            => defaults to 0
+      #   :field_list       => array, defaults to ["*", "score"]
+      #
+      def find_by_fields_by_solr(query_fields,opts={})
+        #create solr_args from fields passed in, needs to be comma separated list of form field1=value1,field2=value2,...
+        escaped_class_name = self.name.gsub(/(:)/, '\\:')
+        query = "#{Solrizer::FieldNameMapper.solr_name(:active_fedora_model, :symbol)}:#{escaped_class_name}" 
+        
+        query_fields.each_pair do |key,value|
+          unless value.nil?
+            solr_key = key
+            #convert to symbol if need be
+            key = key.to_sym if !class_fields.has_key?(key)&&class_fields.has_key?(key.to_sym)
+            #do necessary mapping with suffix in most cases, otherwise ignore as a solr field key that activefedora does not know about
+            if class_fields.has_key?(key) && class_fields[key].has_key?(:type)
+              type = class_fields[key][:type]
+              type = :string unless type.kind_of?(Symbol)
+              solr_key = Solrizer::FieldNameMapper.solr_name(key,type)
+            end
+            
+            escaped_value = value.gsub(/(:)/, '\\:')
+            #escaped_value = escaped_value.gsub(/ /, '\\ ')
+            key = SOLR_DOCUMENT_ID if (key === :id || key === :pid)
+            query = key.to_s.eql?(SOLR_DOCUMENT_ID) ? "#{query} AND #{key}:#{escaped_value}" : "#{query} AND #{solr_key}:#{escaped_value}"  
+          end
+        end
+      
+        query_opts = {}
+        opts.each do |key,value|
+          key = key.to_sym
+          query_opts[key] = value
+        end
+      
+        #set default sort to created date ascending
+        unless query_opts.include?(:sort)
+          query_opts.merge!({:sort=>[Solrizer::FieldNameMapper.solr_name(:system_create,:date)=>:ascending]}) 
+        else
+          #need to convert to solr names for all fields
+          sort_array =[]
+        
+          opts[:sort].collect do |sort|
+            sort_direction = :ascending
+            if sort.respond_to?(:keys)
+              key = sort.keys[0]
+              sort_direction = sort[key]
+              sort_direction =~ /^desc/ ? sort_direction = :descending : :ascending
+            else
+              key = sort.to_s
+            end
+            field_name = key
+            
+            if key.to_s =~ /^system_create/
+              field_name = :system_create_date
+              key = :system_create
+            elsif key.to_s =~ /^system_mod/  
+              field_name = :system_modified_date
+              key = :system_modified
+            end
+         
+            solr_name = field_name 
+            if class_fields.include?(field_name.to_sym)
+              solr_name = Solrizer::FieldNameMapper.solr_name(key,class_fields[field_name.to_sym][:type])
+            end
+            sort_array.push({solr_name=>sort_direction})
+          end
+        
+          query_opts[:sort] = sort_array
+        end
+
+        puts "Querying solr for #{self.name} objects with query: '#{query}'"
+    	results = ActiveFedora::SolrService.instance.conn.query(query,query_opts)
+    	#objects = []
+        #  results.hits.each do |hit|
+        #    puts "get object for #{hit[SOLR_DOCUMENT_ID]}"
+        #    obj = Fedora::Repository.instance.find_model(hit[SOLR_DOCUMENT_ID], self)
+        #    obj.inner_object.new_object = false
+        #    objects.push(obj)
+        #end
+        #objects
+        #ActiveFedora::SolrService.reify_solr_results(results)
+      end
+    
+      def class_fields
+        #create dummy object that is empty by passing in fake pid
+        object = self.new({:pid=>'FAKE'})
+        fields = object.fields
+        #reset id to nothing
+        fields[:id][:values] = []
+        return fields
+      end
 
       #wrapper around instance_variable_set, sets @name to value
       def attribute_set(name, value)

data/lib/active_fedora/nokogiri_datastream.rb

@@ -1,10 +1,14 @@
 require "nokogiri"
 require  "om"
+require "solrizer/xml"
+
 #this class represents a MetadataDatastream, a special case of ActiveFedora::Datastream
 class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     
   include ActiveFedora::MetadataDatastreamHelper
-  include OM::XML
+  include OM::XML::Document
+  include Solrizer::XML::TerminologyBasedSolrizer # this adds support for calling .to_solr
+  
   # extend(OM::XML::Container::ClassMethods)
   
   attr_accessor :ng_xml
@@ -75,15 +79,9 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     return xml.to_xml {|config| config.no_declaration}
   end
   
-  def to_solr(solr_doc = Solr::Document.new) # :nodoc:
-    
-    unless self.class.accessors.nil?
-      self.class.accessors.each_pair do |accessor_name,accessor_info|
-        solrize_accessor(accessor_name, accessor_info, :solr_doc=>solr_doc)
-      end
-    end
-
-    return solr_doc
+  #overriding this method just so metadatahelper method does not get called
+  def from_solr(solr_doc)
+    #do nothing for now 
   end
   
   def solrize_accessor(accessor_name, accessor_info, opts={})
@@ -116,36 +114,43 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
   
   def solrize_node(node, accessor_pointer, solr_doc = Solr::Document.new)
     generic_field_name_base = self.class.accessor_generic_name(*accessor_pointer)
-    generic_field_name = generate_solr_symbol(generic_field_name_base, :text)
+    generic_field_name = Solrizer::FieldNameMapper.solr_name(generic_field_name_base, :text)
     
     solr_doc << Solr::Field.new(generic_field_name => node.text)
     
     if accessor_pointer.length > 1
       hierarchical_field_name_base = self.class.accessor_hierarchical_name(*accessor_pointer)
-      hierarchical_field_name = generate_solr_symbol(hierarchical_field_name_base, :text)
+      hierarchical_field_name = Solrizer::FieldNameMapper.solr_name(hierarchical_field_name_base, :text)
       solr_doc << Solr::Field.new(hierarchical_field_name => node.text)
     end
   end
   
   def update_indexed_attributes(params={}, opts={})    
+    if self.class.terminology.nil?
+      raise "No terminology is set for this NokogiriDatastream class.  Cannot perform update_indexed_attributes"
+    end
     # remove any fields from params that this datastream doesn't recognize    
-    params.delete_if do |field_key,new_values| 
-      if field_key.kind_of?(String)
+    #make sure to make a copy of params so not to modify hash that might be passed to other methods
+    current_params = params.clone
+    current_params.delete_if do |term_pointer,new_values| 
+      if term_pointer.kind_of?(String)
         true
       else
-        self.class.accessor_xpath(*OM.destringify(field_key) ).nil?
+        !self.class.terminology.has_term?(*OM.destringify(term_pointer))
       end
     end
+
     result = {}
-    unless params.empty?
-      result = update_properties( params )
+    unless current_params.empty?
+      result = update_values( current_params )
       self.dirty = true
     end
+    
     return result
   end
   
   def get_values(field_key,default=[])
-    property_values(*field_key)
+    term_values(*field_key)
   end
 
 end

data/lib/active_fedora/qualified_dublin_core_datastream.rb

@@ -6,6 +6,7 @@ module ActiveFedora
   #
   #Fields can still be overridden if more specificity is desired (see ActiveFedora::Datastream#fields method).
   class QualifiedDublinCoreDatastream < MetadataDatastream
+    
     #A frozen array of Dublincore Terms.
     DCTERMS = [
       :contributor, :coverage, :creator,  :description, :format, :identifier, :language, :publisher, :relation,  :source, :title, :abstract, :accessRights, :accrualMethod, :accrualPeriodicity, :accrualPolicy, :alternative, :audience, :available, :bibliographicCitation, :conformsTo, :contributor, :coverage, :created, :creator, :date, :dateAccepted, :dateCopyrighted, :dateSubmitted, :description, :educationLevel, :extent, :format, :hasFormat, :hasPart, :hasVersion, :identifier, :instructionalMethod, :isFormatOf, :isPartOf, :isReferencedBy, :isReplacedBy, :isRequiredBy, :issued, :isVersionOf, :language, :license, :mediator, :medium, :modified, :provenance, :publisher, :references, :relation, :replaces, :requires, :rights, :rightsHolder, :source, :spatial, :subject, :tableOfContents, :temporal, :type, :valid

data/lib/active_fedora/rels_ext_datastream.rb

@@ -1,9 +1,10 @@
+require 'solrizer/field_name_mapper'
 
 module ActiveFedora
   class RelsExtDatastream < Datastream
     
     include ActiveFedora::SemanticNode
-    include ActiveFedora::SolrMapper
+    include Solrizer::FieldNameMapper
     
     
     def initialize(attrs=nil)
@@ -52,5 +53,25 @@ module ActiveFedora
       end
       return solr_doc
     end
+    
+    def from_solr(solr_doc)
+      #cycle through all possible predicates
+      PREDICATE_MAPPINGS.keys.each do |predicate|
+        predicate_symbol = Solrizer::FieldNameMapper.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|
+              r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj)
+              add_relationship(r)
+            end
+          else
+            r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>value)
+            add_relationship(r)
+          end
+        end
+      end
+      @load_from_solr = true
+    end
   end
 end

data/lib/active_fedora/semantic_node.rb

@@ -1,9 +1,9 @@
 module ActiveFedora
   module SemanticNode 
     include MediaShelfClassLevelInheritableAttributes
-    ms_inheritable_attributes  :class_relationships, :internal_uri
+    ms_inheritable_attributes  :class_relationships, :internal_uri, :class_named_relationships_desc
     
-    attr_accessor :internal_uri, :relationships
+    attr_accessor :internal_uri, :named_relationship_desc, :relationships_are_dirty, :load_from_solr
     
     PREDICATE_MAPPINGS = Hash[:is_member_of => "isMemberOf",
                           :has_member => "hasMember",
@@ -40,6 +40,7 @@ module ActiveFedora
     def add_relationship(relationship)
       # Only accept ActiveFedora::Relationships as input arguments
       assert_kind_of 'relationship',  relationship, ActiveFedora::Relationship
+      self.relationships_are_dirty = true
       register_triple(relationship.subject, relationship.predicate, relationship.object)
     end
     
@@ -62,6 +63,56 @@ module ActiveFedora
       end
     end
     
+    def register_named_subject(subject)
+      self.class.register_named_subject(subject)
+    end
+  
+    def register_named_relationship(subject, name, predicate, opts)
+      self.class.register_named_relationship(subject, name, predicate, opts)
+    end
+    
+    def remove_relationship(relationship)
+      @relationships_are_dirty = true
+      unregister_triple(relationship.subject, relationship.predicate, relationship.object)
+    end
+
+    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
+    
+    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)
+    end
+
+    def inbound_relationships(response_format=:uri)
+      rel_values = {}
+      inbound_named_relationship_predicates.each_pair do |name,predicate|
+        objects = self.send("#{name}",{:response_format=>response_format})
+        items = []
+        objects.each do |object|
+          if (response_format == :uri)    
+            #create a Relationship object so that it generates the appropriate uri
+            r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>object)
+            items.push(r.object)
+          else
+            items.push(object)
+          end
+        end
+        unless items.empty?
+          rel_values.merge!({predicate=>items})
+        end
+      end
+      return rel_values  
+    end
+    
     def outbound_relationships()
       if !internal_uri.nil? && !relationships[internal_uri].nil?
         return relationships[:self].merge(relationships[internal_uri]) 
@@ -70,8 +121,10 @@ module ActiveFedora
       end
     end
     
-    def relationships
+    # 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)
     end
     
     def relationships_from_class
@@ -82,10 +135,194 @@ module ActiveFedora
           rels[subj][pred_key] = []
         end
       end
-      #puts "rels from class: #{rels.inspect}"
       return rels
     end
     
+    def named_relationship(name)
+      rels = nil
+      if inbound_relationship_names.include?(name)
+        rels = named_relationships(false)[:inbound][name]
+      elsif outbound_relationship_names.include?(name)
+        rels = named_relationships[:self][name]
+      end
+      rels = [] if rels.nil?
+      return rels
+    end
+    
+    def named_relationships(outbound_only=true)
+      #make sure to update if relationships have been updated
+      if @relationships_are_dirty == true
+        @named_relationships = named_relationships_from_class()
+        @relationships_are_dirty = false
+      end
+      
+      #this will get called normally on first fetch if relationships are not dirty
+      @named_relationships ||= named_relationships_from_class()
+      outbound_only ? @named_relationships : @named_relationships.merge(:inbound=>named_inbound_relationships)      
+    end
+    
+    def named_relationships_from_class()
+      rels = {}
+      named_relationship_predicates.each_pair do |subj, names|
+        if relationships.has_key?(subj)
+          rels[subj] = {}
+          names.each_pair do |name, predicate|
+            rels[subj][name] = (relationships[subj].has_key?(predicate) ? relationships[subj][predicate] : [])
+          end
+        end
+      end
+      return rels
+    end
+    
+    def named_inbound_relationships
+      rels = {}
+      if named_relationships_desc.has_key?(:inbound)&&!named_relationships_desc[:inbound].empty?()
+        inbound_rels = inbound_relationships
+      
+        if named_relationship_predicates.has_key?(:inbound)
+          named_relationship_predicates[:inbound].each do |name, predicate|
+            rels[name] = inbound_rels.has_key?(predicate) ? inbound_rels[predicate] : []
+          end
+        end
+      end
+      return rels
+    end
+    
+    def outbound_named_relationship_predicates
+      named_relationship_predicates.has_key?(:self) ? named_relationship_predicates[:self] : {}
+    end
+
+    def inbound_named_relationship_predicates
+      named_relationship_predicates.has_key?(:inbound) ? named_relationship_predicates[:inbound] : {}
+    end
+    
+    def named_relationship_predicates
+      @named_relationship_predicates ||= named_relationship_predicates_from_class
+    end
+    
+    def named_relationship_predicates_from_class
+      rels = {}
+      named_relationships_desc.each_pair do |subj, names|
+        rels[subj] = {}
+        names.each_pair do |name, args|
+          rels[subj][name] = args[:predicate]
+        end
+      end
+      return rels
+    end
+    
+    def relationship_names
+      names = []
+      named_relationships_desc.each_key do |subject|
+            names = names.concat(named_relationships_desc[subject].keys)
+        end
+        names
+    end
+
+    def inbound_relationship_names
+        named_relationships_desc.has_key?(:inbound) ? named_relationships_desc[:inbound].keys : []
+    end
+
+    def outbound_relationship_names
+        named_relationships_desc.has_key?(:self) ? named_relationships_desc[:self].keys : []
+    end
+    
+    def named_outbound_relationships
+        named_relationships_desc.has_key?(:self) ? named_relationships[:self] : {}
+    end
+  
+    def is_named_relationship?(name, outbound_only=true)
+      if outbound_only
+        outbound_relationship_names.include?(name)
+      else
+        (outbound_relationship_names.include?(name)||inbound_relationship_names.include?(name))
+      end
+    end
+    
+    def named_relationships_desc
+      @named_relationships_desc ||= named_relationships_desc_from_class
+    end
+    
+    def named_relationships_desc_from_class
+      self.class.named_relationships_desc
+    end
+    
+    def named_relationship_type(name)
+      if is_named_relationship?(name,true)
+        subject = outbound_relationship_names.include?(name)? :self : :inbound
+        if named_relationships_desc[subject][name].has_key?(:type)
+          return class_from_name(named_relationships_desc[subject][name][:type])
+        end
+      end
+      return nil  
+    end
+
+    def add_named_relationship(name, object)
+      if is_named_relationship?(name,true)
+        if named_relationships_desc[:self][name].has_key?(:type)
+          klass = class_from_name(named_relationships_desc[:self][name][:type])
+          unless klass.nil?
+            (assert_kind_of_model 'object', object, klass)
+          end
+        end
+        #r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>outbound_named_relationship_predicates[name],:object=>object})
+        #add_relationship(r)
+        add_relationship(outbound_named_relationship_predicates[name],object)
+      else
+        false
+      end
+    end
+    
+    def remove_named_relationship(name, object)
+      if is_named_relationship?(name,true)
+        remove_relationship(outbound_named_relationship_predicates[name],object)
+      else
+        return false
+      end
+    end
+    
+    def assert_kind_of_model(name, object, model_class)
+      raise "Assertion failure: #{name}: #{object.pid} does not have model #{model_class}, it has model #{relationships[:self][:has_model]}" unless object.kind_of_model?(model_class)
+    end
+    
+    ############################################################################
+    # Checks that this class is either of type passed in or a child of that type.
+    # It also makes sure that this object was created as the same type by
+    # checking that hasmodel and the class match.  This would not match
+    # if someone called load_instance on a Fedora Object that was created
+    # via a different model class than the one that was recreated from Fedora.
+    # This is a side-effect of ActiveFedora's behavior that will try to create
+    # the object type specified with the pid given whether it is actually that
+    # object type or not.
+    #
+    # If hasmodel does not match than this will return false indicated it does not
+    # have the correct model.
+    ############################################################################
+    def kind_of_model?(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)
+            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}'"
+          end
+        else
+          raise "has_model relationship does not exist for model #{model_class} check raising exception"
+        end
+      else
+       raise "kind_of? check failed for model #{model_class}, actual #{self.class} raising exception"
+     end
+     return false
+   end
+    
+    def class_from_name(name)
+      klass = name.to_s.split('::').inject(Kernel) {|scope, const_name| 
+      scope.const_get(const_name)}
+      (!klass.nil? && klass.is_a?(::Class)) ? klass : nil
+    end
+    
     # Creates a RELS-EXT datastream for insertion into a Fedora Object
     # @pid
     # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
@@ -134,15 +371,53 @@ module ActiveFedora
     # :is_member_of, :has_member, :is_part_of, :has_part  
       def has_relationship(name, predicate, opts = {})
         opts = {:singular => nil, :inbound => false}.merge(opts)
-        opts[:inbound] == true ? register_predicate(:inbound, predicate) : register_predicate(:self, predicate) 
-      
         if opts[:inbound] == true
+          raise "Duplicate use of predicate for named inbound relationship not allowed" if named_predicate_exists_with_different_name?(:inbound,name,predicate)
+          register_named_relationship(:inbound, name, predicate, opts)
+          register_predicate(:inbound, predicate)
           create_inbound_relationship_finders(name, predicate, opts)
-        else        
+        else
+          raise "Duplicate use of predicate for named outbound relationship not allowed" if named_predicate_exists_with_different_name?(:self,name,predicate)
+          register_named_relationship(:self, name, predicate, opts)
+          register_predicate(:self, predicate)
+          create_named_relationship_methods(name)
           create_outbound_relationship_finders(name, predicate, opts)
         end
+      end
       
+      #allow duplicate has_relationship calls with same name and predicate
+      def named_predicate_exists_with_different_name?(subject,name,predicate)
+        if named_relationships_desc.has_key?(subject)
+          named_relationships_desc[subject].each_pair do |existing_name, args|
+            return true if !args[:predicate].nil? && args[:predicate] == predicate && existing_name != name 
+          end
+        end
+        return false
+      end
+        
+      # named relationships desc are tracked as a hash of structure {name => args}}
+      def named_relationships_desc
+        @class_named_relationships_desc ||= Hash[:self => {}]
+      end
+        
+      def register_named_subject(subject)
+        unless named_relationships_desc.has_key?(subject) 
+          named_relationships_desc[subject] = {} 
+        end
+      end
+  
+      def register_named_relationship(subject, name, predicate, opts)
+        register_named_subject(subject)
+        opts.merge!({:predicate=>predicate})
+        named_relationships_desc[subject][name] = opts
       end
+        
+      def create_named_relationship_methods(name)
+        append_method_name = "#{name.to_s.downcase}_append"
+        remove_method_name = "#{name.to_s.downcase}_remove"
+        self.send(:define_method,:"#{append_method_name}") {|object| add_named_relationship(name,object)}
+        self.send(:define_method,:"#{remove_method_name}") {|object| remove_named_relationship(name,object)}
+      end 
     
       def create_inbound_relationship_finders(name, predicate, opts = {})
         class_eval <<-END
@@ -158,6 +433,8 @@ module ActiveFedora
                 id_array << hit[SOLR_DOCUMENT_ID]
               end
               return id_array
+            elsif opts[:response_format] == :load_from_solr || self.load_from_solr
+              return ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
             else
               return ActiveFedora::SolrService.reify_solr_results(solr_result)
             end
@@ -165,7 +442,10 @@ module ActiveFedora
         end
         def #{name}_ids
           #{name}(:response_format => :id_array)
-        end 
+        end
+        def #{name}_from_solr
+          #{name}(:response_format => :load_from_solr)
+        end
         END
       end
     
@@ -185,6 +465,8 @@ module ActiveFedora
             solr_result = SolrService.instance.conn.query(query)
             if opts[:response_format] == :solr
               return solr_result
+            elsif opts[:response_format] == :load_from_solr || self.load_from_solr
+              return ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
             else
               return ActiveFedora::SolrService.reify_solr_results(solr_result)
             end
@@ -193,6 +475,9 @@ module ActiveFedora
         def #{name}_ids
           #{name}(:response_format => :id_array)
         end
+        def #{name}_from_solr
+          #{name}(:response_format => :load_from_solr)
+        end
         END
       end