acts_as_sourceable 1.0.6 → 2.0.0

data/lib/acts_as_sourceable.rb

@@ -1,4 +1,4 @@
 require 'acts_as_sourceable/acts_as_sourceable'
-require 'acts_as_sourceable/sourceable_institution'
+require 'acts_as_sourceable/registry'
 
 ActiveRecord::Base.extend ActsAsSourceable::ActMethod

data/lib/acts_as_sourceable/acts_as_sourceable.rb

@@ -1,53 +1,92 @@
 module ActsAsSourceable
   module ActMethod
     def acts_as_sourceable(options = {})
-      # Include Class and Instance Methods
-      ActiveRecord::Relation.send(:include, ActsAsSourceable::ActiveRelationMethods)
-      extend ActsAsSourceable::ClassMethods
+      options.assert_valid_keys :through, :cache_column, :used_by
+      raise "Can't have a cache column and be sourced through an association" if options[:through] && options [:cache_column]
+      class_attribute :acts_as_sourceable_options
+      self.acts_as_sourceable_options = options
+
+      # INSTANCE SETUP
       include ActsAsSourceable::InstanceMethods
 
-      has_many :sourceable_institutions, :as => :sourceable, :dependent => :destroy
-      has_many :sources, :through => :sourceable_institutions, :source => :holding_institution
-      
-      # Delegate the relation methods to the relation
-      class << self
-        delegate :update_sources, :unsource, :to => :scoped
+      # If we get our sources through an association use that,
+      # Else use the sourceable institutions table
+      class_eval do
+        if acts_as_sourceable_options[:through]
+          def sources; send(acts_as_sourceable_options[:through]) || []; end
+        else
+          has_one :sourceable_institution, :class_name => 'ActsAsSourceable::Registry', :as => :sourceable, :dependent => :delete
+          def sources; sourceable_institution.try(:sources) || []; end
+        end
       end
 
-      class_attribute :sourceable_cache_column, :sourceable_used_by, :sourceable_sourced_by
-      self.sourceable_cache_column = options[:cache_column]
-      self.sourceable_used_by = options[:used_by]
-      self.sourceable_sourced_by = options[:sourced_by]
-      
+      # CLASS SETUP
+      extend ActsAsSourceable::ClassMethods
+
       # If a cache column is provided, use that to determine which records are sourced and unsourced
       # Elsif the records can be derived, we need to check the flattened item tables for any references
       # Else we check the sourceable_institutions to see if the record has a recorded source
-      if sourceable_cache_column
-        scope :sourced, where(sourceable_cache_column => true)
-        scope :unsourced, where(sourceable_cache_column => false)
+      if options[:cache_column]
+        scope :sourced, where(options[:cache_column] => true)
+        scope :unsourced, where(options[:cache_column] => false)
+      elsif options[:through]
+        scope :sourced, joins(options[:through]).uniq
+        scope :unsourced, joins("LEFT OUTER JOIN (#{sourced.to_sql}) sourced ON sourced.id = #{table_name}.id").where("sourced.id IS NULL")
+      else
+        scope :sourced, joins(:sourceable_institution)
+        scope :unsourced, joins("LEFT OUTER JOIN (#{sourced.to_sql}) sourced ON sourced.id = #{table_name}.id").where("sourced.id IS NULL")
+      end
+
+      # Add a way of finding everything sourced by a particular set of records
+      if options[:through]
+        def sourced_by(*sources)
+          raise NotImplementedError # TODO
+        end
       else
-        scope :sourced, joins(:sourceable_institutions).group("#{table_name}.id")
-        scope :unsourced, joins("LEFT OUTER JOIN sourceable_institutions ON sourceable_id = #{table_name}.id and sourceable_type = '#{self.name}'").where("sourceable_id IS NULL")
+        def sourced_by(*sources)
+          holding_institution_ids, collection_ids, item_ids = ActsAsSourceable::HelperMethods.group_ids_by_class(sources)
+
+          arel_table = ActsAsSourceable::Registry.arel_table
+          h_contraint = arel_table[:holding_institution_ids].array_overlap(holding_institution_ids)
+          c_contraint = arel_table[:collection_ids].array_overlap(collection_ids)
+          i_contraint = arel_table[:item_ids].array_overlap(item_ids)
+
+          sourced.where(h_contraint.or(c_contraint).or(i_contraint))
+        end
       end
 
