ibm_db 5.2.0 → 5.3.1

data/test/models/category.rb

@@ -1,34 +1,46 @@
+# frozen_string_literal: true
+
 class Category < ActiveRecord::Base
   has_and_belongs_to_many :posts
-  has_and_belongs_to_many :special_posts, :class_name => "Post"
-  has_and_belongs_to_many :other_posts, :class_name => "Post"
-  has_and_belongs_to_many :posts_with_authors_sorted_by_author_id, -> { includes(:authors).order("authors.id") }, :class_name => "Post"
+  has_and_belongs_to_many :special_posts, class_name: "Post"
+  has_and_belongs_to_many :other_posts, class_name: "Post"
+  has_and_belongs_to_many :posts_with_authors_sorted_by_author_id, -> { includes(:authors).order("authors.id") }, class_name: "Post"
 
   has_and_belongs_to_many :select_testing_posts,
-                          -> { select 'posts.*, 1 as correctness_marker' },
-                          :class_name => 'Post',
-                          :foreign_key => 'category_id',
-                          :association_foreign_key => 'post_id'
+                          -> { select "posts.*, 1 as correctness_marker" },
+                          class_name: "Post",
+                          foreign_key: "category_id",
+                          association_foreign_key: "post_id"
 
   has_and_belongs_to_many :post_with_conditions,
-                          -> { where :title => 'Yet Another Testing Title' },
-                          :class_name => 'Post'
+                          -> { where title: "Yet Another Testing Title" },
+                          class_name: "Post"
 
-  has_and_belongs_to_many :popular_grouped_posts, -> { group("posts.type").having("sum(comments.post_id) > 2").includes(:comments) }, :class_name => "Post"
-  has_and_belongs_to_many :posts_grouped_by_title, -> { group("title").select("title") }, :class_name => "Post"
+  has_and_belongs_to_many :popular_grouped_posts, -> { group("posts.type").having("sum(comments.post_id) > 2").includes(:comments) }, class_name: "Post"
+  has_and_belongs_to_many :posts_grouped_by_title, -> { group("title").select("title") }, class_name: "Post"
 
   def self.what_are_you
-    'a category...'
+    "a category..."
   end
 
   has_many :categorizations
   has_many :special_categorizations
-  has_many :post_comments, :through => :posts, :source => :comments
+  has_many :post_comments, through: :posts, source: :comments
+  has_many :ordered_post_comments, -> { order(id: :desc) }, through: :posts, source: :comments
+
+  has_many :authors, through: :categorizations
+  has_many :authors_with_select, -> { select "authors.*, categorizations.post_id" }, through: :categorizations, source: :author
 
-  has_many :authors, :through => :categorizations
-  has_many :authors_with_select, -> { select 'authors.*, categorizations.post_id' }, :through => :categorizations, :source => :author
+  scope :general, -> { where(name: "General") }
 
-  scope :general, -> { where(:name => 'General') }
+  # Should be delegated `ast` and `locked` to `arel`.
+  def self.ast
+    raise
+  end
+
+  def self.locked
+    raise
+  end
 end
 
 class SpecialCategory < Category

data/test/models/chef.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Chef < ActiveRecord::Base
   belongs_to :employable, polymorphic: true
   has_many :recipes

data/test/models/citation.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
 class Citation < ActiveRecord::Base
-  belongs_to :reference_of, :class_name => "Book", :foreign_key => :book2_id
+  belongs_to :book, foreign_key: :book1_id, inverse_of: :citations, touch: true
+  belongs_to :reference_of, class_name: "Book", foreign_key: :book2_id
+  has_many :citations
 end

data/test/models/club.rb

@@ -1,25 +1,28 @@
+# frozen_string_literal: true
+
 class Club < ActiveRecord::Base
-  has_one :membership
-  has_many :memberships, :inverse_of => false
-  has_many :members, :through => :memberships
+  has_one :membership, touch: true
+  has_many :memberships, inverse_of: false
+  has_many :members, through: :memberships
   has_one :sponsor
