active-fedora 9.9.1 → 9.10.0.pre1

data/lib/active_fedora/scoping/named.rb

@@ -21,9 +21,17 @@ module ActiveFedora
           if current_scope
             current_scope.clone
           else
-            scope = relation
-            scope.default_scoped = true
-            scope
+            default_scoped
+          end
+        end
+
+        def default_scoped
+          scope = build_default_scope
+
+          if scope
+            relation.spawn.merge!(scope)
+          else
+            relation
           end
         end
       end

data/lib/active_fedora/simple_datastream.rb

@@ -79,7 +79,7 @@ module ActiveFedora
         next if field_key == :location ## FIXME HYDRA-825
         things = send(field_key)
         next unless things
-        field_symbol = ActiveFedora::SolrQueryBuilder.solr_name(field_key, type: field_info[:type])
+        field_symbol = ActiveFedora.index_field_mapper.solr_name(field_key, type: field_info[:type])
         things.val.each do |val|
           ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_symbol, val.to_s)
         end

data/lib/active_fedora/solr_hit.rb

@@ -0,0 +1,71 @@
+module ActiveFedora
+  class SolrHit < Delegator
+    def self.for(hit)
+      return hit if hit.is_a? ActiveFedora::SolrHit
+
+      SolrHit.new(hit)
+    end
+
+    delegate :models, to: :classifier
+
+    def __getobj__
+      @document # return object we are delegating to, required
+    end
+
+    alias static_config __getobj__
+
+    def __setobj__(obj)
+      @document = obj
+    end
+
+    attr_reader :document
+
+    def initialize(document)
+      super
+      @document = document
+    end
+
+    def id
+      document[ActiveFedora.id_field]
+    end
+
+    def rdf_uri
+      ::RDF::URI.new(ActiveFedora::Base.id_to_uri(id))
+    end
+
+    def model(opts = {})
+      best_model_match = classifier.best_model(opts)
+      ActiveFedora::Base.logger.warn "Could not find a model for #{id}, defaulting to ActiveFedora::Base" if ActiveFedora::Base.logger && best_model_match == ActiveFedora::Base
+      best_model_match
+    end
+
+    def model?(model_to_check)
+      models.any? do |model|
+        model_to_check >= model
+      end
+    end
+
+    def instantiate_with_json
+      model.allocate.init_with_json(profile_json) do |allocated_object|
+        create_key = allocated_object.indexing_service.class.create_time_solr_name
+        modified_key = allocated_object.indexing_service.class.modified_time_solr_name
+        allocated_object.resource.set_value(:create_date, DateTime.parse(document[create_key])) if document[create_key]
+        allocated_object.resource.set_value(:modified_date, DateTime.parse(document[modified_key])) if document[modified_key]
+      end
+    end
+
+    def reify(opts = {})
+      model(opts).find(id, cast: true)
+    end
+
+    private
+
+      def classifier
+        ActiveFedora.model_mapper.classifier(document)
+      end
+
+      def profile_json
+        Array(document[ActiveFedora::IndexingService.profile_solr_name]).first
+      end
+  end
+end

data/lib/active_fedora/solr_instance_loader.rb

@@ -12,13 +12,12 @@ module ActiveFedora
     def initialize(context, id, solr_doc = nil)
       @context = context
       @id = id
-      @solr_doc = solr_doc
-      validate_solr_doc_and_id!(@solr_doc)
+      self.solr_doc = solr_doc
     end
 
     def object
       return @object if @object
-      @object = allocate_object
+      @object = solr_doc.instantiate_with_json
       @object.readonly!
       @object.freeze
       @object
@@ -26,46 +25,23 @@ module ActiveFedora
 
     private
 
