active-fedora 8.7.0 → 9.0.0.beta1

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

@@ -2,100 +2,13 @@ module ActiveFedora::Associations::Builder
   class BelongsTo < SingularAssociation #:nodoc:
     self.macro = :belongs_to
 
-    self.valid_options += [:touch]
-
-
-    def build
-      reflection = super
-      add_counter_cache_callbacks(reflection) if options[:counter_cache]
-      add_touch_callbacks(reflection)         if options[:touch]
-      configure_dependency
-      reflection
-    end
-
-    private
-
-      def add_counter_cache_callbacks(reflection)
-        cache_column = reflection.counter_cache_column
-        name         = self.name
-
-        method_name = "belongs_to_counter_cache_after_create_for_#{name}"
-        mixin.redefine_method(method_name) do
-          record = send(name)
-          record.class.increment_counter(cache_column, record.id) unless record.nil?
-        end
-        model.after_create(method_name)
-
-        method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
-        mixin.redefine_method(method_name) do
-          record = send(name)
-          record.class.decrement_counter(cache_column, record.id) unless record.nil?
-        end
-        model.before_destroy(method_name)
-
-        model.send(:module_eval,
-          "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)", __FILE__, __LINE__
-        )
-      end
-
-      def add_touch_callbacks(reflection)
-        name        = self.name
-        method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
-        touch       = options[:touch]
-
-        mixin.redefine_method(method_name) do
-          record = send(name)
-
-          unless record.nil?
-            if touch == true
-              record.touch
-            else
-              record.touch(touch)
-            end
-          end
-        end
-
-        model.after_save(method_name)
-        model.after_touch(method_name)
-        model.after_destroy(method_name)
-      end
-
-      def configure_dependency
-        if options[:dependent]
-          unless [:destroy, :delete].include?(options[:dependent])
-            raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{options[:dependent].inspect})"
-          end
-
-          method_name = "belongs_to_dependent_#{options[:dependent]}_for_#{name}"
-          model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
-            def #{method_name}
-              association = #{name}
-              association.#{options[:dependent]} if association
-            end
-          eoruby
-          model.after_destroy method_name
-        end
-      end
-
-      def define_readers
-        super
-        name = self.name
-        accessor_name = "#{name}_id"
-        model.find_or_create_defined_attribute(accessor_name, 'RELS-EXT', {})
-        mixin.redefine_method(accessor_name) do
-          association(name).id_reader
-        end
-      end
-
-      def define_writers
-        super
-        name = self.name
-        writer_name = "#{name}_id"
-        model.find_or_create_defined_attribute(writer_name, 'RELS-EXT', {})
-        mixin.redefine_method("#{writer_name}=") do |id|
-          raise "can't modify frozen #{self.class}" if self.frozen?
-          association(name).id_writer(id)
-        end
+    def validate_options
+      super
+      if !options[:predicate]
+        raise "You must specify a predicate for #{name}"
+      elsif !options[:predicate].kind_of?(RDF::URI)
+        raise ArgumentError, "Predicate must be a kind of RDF::URI"
       end
+    end
   end
 end

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

@@ -1,56 +1,24 @@
+require 'active_fedora/associations'
 module ActiveFedora::Associations::Builder
   class CollectionAssociation < Association #:nodoc:
     CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
