activerecord 3.2.22.5 → 5.2.8

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2011 David Heinemeier Hansson
+Copyright (c) 2004-2018 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +17,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -1,4 +1,4 @@
-= Active Record -- Object-relational mapping put on rails
+= Active Record -- Object-relational mapping in Rails
 
 Active Record connects classes to relational database tables to establish an
 almost zero-configuration persistence layer for applications. The library
@@ -20,19 +20,19 @@ A short rundown of some of the major features:
    class Product < ActiveRecord::Base
    end
 
-   The Product class is automatically mapped to the table named "products",
-   which might look like this:
+  {Learn more}[link:classes/ActiveRecord/Base.html]
+
+The Product class is automatically mapped to the table named "products",
+which might look like this:
 
    CREATE TABLE products (
-     id int(11) NOT NULL auto_increment,
+     id bigint NOT NULL auto_increment,
      name varchar(255),
      PRIMARY KEY  (id)
    );
 
-   This would also define the following accessors: `Product#name` and
-   `Product#name=(new_name)`
-
-  {Learn more}[link:classes/ActiveRecord/Base.html]
+This would also define the following accessors: <tt>Product#name</tt> and
+<tt>Product#name=(new_name)</tt>.
 
 
 * Associations between objects defined by simple class methods.
@@ -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,10 +61,10 @@ 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]
@@ -80,17 +80,6 @@ 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
-       CommentMailer.new_comment_email("david@loudthinking.com", comment).deliver
-     end
-   end
-
-  {Learn more}[link:classes/ActiveRecord/Observer.html]
-
-
 * Inheritance hierarchies.
 
    class Company < ActiveRecord::Base; end
@@ -124,32 +113,32 @@ A short rundown of some of the major features:
 * 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  => "mysql2",
