active-fedora 9.10.0.pre2 → 9.10.0

data/lib/active_fedora/associations/builder/belongs_to.rb

@@ -4,10 +4,36 @@ module ActiveFedora::Associations::Builder
       :belongs_to
     end
 
-    def validate_options
+    def self.valid_options(options)
+      super + [:optional]
+    end
+
+    def self.valid_dependent_options
+      [:destroy, :delete]
+    end
+
+    def self.validate_options(options)
       super
       raise "You must specify a predicate for #{name}" unless options[:predicate]
       raise ArgumentError, "Predicate must be a kind of RDF::URI" unless options[:predicate].is_a?(RDF::URI)
     end
+
+    def self.define_validations(model, reflection)
+      if reflection.options.key?(:required)
+        reflection.options[:optional] = !reflection.options.delete(:required)
+      end
+
+      required = if reflection.options[:optional].nil?
+                   model.belongs_to_required_by_default
+                 else
+                   !reflection.options[:optional]
+                 end
+
+      super
+
+      if required
+        model.validates_presence_of reflection.name, message: :required
+      end
+    end
   end
 end

data/lib/active_fedora/associations/builder/collection_association.rb

@@ -8,18 +8,49 @@ module ActiveFedora::Associations::Builder
     end
 
     def self.define_callbacks(model, reflection)
+      super
       name = reflection.name
       options = reflection.options
-      super
       CALLBACKS.each { |callback_name| define_callback(model, callback_name, name, options) }
     end
 
+    def self.define_extensions(model, name)
+      if block_given?
+        extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
+        extension = Module.new(&Proc.new)
+        model.parent.const_set(extension_module_name, extension)
+      end
+    end
+
     def self.define_callback(model, callback_name, name, options)
       full_callback_name = "#{callback_name}_for_#{name}"
 
       # TODO : why do i need method_defined? I think its because of the inheritance chain
       model.class_attribute full_callback_name.to_sym unless model.method_defined?(full_callback_name)
-      model.send("#{full_callback_name}=", Array(options[callback_name.to_sym]))
+
+      callbacks = Array(options[callback_name.to_sym]).map do |callback|
+        case callback
+        when Symbol
+          ->(_method, owner, record) { owner.send(callback, record) }
+        when Proc
+          ->(_method, owner, record) { callback.call(owner, record) }
+        else
+          ->(method, owner, record) { callback.send(method, owner, record) }
+        end
+      end
+      model.send("#{full_callback_name}=", callbacks)
+    end
+
+    def self.wrap_scope(scope, mod)
+      if scope
+        if scope.arity > 0
+          proc { |owner| instance_exec(owner, &scope).extending(mod) }
+        else
+          proc { instance_exec(&scope).extending(mod) }
+        end
+      else
+        proc { extending(mod) }
+      end
     end
   end
 end

data/lib/active_fedora/associations/builder/contains.rb

@@ -8,12 +8,12 @@ module ActiveFedora::Associations::Builder
       super + [:autocreate, :block]
     end
 
-    def initialize(model, name, options)
-      super
+    def self.create_reflection(model, name, scope, options, extension = nil)
       options[:class_name] = 'ActiveFedora::File' if options[:class_name].blank?
+      super(model, name, scope, options, extension)
     end
 
-    def validate_options
+    def self.validate_options(options)
       super
       return unless options[:class_name] && !options[:class_name].is_a?(String)
       raise ArgumentError, ":class_name must be a string for contains '#{name}'"

data/lib/active_fedora/associations/builder/directly_contains.rb

@@ -8,13 +8,7 @@ module ActiveFedora::Associations::Builder
       super + [:has_member_relation, :is_member_of_relation] - [:predicate]
     end
 
-    def build
-      reflection = super
-      configure_dependency
-      reflection
-    end
-
-    def validate_options
+    def self.validate_options(options)
       super
       if !options[:has_member_relation] && !options[:is_member_of_relation]
         raise ArgumentError, "You must specify a :has_member_relation or :is_member_of_relation predicate for #{name}"

data/lib/active_fedora/associations/builder/directly_contains_one.rb

@@ -8,11 +8,18 @@ module ActiveFedora::Associations::Builder
       super + [:has_member_relation, :is_member_of_relation, :type, :through] - [:predicate]
     end
 