-    self.valid_options += [ 
+    self.valid_options += [
       :before_add, :after_add, :before_remove, :after_remove
     ]
 
-
-    def self.build(model, name, options)
-      new(model, name, options).build
-    end
-
-    def initialize(model, name, options)
-      super(model, name, options)
+    def self.define_callbacks(model, reflection)
+      name = reflection.name
+      options = reflection.options
+      CALLBACKS.each { |callback_name| define_callback(model, callback_name, name, options) }
     end
 
-    def build
-      reflection = super
-      CALLBACKS.each { |callback_name| define_callback(callback_name) }
-      reflection
-    end
+    def self.define_callback(model, callback_name, name, options)
+      full_callback_name = "#{callback_name}_for_#{name}"
 
-    def writable?
-      true
+      # 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]))
     end
-
-    private
-
-      def define_callback(callback_name)
-        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]))
-      end
-
-      def define_readers
-        super
-
-        name = self.name
-        mixin.redefine_method("#{name.to_s.singularize}_ids") do
-          association(name).ids_reader
-        end
-      end
-
-      def define_writers
-        super
-
-        name = self.name
-        mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
-          association(name).ids_writer(ids)
-        end
-      end
   end
 end

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

@@ -0,0 +1,28 @@
+module ActiveFedora::Associations::Builder
+  class Contains < SingularAssociation #:nodoc:
+    self.macro = :contains
+    self.valid_options += [:autocreate, :block]
+
+    def initialize(model, name, options)
+      super
+      options[:class_name] = 'ActiveFedora::File' if options[:class_name].blank?
+    end
+
+    def validate_options
+      super
+      if options[:class_name] && !options[:class_name].is_a?(String)
+        raise ArgumentError, ":class_name must be a string for contains '#{name}'" unless options[:class_name].is_a? String
+      end
+    end
+
+    def self.define_readers(mixin, name)
+      mixin.send(:define_method, name) do |*params|
+        association(name).reader(*params).tap do |file|
+          set_uri = uri.kind_of?(RDF::URI) ? uri.value.present? : uri.present?
+          file.uri = "#{uri}/#{name}" if set_uri
+        end
+      end
+    end
+  end
+end
+

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

@@ -4,23 +4,33 @@ module ActiveFedora::Associations::Builder
 
     self.valid_options += [:inverse_of, :solr_page_size]
 
+    def validate_options
+      super
+      if !options[:predicate]
+        raise "You must specify a predicate for #{name}"
+      elsif !options[:predicate].kind_of?(RDF::URI)
+        raise ArgumentError, "Predicate must be a kind of RDF::URI"
+      end
+    end
+
     def build
       reflection = super
-      redefine_destroy
+      define_destroy_hook
       reflection
     end
 
     private
 
-      def redefine_destroy
+      def define_destroy_hook
         # Don't use a before_destroy callback since users' before_destroy
         # callbacks will be executed after the association is wiped out.
+        # TODO Update to destroy_associations
         name = self.name
         model.send(:include, Module.new {
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def destroy          # def destroy
-              super              #   super
               #{name}.clear      #   posts.clear
+              super              #   super
             end                  # end
           RUBY
         })

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

@@ -10,6 +10,22 @@ module ActiveFedora::Associations::Builder
       reflection
     end
 
+    def self.define_readers(mixin, name)
+      super
+
+      mixin.redefine_method("#{name.to_s.singularize}_ids") do
+        association(name).ids_reader
+      end
+    end
+
+    def self.define_writers(mixin, name)
+      super
+
+      mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
+        association(name).ids_writer(ids)
+      end
+    end
+
     private
 
       def configure_dependency
@@ -27,16 +43,6 @@ module ActiveFedora::Associations::Builder
       def define_destroy_dependency_method
         name = self.name
         model.send(:define_method, dependency_method_name) do
-          send(name).each do |o|
-            # No point in executing the counter update since we're going to destroy the parent anyway
-            counter_method = ('belongs_to_counter_cache_before_destroy_for_' + self.class.name.downcase).to_sym
-            if o.respond_to?(counter_method)
-              class << o
-                self
-              end.send(:define_method, counter_method, Proc.new {})
-            end
-          end
-
           send(name).delete_all
         end
       end

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

@@ -0,0 +1,14 @@
+module ActiveFedora::Associations::Builder
+  class Property < Association
+
+    self.macro = :rdf
+    self.valid_options = [:class_name, :predicate]
+
+    def initialize(model, name, options)
+      super
+      @name = :"#{name.to_s.singularize}_ids"
+    end
+
+  end
+end
+

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

