active-fedora 5.5.0 → 5.5.1

data/.gitmodules

@@ -1,4 +1,4 @@
 [submodule "jetty"]
 	path = jetty
 	url = git://github.com/projecthydra/hydra-jetty.git
-  ignore = all
+  ignore = dirty

data/History.txt

@@ -1,3 +1,6 @@
+5.5.1
+#34 Allow passing RDF::URI to rdf_type
+
 5.5.0
 Added support for complex rdf structures.
 Changed RdfDatastream to_solr so that it uses the dsid as the solr prefix, not the datastream class name

data/active-fedora.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.add_dependency('rsolr')
   s.add_dependency('om', '~> 1.8.0')
   s.add_dependency('nom-xml', '>=0.5.1')
-  s.add_dependency('solrizer', '~>2.1.0')
+  s.add_dependency('solrizer', '>=2.1.0') #can also use version 3
   s.add_dependency("activeresource", '>= 3.0.0')
   s.add_dependency("activesupport", '>= 3.0.0')
   s.add_dependency("builder", '~> 3.0.0')

data/lib/active_fedora/base.rb

@@ -398,7 +398,7 @@ module ActiveFedora
       else
         raise "Solr document record id and pid do not match" unless pid == solr_doc[SOLR_DOCUMENT_ID]
       end
-      klass = if class_str = solr_doc['has_model_s']
+      klass = if class_str = solr_doc[ActiveFedora::SolrService.solr_name('has_model', :symbol)]
         ActiveFedora::SolrService.class_from_solr_document(solr_doc)
       else
         ActiveFedora::Base

data/lib/active_fedora/nokogiri_datastream.rb

@@ -285,7 +285,7 @@ module ActiveFedora
     end
 
     def generate_solr_symbol(base, data_type)
-      Solrizer.default_field_mapper.solr_name(base.to_sym, data_type)
+      ActiveFedora::SolrService.solr_name(base.to_sym, data_type)
     end
 
     # ** Experimental **

data/lib/active_fedora/querying.rb

@@ -115,22 +115,28 @@ module ActiveFedora
     def create_query_from_hash(conditions)
       clauses = search_model_clause ?  [search_model_clause] : []
       conditions.each_pair do |key,value|
-        unless value.nil?
-          if value.is_a? Array
-            value.each do |val|
-              clauses << "#{key}:#{quote_for_solr(val)}"  
-            end
-          else
-            key = SOLR_DOCUMENT_ID if (key === :id || key === :pid)
-            escaped_value = quote_for_solr(value)
-            clauses << (key.to_s.eql?(SOLR_DOCUMENT_ID) ? "#{key}:#{escaped_value}" : "#{key}:#{escaped_value}")
-          end
-        end
+        clauses << condition_to_clauses(key, value)
       end
       return "*:*" if clauses.empty?
       clauses.compact.join(" AND ")
     end
 
+    def condition_to_clauses(key, value)
+      unless value.nil?
+        # if the key is a property name, turn it into a solr field
+        if self.delegate_registry.include?(key.to_sym)
+          key = ActiveFedora::SolrService.solr_name(key, :string, :searchable)
+        end
+        if value.is_a? Array
+          value.map { |val| "#{key}:#{quote_for_solr(val)}" }
+        else
+          key = SOLR_DOCUMENT_ID if (key === :id || key === :pid)
+          escaped_value = quote_for_solr(value)
+          key.to_s.eql?(SOLR_DOCUMENT_ID) ? "#{key}:#{escaped_value}" : "#{key}:#{escaped_value}"
+        end
+      end
+    end
+
     def create_query_from_string(conditions)
       model_clause = search_model_clause
       model_clause ? "#{model_clause} AND (#{conditions})" : conditions

data/lib/active_fedora/rdf_node.rb

@@ -188,7 +188,7 @@ module ActiveFedora
 
       def rdf_type(uri_or_string=nil)
         if uri_or_string
-          uri = RDF::URI.new(uri_or_string) unless uri_or_string.kind_of? RDF::URI
+          uri = uri_or_string.kind_of?(RDF::URI) ? uri_or_string : RDF::URI.new(uri_or_string) 
           self.config[:type] = {predicate: RDF.type}
           @rdf_type = uri
         end

data/lib/active_fedora/simple_datastream.rb

@@ -48,7 +48,7 @@ module ActiveFedora
     #!! Careful: If you declare two fields that correspond to the same xml node without any qualifiers to differentiate them, 
     #you will end up replicating the values in the underlying datastream, resulting in mysterious dubling, quadrupling, etc. 
     #whenever you edit the field's values.
-    def field(name, datatype=nil, opts={})
+    def field(name, datatype=:string, opts={})
       fields ||= {}
       @fields[name.to_s.to_sym]={:type=>datatype, :values=>[]}.merge(opts)
       # add term to template

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "5.5.0"
+  VERSION = "5.5.1"
 end

data/spec/integration/base_spec.rb

@@ -20,7 +20,8 @@ describe "A base object with metadata" do
       obj = ActiveFedora::Base.find(@obj.pid, :cast=>true)
       obj.foo.should_not be_new
       obj.foo.person.should == ['bob']
-      ActiveFedora::SolrService.query("id:#{@obj.pid.gsub(":", "\\:")}", :fl=>'id person_t').first.should == {"id"=>@obj.pid, 'person_t'=>['bob']}
+      person_field = ActiveFedora::SolrService.solr_name('person', :string, :searchable)
+      ActiveFedora::SolrService.query("id:#{@obj.pid.gsub(":", "\\:")}", :fl=>"id #{person_field}").first.should == {"id"=>@obj.pid, person_field =>['bob']}
     end
   end
 
@@ -39,7 +40,8 @@ describe "A base object with metadata" do
       end
       it "should save the datastream." do
         MockAFBaseRelationship.find(@release.pid).foo.person.should == ['frank']
-        ActiveFedora::SolrService.query("id:#{@release.pid.gsub(":", "\\:")}", :fl=>'id person_t').first.should == {"id"=>@release.pid, 'person_t'=>['frank']}
+        person_field = ActiveFedora::SolrService.solr_name('person', :string, :searchable)
+        ActiveFedora::SolrService.query("id:#{@release.pid.gsub(":", "\\:")}", :fl=>"id #{person_field}").first.should == {"id"=>@release.pid, person_field =>['frank']}
       end
     end
     describe "clone_into a new object" do