-  has_one :sponsored_member, :through => :sponsor, :source => :sponsorable, :source_type => "Member"
+  has_one :sponsored_member, through: :sponsor, source: :sponsorable, source_type: :Member
   belongs_to :category
 
   has_many :favourites, -> { where(memberships: { favourite: true }) }, through: :memberships, source: :member
 
-  scope :general, -> { left_joins(:category).where(categories: { name: "General" }) }
+  scope :general, -> { left_joins(:category).where(categories: { name: "General" }).unscope(:limit) }
 
-  private
+  accepts_nested_attributes_for :membership
 
-  def private_method
-    "I'm sorry sir, this is a *private* club, not a *pirate* club"
-  end
+  private
+    def private_method
+      "I'm sorry sir, this is a *private* club, not a *pirate* club"
+    end
 end
 
 class SuperClub < ActiveRecord::Base
   self.table_name = "clubs"
 
-  has_many :memberships, class_name: 'SuperMembership', foreign_key: 'club_id'
+  has_many :memberships, class_name: "SuperMembership", foreign_key: "club_id"
   has_many :members, through: :memberships
 end

data/test/models/college.rb

@@ -1,5 +1,7 @@
-require_dependency 'models/arunit2_model'
-require 'active_support/core_ext/object/with_options'
+# frozen_string_literal: true
+
+require "models/arunit2_model"
+require "active_support/core_ext/object/with_options"
 
 class College < ARUnit2Model
   has_many :courses

data/test/models/column.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Column < ActiveRecord::Base
   belongs_to :record
 end

data/test/models/column_name.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ColumnName < ActiveRecord::Base
   self.table_name = "colnametests"
 end

data/test/models/comment.rb

@@ -1,23 +1,32 @@
+# frozen_string_literal: true
+
+# `counter_cache` requires association class before `attr_readonly`.
+class Post < ActiveRecord::Base; end
+
 class Comment < ActiveRecord::Base
-  scope :limit_by, lambda {|l| limit(l) }
+  scope :limit_by, lambda { |l| limit(l) }
   scope :containing_the_letter_e, -> { where("comments.body LIKE '%e%'") }
   scope :not_again, -> { where("comments.body NOT LIKE '%again%'") }
-  scope :for_first_post, -> { where(:post_id => 1) }
+  scope :for_first_post, -> { where(post_id: 1) }
   scope :for_first_author, -> { joins(:post).where("posts.author_id" => 1) }
   scope :created, -> { all }
 
-  belongs_to :post, :counter_cache => true
+  belongs_to :post, counter_cache: true
   belongs_to :author,   polymorphic: true
   belongs_to :resource, polymorphic: true
-  belongs_to :developer
+  belongs_to :company, foreign_key: "company"
 
   has_many :ratings
 
-  belongs_to :first_post, :foreign_key => :post_id
+  belongs_to :first_post, foreign_key: :post_id
   belongs_to :special_post_with_default_scope, foreign_key: :post_id
 
-  has_many :children, :class_name => 'Comment', :foreign_key => :parent_id
-  belongs_to :parent, :class_name => 'Comment', :counter_cache => :children_count
+  has_many :children, class_name: "Comment", foreign_key: :parent_id, inverse_of: :parent
+  belongs_to :parent, class_name: "Comment", counter_cache: :children_count, inverse_of: :children
+
+  alias_attribute :entry, :post
+
+  enum label: [:default, :child]
 
   class ::OopsError < RuntimeError; end
 
@@ -29,13 +38,15 @@ class Comment < ActiveRecord::Base
 
   default_scope { extending OopsExtension }
 
+  scope :oops_comments, -> { extending OopsExtension }
+
   # Should not be called if extending modules that having the method exists on an association.
   def self.greeting
     raise
   end
 
   def self.what_are_you
-    'a comment...'
+    "a comment..."
   end
 
   def self.search_by_type(q)
@@ -53,7 +64,12 @@ class Comment < ActiveRecord::Base
 end
 
 class SpecialComment < Comment
