jro_apps/redmine Commit - r10703:a7023dfa9b8e

Replaces find(:first) calls....

Jean-Philippe Lang -

r10703:a7023dfa9b8e

parent child

Context file:

r10703:a7023dfa9b8e

Collapse all files

lib/plugins/acts_as_list/lib/active_record/acts/list.rb +4 -4

             module ActiveRecord
               module Acts #:nodoc:
                 module List #:nodoc:
                   def self.included(base)
                     base.extend(ClassMethods)
                   end
                   # This +acts_as+ extension provides the capabilities for sorting and reordering a number of objects in a list.
                   # The class that has this specified needs to have a +position+ column defined as an integer on
                   # the mapped database table.
                   #
                   # Todo list example:
                   #
                   #   class TodoList < ActiveRecord::Base
                   #     has_many :todo_items, :order => "position"
                   #   end
                   #
                   #   class TodoItem < ActiveRecord::Base
                   #     belongs_to :todo_list
                   #     acts_as_list :scope => :todo_list
                   #   end
                   #
                   #   todo_list.first.move_to_bottom
                   #   todo_list.last.move_higher
                   module ClassMethods
                     # Configuration options are:
                     #
                     # * +column+ - specifies the column name to use for keeping the position integer (default: +position+)
                     # * +scope+ - restricts what is to be considered a list. Given a symbol, it'll attach <tt>_id</tt>
                     #   (if it hasn't already been added) and use that as the foreign key restriction. It's also possible
                     #   to give it an entire string that is interpolated if you need a tighter scope than just a foreign key.
                     #   Example: <tt>acts_as_list :scope => 'todo_list_id = #{todo_list_id} AND completed = 0'</tt>
                     def acts_as_list(options = {})
                       configuration = { :column => "position", :scope => "1 = 1" }
                       configuration.update(options) if options.is_a?(Hash)
                       configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
                       if configuration[:scope].is_a?(Symbol)
                         scope_condition_method = %(
                           def scope_condition
                             if #{configuration[:scope].to_s}.nil?
                               "#{configuration[:scope].to_s} IS NULL"
                             else
                               "#{configuration[:scope].to_s} = \#{#{configuration[:scope].to_s}}"
                             end
                           end
                         )
                       else
                         scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end"
                       end
                       class_eval <<-EOV
                         include ActiveRecord::Acts::List::InstanceMethods
                         def acts_as_list_class
                           ::#{self.name}
                         end
                         def position_column
                           '#{configuration[:column]}'
                         end
                         #{scope_condition_method}
                         before_destroy :remove_from_list
                         before_create  :add_to_list_bottom
                       EOV
                     end
                   end
                   # All the methods available to a record that has had <tt>acts_as_list</tt> specified. Each method works
                   # by assuming the object to be the item in the list, so <tt>chapter.move_lower</tt> would move that chapter
                   # lower in the list of all chapters. Likewise, <tt>chapter.first?</tt> would return +true+ if that chapter is
                   # the first in the list of all chapters.
                   module InstanceMethods
                     # Insert the item at the given position (defaults to the top position of 1).
                     def insert_at(position = 1)
                       insert_at_position(position)
                     end
                     # Swap positions with the next lower item, if one exists.
                     def move_lower
                       return unless lower_item
                       acts_as_list_class.transaction do
                         lower_item.decrement_position
                         increment_position
                       end
                     end
                     # Swap positions with the next higher item, if one exists.
                     def move_higher
                       return unless higher_item
                       acts_as_list_class.transaction do
                         higher_item.increment_position
                         decrement_position
                       end
                     end
                     # Move to the bottom of the list. If the item is already in the list, the items below it have their
                     # position adjusted accordingly.
                     def move_to_bottom
                       return unless in_list?
                       acts_as_list_class.transaction do
                         decrement_positions_on_lower_items
                         assume_bottom_position
                       end
                     end
                     # Move to the top of the list. If the item is already in the list, the items above it have their
                     # position adjusted accordingly.
                     def move_to_top
                       return unless in_list?
                       acts_as_list_class.transaction do
                         increment_positions_on_higher_items
                         assume_top_position
                       end
                     end
                     # Move to the given position
                     def move_to=(pos)
                       case pos.to_s
                       when 'highest'
                         move_to_top
                       when 'higher'
                         move_higher
                       when 'lower'
                         move_lower
                       when 'lowest'
                         move_to_bottom
                       end
                       reset_positions_in_list
                     end
                     def reset_positions_in_list
                       acts_as_list_class.where(scope_condition).reorder("#{position_column} ASC, id ASC").each_with_index do |item, i|
                         unless item.send(position_column) == (i + 1)
                           acts_as_list_class.update_all({position_column => (i + 1)}, {:id => item.id})
                         end
                       end
                     end
                     # Removes the item from the list.
                     def remove_from_list
                       if in_list?
                         decrement_positions_on_lower_items
                         update_attribute position_column, nil
                       end
                     end
                     # Increase the position of this item without adjusting the rest of the list.
                     def increment_position
                       return unless in_list?
                       update_attribute position_column, self.send(position_column).to_i + 1
                     end
                     # Decrease the position of this item without adjusting the rest of the list.
                     def decrement_position
                       return unless in_list?
                       update_attribute position_column, self.send(position_column).to_i - 1
                     end
                     # Return +true+ if this object is the first in the list.
                     def first?
                       return false unless in_list?
                       self.send(position_column) == 1
                     end
                     # Return +true+ if this object is the last in the list.
                     def last?
                       return false unless in_list?
                       self.send(position_column) == bottom_position_in_list
                     end
                     # Return the next higher item in the list.
                     def higher_item
                       return nil unless in_list?