data/spec/integration/complex_rdf_datastream_spec.rb

@@ -89,7 +89,7 @@ END
 
         class MediatorUser
           include ActiveFedora::RdfObject
-          rdf_type "http://purl.org/dc/terms/AgentClass"
+          rdf_type RDF::DC.AgentClass
           map_predicates do |map|
             map.title(:in=> RDF::DC)
           end

data/spec/integration/full_featured_model_spec.rb

@@ -151,7 +151,7 @@ describe ActiveFedora::Base do
     @properties_sample_values.each_pair do |field, value|
       next if field == :hard_copy_availability #FIXME HYDRA-824
       next if field == :location #FIXME HYDRA-825 
-      (@solr_result["#{field.to_s}_t"] || @solr_result["#{field.to_s}_dt"]).should == [::Solrizer::Extractor.format_node_value(value)] 
+      (@solr_result[ActiveFedora::SolrService.solr_name(field, :string, :searchable)] || @solr_result[ActiveFedora::SolrService.solr_name(field, :date)]).should == [::Solrizer::Extractor.format_node_value(value)] 
     end
     
     @dublin_core_sample_values.each_pair do |field, value|

data/spec/integration/ntriples_datastream_spec.rb

@@ -68,15 +68,15 @@ describe ActiveFedora::NtriplesRDFDatastream do
     subject.date_uploaded = Date.parse('2012-11-02')
     subject.date_uploaded.first.should be_kind_of Date
     solr_document = subject.to_solr
-    solr_document["rdf__date_uploaded_dt"].should == ['2012-11-02T00:00:00Z']
+    solr_document[ActiveFedora::SolrService.solr_name('rdf__date_uploaded', :date, :searchable)].should == ['2012-11-02T00:00:00Z']
   end
 
   it "should produce a solr document" do
     @subject = RdfTest.new(title: "War and Peace")
     solr_document = @subject.to_solr
-    solr_document["rdf__title_display"].should == ["War and Peace"]
-    solr_document["rdf__title_facet"].should == ["War and Peace"]
-    solr_document["rdf__title_t"].should == ["War and Peace"]
+    solr_document[ActiveFedora::SolrService.solr_name('rdf__title', :string, :displayable)].should == ["War and Peace"]
+    solr_document[ActiveFedora::SolrService.solr_name('rdf__title', :string, :facetable)].should == ["War and Peace"]
+    solr_document[ActiveFedora::SolrService.solr_name('rdf__title', :string, :searchable)].should == ["War and Peace"]
   end
 
   it "should set and recall values" do

data/spec/integration/om_datastream_spec.rb

@@ -119,7 +119,7 @@ describe ActiveFedora::OmDatastream do
 
     end
     it "should solrize terms with :type=>'date' to *_dt solr terms" do
-      @test_object.to_solr['mods_journal_issue_publication_date_dt'].should == ['2012-11-02T00:00:00Z']
+      @test_object.to_solr[ActiveFedora::SolrService.solr_name('mods_journal_issue_publication_date', :date)].should == ['2012-11-02T00:00:00Z']
     end
   end
 end

data/spec/integration/scoped_query_spec.rb

@@ -15,7 +15,7 @@ describe ActiveFedora::Model do
 
         def to_solr(doc = {})
           doc = super
-          doc['foo_sort'] = doc['foo_t']
+          doc[ActiveFedora::SolrService.solr_name('foo', :string, :sortable)] = doc[ActiveFedora::SolrService.solr_name('foo', :string, :searchable)]
           doc
         end
       
@@ -71,17 +71,18 @@ describe ActiveFedora::Model do
       @test_instance3.delete
     end
     it "should query" do
-      ModelIntegrationSpec::Basic.where(:foo_t => 'Beta').should == [@test_instance1]
+      ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('foo', :string, :searchable)=> 'Beta').should == [@test_instance1]
+      ModelIntegrationSpec::Basic.where('foo' => 'Beta').should == [@test_instance1]
     end
     it "should order" do
-      ModelIntegrationSpec::Basic.order('foo_sort asc').should == [@test_instance2, @test_instance1, @test_instance3]
+      ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :string, :sortable) + ' asc').should == [@test_instance2, @test_instance1, @test_instance3]
     end
     it "should limit" do
       ModelIntegrationSpec::Basic.limit(1).should == [@test_instance1]
     end
 
     it "should chain them" do
-      ModelIntegrationSpec::Basic.where(:bar_t => 'Peanuts').order('foo_sort asc').limit(1).should == [@test_instance2]
+      ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', :string, :searchable) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :string, :sortable) + ' asc').limit(1).should == [@test_instance2]
     end
   end
 end

data/spec/integration/semantic_node_spec.rb

@@ -28,11 +28,11 @@ describe ActiveFedora::SemanticNode do
     class SpecNodeSolrFilterQuery < ActiveFedora::Base
       include ActiveFedora::Relationships
       has_relationship("parts", :is_part_of, :inbound => true)
-      has_relationship("special_parts", :is_part_of, :inbound => true, :solr_fq=>"has_model_s:info\\:fedora\\/afmodel\\:SpecialPart")
+      has_relationship("special_parts", :is_part_of, :inbound => true, :solr_fq=>"#{ActiveFedora::SolrService.solr_name("has_model", :symbol)}:info\\:fedora\\/afmodel\\:SpecialPart")
       has_relationship("containers", :is_member_of)
-      has_relationship("special_containers", :is_member_of, :solr_fq=>"has_model_s:info\\:fedora\\/afmodel\\:SpecialContainer")
+      has_relationship("special_containers", :is_member_of, :solr_fq=>"#{ActiveFedora::SolrService.solr_name("has_model", :symbol)}:info\\:fedora\\/afmodel\\:SpecialContainer")
       has_bidirectional_relationship("bi_containers", :is_member_of, :has_member)
-      has_bidirectional_relationship("bi_special_containers", :is_member_of, :has_member, :solr_fq=>"has_model_s:info\\:fedora\\/afmodel\\:SpecialContainer")
+      has_bidirectional_relationship("bi_special_containers", :is_member_of, :has_member, :solr_fq=>"#{ActiveFedora::SolrService.solr_name("has_model", :symbol)}:info\\:fedora\\/afmodel\\:SpecialContainer")
     end
 
     @test_object = SNSpecModel.new
