activerecord 5.2.3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+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
+"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

@@ -0,0 +1,217 @@
+= 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
+provides a base class that, when subclassed, sets up a mapping between the new
+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*.
+
+Active Record relies heavily on naming in that it uses class and association
+names to establish mappings between respective database tables and foreign key
+columns. Although these mappings can be defined explicitly, it's recommended
+to follow naming conventions, especially when getting started with the
+library.
+
+A short rundown of some of the major features:
+
+* Automated mapping between classes and tables, attributes and columns.
+
+   class Product < ActiveRecord::Base
+   end
+
+  {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 bigint NOT NULL auto_increment,
+     name varchar(255),
+     PRIMARY KEY  (id)
+   );
+
+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.
+
+   class Firm < ActiveRecord::Base
+     has_many   :clients
+     has_one    :account
+     belongs_to :conglomerate
+   end
+
+  {Learn more}[link:classes/ActiveRecord/Associations/ClassMethods.html]
+
+
+* Aggregations of value objects.
+
+   class Account < ActiveRecord::Base
+     composed_of :balance, class_name: 'Money',
+                 mapping: %w(balance amount)
+     composed_of :address,
+                 mapping: [%w(address_street street), %w(address_city city)]
+   end
+
+  {Learn more}[link:classes/ActiveRecord/Aggregations/ClassMethods.html]
+
+
+* Validation rules that can differ for new or existing objects.
+
+    class Account < ActiveRecord::Base
+      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.).
+
+   class Person < ActiveRecord::Base
+     before_destroy :invalidate_payment_plan
+     # the `invalidate_payment_plan` method gets called just before Person#destroy
+   end
+
+  {Learn more}[link:classes/ActiveRecord/Callbacks.html]
+
+
+* Inheritance hierarchies.
+
+   class Company < ActiveRecord::Base; end
+   class Firm < Company; end
+   class Client < Company; end
+   class PriorityClient < Client; end
+
+  {Learn more}[link:classes/ActiveRecord/Base.html]
+
+
+* Transactions.
+
+    # Database transaction
+    Account.transaction do
+      david.withdrawal(100)
+      mary.deposit(100)
+    end
+
+  {Learn more}[link:classes/ActiveRecord/Transactions/ClassMethods.html]
+
+
+* Reflections on columns, associations, and aggregations.
+
+    reflection = Firm.reflect_on_association(:clients)
+    reflection.klass # => Client (class)
+    Firm.columns # Returns an array of column descriptors for the firms table
+
+  {Learn more}[link:classes/ActiveRecord/Reflection/ClassMethods.html]
+
+
+* Database abstraction through simple adapters.
+
+    # connect to 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'
+    )
+
+  {Learn more}[link:classes/ActiveRecord/Base.html] and read about the built-in support for
+  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[https://github.com/colbygk/log4r] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
+
+    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[5.0]
+      def up
+        create_table :system_settings do |t|
+          t.string  :name
+          t.string  :label
+          t.text    :value
+          t.string  :type
+          t.integer :position
+        end
+
+        SystemSetting.create name: 'notice', label: 'Use notice?', value: 1
+      end
+
+      def down
+        drop_table :system_settings
+      end
+    end
+
+  {Learn more}[link:classes/ActiveRecord/Migration.html]
+
+
+== Philosophy
+
+Active Record is an implementation of the object-relational mapping (ORM)
+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,
+  encapsulates the database access, and adds domain logic on that data."
+
+Active Record attempts to provide a coherent wrapper as a solution for the inconvenience that is
+object-relational mapping. The prime directive for this mapping has been to minimize
+the amount of code needed to build a real-world domain model. This is made possible
+by relying on a number of conventions that make it easy for Active Record to infer
+complex relations and structures from a minimal amount of explicit direction.
+
+Convention over Configuration:
+* No XML files!
+* Lots of reflection and run-time extension
+* Magic is not inherently a bad word
+
+Admit the Database:
+* Lets you drop down to SQL for odd cases and performance
+* Doesn't attempt to duplicate or replace data definitions
+
+
+== Download and installation
+
+The latest version of Active Record can be installed with RubyGems:
+
+  $ gem install activerecord
+
+Source code can be downloaded as part of the Rails project on GitHub:
+
+* https://github.com/rails/rails/tree/5-2-stable/activerecord
+
+
+== License
+
+Active Record is released under the MIT license:
+
+* https://opensource.org/licenses/MIT
+
+
+== Support
+
+API documentation is at:
+
+* http://api.rubyonrails.org
+
+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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "benchmark/ips"
+
+TIME    = (ENV["BENCHMARK_TIME"] || 20).to_i
+RECORDS = (ENV["BENCHMARK_RECORDS"] || TIME * 1000).to_i
+
+conn = { adapter: "sqlite3", database: ":memory:" }
+
+ActiveRecord::Base.establish_connection(conn)
+
+class User < ActiveRecord::Base
+  connection.create_table :users, force: true do |t|
+    t.string :name, :email
+    t.timestamps
+  end
+
+  has_many :exhibits
+end
+
+class Exhibit < ActiveRecord::Base
+  connection.create_table :exhibits, force: true do |t|
+    t.belongs_to :user
+    t.string :name
+    t.text :notes
+    t.timestamps
+  end
+
+  belongs_to :user
+
+  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(&:look) end
+  def self.feel(exhibits) exhibits.each(&:feel) end
+end
+
+def progress_bar(int); print "." if (int % 100).zero? ; end
+
+puts "Generating data..."
+
+module ActiveRecord
+  class Faker
+    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
+
+    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
+
+# 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 |record|
+  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
+  )
+  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" }
+  exhibit      = {
+    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
+    Exhibit.new
+  end
+
+  x.report "Model.new (setting attributes)" do
+    Exhibit.new(attrs)
+  end
+
+  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
+
+  x.report "Model.all limit(10,000)" do
+    Exhibit.look Exhibit.limit(10000)
+  end
+
+  x.report "Model.named_scope" do
+    Exhibit.limit(10).with_name.with_notes
+  end
+
+  x.report "Model.create" do
+    Exhibit.create(exhibit)
+  end
+
+  x.report "Resource#attributes=" do
+    e = Exhibit.new(attrs_first)
+    e.attributes = attrs_second
+  end
+
+  x.report "Resource#update" do
+    Exhibit.first.update(name: "bob")
+  end
+
+  x.report "Resource#destroy" do
+    Exhibit.first.destroy
+  end
+
+  x.report "Model.transaction" do
+    Exhibit.transaction { Exhibit.new }
+  end
+
+  x.report "Model.find(id)" do
+    User.find(1)
+  end
+
+  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

data/examples/simple.rb

@@ -0,0 +1,15 @@
+# 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|
+    t.string :name
+  end
+end
+
+bob = Person.create!(name: "bob")
+puts Person.all.inspect
+bob.destroy
+puts Person.all.inspect

data/lib/active_record.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+#--
+# 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
+# "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.
+#++
+
+require "active_support"
+require "active_support/rails"
+require "active_model"
+require "arel"
+require "yaml"
+
+require "active_record/version"
+require "active_model/attribute_set"
+
+module ActiveRecord
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :Callbacks
+  autoload :Core
+  autoload :ConnectionHandling
+  autoload :CounterCache
+  autoload :DynamicMatchers
+  autoload :Enum
+  autoload :InternalMetadata
+  autoload :Explain
+  autoload :Inheritance
+  autoload :Integration
+  autoload :Migration
+  autoload :Migrator, "active_record/migration"
+  autoload :ModelSchema
+  autoload :NestedAttributes
+  autoload :NoTouching
+  autoload :TouchLater
+  autoload :Persistence
+  autoload :QueryCache
+  autoload :Querying
+  autoload :CollectionCacheKey
+  autoload :ReadonlyAttributes
+  autoload :RecordInvalid, "active_record/validations"
+  autoload :Reflection
+  autoload :RuntimeRegistry
+  autoload :Sanitization
+  autoload :Schema
+  autoload :SchemaDumper
+  autoload :SchemaMigration
+  autoload :Scoping
+  autoload :Serialization
+  autoload :StatementCache
+  autoload :Store
+  autoload :Suppressor
+  autoload :Timestamp
+  autoload :Transactions
+  autoload :Translation
+  autoload :Validations
+  autoload :SecureToken
+
+  eager_autoload do
+    autoload :ActiveRecordError, "active_record/errors"
+    autoload :ConnectionNotEstablished, "active_record/errors"
+    autoload :ConnectionAdapters, "active_record/connection_adapters/abstract_adapter"
+
+    autoload :Aggregations
+    autoload :Associations
+    autoload :AttributeAssignment
+    autoload :AttributeMethods
+    autoload :AutosaveAssociation
+
+    autoload :LegacyYamlAdapter
+
+    autoload :Relation
+    autoload :AssociationRelation
+    autoload :NullRelation
+
+    autoload_under "relation" do
+      autoload :QueryMethods
+      autoload :FinderMethods
+      autoload :Calculations
+      autoload :PredicateBuilder
+      autoload :SpawnMethods
+      autoload :Batches
+      autoload :Delegation
+    end
+
+    autoload :Result
+    autoload :TableMetadata
+    autoload :Type
+  end
+
+  module Coders
+    autoload :YAMLColumn, "active_record/coders/yaml_column"
+    autoload :JSON, "active_record/coders/json"
+  end
+
+  module AttributeMethods
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :BeforeTypeCast
+      autoload :Dirty
+      autoload :PrimaryKey
+      autoload :Query
+      autoload :Read
+      autoload :TimeZoneConversion
+      autoload :Write
+      autoload :Serialization
+    end
+  end
+
+  module Locking
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Optimistic
+      autoload :Pessimistic
+    end
+  end
+
+  module ConnectionAdapters
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :AbstractAdapter
+    end
+  end
+
+  module Scoping
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Named
+      autoload :Default
+    end
+  end
+
+  module Tasks
+    extend ActiveSupport::Autoload
+
+    autoload :DatabaseTasks
+    autoload :SQLiteDatabaseTasks, "active_record/tasks/sqlite_database_tasks"
+    autoload :MySQLDatabaseTasks,  "active_record/tasks/mysql_database_tasks"
+    autoload :PostgreSQLDatabaseTasks,
+      "active_record/tasks/postgresql_database_tasks"
+  end
+
+  autoload :TestFixtures, "active_record/fixtures"
+
+  def self.eager_load!
+    super
+    ActiveRecord::Locking.eager_load!
+    ActiveRecord::Scoping.eager_load!
+    ActiveRecord::Associations.eager_load!
+    ActiveRecord::AttributeMethods.eager_load!
+    ActiveRecord::ConnectionAdapters.eager_load!
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  Arel::Table.engine = self
+end
+
+ActiveSupport.on_load(:i18n) do
+  I18n.load_path << File.expand_path("active_record/locale/en.yml", __dir__)
+end
+
+YAML.load_tags["!ruby/object:ActiveRecord::AttributeSet"] = "ActiveModel::AttributeSet"
+YAML.load_tags["!ruby/object:ActiveRecord::Attribute::FromDatabase"] = "ActiveModel::Attribute::FromDatabase"
+YAML.load_tags["!ruby/object:ActiveRecord::LazyAttributeHash"] = "ActiveModel::LazyAttributeHash"