active-fedora 3.0.1 → 3.0.3

data/History.txt

@@ -1,3 +1,12 @@
+3.0.3
+
+Added HasAndBelongsToManyAssociation
+
+3.0.2
+
+YANKED
+
+
 3.0.1
 
 HYDRA-654 -- Fixed reification using has_model as the class instead of active_fedora_model

data/config/predicate_mappings.yml

@@ -38,6 +38,7 @@
     :is_metadata_for: isMetadataFor
     :is_part_of: isPartOf
     :is_subset_of: isSubsetOf
+    :is_topic_of: isTopicOf
   info:fedora/fedora-system:def/model#:
     :has_model: hasModel
 #  http://www.openarchives.org/OAI/2.0/: 

data/lib/active_fedora/associations.rb

@@ -7,6 +7,8 @@ module ActiveFedora
 
     autoload :HasManyAssociation, 'active_fedora/associations/has_many_association'
     autoload :BelongsToAssociation, 'active_fedora/associations/belongs_to_association'
+    autoload :HasAndBelongsToManyAssociation, 'active_fedora/associations/has_and_belongs_to_many_association'
+
 
     autoload :AssociationCollection, 'active_fedora/associations/association_collection'
     autoload :AssociationProxy, 'active_fedora/associations/association_proxy'
@@ -50,6 +52,73 @@ module ActiveFedora
       end
 
 
+      # Specifies a many-to-many relationship with another class. The relatioship is written to both classes simultaneously.
+      #
+      # Adds the following methods for retrieval and query:
+      #
+      # [collection(force_reload = false)]
+      #   Returns an array of all the associated objects.
+      #   An empty array is returned if none are found.
+      # [collection<<(object, ...)]
+      #   Adds one or more objects to the collection by creating associations in the join table
+      #   (<tt>collection.push</tt> and <tt>collection.concat</tt> are aliases to this method).
+      #   Note that this operation instantly fires update sql without waiting for the save or update call on the
+      #   parent object.
+      # [collection.delete(object, ...)]
+      #   Removes one or more objects from the collection by removing their associations from the join table.
+      #   This does not destroy the objects.
+      # [collection=objects]
+      #   Replaces the collection's content by deleting and adding objects as appropriate.
+      # [collection_singular_ids]
+      #   Returns an array of the associated objects' ids.
+      # [collection_singular_ids=ids]
+      #   Replace the collection by the objects identified by the primary keys in +ids+.
+      # [collection.clear]
+      #   Removes every object from the collection. This does not destroy the objects.
+      # [collection.empty?]
+      #   Returns +true+ if there are no associated objects.
+      # [collection.size]
+      #   Returns the number of associated objects.
+      #
+      # (+collection+ is replaced with the symbol passed as the first argument, so
+      # <tt>has_and_belongs_to_many :categories</tt> would add among others <tt>categories.empty?</tt>.)
+      #
+      # === Example
+      #
+      # A Developer class declares <tt>has_and_belongs_to_many :projects</tt>, which will add:
+      # * <tt>Developer#projects</tt>
+      # * <tt>Developer#projects<<</tt>
+      # * <tt>Developer#projects.delete</tt>
+      # * <tt>Developer#projects=</tt>
+      # * <tt>Developer#project_ids</tt>
+      # * <tt>Developer#project_ids=</tt>
+      # * <tt>Developer#projects.clear</tt>
+      # * <tt>Developer#projects.empty?</tt>
+      # * <tt>Developer#projects.size</tt>
+      # * <tt>Developer#projects.find(id)</tt>
+      # * <tt>Developer#projects.exists?(...)</tt>
+      # The declaration may include an options hash to specialize the behavior of the association.
+      #
+      # === Options
+      #
+      # [:class_name]
+      #   Specify the class name of the association. Use it only if that name can't be inferred
+      #   from the association name. So <tt>has_and_belongs_to_many :projects</tt> will by default be linked to the
+      #   Project class, but if the real class name is SuperProject, you'll have to specify it with this option.
+      # [:property]
+      #   <b>REQUIRED</b> Specify the predicate to use when storing the relationship.
+      #
+      # Option examples:
+      #   has_and_belongs_to_many :projects, :property=>:works_on
+      #   has_and_belongs_to_many :nations, :class_name => "Country", :property=>:is_citizen_of
+      def has_and_belongs_to_many(association_id, options = {}, &extension)
+        reflection = create_has_and_belongs_to_many_reflection(association_id, options, &extension)
+        collection_accessor_methods(reflection, HasAndBelongsToManyAssociation)
+        #configure_after_destroy_method_for_has_and_belongs_to_many(reflection)
+        #add_association_callbacks(reflection.name, options)
+      end
+
+
       private 
 
         def create_has_many_reflection(association_id, options)