-      :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
-  MySQL[link:classes/ActiveRecord/ConnectionAdapters/MysqlAdapter.html],
+  MySQL[link:classes/ActiveRecord/ConnectionAdapters/Mysql2Adapter.html],
   PostgreSQL[link:classes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter.html], and
   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[https://github.com/colbygk/log4r] 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.
 
-    class AddSystemSettings < ActiveRecord::Migration
+    class AddSystemSettings < ActiveRecord::Migration[5.0]
       def up
         create_table :system_settings do |t|
           t.string  :name
@@ -159,7 +148,7 @@ 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 down
@@ -173,7 +162,7 @@ A short rundown of some of the major features:
 == Philosophy
 
 Active Record is an implementation of the object-relational mapping (ORM)
-pattern[http://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
+pattern[https://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
 name described by Martin Fowler:
 
   "An object that wraps a row in a database table or view,
@@ -186,7 +175,7 @@ by relying on a number of conventions that make it easy for Active Record to inf
 complex relations and structures from a minimal amount of explicit direction.
 
 Convention over Configuration:
-* No XML-files!
+* No XML files!
 * Lots of reflection and run-time extension
 * Magic is not inherently a bad word
 
@@ -199,24 +188,30 @@ Admit the Database:
 
 The latest version of Active Record can be installed with RubyGems:
 
-  % [sudo] gem install activerecord
+  $ 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:
 
-* https://github.com/rails/rails/tree/3-2-stable/activerecord
+* https://github.com/rails/rails/tree/5-2-stable/activerecord
 
 
 == License
 
-Active Record is released under the MIT license.
+Active Record is released under the MIT license:
+
+* https://opensource.org/licenses/MIT
 
 
 == Support
 
-API documentation is at
+API documentation is at:
 
 * http://api.rubyonrails.org
 
-Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
+Bug reports for the Ruby on Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
+
+Feature requests should be discussed on the rails-core mailing list here:
+
+* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core

data/examples/performance.rb

@@ -1,16 +1,17 @@
-require File.expand_path('../../../load_paths', __FILE__)
+# frozen_string_literal: true
+
 require "active_record"
-require 'benchmark/ips'
+require "benchmark/ips"
 
-TIME    = (ENV['BENCHMARK_TIME'] || 20).to_i
-RECORDS = (ENV['BENCHMARK_RECORDS'] || TIME*1000).to_i
+TIME    = (ENV["BENCHMARK_TIME"] || 20).to_i
+RECORDS = (ENV["BENCHMARK_RECORDS"] || TIME * 1000).to_i
 
-conn = { :adapter => 'sqlite3', :database => ':memory:' }
+conn = { adapter: "sqlite3", database: ":memory:" }
 
 ActiveRecord::Base.establish_connection(conn)
 
 class User < ActiveRecord::Base
-  connection.create_table :users, :force => true do |t|
+  connection.create_table :users, force: true do |t|
     t.string :name, :email
     t.timestamps
   end
@@ -19,7 +20,7 @@ class User < ActiveRecord::Base
 end
 
 class Exhibit < ActiveRecord::Base
-  connection.create_table :exhibits, :force => true do |t|
+  connection.create_table :exhibits, force: true do |t|
     t.belongs_to :user
     t.string :name
     t.text :notes
@@ -39,28 +40,30 @@ class Exhibit < ActiveRecord::Base
     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
+  def self.look(exhibits) exhibits.each(&:look) end
+  def self.feel(exhibits) exhibits.each(&:feel) end
 end
 
-puts 'Generating data...'
+def progress_bar(int); print "." if (int % 100).zero? ; end
+
+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.
+    LOREM = "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
+     Praesent varius tincidunt commodo".split
 
     def self.name
-      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join ' '
+      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join " "
     end
 
     def self.email
-      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join('@') + ".com"
+      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join("@") + ".com"
     end
   end
 end
@@ -71,56 +74,66 @@ end
 
 # Using the same paragraph for all exhibits because it is very slow
 # to generate unique paragraphs for all exhibits.
-notes = ActiveRecord::Faker::LOREM.join ' '
+notes = ActiveRecord::Faker::LOREM.join " "
 today = Date.today
 
 puts "Inserting #{RECORDS} users and exhibits..."
-RECORDS.times do
+RECORDS.times do |record|
   user = User.create(
-    :created_at => today,
-    :name       => ActiveRecord::Faker.name,
-    :email      => ActiveRecord::Faker.email
+    created_at: today,
+    name: ActiveRecord::Faker.name,
+    email: ActiveRecord::Faker.email
   )
 
   Exhibit.create(
-    :created_at => today,
-    :name       => ActiveRecord::Faker.name,
-    :user       => user,
-    :notes      => notes
+    created_at: today,
+    name: ActiveRecord::Faker.name,
+    user: user,
+    notes: notes
   )
+  progress_bar(record)
 end
+puts "Done!\n"
 
 Benchmark.ips(TIME) do |x|
   ar_obj       = Exhibit.find(1)
-  attrs        = { :name => 'sam' }
-  attrs_first  = { :name => 'sam' }
-  attrs_second = { :name => 'tom' }
+  attrs        = { name: "sam" }
+  attrs_first  = { name: "sam" }
+  attrs_second = { name: "tom" }
   exhibit      = {
-    :name       => ActiveRecord::Faker.name,
-    :notes      => notes,
-    :created_at => Date.today
+    name: ActiveRecord::Faker.name,
+    notes: notes,
+    created_at: Date.today
   }
 
   x.report("Model#id") do
     ar_obj.id
   end
 
-  x.report 'Model.new (instantiation)' do
+  x.report "Model.new (instantiation)" do
     Exhibit.new
   end
 
-  x.report 'Model.new (setting attributes)' do
+  x.report "Model.new (setting attributes)" do
     Exhibit.new(attrs)
   end
 
-  x.report 'Model.first' do
+  x.report "Model.first" do
     Exhibit.first.look
   end
 
+  x.report "Model.take" do
+    Exhibit.take
+  end
+
   x.report("Model.all limit(100)") do
     Exhibit.look Exhibit.limit(100)
   end
 
+  x.report("Model.all take(100)") do
+    Exhibit.look Exhibit.take(100)
+  end
+
   x.report "Model.all limit(100) with relationship" do
     Exhibit.feel Exhibit.limit(100).includes(:user)
   end
@@ -129,36 +142,36 @@ Benchmark.ips(TIME) do |x|
     Exhibit.look Exhibit.limit(10000)
   end
 
-  x.report 'Model.named_scope' do
+  x.report "Model.named_scope" do
     Exhibit.limit(10).with_name.with_notes
   end
 
-  x.report 'Model.create' do
+  x.report "Model.create" do
     Exhibit.create(exhibit)
   end
 
-  x.report 'Resource#attributes=' do
+  x.report "Resource#attributes=" do
     e = Exhibit.new(attrs_first)
     e.attributes = attrs_second
   end
 
-  x.report 'Resource#update' do
-    Exhibit.first.update_attributes(:name => 'bob')
+  x.report "Resource#update" do
+    Exhibit.first.update(name: "bob")
   end
 
-  x.report 'Resource#destroy' do
+  x.report "Resource#destroy" do
     Exhibit.first.destroy
   end
 
-  x.report 'Model.transaction' do
+  x.report "Model.transaction" do
     Exhibit.transaction { Exhibit.new }
   end
 
-  x.report 'Model.find(id)' do
+  x.report "Model.find(id)" do
     User.find(1)
   end
 
-  x.report 'Model.find_by_sql' do
+  x.report "Model.find_by_sql" do
     Exhibit.find_by_sql("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}").first
   end
 
@@ -167,6 +180,6 @@ Benchmark.ips(TIME) do |x|
   end
 
   x.report "AR.execute(query)" do
-    ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}")
+    ActiveRecord::Base.connection.execute("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}")
   end
 end

data/examples/simple.rb

@@ -1,14 +1,15 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-require 'active_record'
+# frozen_string_literal: true
+
+require "active_record"
 
 class Person < ActiveRecord::Base
-  establish_connection :adapter => 'sqlite3', :database => 'foobar.db'
-  connection.create_table table_name, :force => true do |t|
+  establish_connection adapter: "sqlite3", database: "foobar.db"
+  connection.create_table table_name, force: true do |t|
     t.string :name
   end
 end
 
-bob = Person.create!(:name => 'bob')
+bob = Person.create!(name: "bob")
 puts Person.all.inspect
 bob.destroy
 puts Person.all.inspect