-      def allocate_object
-        active_fedora_class.allocate.init_with_json(profile_json) do |allocated_object|
-          create_key = allocated_object.indexing_service.class.create_time_solr_name
-          modified_key = allocated_object.indexing_service.class.modified_time_solr_name
-          allocated_object.resource.set_value(:create_date, DateTime.parse(solr_doc[create_key])) if solr_doc[create_key]
-          allocated_object.resource.set_value(:modified_date, DateTime.parse(solr_doc[modified_key])) if solr_doc[modified_key]
-        end
-      end
-
       def solr_doc
         @solr_doc ||= begin
-          result = context.find_with_conditions(id: id)
-          if result.empty?
-            raise ActiveFedora::ObjectNotFoundError, "Object #{id} not found in solr"
-          end
-          @solr_doc = result.first
-          validate_solr_doc_and_id!(@solr_doc)
-          @solr_doc
+          self.solr_doc = context.search_by_id(id)
         end
       end
 
-      def validate_solr_doc_and_id!(document)
-        return true if document.nil?
-        solr_id = document[SOLR_DOCUMENT_ID]
-        return if id == solr_id
-        raise ActiveFedora::FedoraSolrMismatchError, id, solr_id
-      end
-
-      def active_fedora_class
-        @active_fedora_class ||= ActiveFedora::QueryResultBuilder.class_from_solr_document(solr_doc)
+      def solr_doc=(solr_doc)
+        unless solr_doc.nil?
+          solr_doc = ActiveFedora::SolrHit.for(solr_doc)
+          validate_solr_doc_and_id!(solr_doc)
+          @solr_doc = solr_doc
+        end
       end
 
-      def profile_json
-        @profile_json ||= begin
-          profile_json = Array(solr_doc[ActiveFedora::IndexingService.profile_solr_name]).first
-          unless profile_json.present?
-            raise ActiveFedora::ObjectNotFoundError, "Object #{id} does not contain a solrized profile"
-          end
-          profile_json
-        end
+      def validate_solr_doc_and_id!(document)
+        return if id == document.id
+        raise ActiveFedora::FedoraSolrMismatchError, id, document.id
       end
   end
 end

data/lib/active_fedora/solr_query_builder.rb

@@ -1,6 +1,6 @@
 module ActiveFedora
   module SolrQueryBuilder
-    PARSED_SUFFIX = '_tesim'.freeze
+    extend Deprecation
 
     class << self
       # Construct a solr query for a list of ids
@@ -10,18 +10,21 @@ module ActiveFedora
       def construct_query_for_ids(id_array)
         ids = id_array.reject(&:blank?)
         return "id:NEVER_USE_THIS_ID" if ids.empty?
-        "{!terms f=#{SOLR_DOCUMENT_ID}}#{ids.join(',')}"
+        "{!terms f=#{ActiveFedora.id_field}}#{ids.join(',')}"
       end
 
       # 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)
+        Deprecation.warn(ActiveFedora::SolrQueryBuilder, 'ActiveFedora::SolrQueryBuilder.raw_query is deprecated and will be removed in ActiveFedora 10.0. Use .construct_query instead.')
         "_query_:\"{!raw f=#{key}}#{value.gsub('"', '\"')}\""
       end
 
+      # @deprecated
       def solr_name(*args)
-        Solrizer.default_field_mapper.solr_name(*args)
+        Deprecation.warn(ActiveFedora::SolrQueryBuilder, 'ActiveFedora::SolrQueryBuilder.solr_name is deprecated and will be removed in ActiveFedora 10.0. Use ActiveFedora.index_field_mapper.solr_name instead.')
+        ActiveFedora.index_field_mapper.solr_name(*args)
       end
 
       # Create a query with a clause for each key, value
@@ -29,9 +32,9 @@ module ActiveFedora
       # @param [String] join_with ('AND') the value we're joining the clauses with
       # @example
       #   construct_query_for_rel [[:has_model, "info:fedora/afmodel:ComplexCollection"], [:has_model, "info:fedora/afmodel:ActiveFedora_Base"]], 'OR'
-      #   # => _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ComplexCollection" OR _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ActiveFedora_Base"
+      #   # => _query_:"{!field f=has_model_ssim}info:fedora/afmodel:ComplexCollection" OR _query_:"{!field f=has_model_ssim}info:fedora/afmodel:ActiveFedora_Base"
       #