-    def validate_options
-      raise ArgumentError, "you must specify a :through option on #{name}.  #{name} will use the container from that directly_contains association." unless options[:through]
-      inherit_options_from_association(options[:through]) if options[:through]
+    def self.create_reflection(model, name, scope, options, extension = nil)
+      if options[:through]
+        inherit_options_from_association(model, options, options[:through])
+      else
+        raise ArgumentError, "you must specify a :through option on #{name}.  #{name} will use the container from that directly_contains association."
+      end
+
       super
+    end
 
+    def self.validate_options(options)
+      super
       if options[:class_name] == "ActiveFedora::File"
         raise ArgumentError, "You cannot set :class_name of #{name} to ActiveFedora::File because directly_contains_one needs to assert and read RDF.type assertions, which is not supported by ActiveFedora::File.  To make Files support RDF.type assertions, define a subclass of ActiveFedora::File and make it `include ActiveFedora::WithMetadata`. Otherwise, all subclasses of ActiveFedora::Base support RDF.type assertions."
       elsif !options[:has_member_relation] && !options[:is_member_of_relation]
@@ -25,20 +32,16 @@ module ActiveFedora::Associations::Builder
       raise ArgumentError, "You must specify a Type and it must be a kind of RDF::URI"
     end
 
-    private
-
-      # Inherits :has_member_relation from the association corresponding to association_name
-      # @param [Symbol] association_name of the association to inherit from
-      def inherit_options_from_association(association_name)
-        associated_through_reflection = lookup_reflection(association_name)
-        raise ArgumentError, "You specified `:through => #{@reflection.options[:through]}` on the #{name} associaiton but #{model} does not actually have a #{@reflection.options[:through]}` association" if associated_through_reflection.nil? || !associated_through_reflection.name
-        raise ArgumentError, "You must specify a directly_contains association as the :through option on #{name}.  You provided a #{associated_through_reflection.macro}" unless associated_through_reflection.macro == :directly_contains
-        options[:has_member_relation] = associated_through_reflection.options[:has_member_relation] unless options[:has_member_relation]
-        options[:class_name] = associated_through_reflection.options[:class_name] unless options[:class_name] && options[:class_name] != "ActiveFedora::File"
-      end
+    # Inherits :has_member_relation from the association corresponding to association_name
+    # @param [Symbol] association_name of the association to inherit from
+    def self.inherit_options_from_association(model, options, association_name)
+      associated_through_reflection = model._reflect_on_association(association_name)
+      raise ArgumentError, "You specified `:through => #{@reflection.options[:through]}` on the #{name} associaiton but #{model} does not actually have a #{@reflection.options[:through]}` association" if associated_through_reflection.nil? || !associated_through_reflection.name
+      raise ArgumentError, "You must specify a directly_contains association as the :through option on #{name}.  You provided a #{associated_through_reflection.macro}" unless associated_through_reflection.macro == :directly_contains
+      options[:has_member_relation] = associated_through_reflection.options[:has_member_relation] unless options[:has_member_relation]
+      options[:class_name] = associated_through_reflection.options[:class_name] unless options[:class_name] && options[:class_name] != "ActiveFedora::File"
+    end
 
-      def lookup_reflection(association_name)
-        model._reflect_on_association(association_name)
-      end
+    private_class_method :inherit_options_from_association
   end
 end

data/lib/active_fedora/associations/builder/has_and_belongs_to_many.rb

@@ -9,7 +9,7 @@ module ActiveFedora::Associations::Builder
       super + [:inverse_of, :solr_page_size]
     end
 
-    def validate_options
+    def self.validate_options(options)
       super
       Deprecation.warn HasAndBelongsToMany, ":solr_page_size doesn't do anything anymore and will be removed in ActiveFedora 10" if options.key?(:solr_page_size)
       raise "You must specify a predicate for #{name}" unless options[:predicate]

data/lib/active_fedora/associations/builder/has_many.rb

@@ -8,10 +8,8 @@ module ActiveFedora::Associations::Builder
       super + [:as, :dependent, :inverse_of]
     end
 
-    def build
-      reflection = super
-      configure_dependency
-      reflection
+    def self.valid_dependent_options
+      [:destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception]
     end
 
     def self.define_readers(mixin, name)
