has_many_polymorphic 0.0.3

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2007-2011 Collective Idea
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,45 @@
+= HasManyPolymorphic
+
+This mixin adds a has many polymorphic relationship to a model and creates all the relationships needed by rails to handle it.
+        
+== Params
+- Name 
+	- name of the relationship, there is a convention that whatever name you choose, the polymorphic table columns on your through table should match.
+        
+- Options
+	- through - the model that handles the through relationship
+	- models  - models that should be included in this polymophic relationship
+        
+        
+== Added methods
+        
+  - {name param}
+	- the name of your relationship is used for the method name of this method. it will return an array of the models that are related via the has_many relationships
+        
+There is an after_save call back that will save the relationships when they are added or removed. If you want to remove a relationship the models need to be destroyed and this model reloaded.
+        
+== Example Usage
+		  
+    class PreferenceType < ActiveRecord::Base
+      has_many_polymorphic :preferenced_records,
+        :through => :valid_preference_types,
+        :models => [:desktops, :organizers]
+    end
+		  
+this gives you the following
+		
+    preferenceType = PreferenceType.first
+    preferenceType.desktops
+    preferenceType.organizers
+		   
+and
+		   
+		  preferenceType.preferenced_records
+		   
+which is a concatentated array of the models. You also get the following
+		   
+    desktop = Desktop.first
+    desktop.preference_types
+		   
+    organizer = Organizer.first
+    organizer.preference_types

data/lib/has_many_polymorphic.rb

@@ -0,0 +1,7 @@
+require 'has_many_polymorphic/has_many_polymorphic'
+ActiveRecord::Base.send :include, RussellEdge::HasManyPolymorphic
+
+#used to tie into Rails initialization load the models so the relationships are created
+require 'has_many_polymorphic/autoload'
+
+

data/lib/has_many_polymorphic/autoload.rb

@@ -0,0 +1,50 @@
+require 'initializer' unless defined? ::Rails::Initializer
+require 'action_controller/dispatcher' unless defined? ::ActionController::Dispatcher
+
+module RussellEdge
+  module HasManyPolymorphic
+
+=begin rdoc
+Searches for models that use <tt>has_many_polymorphic</tt> and makes sure that they get loaded during app initialization.
+This ensures that helper methods are injected into the target classes.
+=end
+    
+	#define the models that use has_many_polymorphic. has_many_polymorphs combed the file system for models
+	#that had the has_many_polymorphs method.  This is not as robust but more efficent.  It can be set via
+	#
+	#RussellEdge::HasManyPolymorphic::DEFAULT_OPTIONS = { :models => %w(PreferenceType AnotherModel) }
+	# 
+    DEFAULT_OPTIONS = {
+      :models => %w()
+    }
+
+    mattr_accessor :options
+    @@options = HashWithIndifferentAccess.new(DEFAULT_OPTIONS)
+
+    # Dispatcher callback to load polymorphic relationships
+    def self.autoload
+      options[:models].each do |model|
+        #try to load model if it exists.
+        begin
+          model.constantize
+        rescue=>e
+        end
+      end
+      
+    end
+  end
+end
+
+class Rails::Initializer #:nodoc:
+  # Make sure it gets loaded in the console, tests, and migrations
+  def after_initialize_with_autoload
+    after_initialize_without_autoload
+    RussellEdge::HasManyPolymorphic.autoload
+  end
+  alias_method_chain :after_initialize, :autoload
+end
+
+ActionController::Dispatcher.to_prepare(:morpheus_autoload) do
+  # Make sure it gets loaded in the app
+  RussellEdge::HasManyPolymorphic.autoload
+end

data/lib/has_many_polymorphic/has_many_polymorphic.rb

