webpulser-habtm_list 0.1.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [name of plugin creator]
+
+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

@@ -0,0 +1,42 @@
+HabtmList
+=========
+
+This plugin arose out of a page on the Rails wiki:
+http://wiki.rubyonrails.org/rails/pages/BetterHabtmList
+
+The purpose is to allow position-based "acts_as_list"-like behavior in a has_and_belongs_to_many association.  Methods are included to move members up and down in the list.  
+
+The original author of the technique, according to the wiki history, was "Matt."  Sorry, I don't know his last name; I'll give proper credit if he turns up to take it.  I refactored and fixed some bugs in the code, and now I'm simply putting it up on Github.  I'm claiming no ownership rights on this code whatsoever; use it any way you like.
+
+
+Usage
+-----
+class Category < ActiveRecord::Base
+  has_and_belongs_to_many :products,
+                          :order => 'position',
+						  :list => true
+end
+
+Methods
+-------
+*first?(item)* - returns true if item is first in the list
+*last?(item)* - returns true if item is last in the list
+*in_list?(item)* - returns true if item exists in the list
+*higher_item(item)* - returns the item one position above the given item in the list
+*lower_item(item)* - returns the item one position below the given item in the list
+*move_higher(item)* - moves the item up one position in the list
+*move_lower(item)* - moves the item down one position in the list
+*move_to_top(item)* - moves the item to the first position in the list
+*move_to_bottom(item)* - moves the item to the last position in the list
+*add_to_list_top(item)* - adds the item to the list in the first position
+*add_to_list_bottom(item)* - adds the item to the list in the last position
+*move_to_position(item, position)* - moves the item to the stated position in the list
+*reset_positions* - "first aid" method to restore list positions if positions become duplicated or go out of sync (e.g., if records are inserted or updated by external methods)
+
+Support
+-------
+I don't promise any, but if you have any questions or complaints you're welcome to e-mail me at sfeley@gmail.com.
+
+Also check out my podcast, Escape Pod [http://escapepod.org], if you're interested in science fiction short stories.
+ 
+ - Steve Eley

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the habtm_list plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the habtm_list plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'HabtmList'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/webpulser-habtm_list.rb

@@ -0,0 +1,315 @@
+module RailsExtensions
+  module HabtmList
+  
+    def self.append_features(base) #:nodoc:
+      super
+      base.extend(ClassMethods)
+      base.class_eval do
+        class << self
+          alias_method_chain :has_and_belongs_to_many, :list_handling
+        end
+      end
+    end
+
+    module ClassMethods
+      def has_and_belongs_to_many_with_list_handling(name, options={}, &extension)
+        if options.delete(:list)
+          options[:extend] = RailsExtensions::HabtmList::AssociationListMethods
+
+          after_add_callback_symbol = "maintain_list_after_add_for_#{name}".to_sym
+          before_remove_callback_symbol = "maintain_list_before_remove_for_#{name}".to_sym
+          name_ids = "#{name.to_s.singularize}_ids"
+          name_ids_symbol = ":#{name_ids}"
+          
+          options[:after_add] ||= []
+          options[:after_add] << after_add_callback_symbol
+
+          options[:before_remove] ||= []
+          options[:before_remove] << before_remove_callback_symbol
+
+          class_eval <<-EOV
+            def #{after_add_callback_symbol}(added)
+              self.#{name}.add_to_list_bottom(added)
+            end
+            
+            def #{before_remove_callback_symbol}(removed)
+              self.#{name}.remove_from_list(removed)
+            end
+
+            def update_attributes_with_#{name_ids}(params)
+              if params[#{name_ids_symbol}].kind_of?(Array)
+                @list_ids ||= {}
+                @list_ids[#{name_ids_symbol}] = params[#{name_ids_symbol}].reject(&:blank?)
+              end
+
+              update_attributes_without_#{name_ids}(params)
+            end
+
+            alias_method_chain :update_attributes, #{name_ids_symbol}
+            after_save :reset_#{name}_position
+
+            def reset_#{name}_position
+              if @list_ids && @list_ids[#{name_ids_symbol}]
+                self.#{name}.reset_positions_by_ids @list_ids[#{name_ids_symbol}]
+              end
+            end
+          EOV
+        end
+
+        has_and_belongs_to_many_without_list_handling(name, options, &extension)
+      end
+    end
+      
+    module AssociationListMethods
+      def move_to_position(item, position)
+        return if !in_list?(item) || position.to_i == list_position(item)
+        list_item_class.transaction do
+          remove_from_list(item)
+          insert_at_position(item, position)
+        end
+        resort_array
+      end
+  
+      def move_lower(item)
+        list_item_class.transaction do
+          lower = lower_item(item)
+          return unless lower
+          decrement_position(lower)
+          increment_position(item)
+        end
+        resort_array
+      end
+  
+      def move_higher(item)
+        list_item_class.transaction do
+          higher = higher_item(item)
+          return unless higher
+          increment_position(higher)
+          decrement_position(item)
+        end
+        resort_array
+      end
+  
+      def move_to_bottom(item)
+        return unless in_list?(item)
+        list_item_class.transaction do
+          decrement_positions_on_lower_items(item)
+          assume_bottom_position(item)
+        end
+        resort_array
+      end
+  
+      def move_to_top(item)
+        return unless in_list?(item)
+        list_item_class.transaction do
+          increment_positions_on_higher_items(item)
+          assume_top_position(item)
+        end
+        resort_array
+      end
+
+      # should only be called externally from the before_remove callback
+      def remove_from_list(item)
+        decrement_positions_on_lower_items(item) if in_list?(item)
+        item[position_column] = nil
+      end
+
+      def first?(item)
+        item == self.first
+      end
+  
+      def last?(item)
+        item == self.last
+      end
+  
+      def higher_item(item)
+        return nil unless in_list?(item)
+        self.find(:first, :conditions => "#{position_column} = #{(list_position(item) - 1).to_s}")
+      end
+
+      def lower_item(item)
+        return nil unless in_list?(item)
+        self.find(:first, :conditions => "#{position_column} = #{(list_position(item) + 1).to_s}")
+      end
+
+      def in_list?(item)
+        self.include?(item)
+      end
+
+      def add_to_list_bottom(item)
+        item.save! if item.id.nil? # Rails 2.0.2 - Callbacks don't save first on association.create() 
+        list_item_class.transaction do
+          assume_bottom_position(item)
+        end
+        resort_array
+      end
+      
+      def add_to_list_top(item)
+        list_item_class.transaction do
+          increment_positions_on_all_items
+          assume_top_position(item)
+        end
+        resort_array
+      end
+      
+      # "First aid" method in case someone shifts the array around outside these methods, or
+      # the positions in the joins table go totally out of whack.  Don't use it for
+      # simple ordering because it's inefficient.
+      def reset_positions
+        self.each_index do |i|
+          item = self[i]
+          connection.update(
+            "UPDATE #{join_table} SET #{position_column} = #{i} " +
+            "WHERE #{foreign_key} = #{@owner.id} AND #{list_item_foreign_key} = #{item.id}"
+          )
+        end
+      end
+          
+       def reset_positions_by_ids(ids = self.collect(&:id))
+        ids.each_with_index do |id, i|
+          connection.update(
+            "UPDATE #{join_table} SET #{position_column} = #{i} " +
+            "WHERE #{foreign_key} = #{@owner.id} AND #{list_item_foreign_key} = #{id}"
+          ) if id.to_i != 0
+        end
+      end
+     
+  
+      private
+        def position_column
+          @reflection.options[:order] || 'position'
+        end
+        
+        def list_item_class
+          @reflection.klass
+        end
+        
+        def join_table
+          @reflection.options[:join_table]
+        end
+        
+        def foreign_key
+          @reflection.primary_key_name
+        end
+        
+        def list_item_foreign_key
+          @reflection.association_foreign_key
+        end
+        
+        def list_position(item)
+          self.index(item)
+        end
+
+
+        def set_position(item, position)
+          connection.update(
+            "UPDATE #{join_table} SET #{position_column} = #{position} " +
+            "WHERE #{foreign_key} = #{@owner.id} AND #{list_item_foreign_key} = #{item.id}"
+          )
+          if @target
+            obj = @target.find {|obj| obj.id == item.id}
+            obj[position_column] = position if obj
+          end
+        end
+
+        def assume_bottom_position(item)
+          set_position(item, self.length - 1)
+        end
+
+        def assume_top_position(item)
+          set_position(item, 0)
+        end
+
+        def increment_position_by(item, increment)
+          return unless in_list?(item)
+          connection.update(
+            "UPDATE #{join_table} SET #{position_column} = #{position_column} + (#{increment}) " +
+            "WHERE #{foreign_key} = #{@owner.id} AND #{list_item_foreign_key} = #{item.id}"
+          )
+          if @target
+            obj = @target.find {|obj| obj.id == item.id}
+            obj[position_column] = obj[position_column].to_i + increment if obj
+          end
+        end
+
+        def increment_position(item)
+          increment_position_by(item, 1)
+        end
+
+        def decrement_position(item)
+          increment_position_by(item, -1)
+        end
+
+        # This has the effect of moving all the higher items up one.
+        def decrement_positions_on_higher_items(position)
+          connection.update(
+            "UPDATE #{join_table} SET #{position_column} = (#{position_column} - 1) " +
+            "WHERE #{foreign_key} = #{@owner.id} AND #{position_column} <= #{position}"
+          )
+          @target.each { |obj|
+            obj[position_column] = obj[position_column].to_i - 1 if in_list?(obj) && obj[position_column].to_i <= position
+          } if @target
+        end
+    
+        # This has the effect of moving all the lower items up one.
+        def decrement_positions_on_lower_items(item)
+          return unless in_list?(item)
+          position = list_position(item)
+          connection.update(
+            "UPDATE #{join_table} SET #{position_column} = (#{position_column} - 1) " +
+            "WHERE #{foreign_key} = #{@owner.id} AND #{position_column} > #{position}"
+          )
+          @target.each { |obj|
+            obj[position_column] = obj[position_column].to_i - 1 if in_list?(obj) && obj[position_column].to_i > position
+          } if @target
+        end
+
+        # This has the effect of moving all the higher items down one.
+        def increment_positions_on_higher_items(item)
+          return unless in_list?(item)
+          position = list_position(item)
+          connection.update(
+            "UPDATE #{join_table} SET #{position_column} = (#{position_column} + 1) " +
+            "WHERE #{foreign_key} = #{@owner.id} AND #{position_column} < #{position}"
+          )
+          @target.each { |obj|
+            obj[position_column] = obj[position_column].to_i + 1 if in_list?(obj) && obj[position_column].to_i < position
+          } if @target
+        end
+
+        # This has the effect of moving all the lower items down one.
+        def increment_positions_on_lower_items(position)
+          connection.update(
+            "UPDATE #{join_table} SET #{position_column} = (#{position_column} + 1) " +
+            "WHERE #{foreign_key} = #{@owner.id} AND #{position_column} >= #{position}"
+          )
+          @target.each { |obj|
+            obj[position_column] = obj[position_column].to_i + 1 if in_list?(obj) && obj[position_column].to_i >= position
+          } if @target
+        end
+
+        def increment_positions_on_all_items
+          connection.update(
+            "UPDATE #{join_table} SET #{position_column} = (#{position_column} + 1) " +
+            "WHERE #{foreign_key} = #{@owner.id}"
+          )
+          @target.each { |obj|
+            obj[position_column] = obj[position_column].to_i + 1 if in_list?(obj)
+          } if @target
+        end
+
+        def insert_at_position(item, position)
+          remove_from_list(item)
+          increment_positions_on_lower_items(position)
+          set_position(item, position)
+        end
+        
+        # called after changing position values so the array reflects the updated ordering
+        def resort_array
+          @target.sort! {|x,y| x[position_column].to_i <=> y[position_column].to_i} if @target
+        end      
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include,RailsExtensions::HabtmList)

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: webpulser-habtm_list
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- James Healy
+- Cyril LEPAGNOT
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Adds list-like position functionality to Rails has_and_belongs_to_many associations
+email: cyril.lepagnot@webpulser.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- MIT-LICENSE
+- Rakefile
+- lib/webpulser-habtm_list.rb
+has_rdoc: false
+homepage: http://wiki.rubyonrails.org/rails/pages/BetterHabtmList
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: has_and_belongs_to_many list-like
+test_files: []
+