+  has_one :author, through: :post
   default_scope { where(deleted_at: nil) }
+
+  def self.what_are_you
+    "a special comment..."
+  end
 end
 
 class SubSpecialComment < SpecialComment
@@ -66,11 +82,17 @@ class CommentThatAutomaticallyAltersPostBody < Comment
   belongs_to :post, class_name: "PostThatLoadsCommentsInAnAfterSaveHook", foreign_key: :post_id
 
   after_save do |comment|
-    comment.post.update_attributes(body: "Automatically altered")
+    comment.post.update(body: "Automatically altered")
   end
 end
 
 class CommentWithDefaultScopeReferencesAssociation < Comment
-  default_scope ->{ includes(:developer).order('developers.name').references(:developer) }
+  default_scope -> { includes(:developer).order("developers.name").references(:developer) }
   belongs_to :developer
 end
+
+class CommentWithAfterCreateUpdate < Comment
+  after_create do
+    update(body: "bar")
+  end
+end

data/test/models/company.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AbstractCompany < ActiveRecord::Base
   self.abstract_class = true
 end
@@ -7,13 +9,19 @@ class Company < AbstractCompany
 
   validates_presence_of :name
 
-  has_one :dummy_account, :foreign_key => "firm_id", :class_name => "Account"
+  has_one :account, foreign_key: "firm_id"
+  has_one :dummy_account, foreign_key: "firm_id", class_name: "Account"
   has_many :contracts
-  has_many :developers, :through => :contracts
+  has_many :developers, through: :contracts
+  has_many :special_contracts, -> { includes(:special_developer).where.not("developers.id": nil) }
+  has_many :special_developers, through: :special_contracts
+  has_many :comments, foreign_key: "company"
+
+  alias_attribute :new_name, :name
+  attribute :metadata, :json
 
   scope :of_first_firm, lambda {
-    joins(:account => :firm).
-    where('firms.id' => 1)
+    joins(account: :firm).where("companies.id": 1)
   }
 
   def arbitrary_method
@@ -21,13 +29,12 @@ class Company < AbstractCompany
   end
 
   private
+    def private_method
+      "I am Jack's innermost fears and aspirations"
+    end
 
-  def private_method
-    "I am Jack's innermost fears and aspirations"
-  end
-
-  class SpecialCo < Company
-  end
+    class SpecialCo < Company
+    end
 end
 
 module Namespaced
@@ -35,7 +42,7 @@ module Namespaced
   end
 
   class Firm < ::Company
-    has_many :clients, :class_name => 'Namespaced::Client'
+    has_many :clients, class_name: "Namespaced::Client"
   end
 
   class Client < ::Company
@@ -45,45 +52,47 @@ end
 class Firm < Company
   to_param :name
 