@@ -1,32 +1,28 @@
 module ActiveFedora::Associations::Builder
   class SingularAssociation < Association #:nodoc:
-    self.valid_options += [:dependent, :counter_cache, :inverse_of]
+    self.valid_options += [:dependent, :inverse_of]
 
-    def constructable?
+    def self.constructable?
       true
     end
 
-    def define_accessors
+    def self.define_accessors(model, reflection)
       super
-      define_constructors if constructable?
+      define_constructors(model.generated_association_methods, reflection.name)  if constructable?
     end
 
-    private
-
-      def define_constructors
-        name = self.name
-
-        mixin.redefine_method("build_#{name}") do |*params|
-          association(name).build(*params)
-        end
+    def self.define_constructors(mixin, name)
+      mixin.redefine_method("build_#{name}") do |*params|
+        association(name).build(*params)
+      end
 
-        mixin.redefine_method("create_#{name}") do |*params|
-          association(name).create(*params)
-        end
+      mixin.redefine_method("create_#{name}") do |*params|
+        association(name).create(*params)
+      end
 
-        mixin.redefine_method("create_#{name}!") do |*params|
-          association(name).create!(*params)
-        end
+      mixin.redefine_method("create_#{name}!") do |*params|
+        association(name).create!(*params)
       end
+    end
   end
 end

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

@@ -0,0 +1,12 @@
+module ActiveFedora::Associations::Builder
+  class SingularProperty < Property
+
+    self.macro = :singular_rdf
+
+    def initialize(model, name, options)
+      super
+      @name = :"#{name}_id"
+    end
+
+  end
+end

data/lib/active_fedora/associations/collection_association.rb

@@ -5,9 +5,7 @@ module ActiveFedora
 
       def initialize(owner, reflection)
         super
-
         construct_query
-        @proxy = CollectionProxy.new(self)
       end
 
 
@@ -17,14 +15,14 @@ module ActiveFedora
       def reader(opts = false)
         if opts.kind_of?(Hash)
           if opts.delete(:response_format) == :solr
-            return load_from_solr(opts) 
+            return load_from_solr(opts)
           end
           raise ArgumentError, "Hash parameter must include :response_format=>:solr (#{opts.inspect})"
         else
           force_reload = opts
         end
         reload if force_reload || stale_target?
-        proxy
+        @proxy ||= CollectionProxy.new(self)
       end
 
       # Implements the writer method, e.g. foo.items= for Foo.has_many :items
@@ -36,7 +34,7 @@ module ActiveFedora
       def ids_reader
         if loaded?
           load_target.map do |record|
-            record.pid
+            record.id
           end
         else
           load_from_solr.map do |solr_record|
@@ -71,7 +69,7 @@ module ActiveFedora
         first_or_last(:last, *args)
       end
 
-      # Returns the size of the collection 
+      # Returns the size of the collection
       #
       # If the collection has been already loaded +size+ and +length+ are
       # equivalent. If not and you are going to need the records anyway
@@ -117,7 +115,7 @@ module ActiveFedora
         delete(@target.select { |v| !other.include?(v) })
         concat(other_array.select { |v| !current.include?(v) })
       end
-      
+
       def include?(record)
         if record.is_a?(reflection.klass)
           if record.new_record?
@@ -147,37 +145,37 @@ module ActiveFedora
         if attributes.is_a?(Array)
           attributes.collect { |attr| build(attr, &block) }
         else
-          build_record(attributes) do |record|
-            block.call(record) if block_given?
-            add_to_target(record)
-            set_belongs_to_association_for(record)
+          add_to_target(build_record(attributes)) do |record|
+            yield(record) if block_given?
           end
         end
       end
 
       # Add +records+ to this association.  Returns +self+ so method calls may be chained.
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
-      def <<(*records)
+      def concat(*records)
+        load_target unless owner.new_record?
+        concat_records(records)
+      end
+
+      def concat_records(*records)
         result = true
