active-fedora 9.9.1 → 9.10.0.pre1

data/lib/active_fedora/query_result_builder.rb

@@ -1,50 +1,34 @@
 module ActiveFedora
   module QueryResultBuilder
     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))
-        end
+      return to_enum(:lazy_reify_solr_results, solr_results, opts) unless block_given?
+
+      solr_results.each do |hit|
+        yield ActiveFedora::SolrHit.for(hit).reify(opts)
       end
     end
 
     def self.reify_solr_results(solr_results, opts = {})
-      solr_results.collect { |hit| reify_solr_result(hit, opts) }
+      lazy_reify_solr_results(solr_results, opts).to_a
     end
 
     def self.reify_solr_result(hit, _opts = {})
-      klass = class_from_solr_document(hit)
-      klass.find(hit[SOLR_DOCUMENT_ID], cast: true)
+      Deprecation.warn(ActiveFedora::Base, 'ActiveFedora::QueryResultBuilder.reify_solr_result is deprecated and will be removed in ActiveFedora 10.0; call #reify on the SolrHit instead.')
+      ActiveFedora::SolrHit.for(hit).reify
     end
 
     # Returns all possible classes for the solr object
     def self.classes_from_solr_document(hit, _opts = {})
-      classes = []
-
-      hit[HAS_MODEL_SOLR_FIELD].each { |value| classes << Model.from_class_uri(value) }
-
-      classes.compact
+      Deprecation.warn(ActiveFedora::Base, 'ActiveFedora::QueryResultBuilder.classes_from_solr_document is deprecated and will be removed in ActiveFedora 10.0; call #models on the SolrHit instead.')
+      ActiveFedora::SolrHit.for(hit).models
     end
 
     # Returns the best singular class for the solr object
     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?
-      Array(hit[HAS_MODEL_SOLR_FIELD]).each do |value|
-        model_value = Model.from_class_uri(value)
-        next unless 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.
-        best_model_match = model_value if best_model_match > model_value
-      end
-
-      ActiveFedora::Base.logger.warn "Could not find a model for #{hit['id']}, defaulting to ActiveFedora::Base" if ActiveFedora::Base.logger && !best_model_match
-      best_model_match || ActiveFedora::Base
+      Deprecation.warn(ActiveFedora::Base, 'ActiveFedora::QueryResultBuilder.class_from_solr_document is deprecated and will be removed in ActiveFedora 10.0; call #model on the SolrHit instead.')
+      ActiveFedora::SolrHit.for(hit).model(opts)
     end
 
-    HAS_MODEL_SOLR_FIELD = SolrQueryBuilder.solr_name("has_model", :symbol).freeze
+    HAS_MODEL_SOLR_FIELD = ActiveFedora.index_field_mapper.solr_name("has_model", :symbol).freeze
   end
 end

data/lib/active_fedora/querying.rb

@@ -1,7 +1,7 @@
 module ActiveFedora
   module Querying
     delegate :find, :first, :exists?, :where, :limit, :offset, :order, :delete_all,
-             :destroy_all, :count, :last, :find_with_conditions, :find_in_batches, :find_each, to: :all
+             :destroy_all, :count, :last, :find_with_conditions, :find_in_batches, :search_with_conditions, :search_in_batches, :search_by_id, :find_each, to: :all
 
     def self.extended(base)
       base.class_attribute :solr_query_handler

data/lib/active_fedora/rdf/datastream_indexing.rb

@@ -13,7 +13,7 @@ module ActiveFedora::RDF
       config = self.class.config_for_term_or_uri(field)
       return nil unless config && config.behaviors # punt on index names for deep nodes!
       config.behaviors.each do |behavior|
-        result = ActiveFedora::SolrQueryBuilder.solr_name(apply_prefix(field, file_path), behavior, type: config.type)
+        result = ActiveFedora.index_field_mapper.solr_name(apply_prefix(field, file_path), behavior, type: config.type)
         return result if Solrizer::DefaultDescriptors.send(behavior).evaluate_suffix(:text).stored?
       end
       raise RuntimeError "no stored fields were found"

data/lib/active_fedora/reflection.rb

@@ -50,10 +50,10 @@ module ActiveFedora
 
       # Returns the AssociationReflection object for the +association+ (use the symbol).
       #
-      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
-      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      #   Account._reflect_on_association(:owner)             # returns the owner AssociationReflection
+      #   Invoice._reflect_on_association(:line_items).macro  # returns :has_many
       #
-      def reflect_on_association(association)
+      def _reflect_on_association(association)
         val = reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
         unless val
           # When a has_many is paired with a has_and_belongs_to_many the assocation will have a plural name
@@ -92,7 +92,7 @@ module ActiveFedora
       #     has_many :books
       #   end
       #
-      #   Author.reflect_on_association(:books).klass
+      #   Author._reflect_on_association(:books).klass
       #   # => Book
       #
       # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
@@ -110,6 +110,12 @@ module ActiveFedora
         @automatic_inverse_of = nil
       end
 
+      def autosave=(autosave)
+        @options[:autosave] = autosave
+        parent_reflection = self.parent_reflection
+        parent_reflection.autosave = autosave if parent_reflection
+      end
+
       # Returns a new, unsaved instance of the associated class. +options+ will
       # be passed to the class's constructor.
       def build_association(*options, &block)
@@ -171,6 +177,8 @@ module ActiveFedora
     # Holds all the meta-data about an association as it was specified in the
     # Active Record class.
     class AssociationReflection < MacroReflection #:nodoc:
+      attr_accessor :parent_reflection # Reflection
+
       def initialize(macro, name, options, active_fedora)
         super
         @collection = [:has_many, :has_and_belongs_to_many, :directly_contains, :indirectly_contains].include?(macro)
@@ -198,7 +206,7 @@ module ActiveFedora
 
       def solr_key
         @solr_key ||= begin
-          ActiveFedora::SolrQueryBuilder.solr_name(predicate_for_solr, :symbol)
+          ActiveFedora.index_field_mapper.solr_name(predicate_for_solr, :symbol)
         end
       end
 
@@ -226,7 +234,7 @@ module ActiveFedora
       def inverse_of
         return unless inverse_name
 
-        @inverse_of ||= klass.reflect_on_association inverse_name
+        @inverse_of ||= klass._reflect_on_association inverse_name
       end
 
       # Returns whether or not the association should be validated as part of
@@ -299,7 +307,7 @@ module ActiveFedora
             inverse_name = ActiveSupport::Inflector.underscore(options[:as] || active_fedora.name.demodulize).to_sym
 
             begin
-              reflection = klass.reflect_on_association(inverse_name)
+              reflection = klass._reflect_on_association(inverse_name)
             rescue NameError
               # Give up: we couldn't compute the klass type so we won't be able
               # to find any associations either.

data/lib/active_fedora/relation.rb

@@ -62,6 +62,23 @@ module ActiveFedora
       @records
     end
 
+    # Scope all queries to the current scope.
+    #
+    #   Comment.where(post_id: 1).scoping do
+    #     Comment.first
+    #   end
+    #   # => SELECT "comments".* FROM "comments" WHERE "comments"."post_id" = 1 ORDER BY "comments"."id" ASC LIMIT 1
+    #
+    # Please check unscoped if you want to remove all previous scopes (including
+    # the default_scope) during the execution of a block.
+    def scoping
+      previous = klass.current_scope
+      klass.current_scope = self
+      yield
+    ensure
+      klass.current_scope = previous
+    end
+
     def ==(other)
       case other
       when Relation

data/lib/active_fedora/relation/calculations.rb

@@ -8,11 +8,7 @@ module ActiveFedora
       opts[:rows] = limit_value if limit_value
       opts[:sort] = order_values if order_values
 
-      calculate :count, where_values, opts
-    end
-
-    def calculate(_calculation, conditions, _opts = {})
-      SolrService.query(create_query(conditions), raw: true, rows: 0).fetch('response'.freeze)['numFound'.freeze]
+      SolrService.count(create_query(where_values))
     end
   end
 end

data/lib/active_fedora/relation/finder_methods.rb

@@ -87,7 +87,7 @@ module ActiveFedora
       return false unless conditions
       case conditions
       when Hash
-        find_with_conditions(conditions, rows: 1).present?
+        search_with_conditions(conditions, rows: 1).present?
       when String
         find(conditions).present?
       else
@@ -102,15 +102,35 @@ module ActiveFedora
     # hash representing the query part of an solr statement. If a hash is
     # provided, this method will generate conditions based simple equality
     # combined using the boolean AND operator.
-    # @param[Hash] options
+    # @param [Hash] options
     # @option opts [Array] :sort a list of fields to sort by
     # @option opts [Array] :rows number of rows to return
-    def find_with_conditions(conditions, opts = {})
+    def search_with_conditions(conditions, opts = {})
       # set default sort to created date ascending
       opts[:sort] = @klass.default_sort_params unless opts.include?(:sort)
       SolrService.query(create_query(conditions), opts)
     end
 