@@ -100,8 +100,8 @@ describe ActiveFedora::SemanticNode do
     @special_part.add_relationship(:is_part_of, @test_object_query)
     @special_part.save
     
-    @special_container_query = "has_model_s:#{solr_uri("info:fedora/afmodel:SpecialContainer")}"
-    @special_part_query = "has_model_s:#{solr_uri("info:fedora/afmodel:SpecialPart")}"
+    @special_container_query = "#{ActiveFedora::SolrService.solr_name("has_model", :symbol)}:#{solr_uri("info:fedora/afmodel:SpecialContainer")}"
+    @special_part_query = "#{ActiveFedora::SolrService.solr_name("has_model", :symbol)}:#{solr_uri("info:fedora/afmodel:SpecialPart")}"
   end
   
   after(:all) do
@@ -263,17 +263,17 @@ describe ActiveFedora::SemanticNode do
     end
 
     it "should return a solr query for an inbound relationship" do
-      @test_object_query.special_parts_query.should == "#{@test_object_query.relationship_predicates[:inbound]['special_parts']}_s:#{solr_uri(@test_object_query.internal_uri)} AND #{@special_part_query}"
+      @test_object_query.special_parts_query.should == "#{ActiveFedora::SolrService.solr_name(@test_object_query.relationship_predicates[:inbound]['special_parts'], :symbol)}:#{solr_uri(@test_object_query.internal_uri)} AND #{@special_part_query}"
     end
   end
 
   describe "inbound relationship query" do
     it "should return a properly formatted query for a relationship that has a solr filter query defined" do
-      SpecNodeSolrFilterQuery.inbound_relationship_query(@test_object_query.pid,"special_parts").should == "#{@test_object_query.relationship_predicates[:inbound]['special_parts']}_s:#{solr_uri(@test_object_query.internal_uri)} AND #{@special_part_query}"
+      SpecNodeSolrFilterQuery.inbound_relationship_query(@test_object_query.pid,"special_parts").should == "#{ActiveFedora::SolrService.solr_name(@test_object_query.relationship_predicates[:inbound]['special_parts'], :symbol)}:#{solr_uri(@test_object_query.internal_uri)} AND #{@special_part_query}"
     end
 
     it "should return a properly formatted query for a relationship that does not have a solr filter query defined" do
-      SpecNodeSolrFilterQuery.inbound_relationship_query(@test_object_query.pid,"parts").should == "is_part_of_s:#{solr_uri(@test_object_query.internal_uri)}"
+      SpecNodeSolrFilterQuery.inbound_relationship_query(@test_object_query.pid,"parts").should == "#{ActiveFedora::SolrService.solr_name('is_part_of', :symbol)}:#{solr_uri(@test_object_query.internal_uri)}"
     end
   end
 
@@ -305,7 +305,7 @@ describe ActiveFedora::SemanticNode do
         expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND #{@special_container_query})"
       end
       expected_string << " OR "
-      expected_string << "(#{@test_object_query.relationship_predicates[:inbound]['bi_special_containers_inbound']}_s:#{solr_uri(@test_object_query.internal_uri)} AND #{@special_container_query})"
+      expected_string << "(#{ActiveFedora::SolrService.solr_name(@test_object_query.relationship_predicates[:inbound]['bi_special_containers_inbound'], :symbol)}:#{solr_uri(@test_object_query.internal_uri)} AND #{@special_container_query})"
       SpecNodeSolrFilterQuery.bidirectional_relationship_query(@test_object_query.pid,"bi_special_containers",@test_object_query.bi_containers_outbound_ids).should == expected_string
     end
 
@@ -316,7 +316,7 @@ describe ActiveFedora::SemanticNode do
         expected_string << "id:" + id.gsub(/(:)/, '\\:')
       end
       expected_string << " OR "
-      expected_string << "(#{@test_object_query.relationship_predicates[:inbound]['bi_special_containers_inbound']}_s:#{solr_uri(@test_object_query.internal_uri)})"
+      expected_string << "(#{ActiveFedora::SolrService.solr_name(@test_object_query.relationship_predicates[:inbound]['bi_special_containers_inbound'], :symbol)}:#{solr_uri(@test_object_query.internal_uri)})"
       SpecNodeSolrFilterQuery.bidirectional_relationship_query(@test_object_query.pid,"bi_containers",@test_object_query.bi_containers_outbound_ids).should == expected_string
     end
   end
@@ -427,7 +427,7 @@ describe ActiveFedora::SemanticNode do
         expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND #{@special_container_query})"
       end
       expected_string << " OR "
-      expected_string << "(#{@test_object_query.relationship_predicates[:inbound]['bi_special_containers_inbound']}_s:#{solr_uri(@test_object_query.internal_uri)} AND #{@special_container_query})"
+      expected_string << "(#{ActiveFedora::SolrService.solr_name(@test_object_query.relationship_predicates[:inbound]['bi_special_containers_inbound'], :symbol)}:#{solr_uri(@test_object_query.internal_uri)} AND #{@special_container_query})"
       @test_object_query.bi_special_containers_query.should == expected_string
     end
   end

data/spec/samples/hydra-mods_article_datastream.rb

@@ -508,8 +508,8 @@ module Hydra
     def to_solr(solr_doc=Hash.new)
       super(solr_doc)
             
-      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, "object_type_facet", "Article")
-      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, "mods_journal_title_info_facet", "Unknown") if solr_doc["mods_journal_title_info_facet"].nil? 
+      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, Solrizer.default_field_mapper.solr_name('object_type', :string, :facetable), "Article")
+      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, Solrizer.default_field_mapper.solr_name('mods_journal_title_info', :string, :facetable), "Unknown") if solr_doc["mods_journal_title_info_facet"].nil? 
 
       solr_doc
     end

data/spec/unit/base_spec.rb

@@ -392,18 +392,18 @@ describe ActiveFedora::Base do
         @test_object.should_receive(:create_date).and_return("2012-03-04T03:12:02Z")
         @test_object.should_receive(:modified_date).and_return("2012-03-07T03:12:02Z")
         solr_doc = @test_object.to_solr
