active-fedora 9.9.1 → 9.10.0.pre1

data/lib/active_fedora/indexing_service.rb

@@ -16,15 +16,15 @@ module ActiveFedora
     end
 
     def self.profile_solr_name
-      @profile_solr_name ||= ActiveFedora::SolrQueryBuilder.solr_name("object_profile", :displayable)
+      @profile_solr_name ||= ActiveFedora.index_field_mapper.solr_name("object_profile", :displayable)
     end
 
     def self.create_time_solr_name
-      @create_time_solr_name ||= ActiveFedora::SolrQueryBuilder.solr_name('system_create', :stored_sortable, type: :date)
+      @create_time_solr_name ||= ActiveFedora.index_field_mapper.solr_name('system_create', :stored_sortable, type: :date)
     end
 
     def self.modified_time_solr_name
-      @modified_time_solr_name ||= ActiveFedora::SolrQueryBuilder.solr_name('system_modified', :stored_sortable, type: :date)
+      @modified_time_solr_name ||= ActiveFedora.index_field_mapper.solr_name('system_modified', :stored_sortable, type: :date)
     end
 
     def rdf_service
@@ -40,7 +40,7 @@ module ActiveFedora
       Solrizer.set_field(solr_doc, 'system_modified', m_time, :stored_sortable)
       Solrizer.set_field(solr_doc, 'active_fedora_model', object.class.inspect, :stored_sortable)
       solr_doc[QueryResultBuilder::HAS_MODEL_SOLR_FIELD] = object.has_model
-      solr_doc[SOLR_DOCUMENT_ID.to_sym] = object.id
+      solr_doc[ActiveFedora.id_field.to_sym] = object.id
       solr_doc[self.class.profile_solr_name] = profile_service.new(object).export
       object.declared_attached_files.each do |name, file|
         solr_doc.merge! file.to_solr(solr_doc, name: name.to_s)

data/lib/active_fedora/ldp_resource.rb

@@ -16,6 +16,7 @@ module ActiveFedora
     # @param [RDF::Graph] original_graph The graph returned by the LDP server
     # @return [RDF::Graph] A graph striped of any inlined resources present in the original
     def build_graph(original_graph)
+      Deprecation.warn(ActiveFedora::LdpResource, '#build_graph is deprecated and will be removed in active-fedora 10.0')
       inlined_resources = get.graph.query(predicate: Ldp.contains).map(&:object)
 
       # ActiveFedora always wants to copy the resources to a new graph because it

data/lib/active_fedora/model.rb

@@ -1,29 +1,31 @@
-SOLR_DOCUMENT_ID = "id".freeze unless defined?(SOLR_DOCUMENT_ID)
-
 module ActiveFedora
   # = ActiveFedora
   # This module mixes various methods into the including class,
   # much in the way ActiveRecord does.
   module Model
+    # @deprecated
+    # Convenience method for getting class constant based on a string
+    # @example
+    #   ActiveFedora::Model.class_from_string("Om")
+    #   => Om
+    #   ActiveFedora::Model.class_from_string("ActiveFedora::RdfNode::TermProxy")
+    #   => ActiveFedora::RdfNode::TermProxy
+    # @example Search within ActiveFedora::RdfNode for a class called "TermProxy"
+    #   ActiveFedora::Model.class_from_string("TermProxy", ActiveFedora::RdfNode)
+    #   => ActiveFedora::RdfNode::TermProxy
+    def self.class_from_string(*args)
+      Deprecation.warn("ActiveFedora::Model.class_from_string has been deprecated and will be removed in ActiveFedora 10.0. Use ActiveFedora::ModelClassifier.class_from_string instead")
+      ActiveFedora::ModelClassifier.class_from_string(*args)
+    end
+
+    # @deprecated
     # Takes a Fedora URI for a cModel, and returns a
     # corresponding Model if available
     # This method should reverse ClassMethods#to_class_uri
     # @return [Class, False] the class of the model or false, if it does not exist
     def self.from_class_uri(model_value)
-      unless class_exists?(model_value)
-        ActiveFedora::Base.logger.warn "'#{model_value}' is not a real class" if ActiveFedora::Base.logger
-        return nil
-      end
-      ActiveFedora.class_from_string(model_value)
-    end
-
-    def self.class_exists?(class_name)
-      return false if class_name.empty?
-      klass = class_name.constantize
-      return klass.is_a?(Class)
-    rescue NameError
-      return false
+      Deprecation.warn("ActiveFedora::Model.from_class_uri has been deprecated and will be removed in ActiveFedora 10.0. Use ActiveFedora::ModelClassifier.from_class_uri instead")
+      ActiveFedora::ModelClassifier.new(Array(model_value)).best_model
     end
-    private_class_method :class_exists?
   end
 end

