has_many_polymorphic 0.5.0 → 0.6.0

data/README.rdoc

@@ -6,9 +6,10 @@ This mixin adds a has many polymorphic relationship to a model and creates all t
 - Models
 	- the models you want to autoload so all the relationships are created on initialzation of Rails
 	
-== Example Usage
+== Setup
 
-	RussellEdge::HasManyPolymorphic.options[:models] = %w(PreferenceType)
+	You must define the models that you want to use inside an initializer using
+        RussellEdge::HasManyPolymorphic.add_models(%w(PreferenceType)) or RussellEdge::HasManyPolymorphic.add_models("PreferenceType")
 		
 == Params
 - Name 
@@ -42,7 +43,7 @@ this gives you the following
 		   
 and
 		   
-		  preferenceType.preferenced_records
+    preferenceType.preferenced_records
 		   
 which is a concatentated array of the models. You also get the following
 		   

data/lib/has_many_polymorphic/engine.rb

@@ -0,0 +1,44 @@
+module RussellEdge
+  module HasManyPolymorphic
+    class Engine < Rails::Engine
+      isolate_namespace HasManyPolymorphic
+      DEFAULT_OPTIONS = {:models => %w()}
+      @@options = HashWithIndifferentAccess.new(DEFAULT_OPTIONS)
+
+      initializer "has_many_polymorphic.autoload_models", :after => :load_config_initializers do |app|
+        RussellEdge::HasManyPolymorphic::Engine.autoload_models
+      end
+
+      ActiveSupport.on_load(:active_record) do
+        include RussellEdge::HasManyPolymorphic
+      end
+      
+      #set engine to scope
+      engine = self
+      config.to_prepare do
+        engine.autoload_models
+      end
+
+      class << self
+        def add_models(models)
+          if models.is_a? Array
+            @@options[:models] = @@options[:models] | models
+          else
+            @@options[:models] << models
+          end
+        end
+
+        # Dispatcher callback to load polymorphic relationships
+        def autoload_models
+          @@options[:models].each do |model|
+            #try to load model if it exists.
+            begin
+              model.constantize
+            rescue=>e
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/has_many_polymorphic/has_many_polymorphic.rb

@@ -1,143 +1,143 @@
 module RussellEdge #:nodoc:
-    module HasManyPolymorphic #:nodoc:
+  module HasManyPolymorphic #:nodoc:
 
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-      module ClassMethods
+    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
-        ##
+      ##
+      #  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
+      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
+        #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
+        has_many options[:through], :dependent => :destroy
 
-          #create the has_many relationship for each model
+        #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|
-            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
+            belongs_to model.to_s.singularize.to_sym, :class_name => model.to_s.classify, :foreign_key => "#{name.to_s.singularize}_id"
           end
+        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
+        #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
-
-          #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)
+          #set it back to the instance variable
+          self.send("#{instance_array_name.to_s}=", records)
             
-            records
-          end
+          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|
-              #handle STI get superclass class_name if not sub class of ActiveRecord::Base	
-              klass_name = (reln_record.class.superclass == ActiveRecord::Base) ? reln_record.class.name : reln_record.class.superclass.name
-              conditions = "#{name.to_s.singularize}_id = #{reln_record.id} and #{name.to_s.singularize}_type = '#{klass_name}'"
-              exisiting_record = record.send("#{options[:through]}").find(:first,:conditions => conditions)
+        #before we save this model make sure you save all the relationships.
+        before_save do |record|
+          record.send(name).each do |reln_record|
+            #handle STI get superclass class_name if not sub class of ActiveRecord::Base
+            klass_name = (reln_record.class.superclass == ActiveRecord::Base) ? reln_record.class.name : reln_record.class.superclass.name
+            conditions = "#{name.to_s.singularize}_id = #{reln_record.id} and #{name.to_s.singularize}_type = '#{klass_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"] = klass_name
-                values_hash["#{name.to_s.singularize}_id"] = reln_record.id
+            if exisiting_record.nil?
+              values_hash = {}
+              values_hash["#{record.class.name.underscore}_id"] = record.id
+              values_hash["#{name.to_s.singularize}_type"] = klass_name
+              values_hash["#{name.to_s.singularize}_id"] = reln_record.id
               
-                options[:through].to_s.classify.constantize.create(values_hash)
-              end
+              options[:through].to_s.classify.constantize.create(values_hash)
             end
           end
+        end
 			
 	      #include instance methods into this model
-          include RussellEdge::HasManyPolymorphic::InstanceMethods
+        include RussellEdge::HasManyPolymorphic::InstanceMethods
 
-          #add the relationship to the models.
-          options[:models].each do |model|
-            model.to_s.classify.constantize.class_exec do
-              has_many options[:through], :as => name.to_s.singularize
-              has_many target_class_name.tableize, :through => options[:through]
-            end
+        #add the relationship to the models.
+        options[:models].each do |model|
+          model.to_s.classify.constantize.class_exec do
+            has_many options[:through], :as => name.to_s.singularize
+            has_many target_class_name.tableize, :through => options[:through]
           end
-
         end
+
       end
+    end
 				
-      module InstanceMethods
-        #clear array on reload
-        def reload(*args)
-          @records = []
-
-          super args
-        end
+    module InstanceMethods
+      #clear array on reload
+      def reload(*args)
+        @records = []
 
+        super args
       end
 
     end
-  end
+
+  end
+end

data/lib/has_many_polymorphic/version.rb

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

data/lib/has_many_polymorphic.rb

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

metadata

@@ -1,87 +1,61 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: has_many_polymorphic
-version: !ruby/object:Gem::Version 
-  hash: 11
-  prerelease: false
-  segments: 
-  - 0
-  - 5
-  - 0
-  version: 0.5.0
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Russell Holmes
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-08-24 00:00:00 -04:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-11-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &2152612200 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 9
-        segments: 
-        - 2
-        - 3
-        - 5
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 2.3.5
   type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: *2152612200
 description: Simple replacement for has_many_polymorphs
 email: rholmes@tnsolutionsinc.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- lib/has_many_polymorphic/autoload.rb
+files:
+- lib/has_many_polymorphic/engine.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: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+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 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Simple replacement for has_many_polymorphs
 test_files: []
-

data/lib/has_many_polymorphic/autoload.rb

@@ -1,37 +0,0 @@
-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::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
-
-#create Railtie to plugin into rails initialization
-class RussellEdge::HasManyPolymorphic::RailTie < Rails::Railtie
-  initializer "has_many_polymorphic.autoload_models", :after => :initialize do |app|
-      RussellEdge::HasManyPolymorphic.autoload
-   end
-end