-        solr_doc["system_create_dt"].should eql("2012-03-04T03:12:02Z")
-        solr_doc["system_modified_dt"].should eql("2012-03-07T03:12:02Z")
+        solr_doc[ActiveFedora::SolrService.solr_name("system_create", :date, :searchable)].should eql("2012-03-04T03:12:02Z")
+        solr_doc[ActiveFedora::SolrService.solr_name("system_modified", :date, :searchable)].should eql("2012-03-07T03:12:02Z")
         solr_doc[:id].should eql("#{@test_object.pid}")
       end
 
       it "should omit base metadata and RELS-EXT if :model_only==true" do
         @test_object.add_relationship(:has_part, "foo", true)
         solr_doc = @test_object.to_solr(Hash.new, :model_only => true)
-        solr_doc["system_create_dt"].should be_nil
-        solr_doc["system_modified_dt"].should be_nil
+        solr_doc[ActiveFedora::SolrService.solr_name("system_create", :date, :searchable)].should be_nil
+        solr_doc[ActiveFedora::SolrService.solr_name("system_modified", :date, :searchable)].should be_nil
         solr_doc["id"].should be_nil
-        solr_doc["has_part_s"].should be_nil
+        solr_doc[ActiveFedora::SolrService.solr_name("has_part", :symbol)].should be_nil
       end
       
       it "should add self.class as the :active_fedora_model" do
@@ -411,35 +411,9 @@ describe ActiveFedora::Base do
         stub_get_content(@this_pid, ['RELS-EXT', 'someData', 'withText2', 'withText'])
         @test_history = FooHistory.new()
         solr_doc = @test_history.to_solr
-        solr_doc["active_fedora_model_s"].should eql("FooHistory")
+        solr_doc[ActiveFedora::SolrService.solr_name("active_fedora_model", :symbol)].should eql("FooHistory")
       end
 
-      describe "using mappings.yml" do
-        before do
-          @old_mapper = ActiveFedora::SolrService.default_field_mapper.dup
-          ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
-        end
-        after do
-          ActiveFedora::SolrService.default_field_mapper = @old_mapper
-        end
-
-        it "should decide names of solr fields" do      
-          cdate = "2008-07-02T05:09:42Z"
-          mdate = "2009-07-07T23:37:18Z"
-          @test_object.stub(:create_date).and_return(cdate)
-          @test_object.stub(:modified_date).and_return(mdate)
-          
-          solr_doc = @test_object.to_solr
-          [:system_create_dt, :system_modified_dt, :active_fedora_model_s].each do |fn|
-            solr_doc[fn].should == nil
-          end
-          solr_doc["system_create_date"].should eql(cdate)
-          solr_doc["system_modified_date"].should eql(mdate)
-          solr_doc[:id].should eql("#{@test_object.pid}")
-          solr_doc["active_fedora_model_field"].should eql(@test_object.class.inspect)
-        end
-      end
-      
       it "should call .to_solr on all SimpleDatastreams and OmDatastreams, passing the resulting document to solr" do
         mock1 = mock("ds1", :to_solr => {})
         mock2 = mock("ds2", :to_solr => {})
@@ -660,10 +634,10 @@ pending "This is broken, and deprecated.  I don't want to fix it - jcoyne"
 
         @test_object.should_receive(:relationships).and_return(graph)
         solr_doc = @test_object.solrize_relationships
-        solr_doc["is_member_of_s"].should == ["info:fedora/demo:10"]
-        solr_doc["is_part_of_s"].should == ["info:fedora/demo:11"]
-        solr_doc["has_part_s"].should == ["info:fedora/demo:12"]
-        solr_doc["conforms_to_s"].should == ["AnInterface"]
+        solr_doc[ActiveFedora::SolrService.solr_name("is_member_of", :symbol)].should == ["info:fedora/demo:10"]
+        solr_doc[ActiveFedora::SolrService.solr_name("is_part_of", :symbol)].should == ["info:fedora/demo:11"]
+        solr_doc[ActiveFedora::SolrService.solr_name("has_part", :symbol)].should == ["info:fedora/demo:12"]
+        solr_doc[ActiveFedora::SolrService.solr_name("conforms_to", :symbol)].should == ["AnInterface"]
       end
     end
   end

data/spec/unit/ntriples_datastream_spec.rb

@@ -173,25 +173,19 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
     it "should iterate through @fields hash" do
       solr_doc = @subject.to_solr
-      solr_doc["solr_rdf__publisher_t"].should == ["publisher1"]
-      solr_doc["solr_rdf__publisher_sort"].should == ["publisher1"]
-      solr_doc["solr_rdf__publisher_display"].should == ["publisher1"]
-      solr_doc["solr_rdf__publisher_facet"].should == ["publisher1"]
-      solr_doc["solr_rdf__based_near_t"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["solr_rdf__based_near_display"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["solr_rdf__based_near_facet"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["solr_rdf__created_sort"].should == ["2009-10-10"]
-      solr_doc["solr_rdf__created_display"].should == ["2009-10-10"]
-      solr_doc["solr_rdf__title_t"].should == ["fake-title"]
-      solr_doc["solr_rdf__title_sort"].should == ["fake-title"]
-      solr_doc["solr_rdf__title_display"].should == ["fake-title"]
-      solr_doc["solr_rdf__related_url_t"].should == ["http://example.org/"]
-      solr_doc["solr_rdf__empty_field_t"].should be_nil
-
-      #should NOT have these
-      solr_doc["solr_rdf__narrator"].should be_nil
-      solr_doc["solr_rdf__empty_field"].should be_nil
-      solr_doc["solr_rdf__creator"].should be_nil
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :string, :searchable)].should == ["publisher1"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :string, :sortable)].should == ["publisher1"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :string, :displayable)].should == ["publisher1"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :string, :facetable)].should == ["publisher1"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :string, :searchable)].should == ["coverage1", "coverage2"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :string, :displayable)].should == ["coverage1", "coverage2"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :string, :facetable)].should == ["coverage1", "coverage2"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__created", :string, :sortable)].should == ["2009-10-10"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__created", :string, :displayable)].should == ["2009-10-10"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__title", :string, :searchable)].should == ["fake-title"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__title", :string, :sortable)].should == ["fake-title"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__title", :string, :displayable)].should == ["fake-title"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__related_url", :string, :searchable)].should == ["http://example.org/"]
     end
 
     describe "with an actual object" do
@@ -235,17 +229,25 @@ describe ActiveFedora::NtriplesRDFDatastream do
       end
       describe ".to_solr()" do
         it "should return the right fields" do