@@ -29,44 +27,5 @@ module ActiveFedora::Associations::Builder
         association(name).ids_writer(ids)
       end
     end
-
-    private
-
-      def configure_dependency
-        return unless options[:dependent]
-        unless [:destroy, :delete_all, :nullify, :restrict].include?(options[:dependent])
-          raise ArgumentError, "The :dependent option expects either :destroy, :delete_all, " \
-                               ":nullify or :restrict (#{options[:dependent].inspect})"
-        end
-
-        send("define_#{options[:dependent]}_dependency_method")
-        model.before_destroy dependency_method_name
-      end
-
-      def define_destroy_dependency_method
-        name = self.name
-        model.send(:define_method, dependency_method_name) do
-          send(name).delete_all
-        end
-      end
-
-      def define_delete_all_dependency_method
-        name = self.name
-        model.send(:define_method, dependency_method_name) do
-          send(name).delete_all
-        end
-      end
-      alias define_nullify_dependency_method define_delete_all_dependency_method
-
-      def define_restrict_dependency_method
-        name = self.name
-        model.send(:define_method, dependency_method_name) do
-          raise ActiveRecord::DeleteRestrictionError, name unless send(name).empty?
-        end
-      end
-
-      def dependency_method_name
-        "has_many_dependent_for_#{name}"
-      end
   end
 end

data/lib/active_fedora/associations/builder/indirectly_contains.rb

@@ -8,12 +8,6 @@ module ActiveFedora::Associations::Builder
       super + [:has_member_relation, :is_member_of_relation, :inserted_content_relation, :foreign_key, :through] - [:predicate]
     end
 
-    def build
-      reflection = super
-      configure_dependency
-      reflection
-    end
-
     def self.define_readers(mixin, name)
       super
 
@@ -22,7 +16,7 @@ module ActiveFedora::Associations::Builder
       end
     end
 
-    def validate_options
+    def self.validate_options(options)
       super
       if !options[:has_member_relation] && !options[:is_member_of_relation]
         raise ArgumentError, "You must specify a predicate for #{name}"

data/lib/active_fedora/associations/builder/property.rb

@@ -8,19 +8,8 @@ module ActiveFedora::Associations::Builder
       super
     end
 
-    def initialize(model, name, options)
-      super
-      @name = :"#{name.to_s.singularize}_ids"
-    end
-
-    def build
-      super.tap do |reflection|
-        model.index_config[name] = build_index_config(reflection)
-      end
-    end
-
-    def build_index_config(reflection)
-      ActiveFedora::Indexing::Map::IndexObject.new(reflection.predicate_for_solr) { |index| index.as :symbol }
+    def self.better_name(name)
+      :"#{name.to_s.singularize}_ids"
     end
   end
 end

data/lib/active_fedora/associations/builder/singular_association.rb

@@ -1,16 +1,12 @@
 module ActiveFedora::Associations::Builder
   class SingularAssociation < Association #:nodoc:
     def self.valid_options(options)
-      super + [:dependent, :inverse_of]
-    end
-
-    def self.constructable?
-      true
+      super + [:dependent, :inverse_of, :required]
     end
 
     def self.define_accessors(model, reflection)
       super
-      define_constructors(model.generated_association_methods, reflection.name) if constructable?
+      define_constructors(model.generated_association_methods, reflection.name) if reflection.constructable?
     end
 
     def self.define_constructors(mixin, name)

data/lib/active_fedora/associations/builder/singular_property.rb

@@ -4,9 +4,8 @@ module ActiveFedora::Associations::Builder
       :singular_rdf
     end
 
-    def initialize(model, name, options)
-      super
-      @name = :"#{name}_id"
+    def self.better_name(name)
+      :"#{name}_id"
     end
   end
 end

data/lib/active_fedora/associations/collection_association.rb

@@ -100,7 +100,7 @@ module ActiveFedora
       # Replace this collection with +other_array+
       # This will perform a diff and delete/add only records that have changed.
       def replace(other_array)
-        other_array.each { |val| raise_on_type_mismatch(val) }
+        other_array.each { |val| raise_on_type_mismatch!(val) }
 
         load_target
         other   = other_array.size < 100 ? other_array : other_array.to_set
@@ -156,8 +156,7 @@ module ActiveFedora
         result = true
 
         records.flatten.each do |record|
