activerecord 1.15.6 → 2.0.0

data/examples/associations.rb

@@ -1,87 +0,0 @@
-require File.dirname(__FILE__) + '/shared_setup'
-
-logger = Logger.new(STDOUT)
-
-# Database setup ---------------
-
-logger.info "\nCreate tables"
-
-[ "DROP TABLE companies", "DROP TABLE people", "DROP TABLE people_companies",
-  "CREATE TABLE companies (id int(11) auto_increment, client_of int(11), name varchar(255), type varchar(100), PRIMARY KEY (id))",
-  "CREATE TABLE people (id int(11) auto_increment, name varchar(100), PRIMARY KEY (id))",
-  "CREATE TABLE people_companies (person_id int(11), company_id int(11), PRIMARY KEY (person_id, company_id))",
-].each { |statement|
-  # Tables doesn't necessarily already exist
-  begin; ActiveRecord::Base.connection.execute(statement); rescue ActiveRecord::StatementInvalid; end
-}
-
-
-# Class setup ---------------
-
-class Company < ActiveRecord::Base
-  has_and_belongs_to_many :people, :class_name => "Person", :join_table => "people_companies", :table_name => "people"
-end
-
-class Firm < Company
-  has_many :clients, :foreign_key => "client_of"
-
-  def people_with_all_clients
-    clients.inject([]) { |people, client| people + client.people }
-  end
-end
-
-class Client < Company
-  belongs_to :firm, :foreign_key => "client_of"
-end
-
-class Person < ActiveRecord::Base
-  has_and_belongs_to_many :companies, :join_table => "people_companies"
-  def self.table_name() "people" end
-end
-
-
-# Usage ---------------
-
-logger.info "\nCreate fixtures"
-
-Firm.new("name" => "Next Angle").save
-Client.new("name" => "37signals", "client_of" => 1).save
-Person.new("name" => "David").save
-
-
-logger.info "\nUsing Finders"
-
-next_angle = Company.find(1)
-next_angle = Firm.find(1)    
-next_angle = Company.find_first "name = 'Next Angle'"
-next_angle = Firm.find_by_sql("SELECT * FROM companies WHERE id = 1").first
-
-Firm === next_angle
-
-
-logger.info "\nUsing has_many association"
-
-next_angle.has_clients?
-next_angle.clients_count
-all_clients = next_angle.clients
-
-thirty_seven_signals = next_angle.find_in_clients(2)
-
-
-logger.info "\nUsing belongs_to association"
-
-thirty_seven_signals.has_firm?
-thirty_seven_signals.firm?(next_angle)
-
-
-logger.info "\nUsing has_and_belongs_to_many association"
-
-david = Person.find(1)
-david.add_companies(thirty_seven_signals, next_angle)
-david.companies.include?(next_angle)
-david.companies_count == 2
-
-david.remove_companies(next_angle)
-david.companies_count == 1
-
-thirty_seven_signals.people.include?(david)

data/examples/shared_setup.rb

@@ -1,15 +0,0 @@
-# Be sure to change the mysql_connection details and create a database for the example
-
-$: << File.dirname(__FILE__) + '/../lib'
-
-require 'active_record'
-require 'logger'; class Logger; def format_message(severity, timestamp, msg, progname) "#{msg}\n" end; end
-
-ActiveRecord::Base.logger = Logger.new(STDOUT)
-ActiveRecord::Base.establish_connection(
-  :adapter  => "mysql", 
-  :host     => "localhost", 
-  :username => "root", 
-  :password => "", 
-  :database => "activerecord_examples"
-)

data/examples/validation.rb