-          @obj.to_solr.keys.count.should == 13
-          @obj.to_solr.keys.should include("solr_rdf__related_url_t", "solr_rdf__publisher_t", "solr_rdf__publisher_sort",
-                "solr_rdf__publisher_display", "solr_rdf__publisher_facet", "solr_rdf__created_sort",
-                "solr_rdf__created_display", "solr_rdf__title_t", "solr_rdf__title_sort", "solr_rdf__title_display",
-                "solr_rdf__based_near_t", "solr_rdf__based_near_facet", "solr_rdf__based_near_display")
+          @obj.to_solr.keys.should include(ActiveFedora::SolrService.solr_name("solr_rdf__related_url", :string, :searchable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :string, :searchable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :string, :sortable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :string, :displayable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :string, :facetable), 
+                ActiveFedora::SolrService.solr_name("solr_rdf__created", :string, :sortable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__created", :string, :displayable), 
+                ActiveFedora::SolrService.solr_name("solr_rdf__title", :string, :searchable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__title", :string, :sortable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__title", :string, :displayable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :string, :searchable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :string, :facetable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :string, :displayable))
 
         end
 
         it "should return the right values" do
-          @obj.to_solr["solr_rdf__related_url_t"].should == ["http://example.org/blogtastic/"]
-          @obj.to_solr["solr_rdf__based_near_t"].should == ["Tacoma, WA","Renton, WA"]
+          @obj.to_solr[ActiveFedora::SolrService.solr_name("solr_rdf__related_url", :string, :searchable)].should == ["http://example.org/blogtastic/"]
+          @obj.to_solr[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :string, :searchable)].should == ["Tacoma, WA","Renton, WA"]
         end
       end
     end

data/spec/unit/om_datastream_spec.rb

@@ -9,7 +9,13 @@ describe ActiveFedora::OmDatastream do
                       :empty_field => {:values => {}}
                       } 
     @sample_raw_xml = "<foo><xmlelement/></foo>"
-    @solr_doc = {"id"=>"hydrange_article1","name_role_roleTerm_t"=>["creator","submitter","teacher"],"name_0_role_t"=>"\r\ncreator\r\nsubmitter\r\n","name_1_role_t"=>"\r\n teacher \r\n","name_0_role_0_roleTerm_t"=>"creator","name_0_role_1_roleTerm_t"=>"submitter","name_1_role_0_roleTerm_t"=>["teacher"]}
+    @solr_doc = {"id"=>"hydrange_article1",
+      ActiveFedora::SolrService.solr_name("name_role_roleTerm", :string, :searchable) =>["creator","submitter","teacher"],
+      ActiveFedora::SolrService.solr_name("name_0_role", :string, :searchable)=>"\r\ncreator\r\nsubmitter\r\n",
+      ActiveFedora::SolrService.solr_name("name_1_role", :string, :searchable)=>"\r\n teacher \r\n",
+      ActiveFedora::SolrService.solr_name("name_0_role_0_roleTerm", :string, :searchable)=>"creator",
+      ActiveFedora::SolrService.solr_name("name_0_role_1_roleTerm", :string, :searchable)=>"submitter",
+      ActiveFedora::SolrService.solr_name("name_1_role_0_roleTerm", :string, :searchable)=>["teacher"]}
   end
   
   before(:each) do
@@ -47,7 +53,6 @@ describe ActiveFedora::OmDatastream do
     it "should initialize from #xml_template if no xml is provided" do
       ActiveFedora::OmDatastream.should_receive(:xml_template).and_return("<fake template/>")
       n = ActiveFedora::OmDatastream.new
-      n.ensure_xml_loaded
       n.ng_xml.should be_equivalent_to("<fake template/>")
     end
   end
@@ -303,11 +308,11 @@ describe ActiveFedora::OmDatastream do
 
   describe '.has_solr_name?' do
     it "should return true if the given key exists in the solr document passed in" do
-      @test_ds.has_solr_name?("name_0_role_0_roleTerm_t",@solr_doc).should == true
-      @test_ds.has_solr_name?(:name_0_role_0_roleTerm_t,@solr_doc).should == true
-      @test_ds.has_solr_name?("name_1_role_1_roleTerm_t",@solr_doc).should == false
+      @test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("name_0_role_0_roleTerm", :string, :searchable),@solr_doc).should == true
+      @test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("name_0_role_0_roleTerm", :string, :searchable).to_sym,@solr_doc).should == true
+      @test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("name_1_role_1_roleTerm", :string, :searchable),@solr_doc).should == false
       #if not doc passed in should be new empty solr doc and always return false
-      @test_ds.has_solr_name?("name_0_role_0_roleTerm_t").should == false
+      @test_ds.has_solr_name?(ActiveFedora::SolrService.solr_name("name_0_role_0_roleTerm", :string, :searchable)).should == false
     end
   end
 

data/spec/unit/qualified_dublin_core_datastream_spec.rb

@@ -110,7 +110,7 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
       @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.new(nil, 'qdc' )
       @test_ds.title = "War and Peace"
       solr = @test_ds.to_solr
-      solr["title_t"].should == ["War and Peace"]
+      solr[ActiveFedora::SolrService.solr_name('title', :string, :searchable)].should == ["War and Peace"]
     end
 
   end

data/spec/unit/query_spec.rb

@@ -7,7 +7,8 @@ describe ActiveFedora::Base do
       class Basic < ActiveFedora::Base
       end
     end
-    @model_query = "has_model_s:#{solr_uri("info:fedora/afmodel:SpecModel_Basic")}"
+    @model_query = ActiveFedora::SolrService.solr_name("has_model", :symbol) + ":#{solr_uri("info:fedora/afmodel:SpecModel_Basic")}"
+    @sort_query = ActiveFedora::SolrService.solr_name("system_create", :date, :searchable) + ' asc'
   end
   
   after(:all) do
@@ -23,7 +24,7 @@ describe ActiveFedora::Base do
             SpecModel::Basic.should_receive(:find_one).with("changeme:22", nil).and_return("Fake Object2")
             mock_docs = [{"id" => "changeme:30"}, {"id" => "changeme:22"}]
             mock_docs.should_receive(:has_next?).and_return(false)
-            ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
+            ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
             SpecModel::Basic.find(:all).should == ["Fake Object1", "Fake Object2"]
           end
         end
@@ -33,7 +34,7 @@ describe ActiveFedora::Base do
             ActiveFedora::Base.should_receive(:find_one).with("changeme:22", nil).and_return("Fake Object2")
             mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
             mock_docs.should_receive(:has_next?).and_return(false)