-      # Create a scope that returns record that is not used by the associations in sourceable_used_by
-      if sourceable_used_by
-        scope :unused, where(Array(sourceable_used_by).collect {|usage_association| "#{table_name}.id NOT IN (" + select("#{table_name}.id").joins(usage_association).group("#{table_name}.id").to_sql + ")"}.join(' AND '))
+      # Create a scope that returns record that is not used by the associations in options[:used_by]
+      if options[:used_by]
+        scope :unused, where(Array(options[:used_by]).collect {|usage_association| "#{table_name}.id NOT IN (" + select("#{table_name}.id").joins(usage_association).group("#{table_name}.id").to_sql + ")"}.join(' AND '))
         scope :orphaned, unsourced.unused
       else
         scope :orphaned, unsourced
       end
+
+      # ACTIVE RELATION SETUP
+      ActiveRecord::Relation.send(:include, ActsAsSourceable::ActiveRelationMethods)
+
+      # Delegate the relation methods to the relation so we can call Klass.unsourced (do this in the metaclass because all these methods are class level)
+      class << self
+        delegate :add_sources, :add_source, :remove_source, :remove_sources, :unsource, :to => :scoped
+      end
     end
   end
   
   module ActiveRelationMethods
-    def update_sources
-      scoping { @klass.find_each(&:update_sources) }
+    def remove_sources(*sources)
+      scoping { @klass.find_each{|record| record.remove_sources(*sources) } }
     end
+    alias_method :remove_source, :remove_sources
+
+    def add_sources(*sources)
+      scoping { @klass.find_each{|record| record.add_sources(*sources) } }
+    end
+    alias_method :add_source, :add_sources
     
     def unsource