@@ -60,6 +129,10 @@ module ActiveFedora
           create_reflection(:belongs_to, association_id, options, self)
         end
 
+        def create_has_and_belongs_to_many_reflection(association_id, options)
+          create_reflection(:has_and_belongs_to_many, association_id, options, self)
+        end
+
         def association_accessor_methods(reflection, association_proxy_class)
           redefine_method(reflection.name) do |*params|
             force_reload = params.first unless params.empty?

data/lib/active_fedora/associations/association_collection.rb

@@ -69,7 +69,7 @@ module ActiveFedora
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
       def <<(*records)
         result = true
-        load_target if @owner.new_record?
+        load_target unless loaded?
 
         flatten_deeper(records).each do |record|
           raise_on_type_mismatch(record)

data/lib/active_fedora/associations/has_and_belongs_to_many_association.rb

@@ -0,0 +1,117 @@
+module ActiveFedora
+  # = Active Fedora Has And Belongs To Many Association
+  module Associations
+    class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
+      def initialize(owner, reflection)
+        super
+      end
+
+      def find_target
+          @owner.load_outbound_relationship(@reflection.name.to_s, @reflection.options[:property])
+      end
+
+
+      # def create(attributes = {})
+      #   create_record(attributes) { |record| insert_record(record) }
+      # end
+
+      # def create!(attributes = {})
+      #   create_record(attributes) { |record| insert_record(record, true) }
+      # end
+
+      def columns
+        @reflection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
+      end
+
+      # def reset_column_information
+      #   @reflection.reset_column_information
+      # end
+
+      # def has_primary_key?
+      #   @has_primary_key ||= @owner.connection.supports_primary_key? && @owner.connection.primary_key(@reflection.options[:join_table])
+      # end
+
+      protected
+        # def construct_find_options!(options)
+        #   options[:joins]      = Arel::SqlLiteral.new @join_sql
+        #   options[:readonly]   = finding_with_ambiguous_select?(options[:select] || @reflection.options[:select])
+        #   options[:select]   ||= (@reflection.options[:select] || Arel::SqlLiteral.new('*'))
+        # end
+
+        def count_records
+          load_target.size
+        end
+
+        def insert_record(record, force = true, validate = true)
+          if record.new_record?
+            if force
+              record.save!
+            else
+              return false unless record.save(:validate => validate)
+            end
+          end
+
+          ### TODO save relationship
+          @owner.add_relationship(@reflection.options[:property], record)
+          record.add_relationship(@reflection.options[:property], @owner)
+          record.save
+          return true
+        end
+
+        def delete_records(records)
+          records.each do |r| 
+            r.remove_relationship(@reflection.options[:property], @owner)
+          end
+        end
+
+        # def construct_sql
+        #   if @reflection.options[:finder_sql]
+        #     @finder_sql = interpolate_and_sanitize_sql(@reflection.options[:finder_sql])
+        #   else
+        #     @finder_sql = "#{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{owner_quoted_id} "
+        #     @finder_sql << " AND (#{conditions})" if conditions
+        #   end
+
+        #   @join_sql = "INNER JOIN #{@owner.connection.quote_table_name @reflection.options[:join_table]} ON #{@reflection.quoted_table_name}.#{@reflection.klass.primary_key} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
+
+        #   construct_counter_sql
+        # end
+
+        def construct_scope
+          { :find => {  :conditions => @finder_sql,
+                        :joins => @join_sql,
+                        :readonly => false,
+                        :order => @reflection.options[:order],
+                        :include => @reflection.options[:include],
+                        :limit => @reflection.options[:limit] } }
+        end
+
+        # Join tables with additional columns on top of the two foreign keys must be considered
+        # ambiguous unless a select clause has been explicitly defined. Otherwise you can get
+        # broken records back, if, for example, the join column also has an id column. This will
+        # then overwrite the id column of the records coming back.
+        def finding_with_ambiguous_select?(select_clause)
+          !select_clause && columns.size != 2
+        end
+
+      private
+        # def create_record(attributes, &block)
+        #   # Can't use Base.create because the foreign key may be a protected attribute.
+        #   ensure_owner_is_not_new
+        #   if attributes.is_a?(Array)
+        #     attributes.collect { |attr| create(attr) }
+        #   else
+        #     build_record(attributes, &block)
+        #   end
+        # end
+
+        def record_timestamp_columns(record)
+          if record.record_timestamps
+            record.send(:all_timestamp_attributes).map { |x| x.to_s }
+          else
+            []
+          end
+        end
+    end
+  end
+end

