active-fedora 7.0.0.pre2 → 7.0.0.pre3

data/lib/active_fedora/solr_instance_loader.rb

@@ -66,13 +66,7 @@ module ActiveFedora
     end
 
     def active_fedora_class
-      @active_fedora_class ||= begin
-        if solr_doc[ActiveFedora::SolrService.solr_name('has_model', :symbol)]
-          ActiveFedora::SolrService.class_from_solr_document(solr_doc)
-        else
-          ActiveFedora::Base
-        end
-      end
+      @active_fedora_class ||= ActiveFedora::SolrService.class_from_solr_document(solr_doc)
     end
 
     def profile_json

data/lib/active_fedora/solr_service.rb

@@ -2,19 +2,12 @@ require 'rsolr'
 
 module ActiveFedora
   class SolrService 
+    extend Deprecation
     
     include Loggable
     
     attr_reader :conn
 
-    def self.register(host=nil, args={})
-      Thread.current[:solr_service]=self.new(host, args)
-    end
-
-    def self.reset!
-      Thread.current[:solr_service] = nil
-    end
-
     def initialize(host, args)
       host = 'http://localhost:8080/solr' unless host
       args = {:read_timeout => 120, :open_timeout => 120}.merge(args.dup)
@@ -22,120 +15,135 @@ module ActiveFedora
       @conn = RSolr.connect args
     end
     
-    def self.instance
-    # Register Solr
-        
-      unless Thread.current[:solr_service]
-        register(ActiveFedora.solr_config[:url])
+    class << self
+      def register(host=nil, args={})
+        Thread.current[:solr_service] = new(host, args)
       end
 
-      raise SolrNotInitialized unless Thread.current[:solr_service]
-      Thread.current[:solr_service]
-    end
+      def reset!
+        Thread.current[:solr_service] = nil
+      end
 
-    def self.lazy_reify_solr_results(solr_results, opts = {})
-      Enumerator.new do |yielder|
-        solr_results.each do |hit|
-          yielder.yield(reify_solr_result(hit, opts))
+      def instance
+      # Register Solr
+          
+        unless Thread.current[:solr_service]
+          register(ActiveFedora.solr_config[:url])
         end
+
+        raise SolrNotInitialized unless Thread.current[:solr_service]
+        Thread.current[:solr_service]
       end
-    end
-    
-    def self.reify_solr_results(solr_results, opts = {})
-      solr_results.collect {|hit| reify_solr_result(hit, opts)}
-    end
 
-    def self.reify_solr_result(hit, opts = {})
-      klass = class_from_solr_document(hit)
-      if opts[:load_from_solr]
-        klass.load_instance_from_solr(hit[SOLR_DOCUMENT_ID], hit)
-      else
-        klass.find(hit[SOLR_DOCUMENT_ID], cast: true)
+      def lazy_reify_solr_results(solr_results, opts = {})
+        Enumerator.new do |yielder|
+          solr_results.each do |hit|
+            yielder.yield(reify_solr_result(hit, opts))
+          end
+        end
+      end
+      
+      def reify_solr_results(solr_results, opts = {})
+        solr_results.collect {|hit| reify_solr_result(hit, opts)}
       end
-    end
-  
-    def self.class_from_solr_document(hit, opts = {})
-      #Set the default starting point to the class specified, if available.
-      best_model_match = Model.from_class_uri(opts[:class]) unless opts[:class].nil?
 
-      hit[solr_name("has_model", :symbol)].each do |value|
+      def reify_solr_result(hit, opts = {})
+        klass = class_from_solr_document(hit)
+        if opts[:load_from_solr]
+          klass.load_instance_from_solr(hit[SOLR_DOCUMENT_ID], hit)
+        else
+          klass.find(hit[SOLR_DOCUMENT_ID], cast: true)
+        end
+      end
+    
+      def class_from_solr_document(hit, opts = {})
+        #Set the default starting point to the class specified, if available.
+        best_model_match = Model.from_class_uri(opts[:class]) unless opts[:class].nil?
+        hit[HAS_MODEL_SOLR_FIELD].each do |value|
 
-        model_value = Model.from_class_uri(value)
+          model_value = Model.from_class_uri(value)
 
-        if model_value
+          if model_value
 
-          # Set as the first model in case opts[:class] was nil
-          best_model_match ||= model_value
+            # Set as the first model in case opts[:class] was nil
+            best_model_match ||= model_value
 