@@ -0,0 +1,179 @@
+module RussellEdge #:nodoc:
+    module HasManyPolymorphic #:nodoc:
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+      
+        ##
+        #  HasManyPolymorphic
+        #  This mixin adds a has many polymorphic relationship to a model and creates all the relationships needed
+        #  by rails to handle it.
+        #
+        #  Params
+        #
+        #  Name - name of the relationship, there is a convention that whatever name you choose, the polymorphic
+        #  table columns on your through table should match.
+        #
+        #  Options
+        #   - through - the model that handles the through relationship
+        #   - models  - models that should be included in this polymophic relationship
+        #
+        #
+        #  One method is added for you to use
+        #
+        #  - {name param}
+        #    - the name of your relationship is used for the method name of this method. it will return
+        #    an array of the models that are related via the has_many relationships
+        #
+        #  There is an after_save call back that will save the relationships when they are added or removed
+        #  If you want to remove a relationship the models need to be destroyed and this model reloaded.
+        #
+        #  Example Usage
+		#  
+		#  class PreferenceType < ActiveRecord::Base
+		#  	has_morpheus :preferenced_records,
+        #       :through => :valid_preference_types,
+        #       :models => [:desktops, :organizers]
+		#  end
+		#  
+		#  this gives you the following
+		#
+		#  preferenceType = PreferenceType.first
+		#  preferenceType.desktops
+		#  preferenceType.organizers
+		#   
+		#  and
+		#   
+		#  preferenceType.preferenced_records
+		#   
+		#  which is a concatentated array of the models. You also get the following
+		#   
+		#  desktop = Desktop.first
+		#  desktop.preference_types
+		#   
+		#  organizer = Organizer.first
+		#  organizer.preference_types
+        ##
+
+        def has_many_polymorphic(name, options = {})
+          target_class_name = self.name
+          instance_array_name = "#{name}_array".to_sym
+          
+          #declare array to related models
+          attr_accessor instance_array_name
+        
+          #create the has_many relationship
+          has_many options[:through], :dependent => :destroy
+
+          #create the has_many relationship for each model
+          options[:models].each do |model|
+            has_many model, :through => options[:through], :source => model.to_s.singularize,
+              :conditions => ["#{options[:through]}.#{name.to_s.singularize}_type = ?", model.to_s.classify], :dependent => :destroy
+          end
+
+          #modify the through class to add the belongs to relationships
+          options[:through].to_s.classify.constantize.class_exec do
+            options[:models].each do |model|
+              belongs_to model.to_s.singularize.to_sym, :class_name => model.to_s.classify, :foreign_key => "#{name.to_s.singularize}_id"
+            end
+          end
+
+          #I want to keep the  << and push methods of array so this helps to keep them.
+          define_method name do
+            #used the declared instance variable array
+            records = self.send(instance_array_name.to_s)
+            records = records || []
+            options[:models].each do |model|
+              records = records | self.send(model.to_s)
+            end
+            
+            #set it back to the instance variable
+            self.send("#{instance_array_name.to_s}=", records)
+            
+            records
+          end
+
+          #before we save this model make sure you save all the relationships.
+          before_save do |record|
+            record.send(name).each do |reln_record|
+              conditions = "#{name.to_s.singularize}_id = #{reln_record.id} and #{name.to_s.singularize}_type = '#{reln_record.class.name}'"
+              exisiting_record = record.send("#{options[:through]}").find(:first,
+                :conditions => conditions)
+
+              if exisiting_record.nil?
+                values_hash = {}
+                values_hash["#{record.class.name.underscore}_id"] = record.id
+                values_hash["#{name.to_s.singularize}_type"] = reln_record.class.name
+                values_hash["#{name.to_s.singularize}_id"] = reln_record.id
+              
+                options[:through].to_s.classify.constantize.create(values_hash)
+              end
+            end
+          end
+			
+	      #include instance methods into this model
+          include RussellEdge::HasManyPolymorphic::InstanceMethods
+
+          #add the relationship to the models.
+          options[:models].each do |model|
+            model.to_s.classify.constantize.class_exec do
+              #build the has many polymorphic relationship via finder_sql
+              has_many target_class_name.underscore.pluralize.to_sym,
+                :class_name => "#{target_class_name}",
+                :finder_sql => 'SELECT DISTINCT target.* from '+target_class_name.tableize+' target join '+
+                options[:through].to_s+' join_table on join_table.'+target_class_name.underscore.singularize+'_id = target.id '+
+                'and join_table.'+name.to_s.singularize+'_type = \'#{model_class_name}\' and '+
+                'join_table.'+name.to_s.singularize+'_id = #{id}'
+
+              #we want to save the relantionships when the model is saved
+              before_save do |record|
+                record.send(target_class_name.underscore.pluralize).each do |reln_record|
+
+                  db_result = ActiveRecord::Base.connection.select_all("SELECT count(*) as num_rows FROM #{options[:through]}
+                                                    where #{name.to_s.singularize}_id = #{record.id}
+                                                    and #{name.to_s.singularize}_type = '#{record.class.name}'
+                                                    and #{target_class_name.underscore.singularize}_id = #{reln_record.id}")
+
+                  #make sure that the relantionship does not already exist
+                  num_rows = db_result[0]['num_rows'] unless db_result == -1
+                  if num_rows.nil? || num_rows.to_i == 0
+                    values_hash = {}
+                    values_hash["#{reln_record.class.name.underscore}_id"] = reln_record.id
+                    values_hash["#{name.to_s.singularize}_type"] = record.class.name
+                    values_hash["#{name.to_s.singularize}_id"] = record.id
+                    options[:through].to_s.classify.constantize.create(values_hash)
+                  end
+                end
+              end
+            end
+
+            model.to_s.classify.constantize.class_eval do
+              #check if this is using STI if so use the type attribute else use the class name
+              def model_class_name
+                if attributes['type']
+                  attributes['type']
+                else
+                  self.class.to_s
+                end
+              end
+            end
+          end
+
+        end
+      end
+				
+      module InstanceMethods
+        #clear array on reload
+        def reload(*args)
+          @records = []
+
+          super args
+        end
+
+      end
+
+    end
+  end

data/lib/has_many_polymorphic/version.rb

@@ -0,0 +1,3 @@
+module HasManyPolymorphic
+  VERSION = '0.0.3' unless defined?(::HasManyPolymorphic::VERSION)
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: has_many_polymorphic
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Russell Holmes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-26 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id001
+description: Simple replacement for has_many_polymorphs
+email: rholmes@tnsolutionsinc.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/has_many_polymorphic/autoload.rb
+- lib/has_many_polymorphic/has_many_polymorphic.rb
+- lib/has_many_polymorphic/version.rb
+- lib/has_many_polymorphic.rb
+- MIT-LICENSE.txt
+- README.rdoc
+has_rdoc: true
+homepage: https://github.com/russ1985/has_many_polymorphic
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple replacement for has_many_polymorphs
+test_files: []
+