-          raise_on_type_mismatch(record)
-          run_type_validator(record)
+          raise_on_type_mismatch!(record)
           add_to_target(record) do |_r|
             result &&= insert_record(record) unless owner.new_record?
           end
@@ -356,7 +355,7 @@ module ActiveFedora
 
         def delete_or_destroy(records, method)
           records = records.flatten.select { |x| load_target.include?(x) }
-          records.each { |record| raise_on_type_mismatch(record) }
+          records.each { |record| raise_on_type_mismatch!(record) }
           existing_records = records.select(&:persisted?)
 
           records.each { |record| callback(:before_remove, record) }
@@ -374,20 +373,13 @@ module ActiveFedora
 
         def callback(method, record)
           callbacks_for(method).each do |callback|
-            case callback
-            when Symbol
-              @owner.send(callback, record)
-            when Proc
-              callback.call(@owner, record)
-            else
-              callback.send(method, @owner, record)
-            end
+            callback.call(method, owner, record)
           end
         end
 
         def callbacks_for(callback_name)
-          full_callback_name = "#{callback_name}_for_#{@reflection.name}"
-          @owner.class.send(full_callback_name.to_sym) || []
+          full_callback_name = "#{callback_name}_for_#{reflection.name}"
+          owner.class.send(full_callback_name)
         end
 
         def ensure_owner_is_not_new

data/lib/active_fedora/associations/directly_contains_one_association.rb

@@ -33,8 +33,7 @@ module ActiveFedora
       # Ensures that this association's +type+ is set on the record and adds the record to the association's DirectContainer
       def replace(record, *)
         if record
-          raise_on_type_mismatch(record)
-          run_type_validator(record)
+          raise_on_type_mismatch!(record)
           remove_existing_target
           add_type_to_record(record, options[:type])
           add_to_container(record)

data/lib/active_fedora/associations/has_and_belongs_to_many_association.rb

@@ -37,7 +37,7 @@ module ActiveFedora
         result = true
 
         records.flatten.each do |record|
-          raise_on_type_mismatch(record)
+          raise_on_type_mismatch!(record)
           add_to_target(record) do |_r|
             result &&= insert_record(record)
           end

data/lib/active_fedora/associations/has_many_association.rb

@@ -57,6 +57,29 @@ module ActiveFedora
         end
       end
 
+      def handle_dependency
+        case options[:dependent]
+        when :restrict_with_exception
+          raise ActiveFedora::DeleteRestrictionError, reflection.name unless empty?
+
+        when :restrict_with_error
+          unless empty?
+            record = owner.class.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, message || :'restrict_dependent_destroy.has_many', record: record)
+            throw(:abort)
+          end
+
+        else
+          if options[:dependent] == :destroy
+            # No point in executing the counter update since we're going to destroy the parent anyway
+            load_target.each { |t| t.destroyed_by_association = reflection }
+            destroy_all
+          else
+            delete_all
+          end
+        end
+      end
+
       protected
 
         def find_polymorphic_inverse(record)

data/lib/active_fedora/attached_files.rb

@@ -131,7 +131,7 @@ module ActiveFedora
 
       def create_singleton_association(file_path)
         undeclared_files << file_path.to_sym
-        association = Associations::BasicContainsAssociation.new(self, Reflection::AssociationReflection.new(:contains, file_path, { class_name: 'ActiveFedora::File' }, self.class))
+        association = Associations::BasicContainsAssociation.new(self, Reflection::AssociationReflection.new(:contains, file_path, nil, { class_name: 'ActiveFedora::File' }, self.class))
         @association_cache[file_path.to_sym] = association
 
         singleton_class.send :define_method, accessor_name(file_path) do

data/lib/active_fedora/core.rb

@@ -14,6 +14,7 @@ module ActiveFedora
       # Accepts a logger conforming to the interface of Log4r which can be
       # retrieved on both a class and instance level by calling +logger+.
       mattr_accessor :logger, instance_writer: false
+      mattr_accessor :belongs_to_required_by_default, instance_accessor: false
     end
 
     # Constructor.  You may supply a custom +:id+, or we call the Fedora Rest API for the
@@ -31,7 +32,7 @@ module ActiveFedora
       assign_attributes(attributes) if attributes
 
       yield self if block_given?
-      run_callbacks :initialize
+      _run_initialize_callbacks
     end
 
     ##