-        load_target unless loaded?
 
         records.flatten.each do |record|
           raise_on_type_mismatch(record)
-          add_record_to_target_with_callbacks(record) do |r|
-            result &&= insert_record(record)
+          add_to_target(record) do |r|
+            result &&= insert_record(record) unless owner.new_record?
           end
         end
 
-        result && self
+        result && records
       end
 
-      alias_method :push, :<<
-      alias_method :concat, :<<
-
       # Remove all records from this association
       #
       # See delete for more info.
       def delete_all
+        # TODO load_target causes extra loads. Can't we just send delete requests?
         delete(load_target).tap do
           reset
           loaded!
@@ -238,14 +236,20 @@ module ActiveFedora
       def count(options = {})
         @reflection.klass.count(:conditions => @counter_query)
       end
-      
+
+      # Sets the target of this proxy to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = [target]
+        loaded!
+      end
+
       def load_target
         if find_target?
           targets = []
 
           begin
             targets = find_target
-          rescue ObjectNotFoundError => e
+          rescue ObjectNotFoundError, Ldp::Gone => e
             ActiveFedora::Base.logger.error "Solr and Fedora may be out of sync:\n" + e.message if ActiveFedora::Base.logger
             reset
           end
@@ -260,7 +264,9 @@ module ActiveFedora
       def find_target
         # TODO: don't reify, just store the solr results and lazily reify.
         # For now, we set a hard limit of 1000 results.
-        return ActiveFedora::SolrService.reify_solr_results(load_from_solr(rows: 1000))
+        records = ActiveFedora::SolrService.reify_solr_results(load_from_solr(rows: 1000))
+        records.each { |record| set_inverse_instance(record) }
+        records
       end
 
       def merge_target_lists(loaded, existing)
@@ -291,23 +297,9 @@ module ActiveFedora
         SolrService.query(@finder_query, solr_opts.merge(opts))
       end
 
-      def add_record_to_target_with_callbacks(record)
-        callback(:before_add, record)
-        yield(record) if block_given?
-        @target ||= [] unless loaded?
-        if index = @target.index(record)
-          @target[index] = record
-        else
-           @target << record
-        end
-        callback(:after_add, record)
-      #  set_inverse_instance(record, @owner)
-        record
-      end
-
-      def add_to_target(record)
+      def add_to_target(record, skip_callbacks = false)
       #  transaction do
-          callback(:before_add, record)
+          callback(:before_add, record) unless skip_callbacks
           yield(record) if block_given?
 
           if @reflection.options[:uniq] && index = @target.index(record)
@@ -316,7 +308,7 @@ module ActiveFedora
             @target << record
           end
 
-          callback(:after_add, record)
+          callback(:after_add, record) unless skip_callbacks
           set_inverse_instance(record)
        # end
 
@@ -339,80 +331,64 @@ module ActiveFedora
 
         def construct_query
 
-          clauses = {find_predicate => @owner.internal_uri}
+          #TODO use primary_key instead of id
+          clauses = {find_predicate.to_s => @owner.id}
           clauses[:has_model] = @reflection.class_name.constantize.to_class_uri if @reflection.class_name && @reflection.class_name != 'ActiveFedora::Base'
           @counter_query = @finder_query = ActiveFedora::SolrService.construct_query_for_rel(clauses)
         end
 
 
-      private 
-
-        # Assigns the ID of the owner to the corresponding foreign key in +record+.
-        # If the association is polymorphic the type of the owner is also set.
-        def set_belongs_to_association_for(record)
-          unless @owner.new_record?
-            record.add_relationship(find_predicate, @owner)
-          end
-        end
+      private
 
         def find_predicate