data/lib/active_fedora/base.rb

@@ -139,6 +139,10 @@ module ActiveFedora
       @metadata_is_dirty == false
       return result
     end
+
+    def save!
+      save
+    end
     
     # Refreshes the object's info from Fedora
     # Note: Currently just registers any new datastreams that have appeared in fedora

data/lib/active_fedora/reflection.rb

@@ -5,7 +5,7 @@ module ActiveFedora
     module ClassMethods
       def create_reflection(macro, name, options, active_fedora)
         case macro
-          when :has_many, :belongs_to
+          when :has_many, :belongs_to, :has_and_belongs_to_many
             klass = AssociationReflection
             reflection = klass.new(macro, name, options, active_fedora)
         end

data/lib/active_fedora/semantic_node.rb

@@ -552,7 +552,7 @@ module ActiveFedora
             return predicates[predicate], namespace
           end
         end
-        raise ActiveFedora::UnregisteredPredicateError
+        raise ActiveFedora::UnregisteredPredicateError, "Unregistered predicate: #{predicate.inspect}"
       end
 
       

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-    VERSION = "3.0.1"
+    VERSION = "3.0.3"
 end

data/spec/integration/associations_spec.rb

@@ -6,80 +6,136 @@ end
 
 class Book < ActiveFedora::Base 
   belongs_to :library, :property=>:has_constituent
+  has_and_belongs_to_many :topics, :property=>:is_topic_of
+end
+
+class Topic < ActiveFedora::Base 
+  has_and_belongs_to_many :books, :property=>:is_topic_of
 end
 
 describe ActiveFedora::Base do
   describe "an unsaved instance" do
-    before do
-      @library = Library.new()
-      @book = Book.new
-      @book.save
-      @book2 = Book.new
-      @book2.save
-    end
-
-    it "should let you shift onto the association" do
-      @library.new_record?.should be_true
-      @library.books.size == 0
-      @library.books.to_ary.should == []
-      @library.book_ids.should ==[]
-      @library.books << @book
-      @library.books.map(&:pid).should == [@book.pid]
-      @library.book_ids.should ==[@book.pid]
-    end
-
-    it "should let you set an array of objects" do
-      @library.books = [@book, @book2]
-      @library.books.map(&:pid).should == [@book.pid, @book2.pid]
-      @library.save
-
-      @library.books = [@book]
-      @library.books.map(&:pid).should == [@book.pid]
-    
-    end
-    it "should let you set an array of object ids" do
-      @library.book_ids = [@book.pid, @book2.pid]
-      @library.books.map(&:pid).should == [@book.pid, @book2.pid]
-    end
-
-    it "setter should wipe out previously saved relations" do
-      @library.book_ids = [@book.pid, @book2.pid]
-      @library.book_ids = [@book2.pid]
-      @library.books.map(&:pid).should == [@book2.pid]
+    describe "of belongs_to" do
+      before do
+        @library = Library.new()
+        @book = Book.new
+        @book.save
+        @book2 = Book.new
+        @book2.save
+      end
+
+      it "should let you shift onto the association" do
+        @library.new_record?.should be_true
+        @library.books.size == 0
+        @library.books.to_ary.should == []
+        @library.book_ids.should ==[]
+        @library.books << @book
+        @library.books.map(&:pid).should == [@book.pid]
+        @library.book_ids.should ==[@book.pid]
+      end
+
+      it "should let you set an array of objects" do
+        @library.books = [@book, @book2]
+        @library.books.map(&:pid).should == [@book.pid, @book2.pid]
+        @library.save
+
+        @library.books = [@book]
+        @library.books.map(&:pid).should == [@book.pid]
       