-          # If there is an inheritance structure, use the most specific case.
-          if best_model_match > model_value
-            best_model_match = model_value
+            # If there is an inheritance structure, use the most specific case.
+            if best_model_match > model_value
+              best_model_match = model_value
+            end
           end
         end
-      end
-
-      logger.warn "Could not find a model for #{hit["id"]}, defaulting to ActiveFedora::Base" unless best_model_match
-      best_model_match || ActiveFedora::Base
-    end
-    
-    # Construct a solr query for a list of pids
-    # This is used to get a solr response based on the list of pids in an object's RELS-EXT relationhsips
-    # If the pid_array is empty, defaults to a query of "id:NEVER_USE_THIS_ID", which will return an empty solr response
-    # @param [Array] pid_array the pids that you want included in the query
-    def self.construct_query_for_pids(pid_array)
 
-      q = pid_array.reject { |x| x.empty? }.map do |pid|
-        "_query_:\"{!raw f=#{SOLR_DOCUMENT_ID}}#{pid.gsub('"', '\"')}\""
+        logger.warn "Could not find a model for #{hit["id"]}, defaulting to ActiveFedora::Base" unless best_model_match
+        best_model_match || ActiveFedora::Base
+      end
+      
+      # Construct a solr query for a list of pids
+      # This is used to get a solr response based on the list of pids in an object's RELS-EXT relationhsips
+      # If the pid_array is empty, defaults to a query of "id:NEVER_USE_THIS_ID", which will return an empty solr response
+      # @param [Array] pid_array the pids that you want included in the query
+      def construct_query_for_pids(pid_array)
+        q = pid_array.reject { |x| x.empty? }.map { |pid| raw_query(SOLR_DOCUMENT_ID, pid) }
+
+        q.empty? ? "id:NEVER_USE_THIS_ID" : q.join(" OR ".freeze)
       end
 
-      return "id:NEVER_USE_THIS_ID" if q.empty?
+      # Create a raw query clause suitable for sending to solr as an fq element
+      # @param [String] key
+      # @param [String] value
+      def raw_query(key, value)
+        "_query_:\"{!raw f=#{key}}#{value.gsub('"', '\"')}\""
+      end
 
-      return q.join(" OR ")
-    end
+      def solr_name(*args)
+        Solrizer.default_field_mapper.solr_name(*args)
+      end
+      
+      def escape_uri_for_query(uri)
+        Deprecation.warn SolrService, "escape_uri_for_query is deprecated and will be removed in active-fedora 8.0.0. Use RSolr.escape instead."
+        RSolr.escape(uri)
+      end
+      
+      # Create a query with a clause for each key, value
+      # @param [Hash] args key is the predicate, value is the target_uri
+      def construct_query_for_rel(args)
+        clauses = args.map { |predicate, target_uri| raw_query(solr_name(predicate, :symbol), target_uri) }
+        clauses.join(" AND ".freeze)
+      end
 
-    def self.solr_name(*args)
-      Solrizer.default_field_mapper.solr_name(*args)
-    end
-    
-    def self.escape_uri_for_query(uri)
-      return uri.gsub(/(:)/, '\\:').gsub(/(\/)/, '\\/')
-    end
-    
-    # Create a query with a clause for each key, value
-    # @param [Hash] args key is the predicate, value is the target_uri
-    def self.construct_query_for_rel(args)
-      clauses = args.map do |predicate, target_uri|
-        "_query_:\"{!raw f=#{solr_name(predicate, :symbol)}}#{target_uri.gsub('"', '\"')}\""
+      def query(query, args={})
+        raw = args.delete(:raw)
+        args = args.merge(:q=>query, :qt=>'standard')
+        result = SolrService.instance.conn.get('select', :params=>args)
+        return result if raw
+        result['response']['docs']
       end
-      clauses.join(" AND ")
-    end
 
-    def self.query(query, args={})
-      raw = args.delete(:raw)
-      args = args.merge(:q=>query, :qt=>'standard')
-      result = SolrService.instance.conn.get('select', :params=>args)
-      return result if raw
-      result['response']['docs']
-    end
+      # Get the count of records that match the query
+      # @param [String] query a solr query 
+      # @param [Hash] args arguments to pass through to `args' param of SolrService.query (note that :rows will be overwritten to 0)
+      # @return [Integer] number of records matching
+      def count(query, args={})
+        args = args.merge(:raw=>true, :rows=>0)
+        SolrService.query(query, args)['response']['numFound'].to_i
+      end
 