-  has_many :clients, -> { order "id" }, :dependent => :destroy, :before_remove => :log_before_remove, :after_remove  => :log_after_remove
-  has_many :unsorted_clients, :class_name => "Client"
-  has_many :unsorted_clients_with_symbol, :class_name => :Client
-  has_many :clients_sorted_desc, -> { order "id DESC" }, :class_name => "Client"
-  has_many :clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client", :inverse_of => :firm
-  has_many :clients_ordered_by_name, -> { order "name" }, :class_name => "Client"
-  has_many :unvalidated_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :validate => false
-  has_many :dependent_clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client", :dependent => :destroy
-  has_many :exclusively_dependent_clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
-  has_many :limited_clients, -> { limit 1 }, :class_name => "Client"
-  has_many :clients_with_interpolated_conditions, ->(firm) { where "rating > #{firm.rating}" }, :class_name => "Client"
-  has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, :class_name => "Client"
-  has_many :clients_like_ms_with_hash_conditions, -> { where(:name => 'Microsoft').order("id") }, :class_name => "Client"
-  has_many :plain_clients, :class_name => 'Client'
-  has_many :clients_using_primary_key, :class_name => 'Client',
-           :primary_key => 'name', :foreign_key => 'firm_name'
-  has_many :clients_using_primary_key_with_delete_all, :class_name => 'Client',
-           :primary_key => 'name', :foreign_key => 'firm_name', :dependent => :delete_all
-  has_many :clients_grouped_by_firm_id, -> { group("firm_id").select("firm_id") }, :class_name => "Client"
-  has_many :clients_grouped_by_name, -> { group("name").select("name") }, :class_name => "Client"
-
-  has_one :account, :foreign_key => "firm_id", :dependent => :destroy, :validate => true
-  has_one :unvalidated_account, :foreign_key => "firm_id", :class_name => 'Account', :validate => false
-  has_one :account_with_select, -> { select("id, firm_id") }, :foreign_key => "firm_id", :class_name=>'Account'
-  has_one :readonly_account, -> { readonly }, :foreign_key => "firm_id", :class_name => "Account"
+  has_many :clients, -> { order "id" }, dependent: :destroy, before_remove: :log_before_remove, after_remove: :log_after_remove
+  has_many :unsorted_clients, class_name: "Client"
+  has_many :unsorted_clients_with_symbol, class_name: :Client
+  has_many :clients_sorted_desc, -> { order "id DESC" }, class_name: "Client"
+  has_many :clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", inverse_of: :firm
+  has_many :clients_ordered_by_name, -> { order "name" }, class_name: "Client"
+  has_many :unvalidated_clients_of_firm, foreign_key: "client_of", class_name: "Client", validate: false
+  has_many :dependent_clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", dependent: :destroy
+  has_many :exclusively_dependent_clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+  has_many :limited_clients, -> { limit 1 }, class_name: "Client"
+  has_many :clients_with_interpolated_conditions, ->(firm) { where "rating > #{firm.rating}" }, class_name: "Client"
+  has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, class_name: "Client"
+  has_many :clients_like_ms_with_hash_conditions, -> { where(name: "Microsoft").order("id") }, class_name: "Client"
+  has_many :plain_clients, class_name: "Client"
+  has_many :clients_using_primary_key, class_name: "Client",
+           primary_key: "name", foreign_key: "firm_name"
+  has_many :clients_using_primary_key_with_delete_all, class_name: "Client",
+           primary_key: "name", foreign_key: "firm_name", dependent: :delete_all
+  has_many :clients_grouped_by_firm_id, -> { group("firm_id").select("firm_id") }, class_name: "Client"
+  has_many :clients_grouped_by_name, -> { group("name").select("name") }, class_name: "Client"
+
+  has_one :account, foreign_key: "firm_id", dependent: :destroy, validate: true
+  has_one :unvalidated_account, foreign_key: "firm_id", class_name: "Account", validate: false
+  has_one :account_with_select, -> { select("id, firm_id") }, foreign_key: "firm_id", class_name: "Account"
+  has_one :readonly_account, -> { readonly }, foreign_key: "firm_id", class_name: "Account"
   # added order by id as in fixtures there are two accounts for Rails Core
   # Oracle tests were failing because of that as the second fixture was selected
-  has_one :account_using_primary_key, -> { order('id') }, :primary_key => "firm_id", :class_name => "Account"
-  has_one :account_using_foreign_and_primary_keys, :foreign_key => "firm_name", :primary_key => "name", :class_name => "Account"
-  has_one :account_with_inexistent_foreign_key, class_name: 'Account', foreign_key: "inexistent"
-  has_one :deletable_account, :foreign_key => "firm_id", :class_name => "Account", :dependent => :delete
+  has_one :account_using_primary_key, -> { order("id") }, primary_key: "firm_id", class_name: "Account"
+  has_one :account_using_foreign_and_primary_keys, foreign_key: "firm_name", primary_key: "name", class_name: "Account"
+  has_one :account_with_inexistent_foreign_key, class_name: "Account", foreign_key: "inexistent"
+  has_one :deletable_account, foreign_key: "firm_id", class_name: "Account", dependent: :delete
 