-          if @reflection.options[:property]
-            @reflection.options[:property]
+          if @reflection.options[:predicate]
+            reflection.predicate.to_s
           elsif @reflection.class_name && @reflection.class_name != 'ActiveFedora::Base' && @reflection.macro != :has_and_belongs_to_many
             inverse_relation = @owner.class.to_s.underscore.to_sym
             begin
-            find_class_for_relation(@reflection.class_name.constantize)
+              find_class_for_relation(@reflection.class_name.constantize)
             rescue NameError
-              raise "No :property attribute was set or could be inferred for #{@reflection.macro} #{@reflection.name.inspect} on #{@owner.class}"
+              raise "No :predicate attribute was set or could be inferred for #{@reflection.macro} #{@reflection.name.inspect} on #{@owner.class}"
             end
           end
         end
 
         def find_class_for_relation(klass, inverse_relation=@owner.class.to_s.underscore.to_sym)
-          raise "Unable to lookup the :property attribute for #{@reflection.macro} #{@reflection.name.inspect} on #{@owner.class} because #{klass} specifies \"class_name: 'ActiveFedora::Base'\".  Either specify a specific class_name in #{klass} or set :property in the #{@reflection.macro} declaration on #{@owner.class}" if inverse_relation == :'active_fedora/base'
+          raise "Unable to lookup the :predicate attribute for #{@reflection.macro} #{@reflection.name.inspect} on #{@owner.class} because #{klass} specifies \"class_name: 'ActiveFedora::Base'\".  Either specify a specific class_name in #{klass} or set :predicate in the #{@reflection.macro} declaration on #{@owner.class}" if inverse_relation == :'active_fedora/base'
           if klass.reflections.key?(inverse_relation)
             # Try it singular
-            return klass.reflections[inverse_relation].options[:property]
+            return klass.reflections[inverse_relation].predicate
           elsif klass.reflections.key?(inverse_relation.to_s.pluralize.to_sym)
-            # Try it plural 
-            return klass.reflections[inverse_relation.to_s.pluralize.to_sym].options[:property]
+            # Try it plural
+            return klass.reflections[inverse_relation.to_s.pluralize.to_sym].predicate
           end
           find_class_for_relation(klass, @owner.class.superclass.to_s.underscore.to_sym)
         end
 
-        def create_record(attrs)
-          attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
+        def create_record(attributes, raise = false)
+          attributes.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
           ensure_owner_is_not_new
-          record = @reflection.klass.create do
-            @reflection.build_association(attrs)
-          end
-          set_belongs_to_association_for(record)
-          if block_given?
-            add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
-          else
-            add_record_to_target_with_callbacks(record)
+
+          add_to_target(build_record(attributes)) do |record|
+            yield(record) if block_given?
+            insert_record(record, true, raise)
           end
         end
 
-        def build_record(attrs)
-          #attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
-          record = @reflection.build_association(attrs)
-          if block_given?
-            add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
-          else
-            add_record_to_target_with_callbacks(record)
-          end
+        def create_scope
+          scope.scope_for_create.stringify_keys
         end
 
         def delete_or_destroy(records, method)
           records = records.flatten
           records.each { |record| raise_on_type_mismatch(record) }
-          existing_records = records.reject { |r| r.new_record? }
+          existing_records = records.select { |r| r.persisted? }
 
           records.each { |record| callback(:before_remove, record) }
-
           delete_records(existing_records, method) if existing_records.any?
-          records.each { |record| target.delete(record) }
+          records.each do |record|
+            target.delete(record)
+          end
 
           records.each { |record| callback(:after_remove, record) }
         end
@@ -447,9 +423,10 @@ module ActiveFedora
 
           #collection = fetch_first_or_last_using_find?(args) ? scoped : load_target
           collection = load_target
-          collection.send(type, *args)
+          collection.send(type, *args).tap do |record|
+            set_inverse_instance record if record.is_a? ActiveFedora::Base
+          end
         end
-      
     end
   end
 end