@@ -1,85 +0,0 @@
-require File.dirname(__FILE__) + '/shared_setup'
-
-logger = Logger.new(STDOUT)
-
-# Database setup ---------------
-
-logger.info "\nCreate tables"
-
-[ "DROP TABLE people",
-  "CREATE TABLE people (id int(11) auto_increment, name varchar(100), pass varchar(100), email varchar(100), PRIMARY KEY (id))"
-].each { |statement|
-  begin; ActiveRecord::Base.connection.execute(statement); rescue ActiveRecord::StatementInvalid; end # Tables doesn't necessarily already exist
-}
-
-
-# Class setup ---------------
-
-class Person < ActiveRecord::Base
-  # Using 
-  def self.authenticate(name, pass)
-    # find_first "name = '#{name}' AND pass = '#{pass}'" would be open to sql-injection (in a web-app scenario)
-    find_first [ "name = '%s' AND pass = '%s'", name, pass ]
-  end
-
-  def self.name_exists?(name, id = nil)
-    if id.nil?
-      condition = [ "name = '%s'", name ]
-    else
-      # Check if anyone else than the person identified by person_id has that user_name
-      condition = [ "name = '%s' AND id <> %d", name, id ]
-    end
-
-    !find_first(condition).nil?
-  end
-
-  def email_address_with_name
-    "\"#{name}\" <#{email}>"
-  end
-        
-  protected
-    def validate
-      errors.add_on_empty(%w(name pass email))
-      errors.add("email", "must be valid") unless email_address_valid?
-    end
-
-    def validate_on_create
-      if attribute_present?("name") && Person.name_exists?(name)
-          errors.add("name", "is already taken by another person")
-      end
-    end
-
-    def validate_on_update
-      if attribute_present?("name") && Person.name_exists?(name, id)
-          errors.add("name", "is already taken by another person")
-      end
-    end
-  
-  private
-    def email_address_valid?() email =~ /\w[-.\w]*\@[-\w]+[-.\w]*\.\w+/ end
-end
-
-# Usage ---------------
-
-logger.info "\nCreate fixtures"
-david = Person.new("name" => "David Heinemeier Hansson", "pass" => "", "email" => "")
-unless david.save
-  puts "There was #{david.errors.count} error(s)"
-  david.errors.each_full { |error| puts error }
-end
-
-david.pass = "something"
-david.email = "invalid_address"
-unless david.save
-  puts "There was #{david.errors.count} error(s)"
-  puts "It was email with: " + david.errors.on("email")
-end
-
-david.email = "david@loudthinking.com"
-if david.save then puts "David finally made it!" end
-
-
-another_david = Person.new("name" => "David Heinemeier Hansson", "pass" => "xc", "email" => "david@loudthinking")
-unless another_david.save
-  puts "Error on name: " + another_david.errors.on("name")
-end

data/lib/active_record/acts/list.rb

@@ -1,256 +0,0 @@
-module ActiveRecord
-  module Acts #:nodoc:
-    module List #:nodoc:
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      # This act 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 "_id" 
-        #   (if that hasn't been already) 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
-        
-        # 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 =>
-            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
-          )
-        end
-
-        # Return the next lower item in the list.
-        def lower_item
-          return nil unless in_list?
-          acts_as_list_class.find(:first, :conditions =>
-            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
-          )
-        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.find(:first, :conditions => conditions, :order => "#{position_column} DESC")
-          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

data/lib/active_record/acts/nested_set.rb