-  has_one :account_limit_500_with_hash_conditions, -> { where :credit_limit => 500 }, :foreign_key => "firm_id", :class_name => "Account"
+  has_one :account_limit_500_with_hash_conditions, -> { where credit_limit: 500 }, foreign_key: "firm_id", class_name: "Account"
 
-  has_one :unautosaved_account, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
+  has_one :unautosaved_account, foreign_key: "firm_id", class_name: "Account", autosave: false
   has_many :accounts
-  has_many :unautosaved_accounts, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
+  has_many :unautosaved_accounts, foreign_key: "firm_id", class_name: "Account", autosave: false
+
+  has_many :association_with_references, -> { references(:foo) }, class_name: "Client"
 
-  has_many :association_with_references, -> { references(:foo) }, :class_name => 'Client'
+  has_many :developers_with_select, -> { select("id, name, first_name") }, class_name: "Developer"
 
   has_one :lead_developer, class_name: "Developer"
   has_many :projects
@@ -103,32 +112,38 @@ class Firm < Company
 end
 
 class DependentFirm < Company
-  has_one :account, :foreign_key => "firm_id", :dependent => :nullify
-  has_many :companies, :foreign_key => 'client_of', :dependent => :nullify
-  has_one :company, :foreign_key => 'client_of', :dependent => :nullify
+  has_one :account, -> { order(:id) }, foreign_key: "firm_id", dependent: :nullify
+  has_many :companies, foreign_key: "client_of", dependent: :nullify
+  has_one :company, foreign_key: "client_of", dependent: :nullify
 end
 
 class RestrictedWithExceptionFirm < Company
-  has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict_with_exception
-  has_many :companies, -> { order("id") }, :foreign_key => 'client_of', :dependent => :restrict_with_exception
+  has_one :account, -> { order("id") }, foreign_key: "firm_id", dependent: :restrict_with_exception
+  has_many :companies, -> { order("id") }, foreign_key: "client_of", dependent: :restrict_with_exception
 end
 
 class RestrictedWithErrorFirm < Company
-  has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict_with_error
-  has_many :companies, -> { order("id") }, :foreign_key => 'client_of', :dependent => :restrict_with_error
+  has_one :account, -> { order("id") }, foreign_key: "firm_id", dependent: :restrict_with_error
+  has_many :companies, -> { order("id") }, foreign_key: "client_of", dependent: :restrict_with_error
+end
+
+class Agency < Firm
+  has_many :projects, foreign_key: :firm_id
+
+  accepts_nested_attributes_for :projects
 end
 
 class Client < Company
-  belongs_to :firm, :foreign_key => "client_of"
-  belongs_to :firm_with_basic_id, :class_name => "Firm", :foreign_key => "firm_id"
-  belongs_to :firm_with_select, -> { select("id") }, :class_name => "Firm", :foreign_key => "firm_id"
-  belongs_to :firm_with_other_name, :class_name => "Firm", :foreign_key => "client_of"
-  belongs_to :firm_with_condition, -> { where "1 = ?", 1 }, :class_name => "Firm", :foreign_key => "client_of"
-  belongs_to :firm_with_primary_key, :class_name => "Firm", :primary_key => "name", :foreign_key => "firm_name"
-  belongs_to :firm_with_primary_key_symbols, :class_name => "Firm", :primary_key => :name, :foreign_key => :firm_name
-  belongs_to :readonly_firm, -> { readonly }, :class_name => "Firm", :foreign_key => "firm_id"
-  belongs_to :bob_firm, -> { where :name => "Bob" }, :class_name => "Firm", :foreign_key => "client_of"
-  has_many :accounts, :through => :firm, :source => :accounts
+  belongs_to :firm, foreign_key: "client_of"
+  belongs_to :firm_with_basic_id, class_name: "Firm", foreign_key: "firm_id"
+  belongs_to :firm_with_select, -> { select("id") }, class_name: "Firm", foreign_key: "firm_id"
+  belongs_to :firm_with_other_name, class_name: "Firm", foreign_key: "client_of"
+  belongs_to :firm_with_condition, -> { where "1 = ?", 1 }, class_name: "Firm", foreign_key: "client_of"
+  belongs_to :firm_with_primary_key, class_name: "Firm", primary_key: "name", foreign_key: "firm_name"
+  belongs_to :firm_with_primary_key_symbols, class_name: "Firm", primary_key: :name, foreign_key: :firm_name
+  belongs_to :readonly_firm, -> { readonly }, class_name: "Firm", foreign_key: "firm_id"
+  belongs_to :bob_firm, -> { where name: "Bob" }, class_name: "Firm", foreign_key: "client_of"
+  has_many :accounts, through: :firm, source: :accounts
   belongs_to :account
 
   validate do