data/lib/active_fedora/model_classifier.rb

@@ -0,0 +1,77 @@
+module ActiveFedora
+  # Translate model names to classes
+  class ModelClassifier
+    # Convenience method for getting class constant based on a string
+    # @example
+    #   ActiveFedora::Model.class_from_string("Om")
+    #   => Om
+    #   ActiveFedora::Model.class_from_string("ActiveFedora::RdfNode::TermProxy")
+    #   => ActiveFedora::RdfNode::TermProxy
+    # @example Search within ActiveFedora::RdfNode for a class called "TermProxy"
+    #   ActiveFedora::Model.class_from_string("TermProxy", ActiveFedora::RdfNode)
+    #   => ActiveFedora::RdfNode::TermProxy
+    def self.class_from_string(full_class_name, container_class = Kernel)
+      container_class = container_class.name if container_class.is_a? Module
+      container_parts = container_class.split('::')
+      (container_parts + full_class_name.split('::')).flatten.inject(Kernel) do |mod, class_name|
+        if mod == Kernel
+          Object.const_get(class_name)
+        elsif mod.const_defined? class_name.to_sym
+          mod.const_get(class_name)
+        else
+          container_parts.pop
+          class_from_string(class_name, container_parts.join('::'))
+        end
+      end
+    end
+
+    attr_reader :class_names, :default
+
+    def initialize(class_names, default: ActiveFedora::Base)
+      @class_names = Array(class_names)
+      @default = default
+    end
+
+    ##
+    # Convert all the provided class names to class instances
+    def models
+      class_names.map do |uri|
+        classify(uri)
+      end.compact
+    end
+
+    ##
+    # Select the "best" class from the list of class names. We define
+    #    the "best" class as:
+    #     - a subclass of the given default, base class
+    #     - preferring subclasses over the parent class
+    def best_model(opts = {})
+      best_model_match = opts.fetch(:default, default)
+
+      models.each do |model_value|
+        # If there is an inheritance structure, use the most specific case.
+        best_model_match = model_value if best_model_match.nil? || best_model_match > model_value
+      end
+
+      best_model_match
+    end
+
+    private
+
+      def classify(model_value)
+        unless class_exists?(model_value)
+          ActiveFedora::Base.logger.warn "'#{model_value}' is not a real class" if ActiveFedora::Base.logger
+          return nil
+        end
+        ActiveFedora::ModelClassifier.class_from_string(model_value)
+      end
+
+      def class_exists?(class_name)
+        return false if class_name.empty?
+        klass = class_name.constantize
+        return klass.is_a?(Class)
+      rescue NameError
+        return false
+      end
+  end
+end

data/lib/active_fedora/nested_attributes.rb

@@ -60,9 +60,9 @@ module ActiveFedora
         options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
 
         attr_names.each do |association_name|
-          if reflection = reflect_on_association(association_name)
-            reflection.options[:autosave] = true
-            add_autosave_association_callbacks(reflection)
+          if reflection = _reflect_on_association(association_name)
+            reflection.autosave = true
+            define_autosave_association_callbacks(reflection)
             ## TODO this ought to work, but doesn't seem to do the class inheritance right
 
             nested_attributes_options = self.nested_attributes_options.dup
@@ -70,10 +70,8 @@ module ActiveFedora
             self.nested_attributes_options = nested_attributes_options
 
             type = (reflection.collection? ? :collection : :one_to_one)
+            generate_association_writer(association_name, type)
 