-                      acts_as_list_class.find(:first, :conditions =>
+                      acts_as_list_class.where(
                         "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
+                      ).first
                     end
                     # Return the next lower item in the list.
                     def lower_item
                       return nil unless in_list?
-                      acts_as_list_class.find(:first, :conditions =>
+                      acts_as_list_class.where(
                         "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
+                      ).first
                     end
                     # Test if this record is in a list
                     def in_list?
                       !send(position_column).nil?
                     end
                     private
                       def add_to_list_top
                         increment_positions_on_all_items
                       end
                       def add_to_list_bottom
                         self[position_column] = bottom_position_in_list.to_i + 1
                       end
                       # Overwrite this method to define the scope of the list changes
                       def scope_condition() "1" end
                       # Returns the bottom position number in the list.
                       #   bottom_position_in_list    # => 2
                       def bottom_position_in_list(except = nil)
                         item = bottom_item(except)
                         item ? item.send(position_column) : 0
                       end
                       # Returns the bottom item
                       def bottom_item(except = nil)
                         conditions = scope_condition
                         conditions = "#{conditions} AND #{self.class.primary_key} != #{except.id}" if except
                         acts_as_list_class.where(conditions).reorder("#{position_column} DESC").first
                       end
                       # Forces item to assume the bottom position in the list.
                       def assume_bottom_position
                         update_attribute(position_column, bottom_position_in_list(self).to_i + 1)
                       end
                       # Forces item to assume the top position in the list.
                       def assume_top_position
                         update_attribute(position_column, 1)
                       end
                       # This has the effect of moving all the higher items up one.
                       def decrement_positions_on_higher_items(position)
                         acts_as_list_class.update_all(
                           "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} <= #{position}"
                         )
                       end
                       # This has the effect of moving all the lower items up one.
                       def decrement_positions_on_lower_items
                         return unless in_list?
                         acts_as_list_class.update_all(
                           "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
                         )
                       end
                       # This has the effect of moving all the higher items down one.
                       def increment_positions_on_higher_items
                         return unless in_list?
                         acts_as_list_class.update_all(
                           "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
                         )
                       end
                       # This has the effect of moving all the lower items down one.
                       def increment_positions_on_lower_items(position)
                         acts_as_list_class.update_all(
                           "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} >= #{position}"
                        )
                       end
                       # Increments position (<tt>position_column</tt>) of all items in the list.
                       def increment_positions_on_all_items
                         acts_as_list_class.update_all(
                           "#{position_column} = (#{position_column} + 1)",  "#{scope_condition}"
                         )
                       end
                       def insert_at_position(position)
                         remove_from_list
                         increment_positions_on_lower_items(position)
                         self.update_attribute(position_column, position)
                       end
                   end
                 end
               end
             end

lib/plugins/acts_as_versioned/lib/acts_as_versioned.rb +2 -2

             # Copyright (c) 2005 Rick Olson
             #
             # 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.
             module ActiveRecord #:nodoc:
               module Acts #:nodoc:
                 # Specify this act if you want to save a copy of the row in a versioned table.  This assumes there is a
                 # versioned table ready and that your model has a version field.  This works with optimistic locking if the lock_version
                 # column is present as well.
                 #
                 # The class for the versioned model is derived the first time it is seen. Therefore, if you change your database schema you have to restart
                 # your container for the changes to be reflected. In development mode this usually means restarting WEBrick.
                 #
                 #   class Page < ActiveRecord::Base
                 #     # assumes pages_versions table
                 #     acts_as_versioned
                 #   end
                 #
                 # Example:
                 #
                 #   page = Page.create(:title => 'hello world!')
                 #   page.version       # => 1
                 #
                 #   page.title = 'hello world'
                 #   page.save
                 #   page.version       # => 2
                 #   page.versions.size # => 2
                 #
                 #   page.revert_to(1)  # using version number
                 #   page.title         # => 'hello world!'
                 #
                 #   page.revert_to(page.versions.last) # using versioned instance
                 #   page.title         # => 'hello world'
                 #
                 #   page.versions.earliest # efficient query to find the first version
                 #   page.versions.latest   # efficient query to find the most recently created version
                 #
                 #
                 # Simple Queries to page between versions
                 #
                 #   page.versions.before(version)
                 #   page.versions.after(version)
                 #
                 # Access the previous/next versions from the versioned model itself
                 #
                 #   version = page.versions.latest
                 #   version.previous # go back one version
                 #   version.next     # go forward one version
                 #
                 # See ActiveRecord::Acts::Versioned::ClassMethods#acts_as_versioned for configuration options
                 module Versioned
                   CALLBACKS = [:set_new_version, :save_version_on_create, :save_version?, :clear_altered_attributes]
                   def self.included(base) # :nodoc:
                     base.extend ClassMethods
                   end
                   module ClassMethods
                     # == Configuration options
                     #
                     # * <tt>class_name</tt> - versioned model class name (default: PageVersion in the above example)
                     # * <tt>table_name</tt> - versioned model table name (default: page_versions in the above example)
                     # * <tt>foreign_key</tt> - foreign key used to relate the versioned model to the original model (default: page_id in the above example)
                     # * <tt>inheritance_column</tt> - name of the column to save the model's inheritance_column value for STI.  (default: versioned_type)
                     # * <tt>version_column</tt> - name of the column in the model that keeps the version number (default: version)
                     # * <tt>sequence_name</tt> - name of the custom sequence to be used by the versioned model.
                     # * <tt>limit</tt> - number of revisions to keep, defaults to unlimited
                     # * <tt>if</tt> - symbol of method to check before saving a new version.  If this method returns false, a new version is not saved.
                     #   For finer control, pass either a Proc or modify Model#version_condition_met?
                     #
                     #     acts_as_versioned :if => Proc.new { |auction| !auction.expired? }
                     #
                     #   or...
                     #
                     #     class Auction
                     #       def version_condition_met? # totally bypasses the <tt>:if</tt> option
                     #         !expired?
                     #       end
                     #     end
                     #
                     # * <tt>if_changed</tt> - Simple way of specifying attributes that are required to be changed before saving a model.  This takes
                     #   either a symbol or array of symbols.  WARNING - This will attempt to overwrite any attribute setters you may have.
                     #   Use this instead if you want to write your own attribute setters (and ignore if_changed):
                     #
                     #     def name=(new_name)
                     #       write_changed_attribute :name, new_name
                     #     end
                     #
                     # * <tt>extend</tt> - Lets you specify a module to be mixed in both the original and versioned models.  You can also just pass a block
                     #   to create an anonymous mixin:
                     #
                     #     class Auction
                     #       acts_as_versioned do
                     #         def started?
                     #           !started_at.nil?
                     #         end
                     #       end
                     #     end
                     #
                     #   or...
                     #
                     #     module AuctionExtension
                     #       def started?
                     #         !started_at.nil?
                     #       end
                     #     end
                     #     class Auction
                     #       acts_as_versioned :extend => AuctionExtension
                     #     end
                     #
                     #  Example code:
                     #
                     #    @auction = Auction.find(1)
                     #    @auction.started?
                     #    @auction.versions.first.started?
                     #
                     # == Database Schema
                     #
                     # The model that you're versioning needs to have a 'version' attribute. The model is versioned
                     # into a table called #{model}_versions where the model name is singlular. The _versions table should
                     # contain all the fields you want versioned, the same version column, and a #{model}_id foreign key field.
                     #
                     # A lock_version field is also accepted if your model uses Optimistic Locking.  If your table uses Single Table inheritance,
                     # then that field is reflected in the versioned model as 'versioned_type' by default.
                     #
                     # Acts_as_versioned comes prepared with the ActiveRecord::Acts::Versioned::ActMethods::ClassMethods#create_versioned_table
                     # method, perfect for a migration.  It will also create the version column if the main model does not already have it.
                     #
                     #   class AddVersions < ActiveRecord::Migration
                     #     def self.up
                     #       # create_versioned_table takes the same options hash
                     #       # that create_table does
                     #       Post.create_versioned_table
                     #     end
                     #
                     #     def self.down
                     #       Post.drop_versioned_table
                     #     end
                     #   end
                     #
                     # == Changing What Fields Are Versioned
                     #
                     # By default, acts_as_versioned will version all but these fields:
                     #
                     #   [self.primary_key, inheritance_column, 'version', 'lock_version', versioned_inheritance_column]
                     #
                     # You can add or change those by modifying #non_versioned_columns.  Note that this takes strings and not symbols.
                     #
                     #   class Post < ActiveRecord::Base
                     #     acts_as_versioned
                     #     self.non_versioned_columns << 'comments_count'
                     #   end
                     #
                     def acts_as_versioned(options = {}, &extension)
                       # don't allow multiple calls
                       return if self.included_modules.include?(ActiveRecord::Acts::Versioned::ActMethods)
                       send :include, ActiveRecord::Acts::Versioned::ActMethods
                       cattr_accessor :versioned_class_name, :versioned_foreign_key, :versioned_table_name, :versioned_inheritance_column,
                         :version_column, :max_version_limit, :track_altered_attributes, :version_condition, :version_sequence_name, :non_versioned_columns,
                         :version_association_options
                       # legacy
                       alias_method :non_versioned_fields,  :non_versioned_columns
                       alias_method :non_versioned_fields=, :non_versioned_columns=
                       class << self
                         alias_method :non_versioned_fields,  :non_versioned_columns
                         alias_method :non_versioned_fields=, :non_versioned_columns=
                       end
                       send :attr_accessor, :altered_attributes
                       self.versioned_class_name         = options[:class_name]  || "Version"
                       self.versioned_foreign_key        = options[:foreign_key] || self.to_s.foreign_key
                       self.versioned_table_name         = options[:table_name]  || "#{table_name_prefix}#{base_class.name.demodulize.underscore}_versions#{table_name_suffix}"
                       self.versioned_inheritance_column = options[:inheritance_column] || "versioned_#{inheritance_column}"
                       self.version_column               = options[:version_column]     || 'version'
                       self.version_sequence_name        = options[:sequence_name]
                       self.max_version_limit            = options[:limit].to_i
                       self.version_condition            = options[:if] || true
                       self.non_versioned_columns        = [self.primary_key, inheritance_column, 'version', 'lock_version', versioned_inheritance_column]
                       self.version_association_options  = {
                                                             :class_name  => "#{self.to_s}::#{versioned_class_name}",
                                                             :foreign_key => versioned_foreign_key,
                                                             :dependent   => :delete_all
                                                           }.merge(options[:association_options] || {})
                       if block_given?
                         extension_module_name = "#{versioned_class_name}Extension"
                         silence_warnings do
                           self.const_set(extension_module_name, Module.new(&extension))
                         end
                         options[:extend] = self.const_get(extension_module_name)
                       end
                       class_eval do
                         has_many :versions, version_association_options do
                           # finds earliest version of this record
                           def earliest
-                            @earliest ||= find(:first, :order => 'version')
+                            @earliest ||= order('version').first
                           end
                           # find latest version of this record
                           def latest
-                            @latest ||= find(:first, :order => 'version desc')
+                            @latest ||= order('version desc').first
                           end
                         end
                         before_save  :set_new_version
                         after_create :save_version_on_create
                         after_update :save_version
                         after_save   :clear_old_versions
                         after_save   :clear_altered_attributes
                         unless options[:if_changed].nil?
                           self.track_altered_attributes = true
                           options[:if_changed] = [options[:if_changed]] unless options[:if_changed].is_a?(Array)
                           options[:if_changed].each do |attr_name|
                             define_method("#{attr_name}=") do |value|
                               write_changed_attribute attr_name, value
                             end
                           end
                         end
                         include options[:extend] if options[:extend].is_a?(Module)
                       end
                       # create the dynamic versioned model
                       const_set(versioned_class_name, Class.new(ActiveRecord::Base)).class_eval do
                         def self.reloadable? ; false ; end
                         # find first version before the given version
                         def self.before(version)
                           find :first, :order => 'version desc',
                             :conditions => ["#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version]
                         end
                         # find first version after the given version.
                         def self.after(version)
                           find :first, :order => 'version',
                             :conditions => ["#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version]
                         end
                         def previous
                           self.class.before(self)
                         end
                         def next
                           self.class.after(self)
                         end
                         def versions_count
                           page.version
                         end
                       end
                       versioned_class.cattr_accessor :original_class
                       versioned_class.original_class = self
                       versioned_class.table_name = versioned_table_name
                       versioned_class.belongs_to self.to_s.demodulize.underscore.to_sym,
                         :class_name  => "::#{self.to_s}",
                         :foreign_key => versioned_foreign_key
                       versioned_class.send :include, options[:extend]         if options[:extend].is_a?(Module)
                       versioned_class.set_sequence_name version_sequence_name if version_sequence_name
                     end
                   end
                   module ActMethods
                     def self.included(base) # :nodoc:
                       base.extend ClassMethods
                     end
                     # Finds a specific version of this record
                     def find_version(version = nil)
                       self.class.find_version(id, version)
                     end
                     # Saves a version of the model if applicable
                     def save_version
                       save_version_on_create if save_version?
                     end
                     # Saves a version of the model in the versioned table.  This is called in the after_save callback by default
                     def save_version_on_create
                       rev = self.class.versioned_class.new
                       self.clone_versioned_model(self, rev)
                       rev.version = send(self.class.version_column)
                       rev.send("#{self.class.versioned_foreign_key}=", self.id)
                       rev.save
                     end
                     # Clears old revisions if a limit is set with the :limit option in <tt>acts_as_versioned</tt>.
                     # Override this method to set your own criteria for clearing old versions.
                     def clear_old_versions
                       return if self.class.max_version_limit == 0
                       excess_baggage = send(self.class.version_column).to_i - self.class.max_version_limit
                       if excess_baggage > 0
                         sql = "DELETE FROM #{self.class.versioned_table_name} WHERE version <= #{excess_baggage} AND #{self.class.versioned_foreign_key} = #{self.id}"
                         self.class.versioned_class.connection.execute sql
                       end
                     end
                     def versions_count
                       version
                     end
                     # Reverts a model to a given version.  Takes either a version number or an instance of the versioned model
                     def revert_to(version)
                       if version.is_a?(self.class.versioned_class)
                         return false unless version.send(self.class.versioned_foreign_key) == self.id and !version.new_record?
                       else
                         return false unless version = versions.find_by_version(version)
                       end
                       self.clone_versioned_model(version, self)
                       self.send("#{self.class.version_column}=", version.version)
                       true
                     end
                     # Reverts a model to a given version and saves the model.
                     # Takes either a version number or an instance of the versioned model
                     def revert_to!(version)
                       revert_to(version) ? save_without_revision : false
                     end
                     # Temporarily turns off Optimistic Locking while saving.  Used when reverting so that a new version is not created.
                     def save_without_revision
                       save_without_revision!
                       true
                     rescue
                       false
                     end
                     def save_without_revision!
                       without_locking do
                         without_revision do
                           save!
                         end
                       end
                     end
                     # Returns an array of attribute keys that are versioned.  See non_versioned_columns
                     def versioned_attributes
                       self.attributes.keys.select { |k| !self.class.non_versioned_columns.include?(k) }
                     end
                     # If called with no parameters, gets whether the current model has changed and needs to be versioned.
                     # If called with a single parameter, gets whether the parameter has changed.
                     def changed?(attr_name = nil)
                       attr_name.nil? ?
                         (!self.class.track_altered_attributes || (altered_attributes && altered_attributes.length > 0)) :
                         (altered_attributes && altered_attributes.include?(attr_name.to_s))
                     end
                     # keep old dirty? method
                     alias_method :dirty?, :changed?
                     # Clones a model.  Used when saving a new version or reverting a model's version.
                     def clone_versioned_model(orig_model, new_model)
                       self.versioned_attributes.each do |key|
                         new_model.send("#{key}=", orig_model.send(key)) if orig_model.respond_to?(key)
                       end
             					if self.class.columns_hash.include?(self.class.inheritance_column)
                         if orig_model.is_a?(self.class.versioned_class)
                           new_model[new_model.class.inheritance_column] = orig_model[self.class.versioned_inheritance_column]
                         elsif new_model.is_a?(self.class.versioned_class)
                           new_model[self.class.versioned_inheritance_column] = orig_model[orig_model.class.inheritance_column]
                         end
                       end
                     end
                     # Checks whether a new version shall be saved or not.  Calls <tt>version_condition_met?</tt> and <tt>changed?</tt>.
                     def save_version?
                       version_condition_met? && changed?
                     end
                     # Checks condition set in the :if option to check whether a revision should be created or not.  Override this for
                     # custom version condition checking.
                     def version_condition_met?
                       case
                       when version_condition.is_a?(Symbol)
                         send(version_condition)
                       when version_condition.respond_to?(:call) && (version_condition.arity == 1 || version_condition.arity == -1)
                         version_condition.call(self)
                       else
                         version_condition
                       end
                     end
                     # Executes the block with the versioning callbacks disabled.
                     #
                     #   @foo.without_revision do
                     #     @foo.save
                     #   end
                     #
                     def without_revision(&block)
                       self.class.without_revision(&block)
                     end
                     # Turns off optimistic locking for the duration of the block
                     #
                     #   @foo.without_locking do
                     #     @foo.save
                     #   end
                     #
                     def without_locking(&block)
                       self.class.without_locking(&block)
                     end
                     def empty_callback() end #:nodoc:
                     protected
                       # sets the new version before saving, unless you're using optimistic locking.  In that case, let it take care of the version.
                       def set_new_version
                         self.send("#{self.class.version_column}=", self.next_version) if new_record? || (!locking_enabled? && save_version?)
                       end
                       # Gets the next available version for the current record, or 1 for a new record
                       def next_version
                         return 1 if new_record?
                         (versions.calculate(:max, :version) || 0) + 1
                       end
                       # clears current changed attributes.  Called after save.
                       def clear_altered_attributes
                         self.altered_attributes = []
                       end
                       def write_changed_attribute(attr_name, attr_value)
                         # Convert to db type for comparison. Avoids failing Float<=>String comparisons.
                         attr_value_for_db = self.class.columns_hash[attr_name.to_s].type_cast(attr_value)
                         (self.altered_attributes ||= []) << attr_name.to_s unless self.changed?(attr_name) || self.send(attr_name) == attr_value_for_db
                         write_attribute(attr_name, attr_value_for_db)
                       end
                     module ClassMethods
                       # Finds a specific version of a specific row of this model
                       def find_version(id, version = nil)
                         return find(id) unless version
                         conditions = ["#{versioned_foreign_key} = ? AND version = ?", id, version]
                         options = { :conditions => conditions, :limit => 1 }
                         if result = find_versions(id, options).first
                           result
                         else
                           raise RecordNotFound, "Couldn't find #{name} with ID=#{id} and VERSION=#{version}"
                         end
                       end
                       # Finds versions of a specific model.  Takes an options hash like <tt>find</tt>
                       def find_versions(id, options = {})
                         versioned_class.find :all, {
                           :conditions => ["#{versioned_foreign_key} = ?", id],
                           :order      => 'version' }.merge(options)
                       end
                       # Returns an array of columns that are versioned.  See non_versioned_columns
                       def versioned_columns
                         self.columns.select { |c| !non_versioned_columns.include?(c.name) }
                       end
                       # Returns an instance of the dynamic versioned model
                       def versioned_class
                         const_get versioned_class_name
                       end
                       # Rake migration task to create the versioned table using options passed to acts_as_versioned
                       def create_versioned_table(create_table_options = {})
                         # create version column in main table if it does not exist
                         if !self.content_columns.find { |c| %w(version lock_version).include? c.name }
                           self.connection.add_column table_name, :version, :integer
                         end
                         self.connection.create_table(versioned_table_name, create_table_options) do |t|
                           t.column versioned_foreign_key, :integer
                           t.column :version, :integer
                         end
                         updated_col = nil
                         self.versioned_columns.each do |col|
                           updated_col = col if !updated_col && %(updated_at updated_on).include?(col.name)
                           self.connection.add_column versioned_table_name, col.name, col.type,
                             :limit => col.limit,
                             :default => col.default,
                             :scale => col.scale,
                             :precision => col.precision
                         end
                         if type_col = self.columns_hash[inheritance_column]
                           self.connection.add_column versioned_table_name, versioned_inheritance_column, type_col.type,
                             :limit => type_col.limit,
                             :default => type_col.default,
                             :scale => type_col.scale,
                             :precision => type_col.precision
                         end
                         if updated_col.nil?
                           self.connection.add_column versioned_table_name, :updated_at, :timestamp
                         end
                       end
                       # Rake migration task to drop the versioned table
                       def drop_versioned_table
                         self.connection.drop_table versioned_table_name
                       end
                       # Executes the block with the versioning callbacks disabled.
                       #
                       #   Foo.without_revision do
                       #     @foo.save
                       #   end
                       #
                       def without_revision(&block)
                         class_eval do
                           CALLBACKS.each do |attr_name|
                             alias_method "orig_#{attr_name}".to_sym, attr_name
                             alias_method attr_name, :empty_callback
                           end
                         end
                         block.call
                       ensure
                         class_eval do
                           CALLBACKS.each do |attr_name|
                             alias_method attr_name, "orig_#{attr_name}".to_sym
                           end
                         end
                       end
                       # Turns off optimistic locking for the duration of the block
                       #
                       #   Foo.without_locking do
                       #     @foo.save
                       #   end
                       #
                       def without_locking(&block)
                         current = ActiveRecord::Base.lock_optimistically
                         ActiveRecord::Base.lock_optimistically = false if current
                         result = block.call
                         ActiveRecord::Base.lock_optimistically = true if current
                         result
                       end
                     end
                   end
                 end
               end
             end
             ActiveRecord::Base.send :include, ActiveRecord::Acts::Versioned

lib/plugins/awesome_nested_set/lib/awesome_nested_set/awesome_nested_set.rb +6 -6

             module CollectiveIdea #:nodoc:
               module Acts #:nodoc:
                 module NestedSet #:nodoc:
                   # This acts provides Nested Set functionality. Nested Set is a smart way to implement
                   # an _ordered_ tree, with the added feature that you can select the children and all of their
                   # descendants with a single query. The drawback is that insertion or move need some complex
                   # sql queries. But everything is done here by this module!
                   #
                   # Nested sets are appropriate each time you want either an orderd tree (menus,
                   # commercial categories) or an efficient way of querying big trees (threaded posts).
                   #
                   # == API
                   #
                   # Methods names are aligned with acts_as_tree as much as possible to make replacment from one
                   # by another easier.
                   #
                   #   item.children.create(:name => "child1")
                   #
                   # Configuration options are:
                   #
                   # * +:parent_column+ - specifies the column name to use for keeping the position integer (default: parent_id)
                   # * +:left_column+ - column name for left boundry data, default "lft"
                   # * +:right_column+ - column name for right boundry data, default "rgt"
                   # * +:scope+ - restricts what is to be considered a list. Given a symbol, it'll attach "_id"
                   #   (if it hasn't been already) and use that as the foreign key restriction. You
                   #   can also pass an array to scope by multiple attributes.
                   #   Example: <tt>acts_as_nested_set :scope => [:notable_id, :notable_type]</tt>
                   # * +:dependent+ - behavior for cascading destroy. If set to :destroy, all the
                   #   child objects are destroyed alongside this object by calling their destroy
                   #   method. If set to :delete_all (default), all the child objects are deleted
                   #   without calling their destroy method.
                   # * +:counter_cache+ adds a counter cache for the number of children.
                   #   defaults to false.
                   #   Example: <tt>acts_as_nested_set :counter_cache => :children_count</tt>
                   #
                   # See CollectiveIdea::Acts::NestedSet::Model::ClassMethods for a list of class methods and
                   # CollectiveIdea::Acts::NestedSet::Model for a list of instance methods added
                   # to acts_as_nested_set models
                   def acts_as_nested_set(options = {})
                     options = {
                       :parent_column => 'parent_id',
                       :left_column => 'lft',
                       :right_column => 'rgt',
                       :dependent => :delete_all, # or :destroy
                       :counter_cache => false,
                       :order => 'id'
                     }.merge(options)
                     if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
                       options[:scope] = "#{options[:scope]}_id".intern
                     end
                     class_attribute :acts_as_nested_set_options
                     self.acts_as_nested_set_options = options
                     include CollectiveIdea::Acts::NestedSet::Model
                     include Columns
                     extend Columns
                     belongs_to :parent, :class_name => self.base_class.to_s,
                       :foreign_key => parent_column_name,
                       :counter_cache => options[:counter_cache],
                       :inverse_of => :children
                     has_many :children, :class_name => self.base_class.to_s,
                       :foreign_key => parent_column_name, :order => left_column_name,
                       :inverse_of => :parent,
                       :before_add    => options[:before_add],
                       :after_add     => options[:after_add],
                       :before_remove => options[:before_remove],
                       :after_remove  => options[:after_remove]
                     attr_accessor :skip_before_destroy
                     before_create  :set_default_left_and_right
                     before_save    :store_new_parent
                     after_save     :move_to_new_parent
                     before_destroy :destroy_descendants
                     # no assignment to structure fields
                     [left_column_name, right_column_name].each do |column|
                       module_eval <<-"end_eval", __FILE__, __LINE__
                         def #{column}=(x)
                           raise ActiveRecord::ActiveRecordError, "Unauthorized assignment to #{column}: it's an internal field handled by acts_as_nested_set code, use move_to_* methods instead."
                         end
                       end_eval
                     end
                     define_model_callbacks :move
                   end
                   module Model
                     extend ActiveSupport::Concern
                     module ClassMethods
                       # Returns the first root
                       def root
                         roots.first
                       end
                       def roots
                         where(parent_column_name => nil).order(quoted_left_column_name)
                       end
                       def leaves
                         where("#{quoted_right_column_name} - #{quoted_left_column_name} = 1").order(quoted_left_column_name)
                       end
                       def valid?
                         left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?
                       end
                       def left_and_rights_valid?
                         joins("LEFT OUTER JOIN #{quoted_table_name} AS parent ON " +
                             "#{quoted_table_name}.#{quoted_parent_column_name} = parent.#{primary_key}").
                         where(
                             "#{quoted_table_name}.#{quoted_left_column_name} IS NULL OR " +
                             "#{quoted_table_name}.#{quoted_right_column_name} IS NULL OR " +
                             "#{quoted_table_name}.#{quoted_left_column_name} >= " +
                               "#{quoted_table_name}.#{quoted_right_column_name} OR " +
                             "(#{quoted_table_name}.#{quoted_parent_column_name} IS NOT NULL AND " +
                               "(#{quoted_table_name}.#{quoted_left_column_name} <= parent.#{quoted_left_column_name} OR " +
                               "#{quoted_table_name}.#{quoted_right_column_name} >= parent.#{quoted_right_column_name}))"
                         ).count == 0
                       end
                       def no_duplicates_for_columns?
                         scope_string = Array(acts_as_nested_set_options[:scope]).map do |c|
                           connection.quote_column_name(c)
                         end.push(nil).join(", ")
                         [quoted_left_column_name, quoted_right_column_name].all? do |column|
                           # No duplicates
                           select("#{scope_string}#{column}, COUNT(#{column})").
                               group("#{scope_string}#{column}").
                               having("COUNT(#{column}) > 1").
                               first.nil?
                         end
                       end
                       # Wrapper for each_root_valid? that can deal with scope.
                       def all_roots_valid?
                         if acts_as_nested_set_options[:scope]
                           roots.group(scope_column_names).group_by{|record| scope_column_names.collect{|col| record.send(col.to_sym)}}.all? do |scope, grouped_roots|
                             each_root_valid?(grouped_roots)
                           end
                         else
                           each_root_valid?(roots)
                         end
                       end
                       def each_root_valid?(roots_to_validate)
                         left = right = 0
                         roots_to_validate.all? do |root|
                           (root.left > left && root.right > right).tap do
                             left = root.left
                             right = root.right
                           end
                         end
                       end
                       # Rebuilds the left & rights if unset or invalid.
                       # Also very useful for converting from acts_as_tree.
                       def rebuild!(validate_nodes = true)
                         # Don't rebuild a valid tree.
                         return true if valid?
                         scope = lambda{|node|}
                         if acts_as_nested_set_options[:scope]
                           scope = lambda{|node|
                             scope_column_names.inject(""){|str, column_name|
                               str << "AND #{connection.quote_column_name(column_name)} = #{connection.quote(node.send(column_name.to_sym))} "
                             }
                           }
                         end
                         indices = {}
                         set_left_and_rights = lambda do |node|
                           # set left
                           node[left_column_name] = indices[scope.call(node)] += 1
                           # find
                           where(["#{quoted_parent_column_name} = ? #{scope.call(node)}", node]).order(acts_as_nested_set_options[:order]).each{|n| set_left_and_rights.call(n) }
                           # set right
                           node[right_column_name] = indices[scope.call(node)] += 1
                           node.save!(:validate => validate_nodes)
                         end
                         # Find root node(s)
                         root_nodes = where("#{quoted_parent_column_name} IS NULL").order(acts_as_nested_set_options[:order]).each do |root_node|
                           # setup index for this scope
                           indices[scope.call(root_node)] ||= 0
                           set_left_and_rights.call(root_node)
                         end
                       end
                       # Iterates over tree elements and determines the current level in the tree.
                       # Only accepts default ordering, odering by an other column than lft
                       # does not work. This method is much more efficent than calling level
                       # because it doesn't require any additional database queries.
                       #
                       # Example:
                       #    Category.each_with_level(Category.root.self_and_descendants) do |o, level|
                       #
                       def each_with_level(objects)
                         path = [nil]
                         objects.each do |o|
                           if o.parent_id != path.last
                             # we are on a new level, did we decent or ascent?
                             if path.include?(o.parent_id)
                               # remove wrong wrong tailing paths elements
                               path.pop while path.last != o.parent_id
                             else
                               path << o.parent_id
                             end
                           end
                           yield(o, path.length - 1)
                         end
                       end
                     end
                     # Any instance method that returns a collection makes use of Rails 2.1's named_scope (which is bundled for Rails 2.0), so it can be treated as a finder.
                     #
                     #   category.self_and_descendants.count
                     #   category.ancestors.find(:all, :conditions => "name like '%foo%'")
                     # Value of the parent column
                     def parent_id
                       self[parent_column_name]
                     end
                     # Value of the left column
                     def left
                       self[left_column_name]
                     end
                     # Value of the right column
                     def right
                       self[right_column_name]
                     end
                     # Returns true if this is a root node.
                     def root?
                       parent_id.nil?
                     end
                     def leaf?
                       new_record? || (right - left == 1)
                     end
                     # Returns true is this is a child node
                     def child?
                       !parent_id.nil?
                     end
                     # Returns root
                     def root
                       self_and_ancestors.where(parent_column_name => nil).first
                     end
                     # Returns the array of all parents and self
                     def self_and_ancestors
                       nested_set_scope.where([
                         "#{self.class.quoted_table_name}.#{quoted_left_column_name} <= ? AND #{self.class.quoted_table_name}.#{quoted_right_column_name} >= ?", left, right
                       ])
                     end
                     # Returns an array of all parents
                     def ancestors
                       without_self self_and_ancestors
                     end
                     # Returns the array of all children of the parent, including self
                     def self_and_siblings
                       nested_set_scope.where(parent_column_name => parent_id)
                     end
                     # Returns the array of all children of the parent, except self
                     def siblings
                       without_self self_and_siblings
                     end
                     # Returns a set of all of its nested children which do not have children
                     def leaves
                       descendants.where("#{self.class.quoted_table_name}.#{quoted_right_column_name} - #{self.class.quoted_table_name}.#{quoted_left_column_name} = 1")
                     end
                     # Returns the level of this object in the tree
                     # root level is 0
                     def level
                       parent_id.nil? ? 0 : ancestors.count
                     end
                     # Returns a set of itself and all of its nested children
                     def self_and_descendants
                       nested_set_scope.where([
                         "#{self.class.quoted_table_name}.#{quoted_left_column_name} >= ? AND #{self.class.quoted_table_name}.#{quoted_right_column_name} <= ?", left, right
                       ])
                     end
                     # Returns a set of all of its children and nested children
                     def descendants
                       without_self self_and_descendants
                     end
                     def is_descendant_of?(other)
                       other.left < self.left && self.left < other.right && same_scope?(other)
                     end
                     def is_or_is_descendant_of?(other)
                       other.left <= self.left && self.left < other.right && same_scope?(other)
                     end
                     def is_ancestor_of?(other)
                       self.left < other.left && other.left < self.right && same_scope?(other)
                     end
                     def is_or_is_ancestor_of?(other)
                       self.left <= other.left && other.left < self.right && same_scope?(other)
                     end
                     # Check if other model is in the same scope
                     def same_scope?(other)
                       Array(acts_as_nested_set_options[:scope]).all? do |attr|
                         self.send(attr) == other.send(attr)
                       end
                     end
                     # Find the first sibling to the left
                     def left_sibling
                       siblings.where(["#{self.class.quoted_table_name}.#{quoted_left_column_name} < ?", left]).
                               order("#{self.class.quoted_table_name}.#{quoted_left_column_name} DESC").last
                     end
                     # Find the first sibling to the right
                     def right_sibling
                       siblings.where(["#{self.class.quoted_table_name}.#{quoted_left_column_name} > ?", left]).first
                     end
                     # Shorthand method for finding the left sibling and moving to the left of it.
                     def move_left
                       move_to_left_of left_sibling
                     end
                     # Shorthand method for finding the right sibling and moving to the right of it.
                     def move_right
                       move_to_right_of right_sibling
                     end
                     # Move the node to the left of another node (you can pass id only)
                     def move_to_left_of(node)
                       move_to node, :left
                     end
                     # Move the node to the left of another node (you can pass id only)
                     def move_to_right_of(node)
                       move_to node, :right
                     end
                     # Move the node to the child of another node (you can pass id only)
                     def move_to_child_of(node)
                       move_to node, :child
                     end
                     # Move the node to root nodes
                     def move_to_root
                       move_to nil, :root
                     end
                     def move_possible?(target)
                       self != target && # Can't target self
                       same_scope?(target) && # can't be in different scopes
                       # !(left..right).include?(target.left..target.right) # this needs tested more
                       # detect impossible move
                       !((left <= target.left && right >= target.left) or (left <= target.right && right >= target.right))
                     end
                     def to_text
                       self_and_descendants.map do |node|
                         "#{'*'*(node.level+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"
                       end.join("\n")
                     end
                   protected
                     def without_self(scope)
                       scope.where(["#{self.class.quoted_table_name}.#{self.class.primary_key} != ?", self])
                     end
                     # All nested set queries should use this nested_set_scope, which performs finds on
                     # the base ActiveRecord class, using the :scope declared in the acts_as_nested_set
                     # declaration.
                     def nested_set_scope(options = {})
                       options = {:order => "#{self.class.quoted_table_name}.#{quoted_left_column_name}"}.merge(options)
                       scopes = Array(acts_as_nested_set_options[:scope])
                       options[:conditions] = scopes.inject({}) do |conditions,attr|
                         conditions.merge attr => self[attr]
                       end unless scopes.empty?
                       self.class.base_class.scoped options
                     end
                     def store_new_parent
                       @move_to_new_parent_id = send("#{parent_column_name}_changed?") ? parent_id : false
                       true # force callback to return true
                     end
                     def move_to_new_parent
                       if @move_to_new_parent_id.nil?
                         move_to_root
                       elsif @move_to_new_parent_id
                         move_to_child_of(@move_to_new_parent_id)
                       end
                     end
                     # on creation, set automatically lft and rgt to the end of the tree
                     def set_default_left_and_right
-                      highest_right_row = nested_set_scope(:order => "#{quoted_right_column_name} desc").find(:first, :limit => 1,:lock => true )
+                      highest_right_row = nested_set_scope(:order => "#{quoted_right_column_name} desc").limit(1).lock(true).first
                       maxright = highest_right_row ? (highest_right_row[right_column_name] || 0) : 0
                       # adds the new node to the right of all existing nodes
                       self[left_column_name] = maxright + 1
                       self[right_column_name] = maxright + 2
                     end
                     def in_tenacious_transaction(&block)
                       retry_count = 0
                       begin
                         transaction(&block)
                       rescue ActiveRecord::StatementInvalid => error
                         raise unless connection.open_transactions.zero?
                         raise unless error.message =~ /Deadlock found when trying to get lock|Lock wait timeout exceeded/
                         raise unless retry_count < 10
                         retry_count += 1
                         logger.info "Deadlock detected on retry #{retry_count}, restarting transaction"
                         sleep(rand(retry_count)*0.1) # Aloha protocol
                         retry
                       end
                     end
                     # Prunes a branch off of the tree, shifting all of the elements on the right
                     # back to the left so the counts still work.
                     def destroy_descendants
                       return if right.nil? || left.nil? || skip_before_destroy
                       in_tenacious_transaction do
                         reload_nested_set
                         # select the rows in the model that extend past the deletion point and apply a lock
-                        self.class.base_class.find(:all,
+                        self.class.base_class.
-                          :select => "id",
+                          select("id").
-                          :conditions => ["#{quoted_left_column_name} >= ?", left],
+                          where("#{quoted_left_column_name} >= ?", left).
-                          :lock => true
+                          lock(true).
+                          all
                         if acts_as_nested_set_options[:dependent] == :destroy
                           descendants.each do |model|
                             model.skip_before_destroy = true
                             model.destroy
                           end
                         else
                           nested_set_scope.delete_all(
                             ["#{quoted_left_column_name} > ? AND #{quoted_right_column_name} < ?",
                               left, right]
                           )
                         end
                         # update lefts and rights for remaining nodes
                         diff = right - left + 1
                         nested_set_scope.update_all(
                           ["#{quoted_left_column_name} = (#{quoted_left_column_name} - ?)", diff],
                           ["#{quoted_left_column_name} > ?", right]
                         )
                         nested_set_scope.update_all(
                           ["#{quoted_right_column_name} = (#{quoted_right_column_name} - ?)", diff],
                           ["#{quoted_right_column_name} > ?", right]
                           )
             reload
                           # Don't allow multiple calls to destroy to corrupt the set
                         self.skip_before_destroy = true
                       end
                     end
                     # reload left, right, and parent
                     def reload_nested_set
                       reload(
                         :select => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{quoted_parent_column_name}",
                         :lock => true
                       )
                     end
                     def move_to(target, position)
                       raise ActiveRecord::ActiveRecordError, "You cannot move a new node" if self.new_record?
                       run_callbacks :move do
                         in_tenacious_transaction do
                           if target.is_a? self.class.base_class
                             target.reload_nested_set
                           elsif position != :root
                             # load object if node is not an object
                             target = nested_set_scope.find(target)
                           end
                           self.reload_nested_set
                           unless position == :root || move_possible?(target)
                             raise ActiveRecord::ActiveRecordError, "Impossible move, target node cannot be inside moved tree."
                           end
                           bound = case position
                             when :child;  target[right_column_name]
                             when :left;   target[left_column_name]
                             when :right;  target[right_column_name] + 1
                             when :root;   1
                             else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{position}' received)."
                           end
                           if bound > self[right_column_name]
                             bound = bound - 1
                             other_bound = self[right_column_name] + 1
                           else
                             other_bound = self[left_column_name] - 1
                           end
                           # there would be no change
                           return if bound == self[right_column_name] || bound == self[left_column_name]
                           # we have defined the boundaries of two non-overlapping intervals,
                           # so sorting puts both the intervals and their boundaries in order
                           a, b, c, d = [self[left_column_name], self[right_column_name], bound, other_bound].sort
                           # select the rows in the model between a and d, and apply a lock
                           self.class.base_class.select('id').lock(true).where(
                             ["#{quoted_left_column_name} >= :a and #{quoted_right_column_name} <= :d", {:a => a, :d => d}]
                           )
                           new_parent = case position
                             when :child;  target.id
                             when :root;   nil
                             else          target[parent_column_name]
                           end
                           self.nested_set_scope.update_all([
                             "#{quoted_left_column_name} = CASE " +
                               "WHEN #{quoted_left_column_name} BETWEEN :a AND :b " +
                                 "THEN #{quoted_left_column_name} + :d - :b " +
                               "WHEN #{quoted_left_column_name} BETWEEN :c AND :d " +
                                 "THEN #{quoted_left_column_name} + :a - :c " +
                               "ELSE #{quoted_left_column_name} END, " +
                             "#{quoted_right_column_name} = CASE " +
                               "WHEN #{quoted_right_column_name} BETWEEN :a AND :b " +
                                 "THEN #{quoted_right_column_name} + :d - :b " +
                               "WHEN #{quoted_right_column_name} BETWEEN :c AND :d " +
                                 "THEN #{quoted_right_column_name} + :a - :c " +
                               "ELSE #{quoted_right_column_name} END, " +
                             "#{quoted_parent_column_name} = CASE " +
                               "WHEN #{self.class.base_class.primary_key} = :id THEN :new_parent " +
                               "ELSE #{quoted_parent_column_name} END",
                             {:a => a, :b => b, :c => c, :d => d, :id => self.id, :new_parent => new_parent}
                           ])
                         end
                         target.reload_nested_set if target
                         self.reload_nested_set
                       end
                     end
                   end
                   # Mixed into both classes and instances to provide easy access to the column names
                   module Columns
                     def left_column_name
                       acts_as_nested_set_options[:left_column]
                     end
                     def right_column_name
                       acts_as_nested_set_options[:right_column]
                     end
                     def parent_column_name
                       acts_as_nested_set_options[:parent_column]
                     end
                     def scope_column_names
                       Array(acts_as_nested_set_options[:scope])
                     end
                     def quoted_left_column_name
                       connection.quote_column_name(left_column_name)
                     end
                     def quoted_right_column_name
                       connection.quote_column_name(right_column_name)
                     end
                     def quoted_parent_column_name
                       connection.quote_column_name(parent_column_name)
                     end
                     def quoted_scope_column_names
                       scope_column_names.collect {|column_name| connection.quote_column_name(column_name) }
                     end
                   end
                 end
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages