activerecord 3.0.0 → 4.0.0

data/MIT-LICENSE

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

data/README.rdoc

@@ -3,7 +3,7 @@
 Active Record connects classes to relational database tables to establish an
 almost zero-configuration persistence layer for applications. The library
 provides a base class that, when subclassed, sets up a mapping between the new
-class and an existing table in the database. In context of an application,
+class and an existing table in the database. In the context of an application,
 these classes are commonly referred to as *models*. Models can also be
 connected to other models; this is done by defining *associations*.
 
@@ -49,10 +49,10 @@ A short rundown of some of the major features:
 * Aggregations of value objects.
 
    class Account < ActiveRecord::Base
-     composed_of :balance, :class_name => "Money",
-                 :mapping => %w(balance amount)
+     composed_of :balance, class_name: 'Money',
+                 mapping: %w(balance amount)
      composed_of :address,
-                 :mapping => [%w(address_street street), %w(address_city city)]
+                 mapping: [%w(address_street street), %w(address_city city)]
    end
 
   {Learn more}[link:classes/ActiveRecord/Aggregations/ClassMethods.html]
@@ -61,16 +61,16 @@ A short rundown of some of the major features:
 * Validation rules that can differ for new or existing objects.
 
     class Account < ActiveRecord::Base
-      validates_presence_of     :subdomain, :name, :email_address, :password
-      validates_uniqueness_of   :subdomain
-      validates_acceptance_of   :terms_of_service, :on => :create
-      validates_confirmation_of :password, :email_address, :on => :create
+      validates :subdomain, :name, :email_address, :password, presence: true
+      validates :subdomain, uniqueness: true
+      validates :terms_of_service, acceptance: true, on: :create
+      validates :password, :email_address, confirmation: true, on: :create
     end
 
   {Learn more}[link:classes/ActiveRecord/Validations.html]
 
 
-* Callbacks available for the entire life cycle (instantiation, saving, destroying, validating, etc.)
+* Callbacks available for the entire life cycle (instantiation, saving, destroying, validating, etc.).
 
    class Person < ActiveRecord::Base
      before_destroy :invalidate_payment_plan
@@ -80,18 +80,7 @@ A short rundown of some of the major features:
   {Learn more}[link:classes/ActiveRecord/Callbacks.html]
 
 
-* Observers that react to changes in a model
-
-   class CommentObserver < ActiveRecord::Observer
-     def after_create(comment) # is called just after Comment#save
-       Notifications.deliver_new_comment("david@loudthinking.com", comment)
-     end
-   end
-
-  {Learn more}[link:classes/ActiveRecord/Observer.html]
-
-
-* Inheritance hierarchies
+* Inheritance hierarchies.
 
    class Company < ActiveRecord::Base; end
    class Firm < Company; end
@@ -101,7 +90,7 @@ A short rundown of some of the major features:
   {Learn more}[link:classes/ActiveRecord/Base.html]
 
 
-* Transactions
+* Transactions.
 
     # Database transaction
     Account.transaction do
@@ -112,7 +101,7 @@ A short rundown of some of the major features:
   {Learn more}[link:classes/ActiveRecord/Transactions/ClassMethods.html]
 
 
-* Reflections on columns, associations, and aggregations
+* Reflections on columns, associations, and aggregations.
 
     reflection = Firm.reflect_on_association(:clients)
     reflection.klass # => Client (class)
@@ -121,18 +110,18 @@ A short rundown of some of the major features:
   {Learn more}[link:classes/ActiveRecord/Reflection/ClassMethods.html]
 
 
-* Database abstraction through simple adapters
+* Database abstraction through simple adapters.
 
     # connect to SQLite3
-    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => "dbfile.sqlite3")
+    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: 'dbfile.sqlite3')
 
     # connect to MySQL with authentication
     ActiveRecord::Base.establish_connection(
-      :adapter  => "mysql",
-      :host     => "localhost",
-      :username => "me",
-      :password => "secret",
-      :database => "activerecord"
+      adapter:  'mysql2',
+      host:     'localhost',
+      username: 'me',
+      password: 'secret',
+      database: 'activerecord'
     )
 
   {Learn more}[link:classes/ActiveRecord/Base.html] and read about the built-in support for
@@ -141,16 +130,16 @@ A short rundown of some of the major features:
   SQLite3[link:classes/ActiveRecord/ConnectionAdapters/SQLite3Adapter.html].
 
 
-* Logging support for Log4r[http://log4r.sourceforge.net] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc]
+* Logging support for Log4r[http://log4r.rubyforge.org] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
 
-    ActiveRecord::Base.logger = Logger.new(STDOUT)
-    ActiveRecord::Base.logger = Log4r::Logger.new("Application Log")
+    ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
+    ActiveRecord::Base.logger = Log4r::Logger.new('Application Log')
 
 
-* Database agnostic schema management with Migrations
+* Database agnostic schema management with Migrations.
 
     class AddSystemSettings < ActiveRecord::Migration
-      def self.up
+      def up
         create_table :system_settings do |t|
           t.string  :name
           t.string  :label
@@ -159,10 +148,10 @@ A short rundown of some of the major features:
           t.integer :position
         end
 
-        SystemSetting.create :name => "notice", :label => "Use notice?", :value => 1
+        SystemSetting.create name: 'notice', label: 'Use notice?', value: 1
       end
 
-      def self.down
+      def down
         drop_table :system_settings
       end
     end
@@ -197,26 +186,28 @@ Admit the Database:
 
 == Download and installation
 
-The latest version of Active Record can be installed with Rubygems:
+The latest version of Active Record can be installed with RubyGems:
 
   % [sudo] gem install activerecord
 
-Source code can be downloaded as part of the Rails project on GitHub
+Source code can be downloaded as part of the Rails project on GitHub:
 
-* http://github.com/rails/rails/tree/master/activerecord/
+* https://github.com/rails/rails/tree/master/activerecord
 
 
 == License
 
-Active Record is released under the MIT license.
+Active Record is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT
 
 
 == Support
 
-API documentation is at
+API documentation is at:
 
-* http://api.rubyonrails.com
+* http://api.rubyonrails.org
 
 Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
 
-* https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets
+* https://github.com/rails/rails/issues

data/examples/performance.rb

@@ -1,31 +1,11 @@
-#!/usr/bin/env ruby -KU
-
-TIMES = (ENV['N'] || 10000).to_i
-require 'rubygems'
-
-gem 'addressable',  '~>2.0'
-gem 'faker',        '~>0.3.1'
-gem 'rbench',       '~>0.2.3'
-
-require 'addressable/uri'
-require 'faker'
-require 'rbench'
-
-require File.expand_path("../../../load_paths", __FILE__)
+require File.expand_path('../../../load_paths', __FILE__)
 require "active_record"
+require 'benchmark/ips'
 
-conn = { :adapter => 'mysql',
-  :database => 'activerecord_unittest',
-  :username => 'rails', :password => '',
-  :encoding => 'utf8' }
+TIME    = (ENV['BENCHMARK_TIME'] || 20).to_i
+RECORDS = (ENV['BENCHMARK_RECORDS'] || TIME*1000).to_i
 
-conn[:socket] = Pathname.glob(%w[
-  /opt/local/var/run/mysql5/mysqld.sock
-  /tmp/mysqld.sock
-  /tmp/mysql.sock
-  /var/mysql/mysql.sock
-  /var/run/mysqld/mysqld.sock
-]).find { |path| path.socket? }
+conn = { :adapter => 'sqlite3', :database => ':memory:' }
 
 ActiveRecord::Base.establish_connection(conn)
 
@@ -51,112 +31,142 @@ class Exhibit < ActiveRecord::Base
   def look; attributes end
   def feel; look; user.name end
 
+  def self.with_name
+    where("name IS NOT NULL")
+  end
+
+  def self.with_notes
+    where("notes IS NOT NULL")
+  end
+
   def self.look(exhibits) exhibits.each { |e| e.look } end
   def self.feel(exhibits) exhibits.each { |e| e.feel } end
 end
 
-sqlfile = File.expand_path("../performance.sql", __FILE__)
-
-if File.exists?(sqlfile)
-  mysql_bin = %w[mysql mysql5].detect { |bin| `which #{bin}`.length > 0 }
-  `#{mysql_bin} -u #{conn[:username]} #{"-p#{conn[:password]}" unless conn[:password].blank?} #{conn[:database]} < #{sqlfile}`
-else
-  puts 'Generating data...'
-
-  # pre-compute the insert statements and fake data compilation,
-  # so the benchmarks below show the actual runtime for the execute
-  # method, minus the setup steps
-
-  # Using the same paragraph for all exhibits because it is very slow
-  # to generate unique paragraphs for all exhibits.
-  notes = Faker::Lorem.paragraphs.join($/)
-  today = Date.today
-
-  puts 'Inserting 10,000 users and exhibits...'
-  10_000.times do
-    user = User.create(
-      :created_at => today,
-      :name       => Faker::Name.name,
-      :email      => Faker::Internet.email
-    )
-
-    Exhibit.create(
-      :created_at => today,
-      :name       => Faker::Company.name,
-      :user       => user,
-      :notes      => notes
-    )
-  end
-
-  mysqldump_bin = %w[mysqldump mysqldump5].select { |bin| `which #{bin}`.length > 0 }
-  `#{mysqldump_bin} -u #{conn[:username]} #{"-p#{conn[:password]}" unless conn[:password].blank?} #{conn[:database]} exhibits users > #{sqlfile}`
+puts 'Generating data...'
+
+module ActiveRecord
+  class Faker
+    LOREM = %Q{Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse non aliquet diam. Curabitur vel urna metus, quis malesuada elit.
+     Integer consequat tincidunt felis. Etiam non erat dolor. Vivamus imperdiet nibh sit amet diam eleifend id posuere diam malesuada. Mauris at accumsan sem.
+     Donec id lorem neque. Fusce erat lorem, ornare eu congue vitae, malesuada quis neque. Maecenas vel urna a velit pretium fermentum. Donec tortor enim,
+     tempor venenatis egestas a, tempor sed ipsum. Ut arcu justo, faucibus non imperdiet ac, interdum at diam. Pellentesque ipsum enim, venenatis ut iaculis vitae,
+     varius vitae sem. Sed rutrum quam ac elit euismod bibendum. Donec ultricies ultricies magna, at lacinia libero mollis aliquam. Sed ac arcu in tortor elementum
+     tincidunt vel interdum sem. Curabitur eget erat arcu. Praesent eget eros leo. Nam magna enim, sollicitudin vehicula scelerisque in, vulputate ut libero.
+     Praesent varius tincidunt commodo}.split
+
+    def self.name
+      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join ' '
+    end
+
+    def self.email
+      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join('@') + ".com"
+    end
+  end
 end
 
-RBench.run(TIMES) do
-  column :times
-  column :ar
+# pre-compute the insert statements and fake data compilation,
+# so the benchmarks below show the actual runtime for the execute
+# method, minus the setup steps
+
+# Using the same paragraph for all exhibits because it is very slow
+# to generate unique paragraphs for all exhibits.
+notes = ActiveRecord::Faker::LOREM.join ' '
+today = Date.today
+
+puts "Inserting #{RECORDS} users and exhibits..."
+RECORDS.times do
+  user = User.create(
+    :created_at => today,
+    :name       => ActiveRecord::Faker.name,
+    :email      => ActiveRecord::Faker.email
+  )
+
+  Exhibit.create(
+    :created_at => today,
+    :name       => ActiveRecord::Faker.name,
+    :user       => user,
+    :notes      => notes
+  )
+end
 
-  report 'Model#id', (TIMES * 100).ceil do
-    ar_obj = Exhibit.find(1)
+Benchmark.ips(TIME) do |x|
+  ar_obj       = Exhibit.find(1)
+  attrs        = { :name => 'sam' }
+  attrs_first  = { :name => 'sam' }
+  attrs_second = { :name => 'tom' }
+  exhibit      = {
+    :name       => ActiveRecord::Faker.name,
+    :notes      => notes,
+    :created_at => Date.today
+  }
 
-    ar { ar_obj.id }
+  x.report("Model#id") do
+    ar_obj.id
   end
 
-  report 'Model.new (instantiation)' do
-    ar { Exhibit.new }
+  x.report 'Model.new (instantiation)' do
+    Exhibit.new
   end
 
-  report 'Model.new (setting attributes)' do
-    attrs = { :name => 'sam' }
-    ar { Exhibit.new(attrs) }
+  x.report 'Model.new (setting attributes)' do
+    Exhibit.new(attrs)
   end
 
-  report 'Model.first' do
-    ar { Exhibit.first.look }
+  x.report 'Model.first' do
+    Exhibit.first.look
   end
 
-  report 'Model.all limit(100)', (TIMES / 10).ceil do
-    ar { Exhibit.look Exhibit.limit(100) }
+  x.report("Model.all limit(100)") do
+    Exhibit.look Exhibit.limit(100)
   end
 
-  report 'Model.all limit(100) with relationship', (TIMES / 10).ceil do
-    ar { Exhibit.feel Exhibit.limit(100).includes(:user) }
+  x.report "Model.all limit(100) with relationship" do
+    Exhibit.feel Exhibit.limit(100).includes(:user)
   end
 
-  report 'Model.all limit(10,000)', (TIMES / 1000).ceil do
-    ar { Exhibit.look Exhibit.limit(10000) }
+  x.report "Model.all limit(10,000)" do
+    Exhibit.look Exhibit.limit(10000)
   end
 
-  exhibit = {
-    :name       => Faker::Company.name,
-    :notes      => Faker::Lorem.paragraphs.join($/),
-    :created_at => Date.today
-  }
+  x.report 'Model.named_scope' do
+    Exhibit.limit(10).with_name.with_notes
+  end
 
-  report 'Model.create' do
-    ar { Exhibit.create(exhibit) }
+  x.report 'Model.create' do
+    Exhibit.create(exhibit)
   end
 
-  report 'Resource#attributes=' do
-    attrs_first  = { :name => 'sam' }
-    attrs_second = { :name => 'tom' }
-    ar { exhibit = Exhibit.new(attrs_first); exhibit.attributes = attrs_second }
+  x.report 'Resource#attributes=' do
+    e = Exhibit.new(attrs_first)
+    e.attributes = attrs_second
   end
 
-  report 'Resource#update' do
-    ar { Exhibit.first.update_attributes(:name => 'bob') }
+  x.report 'Resource#update' do
+    Exhibit.first.update(name: 'bob')
   end
 
-  report 'Resource#destroy' do
-    ar { Exhibit.first.destroy }
+  x.report 'Resource#destroy' do
+    Exhibit.first.destroy
   end
 
-  report 'Model.transaction' do
-    ar { Exhibit.transaction { Exhibit.new } }
+  x.report 'Model.transaction' do
+    Exhibit.transaction { Exhibit.new }
   end
 
-  summary 'Total'
-end
+  x.report 'Model.find(id)' do
+    User.find(1)
+  end
 
-ActiveRecord::Migration.drop_table "exhibits"
-ActiveRecord::Migration.drop_table "users"
+  x.report 'Model.find_by_sql' do
+    Exhibit.find_by_sql("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}").first
+  end
+
+  x.report "Model.log" do
+    Exhibit.connection.send(:log, "hello", "world") {}
+  end
+
+  x.report "AR.execute(query)" do
+    ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}")
+  end
+end