-      #   construct_query_for_rel [[Book.reflect_on_association(:library), "foo/bar/baz"]]
+      #   construct_query_for_rel [[Book._reflect_on_association(:library), "foo/bar/baz"]]
       def construct_query_for_rel(field_pairs, join_with = ' AND ')
         field_pairs = field_pairs.to_a if field_pairs.is_a? Hash
         construct_query(property_values_to_solr(field_pairs), join_with)
@@ -43,7 +46,7 @@ module ActiveFedora
       # @return [String] a solr query
       # @example
       #   construct_query([['library_id_ssim', '123'], ['owner_ssim', 'Fred']])
-      #   # => "_query_:\"{!raw f=library_id_ssim}123\" AND _query_:\"{!raw f=owner_ssim}Fred\""
+      #   # => "_query_:\"{!field f=library_id_ssim}123\" AND _query_:\"{!field f=owner_ssim}Fred\""
       def construct_query(field_pairs, join_with = ' AND ')
         pairs_to_clauses(field_pairs).join(join_with)
       end
@@ -66,12 +69,7 @@ module ActiveFedora
           values << nil if values.empty?
           values.map do |value|
             if value.present?
-              if parsed?(field)
-                # If you do a raw query on a parsed field you won't get the matches you expect.
-                "#{field}:#{solr_escape(value)}"
-              else
-                raw_query(field, value)
-              end
+              field_query(field, value)
             else
               # Check that the field is not present. In SQL: "WHERE field IS NULL"
               "-#{field}:[* TO *]"
@@ -79,16 +77,6 @@ module ActiveFedora
           end
         end
 
-        def parsed?(field)
-          field.end_with?(PARSED_SUFFIX)
-        end
-
-        # Adds esaping for spaces which are not handled by RSolr.solr_escape
-        # See rsolr/rsolr#101
-        def solr_escape(terms)
-          RSolr.solr_escape(terms).gsub(/\s+/, "\\ ")
-        end
-
         # Given a list of pairs (e.g. [field name, values]), convert the field names
         # to solr names
         # @param [Array<Array>] pairs a list of pairs of property name and values
@@ -97,8 +85,8 @@ module ActiveFedora
         #   property_values_to_solr([['library_id', '123'], ['owner', 'Fred']])
         #   # => [['library_id_ssim', '123'], ['owner_ssim', 'Fred']]
         def property_values_to_solr(pairs)
-          pairs.each_with_object([]) do |(property, value), list|
-            list << [solr_field(property), value]
+          pairs.map do |(property, value)|
+            [solr_field(property), value]
           end
         end
 
@@ -109,9 +97,16 @@ module ActiveFedora
           when ActiveFedora::Reflection::AssociationReflection
             field.solr_key
           else
-            solr_name(field, :symbol)
+            ActiveFedora.index_field_mapper.solr_name(field, :symbol)
           end
         end
+
+        # Create a raw query clause suitable for sending to solr as an fq element
+        # @param [String] key
+        # @param [String] value
+        def field_query(key, value)
+          "_query_:\"{!field f=#{key}}#{value.gsub('"', '\"')}\""
+        end
     end
   end
 end

data/lib/active_fedora/solr_service.rb

@@ -49,19 +49,19 @@ module ActiveFedora
       end
 
       def reify_solr_result(hit, opts = {})
-        Deprecation.warn SolrService, "SolrService.reify_solr_result is deprecated. Use QueryResultBuilder.reify_solr_result instead. This will be removed in active-fedora 10.0"
+        Deprecation.warn SolrService, "SolrService.reify_solr_result is deprecated. Use SolrHit#reify instead. This will be removed in active-fedora 10.0"
         QueryResultBuilder.reify_solr_result(hit, opts)
       end
 
       # Returns all possible classes for the solr object
       def classes_from_solr_document(hit, opts = {})