-    # Get the count of records that match the query
-    # @param [String] query a solr query 
-    # @param [Hash] args arguments to pass through to `args' param of SolrService.query (note that :rows will be overwritten to 0)
-    # @return [Integer] number of records matching
-    def self.count(query, args={})
-      args = args.merge(:raw=>true, :rows=>0)
-      SolrService.query(query, args)['response']['numFound'].to_i
-    end
+      # @param [Hash] doc the document to index
+      # @param [Hash] params 
+      #   :commit => commits immediately
+      #   :softCommit => commit to memory, but don't flush to disk
+      def add(doc, params = {})
+        SolrService.instance.conn.add(doc, params: params)
+      end
 
-    def self.add(doc)
-      SolrService.instance.conn.add(doc)
+      def commit
+        SolrService.instance.conn.commit
+      end
     end
 
-    def self.commit
-      SolrService.instance.conn.commit
-    end
+    HAS_MODEL_SOLR_FIELD = solr_name("has_model", :symbol).freeze
 
-  
-end #SolrService
-class SolrNotInitialized < StandardError;end
+  end #SolrService
+  class SolrNotInitialized < StandardError;end
 end #ActiveFedora

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "7.0.0.pre2"
+  VERSION = "7.0.0.pre3"
 end

data/lib/generators/active_fedora/config/solr/templates/solr_conf/conf/schema.xml

@@ -7,6 +7,11 @@
   <uniqueKey>id</uniqueKey>
   
   <fields>
+    <!-- If you remove this field, you must _also_ disable the update log in solrconfig.xml
+    or Solr won't start. _version_ and update log are required for SolrCloud
+    --> 
+    <field name="_version_" type="long" indexed="true" stored="true"/>
+   
     <field name="id" type="string" stored="true" indexed="true" multiValued="false" required="true"/>
     <field name="timestamp" type="date" indexed="true" stored="true" default="NOW" multiValued="false"/>
     

data/lib/generators/active_fedora/config/solr/templates/solr_conf/conf/solrconfig.xml

@@ -16,6 +16,57 @@
   
   <dataDir>${solr.data.dir:}</dataDir>
 
+    <!-- The default high-performance update handler -->
+  <updateHandler class="solr.DirectUpdateHandler2">
+
+    <!-- Enables a transaction log, used for real-time get, durability, and
+         and solr cloud replica recovery.  The log can grow as big as
+         uncommitted changes to the index, so use of a hard autoCommit
+         is recommended (see below).
+         "dir" - the target directory for transaction logs, defaults to the
+                solr data directory.  --> 
+    <updateLog>
+      <str name="dir">${solr.ulog.dir:}</str>
+    </updateLog>
+ 
+    <!-- AutoCommit
+
+         Perform a hard commit automatically under certain conditions.
+         Instead of enabling autoCommit, consider using "commitWithin"
+         when adding documents. 
+
+         http://wiki.apache.org/solr/UpdateXmlMessages
+
+         maxDocs - Maximum number of documents to add since the last
+                   commit before automatically triggering a new commit.
+
+         maxTime - Maximum amount of time in ms that is allowed to pass
+                   since a document was added before automatically
+                   triggering a new commit. 
+         openSearcher - if false, the commit causes recent index changes
+           to be flushed to stable storage, but does not cause a new
+           searcher to be opened to make those changes visible.
+
+         If the updateLog is enabled, then it's highly recommended to
+         have some sort of hard autoCommit to limit the log size.
+      -->
+     <autoCommit> 
+       <maxTime>${solr.autoCommit.maxTime:15000}</maxTime> 
+       <openSearcher>false</openSearcher> 
+     </autoCommit>
+
+    <!-- softAutoCommit is like autoCommit except it causes a
+         'soft' commit which only ensures that changes are visible
+         but does not ensure that data is synced to disk.  This is
+         faster and more near-realtime friendly than a hard commit.
+      -->
+
+     <autoSoftCommit> 
+       <maxTime>${solr.autoSoftCommit.maxTime:-1}</maxTime> 
+     </autoSoftCommit>
+
+  </updateHandler>
+
   <requestHandler name="search" class="solr.SearchHandler" default="true">
     <!-- default values for query parameters can be specified, these
          will be overridden by parameters in the request