+      end
+      it "should let you set an array of object ids" do
+        @library.book_ids = [@book.pid, @book2.pid]
+        @library.books.map(&:pid).should == [@book.pid, @book2.pid]
+      end
+
+      it "setter should wipe out previously saved relations" do
+        @library.book_ids = [@book.pid, @book2.pid]
+        @library.book_ids = [@book2.pid]
+        @library.books.map(&:pid).should == [@book2.pid]
+        
+      end
+
+
+      after do
+        @book.delete
+        @book2.delete
+      end
     end
-
-    after do
-      @book.delete
-      @book2.delete
+    describe "of has_many_and_belongs_to" do
+      before do
+        @topic1 = Topic.new
+        @topic1.save
+        @topic2 = Topic.new
+        @topic2.save
+      end
+      it "habtm should set relationships bidirectionally" do
+        @book = Book.new
+        @book.topics << @topic1
+        @book.topics.map(&:pid).should == [@topic1.pid]
+        Topic.find(@topic1.pid).books.map(&:pid).should == [] #Can't have saved it because @book isn't saved yet.
+      end
+      after do
+        @topic1.delete
+        @topic2.delete
+      end
     end
   end
 
+  
 
-  describe "a saved instance" do
-    before do
-      @library = Library.new()
-      @library.save()
-      @book = Book.new
-      @book.save
-    end
-    it "should have many books once it has been saved" do
-      @library.save
-      @library.books << @book
-
-      @book.library.pid.should == @library.pid
-      @library.books.reload
-      @library.books.map(&:pid).should == [@book.pid]
-
-
-      @library2 = Library.find(@library.pid)
-      @library2.books.map(&:pid).should == [@book.pid]
 
-    
+  describe "a saved instance" do
+    describe "of belongs_to" do
+      before do
+        @library = Library.new()
+        @library.save()
+        @book = Book.new
+        @book.save
+      end
+      it "should have many books once it has been saved" do
+        @library.books << @book
+
+        @book.library.pid.should == @library.pid
+        @library.books.reload
+        @library.books.map(&:pid).should == [@book.pid]
+
+
+        @library2 = Library.find(@library.pid)
+        @library2.books.map(&:pid).should == [@book.pid]
+      end
+      after do
+        @library.delete
+        @book.delete
+      end
     end
-    after do
-      @library.delete
-      @book.delete
+    describe "of has_many_and_belongs_to" do
+      before do
+        @topic1 = Topic.new
+        @topic1.save
+        @topic2 = Topic.new
+        @topic2.save
+        @book = Book.new
+        @book.save
+      end
+      it "habtm should set relationships bidirectionally" do
+        @book.topics << @topic1
+        @book.topics.map(&:pid).should == [@topic1.pid]
+        Topic.find(@topic1.pid).books.map(&:pid).should == [@book.pid] #Can't have saved it because @book isn't saved yet.
+      end
+      it "should save new child objects" do
+        @book.topics << Topic.new
+        @book.topics.first.pid.should_not be_nil
+      end
+      it "should clear out the old associtions" do
+        @book.topics = [@topic1]
+        @book.topics = [@topic2]
+        @book.topic_ids.should == [@topic2.pid]
+      end
+      after do
+        @book.delete
+        @topic1.delete
+        @topic2.delete
+      end
     end
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: active-fedora
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 1
   prerelease: 
   segments: 
   - 3
   - 0
-  - 1
-  version: 3.0.1
+  - 3
+  version: 3.0.3
 platform: ruby
 authors: 
 - Matt Zumwalt
@@ -520,6 +520,7 @@ files:
 - lib/active_fedora/associations/association_collection.rb
 - lib/active_fedora/associations/association_proxy.rb
 - lib/active_fedora/associations/belongs_to_association.rb
+- lib/active_fedora/associations/has_and_belongs_to_many_association.rb
 - lib/active_fedora/associations/has_many_association.rb
 - lib/active_fedora/attribute_methods.rb
 - lib/active_fedora/base.rb