-        Deprecation.warn SolrService, "SolrService.classes_from_solr_document is deprecated. Use QueryResultBuilder.classes_from_solr_document instead. This will be removed in active-fedora 10.0"
+        Deprecation.warn SolrService, "SolrService.classes_from_solr_document is deprecated. Use SolrHit#models instead. This will be removed in active-fedora 10.0"
         QueryResultBuilder.classes_from_solr_document(hit, opts)
       end
 
       # Returns the best singular class for the solr object
       def class_from_solr_document(hit, opts = {})
-        Deprecation.warn SolrService, "SolrService.class_from_solr_document is deprecated. Use QueryResultBuilder.class_from_solr_document instead. This will be removed in active-fedora 10.0"
+        Deprecation.warn SolrService, "SolrService.class_from_solr_document is deprecated. Use SolrHit#model instead. This will be removed in active-fedora 10.0"
         QueryResultBuilder.class_from_solr_document(hit, opts)
       end
 
@@ -83,8 +83,8 @@ module ActiveFedora
       # @param [String] key
       # @param [String] value
       def raw_query(key, value)
-        Deprecation.warn SolrService, "SolrService.raw_query is deprecated. Use SolrQueryBuilder.raw_query instead. This will be removed in active-fedora 10.0"
-        SolrQueryBuilder.raw_query(key, value)
+        Deprecation.warn SolrService, "SolrService.raw_query is deprecated. Use SolrQueryBuilder.construct_query instead. This will be removed in active-fedora 10.0"
+        SolrQueryBuilder.construct_query(key, value)
       end
 
       def solr_name(*args)
@@ -97,20 +97,31 @@ module ActiveFedora
       # @param [String] join_with ('AND') the value we're joining the clauses with
       # @example
       #   construct_query_for_rel [[:has_model, "info:fedora/afmodel:ComplexCollection"], [:has_model, "info:fedora/afmodel:ActiveFedora_Base"]], 'OR'
-      #   # => _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ComplexCollection" OR _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ActiveFedora_Base"
+      #   # => _query_:"{!field f=has_model_ssim}info:fedora/afmodel:ComplexCollection" OR _query_:"{!field f=has_model_ssim}info:fedora/afmodel:ActiveFedora_Base"
       #
-      #   construct_query_for_rel [[Book.reflect_on_association(:library), "foo/bar/baz"]]
+      #   construct_query_for_rel [[Book._reflect_on_association(:library), "foo/bar/baz"]]
       def construct_query_for_rel(field_pairs, join_with = 'AND')
         Deprecation.warn SolrService, "SolrService.construct_query_for_rel is deprecated. Use SolrQueryBuilder.construct_query_for_rel instead. This will be removed in active-fedora 10.0"
         SolrQueryBuilder.construct_query_for_rel(field_pairs, join_with)
       end
 
+      def get(query, args = {})
+        args = args.merge(q: query, qt: 'standard')
+        SolrService.instance.conn.get(select_path, params: args)
+      end
+
       def query(query, args = {})
         raw = args.delete(:raw)
-        args = args.merge(q: query, qt: 'standard')
-        result = SolrService.instance.conn.get(select_path, params: args)
-        return result if raw
-        result['response']['docs']
+        result = get(query, args)
+
+        if raw
+          Deprecation.warn SolrService, "SolrService.query with raw: true is deprecated. Use SolrService.get instead. This will be removed in active-fedora 10.0"
+          return result
+        end
+
+        result['response']['docs'].map do |doc|
+          ActiveFedora::SolrHit.new(doc)
+        end
       end
 
       def delete(id)
@@ -122,8 +133,8 @@ module ActiveFedora
       # @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
+        args = args.merge(rows: 0)
+        SolrService.get(query, args)['response']['numFound'].to_i
       end
 
       # @param [Hash] doc the document to index

data/lib/active_fedora/type.rb

@@ -0,0 +1,8 @@
+
+require 'active_fedora/type/value'
+require 'active_fedora/type/boolean'
+
+module ActiveFedora
+  module Type
+  end
+end