+    # Returns a single solr hit matching the given id
+    # @param [String] id document id
+    # @param [Hash] opts
+    def search_by_id(id, opts = {})
+      opts[:rows] = 1
+      result = search_with_conditions({ id: id }, opts)
+
+      if result.empty?
+        raise ActiveFedora::ObjectNotFoundError, "Object #{id} not found in solr"
+      end
+
+      result.first
+    end
+
+    # @deprecated
+    def find_with_conditions(*args)
+      Deprecation.warn(ActiveFedora::Base, '.find_with_conditions is deprecated and will be removed in active-fedora 10.0; use .search_with_conditions instead')
+      search_with_conditions(*args)
+    end
+
     # Yields the found ActiveFedora::Base object to the passed block
     #
     # @param [Hash] conditions the conditions for the solr search to match
@@ -118,12 +138,12 @@ module ActiveFedora
     # @option opts [Boolean] :cast (true) when true, examine the model and cast it to the first known cModel
     def find_each(conditions = {}, opts = {})
       cast = opts.delete(:cast)
-      find_in_batches(conditions, opts.merge(fl: SOLR_DOCUMENT_ID)) do |group|
+      search_in_batches(conditions, opts.merge(fl: ActiveFedora.id_field)) do |group|
         group.each do |hit|
           begin
-            yield(load_from_fedora(hit[SOLR_DOCUMENT_ID], cast))
+            yield(load_from_fedora(hit[ActiveFedora.id_field], cast))
           rescue Ldp::Gone
-            ActiveFedora::Base.logger.error "Although #{hit[SOLR_DOCUMENT_ID]} was found in Solr, it doesn't seem to exist in Fedora. The index is out of synch." if ActiveFedora::Base.logger
+            ActiveFedora::Base.logger.error "Although #{hit[ActiveFedora.id_field]} was found in Solr, it doesn't seem to exist in Fedora. The index is out of synch." if ActiveFedora::Base.logger
           end
         end
       end
@@ -140,11 +160,10 @@ module ActiveFedora
     # @option opts [Array] :rows number of rows to return
     #
     # @example
-    #  Person.find_in_batches('age_t'=>'21', {:batch_size=>50}) do |group|
+    #  Person.search_in_batches('age_t'=>'21', {:batch_size=>50}) do |group|
     #  group.each { |person| puts person['name_t'] }
     #  end
-
-    def find_in_batches(conditions, opts = {})
+    def search_in_batches(conditions, opts = {})
       opts[:q] = create_query(conditions)
       opts[:qt] = @klass.solr_query_handler
       # set default sort to created date ascending
@@ -163,6 +182,12 @@ module ActiveFedora
       end
     end
 
+    # @deprecated
+    def find_in_batches(*args)
+      Deprecation.warn(ActiveFedora::Base, '.find_in_batches is deprecated and will be removed in active-fedora 10.0; use .search_in_batches instead')
+      search_in_batches(*args)
+    end
+
     # Retrieve the Fedora object with the given id, explore the returned object
     # Raises a ObjectNotFoundError if the object is not found.
     # @param [String] id of the object to load
@@ -174,7 +199,7 @@ module ActiveFedora
       if where_values.empty?
         load_from_fedora(id, cast)
       else
-        conditions = where_values + [ActiveFedora::SolrQueryBuilder.raw_query(SOLR_DOCUMENT_ID, id)]
+        conditions = where_values + [ActiveFedora::SolrQueryBuilder.construct_query(ActiveFedora.id_field => id)]
         query = conditions.join(" AND ".freeze)
         to_enum(:find_each, query, {}).to_a.first
       end
@@ -193,8 +218,7 @@ module ActiveFedora
         if @klass == ActiveFedora::Base && cast == false
           ActiveFedora::Base
         else
-          # The true class may be a subclass of @klass, so always use from_class_uri
-          resource_class = Model.from_class_uri(has_model_value(resource)) || ActiveFedora::Base
+          resource_class = has_model_value(resource)
           unless equivalent_class?(resource_class)
             raise ActiveFedora::ActiveFedoraError, "Model mismatch. Expected #{@klass}. Got: #{resource_class}"
           end
@@ -203,18 +227,7 @@ module ActiveFedora
       end
 
       def has_model_value(resource)
-        best_model_match = nil
-
-        resource.graph.query([nil, ActiveFedora::RDF::Fcrepo::Model.hasModel, nil]).each do |rg|
-          model_value = Model.from_class_uri(rg.object.to_s)
-          next unless model_value
-          best_model_match ||= model_value
-
-          # If there is an inheritance structure, use the most specific case.
-          best_model_match = model_value if best_model_match > model_value
-        end
-
-        best_model_match.to_s
+        ActiveFedora.model_mapper.classifier(resource).best_model
       end
 
       def equivalent_class?(other_class)
@@ -276,9 +289,9 @@ module ActiveFedora
       def field_name_for(key)
         if @klass.delegated_attributes.key?(key)
           # TODO: Check to see if `key' is a possible solr field for this class, if it isn't try :searchable instead