-            ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>'*:*', :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
+            ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>'*:*', :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
             ActiveFedora::Base.find(:all).should == ["Fake Object1", "Fake Object2"]
           end
         end
@@ -71,7 +72,7 @@ describe ActiveFedora::Base do
             rows == 1000 &&
             method == 'select' &&
             hash[:params] &&
-            hash[:params][:sort] == ['system_create_dt asc'] &&
+            hash[:params][:sort] == [@sort_query] &&
             hash[:params][:fl] == 'id' && 
             hash[:params][:q].split(" AND ").include?(@model_query) &&
             hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
@@ -88,7 +89,7 @@ describe ActiveFedora::Base do
     it "should query solr for all objects with :active_fedora_model_s of self.class" do
       mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
       mock_docs.should_receive(:has_next?).and_return(false)
-      ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => ['system_create_dt asc'], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
+      ActiveFedora::SolrService.instance.conn.should_receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
       
       SpecModel::Basic.should_receive(:find_one).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
       SpecModel::Basic.should_receive(:find_one).with("changeme:22", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:22'))
@@ -108,7 +109,7 @@ describe ActiveFedora::Base do
             rows == 1000 &&
             method == 'select' &&
             hash[:params] &&
-            hash[:params][:sort] == ['system_create_dt asc'] && 
+            hash[:params][:sort] == [@sort_query] && 
             hash[:params][:fl] == 'id' && 
             hash[:params][:q].split(" AND ").include?(@model_query) &&
             hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
@@ -132,7 +133,7 @@ describe ActiveFedora::Base do
             rows == 1002 &&
             method == 'select' &&
             hash[:params] &&
-            hash[:params][:sort] == ['system_create_dt asc'] && 
+            hash[:params][:sort] == [@sort_query] && 
             hash[:params][:fl] == 'id' && 
             hash[:params][:q].split(" AND ").include?(@model_query) &&
             hash[:params][:q].split(" AND ").include?("foo:\"bar\"") &&
@@ -196,12 +197,12 @@ describe ActiveFedora::Base do
 
     it "shouldn't use the class if it's called on AF:Base " do
       mock_result = stub('Result')
-      ActiveFedora::SolrService.should_receive(:query).with('baz:"quack"', {:sort => ['system_create_dt asc']}).and_return(mock_result)
+      ActiveFedora::SolrService.should_receive(:query).with('baz:"quack"', {:sort => [@sort_query]}).and_return(mock_result)
       ActiveFedora::Base.find_with_conditions(:baz=>'quack').should == mock_result
     end
     it "should use the query string if it's provided" do
       mock_result = stub('Result')
-      ActiveFedora::SolrService.should_receive(:query).with('chunky:monkey', {:sort => ['system_create_dt asc']}).and_return(mock_result)
+      ActiveFedora::SolrService.should_receive(:query).with('chunky:monkey', {:sort => [@sort_query]}).and_return(mock_result)
       ActiveFedora::Base.find_with_conditions('chunky:monkey').should == mock_result
     end
   end

data/spec/unit/relationships_spec.rb

@@ -20,9 +20,9 @@ describe ActiveFedora::Relationships do
     end
     
     before(:all) do
-      @part_of_sample = "is_part_of_s:#{solr_uri("info:fedora/test:sample_pid")}"
-      @constituent_of_sample = "is_constituent_of_s:#{solr_uri("info:fedora/test:sample_pid")}"
-      @is_part_query = "has_model_s:#{solr_uri("info:fedora/SpecialPart")}"
+      @part_of_sample = ActiveFedora::SolrService.solr_name("is_part_of", :symbol) + ":#{solr_uri("info:fedora/test:sample_pid")}"
+      @constituent_of_sample = ActiveFedora::SolrService.solr_name("is_constituent_of", :symbol) + ":#{solr_uri("info:fedora/test:sample_pid")}"
+      @is_part_query = ActiveFedora::SolrService.solr_name("has_model", :symbol) + ":#{solr_uri("info:fedora/SpecialPart")}"
     end
 
     before(:each) do
@@ -181,9 +181,9 @@ describe ActiveFedora::Relationships do
       end
       
       it "resulting finder should search against solr and use Model#find to build an array of objects" do
-        @sample_solr_hits = [{"id"=>"_PID1_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]},
-                              {"id"=>"_PID2_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]},
-                              {"id"=>"_PID3_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]}]
+        @sample_solr_hits = [{"id"=>"_PID1_", ActiveFedora::SolrService.solr_name('has_model', :symbol)=>["info:fedora/afmodel:AudioRecord"]},
+                              {"id"=>"_PID2_", ActiveFedora::SolrService.solr_name('has_model', :symbol)=>["info:fedora/afmodel:AudioRecord"]},
+                              {"id"=>"_PID3_", ActiveFedora::SolrService.solr_name('has_model', :symbol)=>["info:fedora/afmodel:AudioRecord"]}]
         SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
         local_node = SpecNode.new()
         local_node.should_receive(:pid).and_return("test:sample_pid")
@@ -256,9 +256,9 @@ describe ActiveFedora::Relationships do
           local_node.should_receive(:ids_for_outbound).with(:is_member_of).and_return(["my:_PID1_", "my:_PID2_", "my:_PID3_"])
 
           #ActiveFedora::ContentModel.should_receive(:known_models_for).and_return([SpecNode]).times(3)
-          ActiveFedora::SolrService.should_receive(:query).with("id:my\\:_PID1_ OR id:my\\:_PID2_ OR id:my\\:_PID3_").and_return([{"id"=> "my:_PID1_", "has_model_s"=>["info:fedora/afmodel:SpecNode"]},
-                         {"id"=> "my:_PID2_", "has_model_s"=>["info:fedora/afmodel:SpecNode"]}, 
-                         {"id"=> "my:_PID3_", "has_model_s"=>["info:fedora/afmodel:SpecNode"]}])
+          ActiveFedora::SolrService.should_receive(:query).with("id:my\\:_PID1_ OR id:my\\:_PID2_ OR id:my\\:_PID3_").and_return([{"id"=> "my:_PID1_", ActiveFedora::SolrService.solr_name('has_model', :symbol)=>["info:fedora/afmodel:SpecNode"]},
+                         {"id"=> "my:_PID2_", ActiveFedora::SolrService.solr_name('has_model', :symbol)=>["info:fedora/afmodel:SpecNode"]}, 
+                         {"id"=> "my:_PID3_", ActiveFedora::SolrService.solr_name('has_model', :symbol)=>["info:fedora/afmodel:SpecNode"]}])
           ActiveFedora::DigitalObject.should_receive(:find).with(SpecNode, 'my:_PID1_').and_return(stub("inner obj", :'new?'=>false, :pid=>'my:_PID1_'))
           ActiveFedora::DigitalObject.should_receive(:find).with(SpecNode, 'my:_PID2_').and_return(stub("inner obj", :'new?'=>false, :pid=>'my:_PID2_'))
           ActiveFedora::DigitalObject.should_receive(:find).with(SpecNode, 'my:_PID3_').and_return(stub("inner obj", :'new?'=>false, :pid=>'my:_PID3_'))
@@ -462,13 +462,13 @@ describe ActiveFedora::Relationships do
   describe "relationship_query" do
     before do
       class MockNamedRelationshipQuery < SpecNode
-        register_relationship_desc(:inbound, "testing_inbound_query", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+        register_relationship_desc(:inbound, "testing_inbound_query", :is_part_of, :type=>SpecNode, :solr_fq=>"#{ActiveFedora::SolrService.solr_name('has_model', :symbol)}:info\\:fedora/SpecialPart")
         register_relationship_desc(:inbound, "testing_inbound_no_solr_fq", :is_part_of, :type=>SpecNode)
-        register_relationship_desc(:self, "testing_outbound_query", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+        register_relationship_desc(:self, "testing_outbound_query", :is_part_of, :type=>SpecNode, :solr_fq=>"#{ActiveFedora::SolrService.solr_name('has_model', :symbol)}:info\\:fedora/SpecialPart")
         register_relationship_desc(:self, "testing_outbound_no_solr_fq", :is_part_of, :type=>SpecNode)
         #for bidirectional relationship testing need to register both outbound and inbound names
-        register_relationship_desc(:self, "testing_bi_query_outbound", :has_part, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
-        register_relationship_desc(:inbound, "testing_bi_query_inbound", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+        register_relationship_desc(:self, "testing_bi_query_outbound", :has_part, :type=>SpecNode, :solr_fq=>"#{ActiveFedora::SolrService.solr_name('has_model', :symbol)}:info\\:fedora/SpecialPart")
+        register_relationship_desc(:inbound, "testing_bi_query_inbound", :is_part_of, :type=>SpecNode, :solr_fq=>"#{ActiveFedora::SolrService.solr_name('has_model', :symbol)}:info\\:fedora/SpecialPart")
         register_relationship_desc(:self, "testing_bi_no_solr_fq_outbound", :has_part, :type=>SpecNode)
         register_relationship_desc(:inbound, "testing_bi_no_solr_fq_inbound", :is_part_of, :type=>SpecNode)
       end
@@ -766,8 +766,8 @@ describe ActiveFedora::Relationships do
     describe "bidirectional_relationship_query" do
       before do
         class MockBiNamedRelationshipQuery < SpecNode
-          register_relationship_desc(:self, "testing_query_outbound", :has_part, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora\\/SpecialPart")
-          register_relationship_desc(:inbound, "testing_query_inbound", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora\\/SpecialPart")
+          register_relationship_desc(:self, "testing_query_outbound", :has_part, :type=>SpecNode, :solr_fq=>"#{ActiveFedora::SolrService.solr_name('has_model', :symbol)}:info\\:fedora\\/SpecialPart")
+          register_relationship_desc(:inbound, "testing_query_inbound", :is_part_of, :type=>SpecNode, :solr_fq=>"#{ActiveFedora::SolrService.solr_name('has_model', :symbol)}:info\\:fedora\\/SpecialPart")
           create_bidirectional_relationship_name_methods("testing","testing_outbound")
           register_relationship_desc(:self, "testing_no_solr_fq_outbound", :has_part, :type=>SpecNode)
           register_relationship_desc(:inbound, "testing_no_solr_fq_inbound", :is_part_of, :type=>SpecNode)
@@ -796,7 +796,7 @@ describe ActiveFedora::Relationships do
           expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND #{@is_part_query})"
         end
         expected_string << " OR "
-        expected_string << "(is_part_of_s:info\\:fedora\\/changeme\\:6 AND #{@is_part_query})"
+        expected_string << "(#{ActiveFedora::SolrService.solr_name('is_part_of', :symbol)}:info\\:fedora\\/changeme\\:6 AND #{@is_part_query})"
         MockBiNamedRelationshipQuery.bidirectional_relationship_query("changeme:6","testing_query",ids).should == expected_string
       end
 
@@ -808,7 +808,7 @@ describe ActiveFedora::Relationships do
           expected_string << "id:" + id.gsub(/(:)/, '\\:')
         end
         expected_string << " OR "
-        expected_string << "(is_part_of_s:info\\:fedora\\/changeme\\:6)"
+        expected_string << "(#{ActiveFedora::SolrService.solr_name('is_part_of', :symbol)}:info\\:fedora\\/changeme\\:6)"
         MockBiNamedRelationshipQuery.bidirectional_relationship_query("changeme:6","testing_no_solr_fq",ids).should == expected_string
       end
     end
@@ -816,7 +816,7 @@ describe ActiveFedora::Relationships do
     describe "inbound_relationship_query" do
       before do
         class MockInboundNamedRelationshipQuery < SpecNode
-          register_relationship_desc(:inbound, "testing_inbound_query", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:#{solr_uri("info:fedora/SpecialPart")}")
+          register_relationship_desc(:inbound, "testing_inbound_query", :is_part_of, :type=>SpecNode, :solr_fq=>"#{ActiveFedora::SolrService.solr_name('has_model', :symbol)}:#{solr_uri("info:fedora/SpecialPart")}")
           register_relationship_desc(:inbound, "testing_inbound_no_solr_fq", :is_part_of, :type=>SpecNode)
         end
       end
@@ -825,11 +825,11 @@ describe ActiveFedora::Relationships do
       end
 
       it "should return a properly formatted query for a relationship that has a solr filter query defined" do
-        MockInboundNamedRelationshipQuery.inbound_relationship_query("changeme:1","testing_inbound_query").should == "is_part_of_s:info\\:fedora\\/changeme\\:1 AND #{@is_part_query}"
+        MockInboundNamedRelationshipQuery.inbound_relationship_query("changeme:1","testing_inbound_query").should == "#{ActiveFedora::SolrService.solr_name('is_part_of', :symbol)}:info\\:fedora\\/changeme\\:1 AND #{@is_part_query}"
       end
       
       it "should return a properly formatted query for a relationship that does not have a solr filter query defined" do
-        MockInboundNamedRelationshipQuery.inbound_relationship_query("changeme:1","testing_inbound_no_solr_fq").should == "is_part_of_s:info\\:fedora\\/changeme\\:1"
+        MockInboundNamedRelationshipQuery.inbound_relationship_query("changeme:1","testing_inbound_no_solr_fq").should == "#{ActiveFedora::SolrService.solr_name('is_part_of', :symbol)}:info\\:fedora\\/changeme\\:1"
       end
     end
 
@@ -839,7 +839,7 @@ describe ActiveFedora::Relationships do
     describe "outbound_relationship_query" do
       before do
         class MockOutboundNamedRelationshipQuery < SpecNode
-          register_relationship_desc(:self, "testing_query", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:#{solr_uri("info:fedora/SpecialPart")}")
+          register_relationship_desc(:self, "testing_query", :is_part_of, :type=>SpecNode, :solr_fq=>"#{ActiveFedora::SolrService.solr_name('has_model', :symbol)}:#{solr_uri("info:fedora/SpecialPart")}")
           register_relationship_desc(:self,"testing_no_solr_fq", :is_part_of, :type=>SpecNode)
         end
       end
@@ -852,7 +852,7 @@ describe ActiveFedora::Relationships do
         expected_string = ""
         ids.each_with_index do |id,index|
           expected_string << " OR " if index > 0
-          expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND has_model_s:#{solr_uri("info:fedora/SpecialPart")})"
+          expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND #{ActiveFedora::SolrService.solr_name('has_model', :symbol)}:#{solr_uri("info:fedora/SpecialPart")})"
         end
         MockOutboundNamedRelationshipQuery.outbound_relationship_query("testing_query",ids).should == expected_string
       end

data/spec/unit/simple_datastream_spec.rb

@@ -54,8 +54,8 @@ describe ActiveFedora::SimpleDatastream do
   describe "#to_solr" do
     it "should have title" do
       solr = @test_ds.to_solr
-      solr["publisher_t"].should == ["publisher1"]
-      solr["creation_date_dt"].should == ["2012-01-15"]
+      solr[ActiveFedora::SolrService.solr_name('publisher', :string, :searchable)].should == ["publisher1"]
+      solr[ActiveFedora::SolrService.solr_name('creation_date', :date)].should == ["2012-01-15"]
     end
   end
 

data/spec/unit/solr_config_options_spec.rb

@@ -19,22 +19,6 @@ describe ActiveFedora do
   end
   
   
-  describe "field name mappings" do
-    after(:all) do
-      # Revert to default mappings after running tests
-      # ActiveFedora::SolrService.load_mappings
-    end
-    # it "should default to using the mappings for the current schema" do
-    #   from_default_yml = YAML::load(File.open(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings.yml")))
-    #   ActiveFedora::SolrService.mappings[:searchable].data_types[:date].opts[:suffix].should == from_default_yml["searchable"]["date"]    
-    # end
-    # it "should allow you to provide your own mappings file" do
-    #   ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
-    #   ActiveFedora::SolrService.mappings[:searchable].data_types[:date].opts[:suffix].should == "_date"      
-    #   ActiveFedora::SolrService.mappings[:searchable].data_types[:default].opts[:suffix].should == "_field"
-    # end
-  end
-  
   describe "SOLR_DOCUMENT_ID" do
     before(:all) do
       SOLR_DOCUMENT_ID = "MY_SAMPLE_ID"
@@ -50,7 +34,7 @@ describe ActiveFedora do
 
     it "should be used by ActiveFedora::Base#find_with_conditions" do
       mock_response = mock("SolrResponse")
-      ActiveFedora::SolrService.should_receive(:query).with("has_model_s:info\\:fedora\\/afmodel\\:SolrSpecModel_Basic AND " + SOLR_DOCUMENT_ID + ':"changeme\\:30"', {:sort => ['system_create_dt asc']}).and_return(mock_response)
+      ActiveFedora::SolrService.should_receive(:query).with("#{ActiveFedora::SolrService.solr_name("has_model", :symbol)}:info\\:fedora\\/afmodel\\:SolrSpecModel_Basic AND " + SOLR_DOCUMENT_ID + ':"changeme\\:30"', {:sort => ["#{ActiveFedora::SolrService.solr_name("system_create", :date)} asc"]}).and_return(mock_response)
   
       SolrSpecModel::Basic.find_with_conditions(:id=>"changeme:30").should equal(mock_response)
     end

data/spec/unit/solr_service_spec.rb

@@ -45,9 +45,9 @@ describe ActiveFedora::SolrService do
         def self.connection_for_pid(pid)
         end
       end
-      @sample_solr_hits = [{"id"=>"my:_PID1_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]},
-                            {"id"=>"my:_PID2_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]},
-                            {"id"=>"my:_PID3_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]}]
+      @sample_solr_hits = [{"id"=>"my:_PID1_", ActiveFedora::SolrService.solr_name("has_model", :symbol)=>["info:fedora/afmodel:AudioRecord"]},
+                            {"id"=>"my:_PID2_", ActiveFedora::SolrService.solr_name("has_model", :symbol)=>["info:fedora/afmodel:AudioRecord"]},
+                            {"id"=>"my:_PID3_", ActiveFedora::SolrService.solr_name("has_model", :symbol)=>["info:fedora/afmodel:AudioRecord"]}]
     end
     it "should use Repository.find to instantiate objects" do
       AudioRecord.should_receive(:find).with("my:_PID1_")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-fedora
 version: !ruby/object:Gem::Version
-  version: 5.5.0
+  version: 5.5.1
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-18 00:00:00.000000000 Z
+date: 2013-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rsolr
@@ -66,7 +66,7 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.1.0
   type: :runtime
@@ -74,7 +74,7 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.1.0
 - !ruby/object:Gem::Dependency
@@ -565,7 +565,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3492358049671334193
+      hash: 2863321787483919709
 requirements: []
 rubyforge_project: rubyfedora
 rubygems_version: 1.8.24