-      scoping { @klass.update_all("#{sourceable_cache_column} = false", @klass.sourceable_cache_column => true) } if @klass.sourceable_cache_column
-      scoping { SourceableInstitution.where("sourceable_type = ? AND sourceable_id IN (#{@klass.select(:id).to_sql})", @klass.name).delete_all }
+      scoping { @klass.update_all("#{acts_as_sourceable_options[:cache_column]} = false", @klass.acts_as_sourceable_options[:cache_column] => true) } if @klass.acts_as_sourceable_options[:cache_column]
+      scoping { ActsAsSourceable::Registry.where("sourceable_type = ? AND sourceable_id IN (#{@klass.select("#{@klass.table_name}.id").to_sql})", @klass.name).delete_all }
     end
   end
 
@@ -61,27 +100,10 @@ module ActsAsSourceable
     def acts_like_sourceable?
       true
     end
-    
-    # Automatically update the sources for this model
-    # If the model gets its sources from another model, collect the sources of that model and record them as your own
-    # Else, this model must belong to a holding institution, so that is the source
-    def update_sources
-      if sourceable_sourced_by
-        if self.class.reflect_on_association(sourceable_sourced_by.to_sym).collection?
-          source_id_sql = send(sourceable_sourced_by).joins(:sourceable_institutions).select("sourceable_institutions.holding_institution_id").to_sql
-          sources = HoldingInstitution.where("id IN (#{source_id_sql})")
-          set_sources(sources)
-        else
-          set_sources(send(sourceable_sourced_by).sources)
-        end
-      else
-        set_sources(holding_institution)
-      end
-    end
-    
+        
     def sourced?
-      if sourceable_cache_column
-        self[sourceable_cache_column]
+      if acts_as_sourceable_options[:cache_column]
+        self[acts_as_sourceable_options[:cache_column]]
       else
         self.class.sourced.exists?(self)
       end
@@ -91,32 +113,97 @@ module ActsAsSourceable
       !sourced?
     end
 
-    # NOTE: We do a much more verbose method of assigning sources than the obvious self.sources = Array(holding_institutions)
-    #       because HoldingInstitutions are present in the production database, and assigning sources causes rails to use the
-    #       production database (as opposed to the conversion database) to check for existing sources. This is obviously bad
-    #       because the sources in the production database do not reflect those that are in the conversion database since we
-    #       unsource many things during conversion.
-    def set_sources(holding_institutions)
-      holding_institution_ids = Array(holding_institutions).collect(&:id)
-      existing_source_ids = sourceable_institutions.pluck('holding_institution_id')
-      
-      # Delete those that have been removed
-      condition = holding_institution_ids.any? ? ["holding_institution_id NOT IN (?)", existing_source_ids] : nil # Can't use "NOT IN (?)" for an empty array because the result is always false
-      SourceableInstitution.where(:sourceable_type => self.class.name, :sourceable_id => self.id).delete_all(condition)
-      
-      # Add those that are not present
-      holding_institution_ids.each do |holding_institution_id|
-        self.sourceable_institutions << SourceableInstitution.new(:holding_institution_id => holding_institution_id) unless existing_source_ids.include?(holding_institution_id)
+    # Add the given holding_institutions, collections, and items
+    def add_sources(*sources)
+      holding_institution_ids, collection_ids, item_ids = ActsAsSourceable::HelperMethods.group_ids_by_class(sources)
+      registry = init_registry_entry
+      set_sources(registry.holding_institution_ids + holding_institution_ids, registry.collection_ids + collection_ids, registry.item_ids + item_ids)
+    end
+    alias_method :add_source, :add_sources
+
+    # Remove the given holding_institutions, collections, and items
+    def remove_sources(*sources)
+      holding_institution_ids, collection_ids, item_ids = ActsAsSourceable::HelperMethods.group_ids_by_class(sources)
+      registry = init_registry_entry
+      set_sources(registry.holding_institution_ids - holding_institution_ids, registry.collection_ids - collection_ids, registry.item_ids - item_ids)
+    end
+    alias_method :remove_source, :remove_sources
+
+    # Record which holding_institution, collection, and optionally which item the record came from
+    # If the record has no sources, the sourceable institution is deleted
+    # NOTE: HoldingInstitutions are stored in the production database (so don't get any crazy ideas when refactoring this code)
+    def set_sources(holding_institution_ids, collection_ids, item_ids)
+      registry = init_registry_entry
+      registry.holding_institution_ids = Array(holding_institution_ids).uniq
+      registry.collection_ids = Array(collection_ids).uniq
+      registry.item_ids = Array(item_ids).uniq
+
+      if holding_institution_ids.any? || collection_ids.any? || item_ids.any?
+        registry.save!
+        set_sourceable_cache_column(true)
+      elsif registry.persisted?
+        registry.destroy
+        set_sourceable_cache_column(false)
       end
-      
-      set_sourceable_cache_column(holding_institution_ids.any?)
     end
     
     private
+
+    def init_registry_entry
+      raise "Cannot set sources of a #{self.class.name}. They are sourced through #{acts_as_sourceable_options[:through]}" if acts_as_sourceable_options[:through]
+
+      ActsAsSourceable::Registry.where(:sourceable_type => self.class.name, :sourceable_id => self.id).first_or_initialize
+    end
     
     def set_sourceable_cache_column(value)
-      # Update via sql because we don't need callbacks and validations called 
-      self.class.update_all({sourceable_cache_column => value}, :id => id) if sourceable_cache_column
+      update_column(acts_as_sourceable_options[:cache_column], value) if acts_as_sourceable_options[:cache_column] # Update via sql because we don't need callbacks and validations called
+    end
+  end
+
+  module HelperMethods
+    # Given an array of HoldingInstitutions, Collections, and Items, returns arrays containing only the records of each class.
+    # Order of return arrays is [HoldingInstitutions, Collections, Items]
+    def self.group_by_class(*sources)
+      groups = Array(sources).flatten.group_by(&:class)
+      return [groups[HoldingInstitution] || [], groups[Collection] || [], groups[Item] || []]
+    end
+
+    def self.group_ids_by_class(*sources)
+      group_by_class(*sources).collect!{|group| group.collect(&:id)}
+    end
+
+    # Removes sourceable institutions that no longer belong to a record or holding institution
+    def self.garbage_collect
+      ActsAsSourceable::Registry.pluck(:sourceable_type).uniq.each do |sourceable_type|
+        sourceable_table_name = sourceable_type.constantize.table_name
+        sourceable_id_sql = ActsAsSourceable::Registry
+          .select("#{ActsAsSourceable::Registry.table_name}.id")
+          .where(:sourceable_type => sourceable_type)
+          .joins("LEFT OUTER JOIN #{sourceable_table_name} ON #{sourceable_table_name}.id = #{ActsAsSourceable::Registry.table_name}.sourceable_id")
+          .where("#{sourceable_table_name}.id IS NULL").to_sql
+
+        ActsAsSourceable::Registry.delete_all("id IN (#{sourceable_id_sql})")
+      end
+
+
+      # Repair all Registry entries that reference missing items, collections, or holding institutions
+      holding_institution_ids = HoldingInstitution.pluck(:id)
+      collection_ids = Collection.pluck(:id)
+
+      [:holding_institution, :collection, :item].each do |type|
+        registries = ActsAsSourceable::Registry
+        registries = registries.joins("LEFT OUTER JOIN #{type}s ON #{type}s.id = ANY(#{type}_ids)")
+        registries = registries.group("#{ActsAsSourceable::Registry.table_name}.id")        
+        # Having at least one listed source_id and no matching sources, or fewer matches than the total listed sources
+        registries = registries.having("(array_length(#{type}_ids, 1) > 0 AND EVERY(#{type}s.id IS NULL)) OR count(*) < array_length(#{type}_ids, 1)")
+
+        # Fix the registry entries that are wrong
+        registries.includes(:sourceable).each do |registry|
+          item_ids = Item.where(:id => registry.item_ids).pluck(:id)
+          # ActiveRecord::Base.logger.debug "Registry #{registry.id}: holding_institution_ids: #{registry.holding_institution_ids.inspect} => #{registry.holding_institution_ids & holding_institution_ids}, collection_ids: #{registry.collection_ids.inspect} => #{registry.collection_ids & collection_ids}, item_ids: #{registry.item_ids.inspect} => #{registry.item_ids & item_ids} "
+          registry.sourceable.set_sources(registry.holding_institution_ids & holding_institution_ids, registry.collection_ids & collection_ids, registry.item_ids & item_ids)
+        end
+      end
     end
   end
 end

data/lib/acts_as_sourceable/registry.rb

@@ -0,0 +1,12 @@
+module ActsAsSourceable
+  class Registry < ActiveRecord::Base
+    self.table_name = 'acts_as_sourceable_registry'
+
+    belongs_to :sourceable, :polymorphic => true
+    validates_presence_of :sourceable_type, :sourceable_id
+
+    def sources
+       HoldingInstitution.find(self.holding_institution_ids) + Collection.find(self.collection_ids) + Item.find(self.item_ids)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_sourceable
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,8 +10,19 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2010-09-16 00:00:00.000000000 Z
-dependencies: []
+date: 2013-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: postgres_ext
+  requirement: &70193900896400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70193900896400
 description: Allows the RRN to perform garbage collection on categories that are no
   longer referenced.
 email: technical@rrnpilot.org
@@ -20,7 +31,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/acts_as_sourceable/acts_as_sourceable.rb
-- lib/acts_as_sourceable/sourceable_institution.rb
+- lib/acts_as_sourceable/registry.rb
 - lib/acts_as_sourceable.rb
 - README.rdoc
 homepage: http://github.com/rrn/acts_as_sourceable

data/lib/acts_as_sourceable/sourceable_institution.rb

@@ -1,16 +0,0 @@
-class SourceableInstitution < ActiveRecord::Base
-  belongs_to :sourceable, :polymorphic => true
-  belongs_to :holding_institution
-
-  validates_presence_of :sourceable_type, :sourceable_id, :holding_institution_id
-  
-  # Removes sourceable institutions that no longer belong to a record or holding institution
-  def self.garbage_collect
-    ActiveRecord::Base.connection.select_values(SourceableInstitution.select("DISTINCT sourceable_type").to_sql).each do |sourceable_type|
-      sourceable_table_name = sourceable_type.constantize.table_name
-      sourceable_id_sql = SourceableInstitution.select("sourceable_institutions.id").where(:sourceable_type => sourceable_type).joins("LEFT OUTER JOIN #{sourceable_table_name} ON #{sourceable_table_name}.id = sourceable_institutions.sourceable_id").where("#{sourceable_table_name}.id IS NULL").to_sql
-      SourceableInstitution.delete_all("id IN (#{sourceable_id_sql})")
-    end
-    SourceableInstitution.delete_all(["holding_institution_id NOT IN (?)", HoldingInstitution.all.collect(&:id)])
-  end  
-end