@@ -1,211 +0,0 @@
-module ActiveRecord
-  module Acts #:nodoc:
-    module NestedSet #:nodoc:
-      def self.included(base)
-        base.extend(ClassMethods)              
-      end  
-
-      # This acts provides Nested Set functionality.  Nested Set is similiar to Tree, but with
-      # the added feature that you can select the children and all of their descendents with
-      # a single query.  A good use case for this is a threaded post system, where you want
-      # to display every reply to a comment without multiple selects.
-      #
-      # A google search for "Nested Set" should point you in the direction to explain the
-      # database theory.  I figured out a bunch of this from
-      # http://threebit.net/tutorials/nestedset/tutorial1.html
-      #
-      # Instead of picturing a leaf node structure with children pointing back to their parent,
-      # the best way to imagine how this works is to think of the parent entity surrounding all
-      # of its children, and its parent surrounding it, etc.  Assuming that they are lined up
-      # horizontally, we store the left and right boundries in the database.
-      #
-      # Imagine:
-      #   root
-      #     |_ Child 1
-      #       |_ Child 1.1
-      #       |_ Child 1.2
-      #     |_ Child 2
-      #       |_ Child 2.1
-      #       |_ Child 2.2
-      #
-      # If my cirlces in circles description didn't make sense, check out this sweet
-      # ASCII art:
-      #
-      #     ___________________________________________________________________
-      #    |  Root                                                             |
-      #    |    ____________________________    ____________________________   |
-      #    |   |  Child 1                  |   |  Child 2                  |   |
-      #    |   |   __________   _________  |   |   __________   _________  |   |
-      #    |   |  |  C 1.1  |  |  C 1.2 |  |   |  |  C 2.1  |  |  C 2.2 |  |   |
-      #    1   2  3_________4  5________6  7   8  9_________10 11_______12 13  14
-      #    |   |___________________________|   |___________________________|   |
-      #    |___________________________________________________________________| 
-      #
-      # The numbers represent the left and right boundries.  The table then might
-      # look like this:
-      #    ID | PARENT | LEFT | RIGHT | DATA
-      #     1 |      0 |    1 |    14 | root
-      #     2 |      1 |    2 |     7 | Child 1
-      #     3 |      2 |    3 |     4 | Child 1.1
-      #     4 |      2 |    5 |     6 | Child 1.2
-      #     5 |      1 |    8 |    13 | Child 2
-      #     6 |      5 |    9 |    10 | Child 2.1
-      #     7 |      5 |   11 |    12 | Child 2.2
-      #
-      # So, to get all children of an entry, you
-      #     SELECT * WHERE CHILD.LEFT IS BETWEEN PARENT.LEFT AND PARENT.RIGHT
-      #
-      # To get the count, it's (LEFT - RIGHT + 1)/2, etc.
-      #
-      # To get the direct parent, it falls back to using the PARENT_ID field.   
-      #
-      # There are instance methods for all of these.
-      #
-      # The structure is good if you need to group things together; the downside is that
-      # keeping data integrity is a pain, and both adding and removing an entry
-      # require a full table write.        
-      #
-      # This sets up a before_destroy trigger to prune the tree correctly if one of its
-      # elements gets deleted.
-      #
-      module ClassMethods                      
-        # 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 that hasn't been already) 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_nested_set(options = {})
-          configuration = { :parent_column => "parent_id", :left_column => "lft", :right_column => "rgt", :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::NestedSet::InstanceMethods
-
-            #{scope_condition_method}
-            
-            def left_col_name() "#{configuration[:left_column]}" end
-
-            def right_col_name() "#{configuration[:right_column]}" end
-              
-            def parent_column() "#{configuration[:parent_column]}" end
-
-          EOV
-        end
-      end
-      
-      module InstanceMethods
-        # Returns true is this is a root node.  
-        def root?
-          parent_id = self[parent_column]
-          (parent_id == 0 || parent_id.nil?) && (self[left_col_name] == 1) && (self[right_col_name] > self[left_col_name])
-        end                                                                                             
-                                    
-        # Returns true is this is a child node
-        def child?                          
-          parent_id = self[parent_column]
-          !(parent_id == 0 || parent_id.nil?) && (self[left_col_name] > 1) && (self[right_col_name] > self[left_col_name])
-        end     
-        
-        # Returns true if we have no idea what this is
-        def unknown?
-          !root? && !child?
-        end
-
-                     
-        # Adds a child to this object in the tree.  If this object hasn't been initialized,
-        # it gets set up as a root node.  Otherwise, this method will update all of the
-        # other elements in the tree and shift them to the right, keeping everything
-        # balanced. 
-        def add_child( child )     
-          self.reload
-          child.reload
-
-          if child.root?
-            raise "Adding sub-tree isn\'t currently supported"
-          else
-            if ( (self[left_col_name] == nil) || (self[right_col_name] == nil) )
-              # Looks like we're now the root node!  Woo
-              self[left_col_name] = 1
-              self[right_col_name] = 4
-              
-              # What do to do about validation?
-              return nil unless self.save
-              
-              child[parent_column] = self.id
-              child[left_col_name] = 2
-              child[right_col_name]= 3
-              return child.save
-            else
-              # OK, we need to add and shift everything else to the right
-              child[parent_column] = self.id
-              right_bound = self[right_col_name]
-              child[left_col_name] = right_bound
-              child[right_col_name] = right_bound + 1
-              self[right_col_name] += 2
-              self.class.base_class.transaction {
-                self.class.base_class.update_all( "#{left_col_name} = (#{left_col_name} + 2)",  "#{scope_condition} AND #{left_col_name} >= #{right_bound}" )
-                self.class.base_class.update_all( "#{right_col_name} = (#{right_col_name} + 2)",  "#{scope_condition} AND #{right_col_name} >= #{right_bound}" )
-                self.save
-                child.save
-              }
-            end
-          end                                   
-        end
-                                   
-        # Returns the number of nested children of this object.
-        def children_count
-          return (self[right_col_name] - self[left_col_name] - 1)/2
-        end
-                                                               
-        # Returns a set of itself and all of its nested children
-        def full_set
-          self.class.base_class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} BETWEEN #{self[left_col_name]} and #{self[right_col_name]})" )
-        end
-                  
-        # Returns a set of all of its children and nested children
-        def all_children
-          self.class.base_class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} > #{self[left_col_name]}) and (#{right_col_name} < #{self[right_col_name]})" )
-        end
-                                  
-        # Returns a set of only this entry's immediate children
-        def direct_children
-          self.class.base_class.find(:all, :conditions => "#{scope_condition} and #{parent_column} = #{self.id}")
-        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 before_destroy
-          return if self[right_col_name].nil? || self[left_col_name].nil?
-          dif = self[right_col_name] - self[left_col_name] + 1
-
-          self.class.base_class.transaction {
-            self.class.base_class.delete_all( "#{scope_condition} and #{left_col_name} > #{self[left_col_name]} and #{right_col_name} < #{self[right_col_name]}" )
-            self.class.base_class.update_all( "#{left_col_name} = (#{left_col_name} - #{dif})",  "#{scope_condition} AND #{left_col_name} >= #{self[right_col_name]}" )
-            self.class.base_class.update_all( "#{right_col_name} = (#{right_col_name} - #{dif} )",  "#{scope_condition} AND #{right_col_name} >= #{self[right_col_name]}" )
-          }
-        end
-      end
-    end
-  end
-end