-            # def pirate_attributes=(attributes)
-            #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
-            # end
             class_eval <<-eoruby, __FILE__, __LINE__ + 1
               remove_possible_method(:#{association_name}_attributes=)
 
@@ -83,6 +81,7 @@ module ActiveFedora
             eoruby
           elsif reflect_on_property(association_name)
             resource_class.accepts_nested_attributes_for(association_name, options)
+            generate_property_writer(association_name, type)
 
             # Delegate the setter to the resource.
             class_eval <<-eoruby, __FILE__, __LINE__ + 1
@@ -98,6 +97,53 @@ module ActiveFedora
           end
         end
       end
+
+      private
+
+        # Generates a writer method for this association. Serves as a point for
+        # accessing the objects in the association. For example, this method
+        # could generate the following:
+        #
+        #   def pirate_attributes=(attributes)
+        #     assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
+        #   end
+        #
+        # This redirects the attempts to write objects in an association through
+        # the helper methods defined below. Makes it seem like the nested
+        # associations are just regular associations.
+        def generate_association_writer(association_name, type)
+          generated_association_methods.module_eval <<-eoruby, __FILE__, __LINE__ + 1
+            if method_defined?(:#{association_name}_attributes=)
+              remove_method(:#{association_name}_attributes=)
+            end
+            def #{association_name}_attributes=(attributes)
+              assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
+            end
+          eoruby
+        end
+
+        # Generates a writer method for this association. Serves as a point for
+        # accessing the objects in the association. For example, this method
+        # could generate the following:
+        #
+        #   def pirate_attributes=(attributes)
+        #     assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
+        #   end
+        #
+        # This redirects the attempts to write objects in an association through
+        # the helper methods defined below. Makes it seem like the nested
+        # associations are just regular associations.
+        def generate_property_writer(association_name, _type)
+          generated_association_methods.module_eval <<-eoruby, __FILE__, __LINE__ + 1
+            if method_defined?(:#{association_name}_attributes=)
+              remove_method(:#{association_name}_attributes=)
+            end
+            def #{association_name}_attributes=(attributes)
+              attribute_will_change!(:#{association_name})
+              resource.#{association_name}_attributes=(attributes)
+            end
+          eoruby
+        end
     end
 
     # Returns ActiveFedora::Base#marked_for_destruction? It's
@@ -115,13 +161,63 @@ module ActiveFedora
       # These hash keys are nested attributes implementation details.
       UNASSIGNABLE_KEYS = %w( id _destroy ).freeze
 
+      # Assigns the given attributes to the association.
+      #
+      # If an associated record does not yet exist, one will be instantiated. If
+      # an associated record already exists, the method's behavior depends on
+      # the value of the update_only option. If update_only is +false+ and the
+      # given attributes include an <tt>:id</tt> that matches the existing record's
+      # id, then the existing record will be modified. If no <tt>:id</tt> is provided
+      # it will be replaced with a new record. If update_only is +true+ the existing
+      # record will be modified regardless of whether an <tt>:id</tt> is provided.
+      #
+      # If the given attributes include a matching <tt>:id</tt> attribute, or
+      # update_only is true, and a <tt>:_destroy</tt> key set to a truthy value,
+      # then the existing record will be marked for destruction.
+      def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
+        options = nested_attributes_options[association_name]
+
+        attributes = attributes.to_h if attributes.respond_to?(:permitted?)
+        attributes = attributes.with_indifferent_access
+        existing_record = send(association_name)
+
+        if (options[:update_only] || !attributes['id'].blank?) && existing_record &&
+           (options[:update_only] || existing_record.id.to_s == attributes['id'].to_s)
+          assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy]) unless call_reject_if(association_name, attributes)
+
+        elsif attributes['id'].present?
+          raise_nested_attributes_record_not_found!(association_name, attributes['id'])
+
+        elsif !reject_new_record?(association_name, attributes)
+          assignable_attributes = attributes.except(*UNASSIGNABLE_KEYS)
+
+          if existing_record && existing_record.new_record?
+            existing_record.assign_attributes(assignable_attributes)
+            association(association_name).initialize_attributes(existing_record)
+          else
+            method = "build_#{association_name}"
+            if respond_to?(method)
+              send(method, assignable_attributes)
+            else
+              raise ArgumentError, "Cannot build association `#{association_name}'. Are you trying to build a polymorphic one-to-one association?"
+            end
+          end
+        end
+      end
+
       def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
         options = nested_attributes_options[association_name]
 
-        if options[:limit] && attributes_collection.size > options[:limit]
-          raise TooManyRecords, "Maximum #{options[:limit]} records are allowed. Got #{attributes_collection.size} records instead."
+        if attributes_collection.respond_to?(:permitted?)
+          attributes_collection = attributes_collection.to_h
         end
 
+        unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+          raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+        end
+
+        check_record_limit!(options[:limit], attributes_collection)
+
         if attributes_collection.is_a? Hash
           keys = attributes_collection.keys
           attributes_collection = if keys.include?('id') || keys.include?(:id)
@@ -134,13 +230,14 @@ module ActiveFedora
         association = send(association_name)
 
         existing_records = if association.loaded?
-                             association.to_a
+                             association.target
                            else
                              attribute_ids = attributes_collection.map { |a| a['id'] || a[:id] }.compact
                              attribute_ids.present? ? association.to_a.select { |x| attribute_ids.include?(x.id) } : []
                            end
 
         attributes_collection.each do |attributes|
+          attributes = attributes.to_h if attributes.respond_to?(:permitted)
           attributes = attributes.with_indifferent_access
 
           if attributes['id'].blank?
@@ -156,11 +253,31 @@ module ActiveFedora
             end
 
           else
-            raise_nested_attributes_record_not_found(association_name, attributes['id'])
+            raise_nested_attributes_record_not_found!(association_name, attributes['id'])
           end
         end
       end
 
+      # Takes in a limit and checks if the attributes_collection has too many
+      # records. It accepts limit in the form of symbol, proc, or
+      # number-like object (anything that can be compared with an integer).
+      #
+      # Raises TooManyRecords error if the attributes_collection is
+      # larger than the limit.
+      def check_record_limit!(limit, attributes_collection)
+        return unless limit
+        limit = case limit
+                when Symbol
+                  send(limit)
+                when Proc
+                  limit.call
+                else
+                  limit
+                end
+
+        raise TooManyRecords, "Maximum #{limit} records are allowed. Got #{attributes_collection.size} records instead." if limit && attributes_collection.size > limit
+      end
+
       # Updates a record with the +attributes+ or marks it for destruction if
       # +allow_destroy+ is +true+ and has_destroy_flag? returns +true+.
       def assign_to_or_mark_for_destruction(record, attributes, allow_destroy)
@@ -170,19 +287,14 @@ module ActiveFedora
 
       # Determines if a hash contains a truthy _destroy key.
       def has_destroy_flag?(hash)
-        ["1", "true"].include?(hash['_destroy'].to_s)
+        Type::Boolean.new.cast(hash['_destroy'])
       end
 
       # Determines if a new record should be rejected by checking
       # has_destroy_flag? or if a <tt>:reject_if</tt> proc exists for this
       # association and evaluates to +true+.
       def reject_new_record?(association_name, attributes)
-        has_destroy_flag?(attributes) || call_reject_if(association_name, attributes)
-      end
-
-      def raise_nested_attributes_record_not_found(association_name, record_id)
-        reflection = self.class.reflect_on_association(association_name)
-        raise ObjectNotFoundError, "Couldn't find #{reflection.klass.name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
+        will_be_destroyed?(association_name, attributes) || call_reject_if(association_name, attributes)
       end
 
       # Determines if a record with the particular +attributes+ should be
@@ -191,8 +303,9 @@ module ActiveFedora
       #
       # Returns false if there is a +destroy_flag+ on the attributes.
       def call_reject_if(association_name, attributes)
+        return false if will_be_destroyed?(association_name, attributes)
+
         opts = nested_attributes_options[association_name]
-        return false if has_destroy_flag?(attributes) && opts[:allow_destroy]
         case callback = opts[:reject_if]
         when Symbol
           method(callback).arity == 0 ? send(callback) : send(callback, attributes)
@@ -200,5 +313,19 @@ module ActiveFedora
           callback.call(attributes)
         end
       end
+
+      # Only take into account the destroy flag if <tt>:allow_destroy</tt> is true
+      def will_be_destroyed?(association_name, attributes)
+        allow_destroy?(association_name) && has_destroy_flag?(attributes)
+      end
+
+      def allow_destroy?(association_name)
+        nested_attributes_options[association_name][:allow_destroy]
+      end
+
+      def raise_nested_attributes_record_not_found!(association_name, record_id)
+        reflection = self.class._reflect_on_association(association_name).klass.name
+        raise ObjectNotFoundError, "Couldn't find #{reflection.klass.name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
+      end
   end
 end

data/lib/active_fedora/persistence.rb

@@ -57,7 +57,7 @@ module ActiveFedora
         raise ObjectNotFoundError, "Unable to find #{id} in the repository"
       end
 
-      ActiveFedora::SolrService.delete(id) if ENABLE_SOLR_UPDATES
+      ActiveFedora::SolrService.delete(id) if ActiveFedora.enable_solr_updates?
       self.class.eradicate(id) if opts[:eradicate]
       freeze
     end

data/lib/active_fedora/predicates.rb

@@ -14,6 +14,7 @@ module ActiveFedora
     end
 
     def self.find_graph_predicate(predicate)
+      Deprecation.warn("find_graph_predicate has been deprecated and will be removed in ActiveFedora 10.0")
       # TODO, these could be cached
       case predicate
       when :has_model, "hasModel", :hasModel
@@ -42,6 +43,7 @@ module ActiveFedora
     end
 
     def self.vocabularies(vocabs = {})
+      Deprecation.warn("vocabularies has been deprecated and will be removed in ActiveFedora 10.0")
       @vocabularies ||= vocabs
       predicate_mappings.keys.each do |ns|
         @vocabularies[ns] = ::RDF::Vocabulary.new(ns) unless @vocabularies.key? ns
@@ -75,6 +77,7 @@ module ActiveFedora
     end
 
     def self.predicate_namespaces
+      Deprecation.warn("predicate_namespaces has been deprecated and will be removed in ActiveFedora 10.0")
       predicate_config[:predicate_namespaces] ||= {}
     end
 

data/lib/active_fedora/qualified_dublin_core_datastream.rb

@@ -147,7 +147,7 @@ module ActiveFedora
       @fields.each do |field_key, field_info|
         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)
         end