data/lib/active_fedora/type/boolean.rb

@@ -0,0 +1,23 @@
+# DO NOT EDIT THIS FILE
+# Plucked from ActiveModel::Type::Boolean in Rails 5
+module ActiveFedora
+  module Type
+    class Boolean < Value # :nodoc:
+      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].to_set
+
+      def type
+        :boolean
+      end
+
+      private
+
+        def cast_value(value)
+          if value == ''
+            nil
+          else
+            !FALSE_VALUES.include?(value)
+          end
+        end
+    end
+  end
+end

data/lib/active_fedora/type/value.rb

@@ -0,0 +1,118 @@
+# DO NOT EDIT THIS FILE
+# Plucked from ActiveModel::Type::Boolean in Rails 5
+module ActiveFedora
+  module Type
+    class Value
+      attr_reader :precision, :scale, :limit
+
+      def initialize(precision: nil, limit: nil, scale: nil)
+        @precision = precision
+        @scale = scale
+        @limit = limit
+      end
+
+      def type # :nodoc:
+      end
+
+      # Converts a value from database input to the appropriate ruby type. The
+      # return value of this method will be returned from
+      # ActiveRecord::AttributeMethods::Read#read_attribute. The default
+      # implementation just calls Value#cast.
+      #
+      # +value+ The raw input, as provided from the database.
+      def deserialize(value)
+        cast(value)
+      end
+
+      # Type casts a value from user input (e.g. from a setter). This value may
+      # be a string from the form builder, or a ruby object passed to a setter.
+      # There is currently no way to differentiate between which source it came
+      # from.
+      #
+      # The return value of this method will be returned from
+      # ActiveRecord::AttributeMethods::Read#read_attribute. See also:
+      # Value#cast_value.
+      #
+      # +value+ The raw input, as provided to the attribute setter.
+      def cast(value)
+        cast_value(value) unless value.nil?
+      end
+
+      # Casts a value from the ruby type to a type that the database knows how
+      # to understand. The returned value from this method should be a
+      # +String+, +Numeric+, +Date+, +Time+, +Symbol+, +true+, +false+, or
+      # +nil+.
+      def serialize(value)
+        value
+      end
+
+      # Type casts a value for schema dumping. This method is private, as we are
+      # hoping to remove it entirely.
+      def type_cast_for_schema(value) # :nodoc:
+        value.inspect
+      end
+
+      # These predicates are not documented, as I need to look further into
+      # their use, and see if they can be removed entirely.
+      def binary? # :nodoc:
+        false
+      end
+
+      # Determines whether a value has changed for dirty checking. +old_value+
+      # and +new_value+ will always be type-cast. Types should not need to
+      # override this method.
+      def changed?(old_value, new_value, _new_value_before_type_cast)
+        old_value != new_value
+      end
+
+      # Determines whether the mutable value has been modified since it was
+      # read. Returns +false+ by default. If your type returns an object
+      # which could be mutated, you should override this method. You will need
+      # to either:
+      #
+      # - pass +new_value+ to Value#serialize and compare it to
+      #   +raw_old_value+
+      #
+      # or
+      #
+      # - pass +raw_old_value+ to Value#deserialize and compare it to
+      #   +new_value+
+      #
+      # +raw_old_value+ The original value, before being passed to
+      # +deserialize+.
+      #
+      # +new_value+ The current value, after type casting.
+      def changed_in_place?(_raw_old_value, _new_value)
+        false
+      end
+
+      def map(value) # :nodoc:
+        yield value
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          precision == other.precision &&
+          scale == other.scale &&
+          limit == other.limit
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, precision, scale, limit].hash
+      end
+
+      def assert_valid_value(*)
+      end
+
+      private
+
+        # Convenience method for types which do not need separate type casting
+        # behavior for user and database inputs. Called by Value#cast for
+        # values except +nil+.
+        def cast_value(value) # :doc:
+          value
+        end
+    end
+  end
+end