@@ -141,6 +156,21 @@ class Client < Company
     raise RaisedOnSave if raise_on_save
   end
 
+  attr_accessor :throw_on_save
+  before_save do
+    throw :abort if throw_on_save
+  end
+
+  attr_accessor :rollback_on_save
+  after_save do
+    raise ActiveRecord::Rollback if rollback_on_save
+  end
+
+  attr_accessor :rollback_on_create_called
+  after_rollback(on: :create) do |client|
+    client.rollback_on_create_called = true
+  end
+
   class RaisedOnDestroy < RuntimeError; end
   attr_accessor :raise_on_destroy
   before_destroy do
@@ -151,7 +181,7 @@ class Client < Company
   # is calling client.destroy, deleting from the database, or setting
   # foreign keys to NULL.
   def self.destroyed_client_ids
-    @destroyed_client_ids ||= Hash.new { |h,k| h[k] = [] }
+    @destroyed_client_ids ||= Hash.new { |h, k| h[k] = [] }
   end
 
   before_destroy do |client|
@@ -170,20 +200,13 @@ class Client < Company
 
   def overwrite_to_raise
   end
-
-  class << self
-    private
-
-    def private_method
-      "darkness"
-    end
-  end
 end
 
 class ExclusivelyDependentFirm < Company
-  has_one :account, :foreign_key => "firm_id", :dependent => :delete
-  has_many :dependent_sanitized_conditional_clients_of_firm, -> { order("id").where("name = 'BigShot Inc.'") }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
-  has_many :dependent_conditional_clients_of_firm, -> { order("id").where("name = ?", 'BigShot Inc.') }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
+  has_one :account, foreign_key: "firm_id", dependent: :delete
+  has_many :dependent_sanitized_conditional_clients_of_firm, -> { order("id").where("name = 'BigShot Inc.'") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+  has_many :dependent_hash_conditional_clients_of_firm, -> { order("id").where(name: "BigShot Inc.") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+  has_many :dependent_conditional_clients_of_firm, -> { order("id").where("name = ?", "BigShot Inc.") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
 end
 
 class SpecialClient < Client
@@ -192,39 +215,12 @@ end
 class VerySpecialClient < SpecialClient
 end
 
-class Account < ActiveRecord::Base
-  belongs_to :firm, :class_name => 'Company'
-  belongs_to :unautosaved_firm, :foreign_key => "firm_id", :class_name => "Firm", :autosave => false
-
-  alias_attribute :available_credit, :credit_limit
-
-  def self.destroyed_account_ids
-    @destroyed_account_ids ||= Hash.new { |h,k| h[k] = [] }
-  end
-
-  # Test private kernel method through collection proxy using has_many.
-  def self.open
-    where('firm_name = ?', '37signals')
-  end
-
-  before_destroy do |account|
-    if account.firm
-      Account.destroyed_account_ids[account.firm.id] << account.id
-    end
-    true
-  end
-
-  validate :check_empty_credit_limit
-
-  protected
-
-  def check_empty_credit_limit
-    errors.add("credit_limit", :blank) if credit_limit.blank?
-  end
-
-  private
+class NewlyContractedCompany < Company
+  has_many :new_contracts, foreign_key: "company_id"
 
-  def private_method
-    "Sir, yes sir!"
+  before_save do
+    self.new_contracts << NewContract.new
   end
 end
+
+require "models/account"