data/spec/integration/has_many_associations_spec.rb

@@ -188,6 +188,13 @@ describe "Deleting a dependent relationship" do
     item.delete
   end
 
+  it "should not save deleted objects" do
+    item.components << component
+    item.save!
+    c2 = Component.find(component.id)
+    c2.delete
+    item.delete
+  end
 end
 
 describe "Autosave" do

data/spec/integration/scoped_query_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe "scoped queries" do
-  
+
   before(:each) do 
     module ModelIntegrationSpec
       class Basic < ActiveFedora::Base

data/spec/integration/solr_service_spec.rb

@@ -36,7 +36,7 @@ describe ActiveFedora::SolrService do
       Object.send(:remove_const, :FooObject)
     end
     it "should return an array of objects that are of the class stored in active_fedora_model_s" do
-      query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
+      query = "id\:#{RSolr.escape(@test_object.pid)} OR id\:#{RSolr.escape(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result)
       result.length.should == 2
@@ -46,7 +46,7 @@ describe ActiveFedora::SolrService do
     end
     
     it 'should load objects from solr data if a :load_from_solr option is passed in' do
-      query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
+      query = "id\:#{RSolr.escape(@test_object.pid)} OR id\:#{RSolr.escape(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       result.length.should == 2
@@ -67,7 +67,7 @@ describe ActiveFedora::SolrService do
     end
     
     it 'should #reify a lightweight object as a new instance' do
-      query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
+      query = "id\:#{RSolr.escape(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
@@ -79,7 +79,7 @@ describe ActiveFedora::SolrService do
     end
     
     it 'should #reify! a lightweight object within the same instance' do
-      query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
+      query = "id\:#{RSolr.escape(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
@@ -90,7 +90,7 @@ describe ActiveFedora::SolrService do
     end
     
     it 'should raise an exception when attempting to reify a first-class object' do
-      query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
+      query = "id\:#{RSolr.escape(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
@@ -101,7 +101,7 @@ describe ActiveFedora::SolrService do
     end
   
     it 'should call load_instance_from_solr if :load_from_solr option passed in' do
-      query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
+      query = "id\:#{RSolr.escape(@test_object.pid)} OR id\:#{RSolr.escape(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
       ActiveFedora::Base.should_receive(:load_instance_from_solr).once
       FooObject.should_receive(:load_instance_from_solr).once

data/spec/unit/base_extra_spec.rb

@@ -9,8 +9,9 @@ describe ActiveFedora::Base do
   describe ".update_index" do
     before do
       mock_conn = double("SolrConnection")
-      mock_conn.should_receive(:add)
-      mock_conn.should_receive(:commit)
+      mock_conn.should_receive(:add) do |_, opts|
+        opts.should == {:params=>{:softCommit=>true}}
+      end
       mock_ss = double("SolrService")
       mock_ss.stub(:conn).and_return(mock_conn)
       ActiveFedora::SolrService.stub(:instance).and_return(mock_ss)
@@ -60,8 +61,7 @@ describe ActiveFedora::Base do
     it "should delete object from repository and index" do
       @test_object.inner_object.stub(:delete)
       mock_conn = double("SolrConnection")
-      mock_conn.should_receive(:delete_by_id).with(nil) 
-      mock_conn.should_receive(:commit)
+      mock_conn.should_receive(:delete_by_id).with(nil, {:params=>{"softCommit"=>true}}) 
       mock_ss = double("SolrService")
       mock_ss.stub(:conn).and_return(mock_conn)
       ActiveFedora::SolrService.stub(:instance).and_return(mock_ss)

data/spec/unit/base_spec.rb

@@ -203,13 +203,13 @@ describe ActiveFedora::Base do
     ### Methods for ActiveModel::Conversions
     it "should have to_param once it's saved" do
       @test_object.to_param.should be_nil
-      @test_object.inner_object.stub(:new? => false, :pid => 'foo:123')
+      @test_object.inner_object.stub(new_record?: false, pid: 'foo:123')
       @test_object.to_param.should == 'foo:123'
     end
 
     it "should have to_key once it's saved" do
       @test_object.to_key.should be_nil
-      @test_object.inner_object.stub(new?: false, pid: 'foo:123')
+      @test_object.inner_object.stub(new_record?: false, pid: 'foo:123')
       @test_object.to_key.should == ['foo:123']
     end