-          ActiveFedora::SolrQueryBuilder.solr_name(key, :stored_searchable, type: :string)
+          ActiveFedora.index_field_mapper.solr_name(key, :stored_searchable, type: :string)
         elsif key == :id
-          SOLR_DOCUMENT_ID
+          ActiveFedora.id_field
         else
           key.to_s
         end

data/lib/active_fedora/scoping.rb

@@ -14,6 +14,11 @@ module ActiveFedora
       def current_scope=(scope) #:nodoc:
         Thread.current["#{self}_current_scope"] = scope
       end
+
+      # Are there attributes associated with this scope?
+      def scope_attributes? # :nodoc:
+        current_scope
+      end
     end
   end
 end

data/lib/active_fedora/scoping/default.rb

@@ -3,6 +3,14 @@ module ActiveFedora
     module Default
       extend ActiveSupport::Concern
 
+      included do
+        class_attribute :default_scopes, instance_writer: false, instance_predicate: false
+        class_attribute :default_scope_override, instance_writer: false, instance_predicate: false
+
+        self.default_scopes = []
+        self.default_scope_override = nil
+      end
+
       module ClassMethods
         # Returns a scope for the model without the +default_scope+.
         #
@@ -32,6 +40,111 @@ module ActiveFedora
         def unscoped
           block_given? ? relation.scoping { yield } : relation
         end
+
+        # Are there attributes associated with this scope?
+        def scope_attributes? # :nodoc:
+          super || default_scopes.any? || respond_to?(:default_scope)
+        end
+
+        protected
+
+          # Use this macro in your model to set a default scope for all operations on
+          # the model.
+          #
+          #   class Article < ActiveRecord::Base
+          #     default_scope { where(published: true) }
+          #   end
+          #
+          #   Article.all # => SELECT * FROM articles WHERE published = true
+          #
+          # The #default_scope is also applied while creating/building a record.
+          # It is not applied while updating a record.
+          #
+          #   Article.new.published    # => true
+          #   Article.create.published # => true
+          #
+          # (You can also pass any object which responds to +call+ to the
+          # +default_scope+ macro, and it will be called when building the
+          # default scope.)
+          #
+          # If you use multiple #default_scope declarations in your model then
+          # they will be merged together:
+          #
+          #   class Article < ActiveRecord::Base
+          #     default_scope { where(published: true) }
+          #     default_scope { where(rating: 'G') }
+          #   end
+          #
+          #   Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'
+          #
+          # This is also the case with inheritance and module includes where the
+          # parent or module defines a #default_scope and the child or including
+          # class defines a second one.
+          #
+          # If you need to do more complex things with a default scope, you can
+          # alternatively define it as a class method:
+          #
+          #   class Article < ActiveRecord::Base
+          #     def self.default_scope
+          #       # Should return a scope, you can call 'super' here etc.
+          #     end
+          #   end
+          def default_scope(scope = nil)
+            scope = Proc.new if block_given?
+
+            if scope.is_a?(Relation) || !scope.respond_to?(:call)
+              raise ArgumentError,
+                    "Support for calling #default_scope without a block is removed. For example instead " \
+                    "of `default_scope where(color: 'red')`, please use " \
+                    "`default_scope { where(color: 'red') }`. (Alternatively you can just redefine " \
+                    "self.default_scope.)"
+            end
+
+            self.default_scopes += [scope]
+          end
+
+          def build_default_scope(base_rel = nil) # :nodoc:
+            return if abstract_class?
+
+            if default_scope_override.nil?
+              self.default_scope_override = !Base.is_a?(method(:default_scope).owner)
+            end
+
+            if default_scope_override
+              # The user has defined their own default scope method, so call that
+              evaluate_default_scope { default_scope }
+            elsif default_scopes.any?
+              base_rel ||= relation
+              evaluate_default_scope do
+                default_scopes.inject(base_rel) do |default_scope, scope|
+                  scope = scope.respond_to?(:to_proc) ? scope : scope.method(:call)
+                  default_scope.merge(base_rel.instance_exec(&scope))
+                end
+              end
+            end
+          end
+
+          def ignore_default_scope? # :nodoc:
+            Thread.current["#{self}_ignore_default_scope"]
+          end
+
+          def ignore_default_scope=(ignore) # :nodoc:
+            Thread.current["#{self}_ignore_default_scope"] = ignore
+          end
+
+          # The ignore_default_scope flag is used to prevent an infinite recursion
+          # situation where a default scope references a scope which has a default
+          # scope which references a scope...
+          def evaluate_default_scope # :nodoc:
+            return if ignore_default_scope?
+
+            begin
+              self.ignore_default_scope = true
+              yield
+            ensure
+              self.ignore_default_scope = false
+            end
+          end
       end
     end
   end