ibm_db 5.2.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/models/developer.rb

@@ -1,12 +1,27 @@
-require 'ostruct'
+# frozen_string_literal: true
 
-module DeveloperProjectsAssociationExtension2
-  def find_least_recent
-    order("id ASC").first
-  end
-end
+require "ostruct"
 
 class Developer < ActiveRecord::Base
+  module TimestampAliases
+    extend ActiveSupport::Concern
+
+    included do
+      alias_attribute :created_at, :legacy_created_at
+      alias_attribute :updated_at, :legacy_updated_at
+      alias_attribute :created_on, :legacy_created_on
+      alias_attribute :updated_on, :legacy_updated_on
+    end
+  end
+
+  include TimestampAliases
+
+  module ProjectsAssociationExtension2
+    def find_least_recent
+      order("id ASC").first
+    end
+  end
+
   self.ignored_columns = %w(first_name last_name)
 
   has_and_belongs_to_many :projects do
@@ -16,63 +31,75 @@ class Developer < ActiveRecord::Base
   end
 
   belongs_to :mentor
+  belongs_to :strict_loading_mentor, strict_loading: true, foreign_key: :mentor_id, class_name: "Mentor"
+  belongs_to :strict_loading_off_mentor, strict_loading: false, foreign_key: :mentor_id, class_name: "Mentor"
 
   accepts_nested_attributes_for :projects
 
   has_and_belongs_to_many :shared_computers, class_name: "Computer"
 
   has_and_belongs_to_many :projects_extended_by_name,
-      -> { extending(DeveloperProjectsAssociationExtension) },
-      :class_name => "Project",
-      :join_table => "developers_projects",
-      :association_foreign_key => "project_id"
+      -> { extending(ProjectsAssociationExtension) },
+      class_name: "Project",
+      join_table: "developers_projects",
+      association_foreign_key: "project_id"
 
   has_and_belongs_to_many :projects_extended_by_name_twice,
-      -> { extending(DeveloperProjectsAssociationExtension, DeveloperProjectsAssociationExtension2) },
-      :class_name => "Project",
-      :join_table => "developers_projects",
-      :association_foreign_key => "project_id"
+      -> { extending(ProjectsAssociationExtension, ProjectsAssociationExtension2) },
+      class_name: "Project",
+      join_table: "developers_projects",
+      association_foreign_key: "project_id"
 
   has_and_belongs_to_many :projects_extended_by_name_and_block,
-      -> { extending(DeveloperProjectsAssociationExtension) },
-      :class_name => "Project",
-      :join_table => "developers_projects",
-      :association_foreign_key => "project_id" do
+      -> { extending(ProjectsAssociationExtension) },
+      class_name: "Project",
+      join_table: "developers_projects",
+      association_foreign_key: "project_id" do
         def find_least_recent
           order("id ASC").first
         end
       end
 
-  has_and_belongs_to_many :special_projects, :join_table => 'developers_projects', :association_foreign_key => 'project_id'
+  has_and_belongs_to_many :strict_loading_projects,
+                          join_table: :developers_projects,
+                          association_foreign_key: :project_id,
+                          class_name: "Project",
+                          strict_loading: true
+
+  has_and_belongs_to_many :special_projects, join_table: "developers_projects", association_foreign_key: "project_id"
   has_and_belongs_to_many :sym_special_projects,
-                          :join_table => :developers_projects,
-                          :association_foreign_key => 'project_id',
-                          :class_name => 'SpecialProject'
+                          join_table: :developers_projects,
+                          association_foreign_key: "project_id",
+                          class_name: "SpecialProject"
 
   has_many :audit_logs
+  has_many :required_audit_logs, class_name: "AuditLogRequired"
+  has_many :strict_loading_audit_logs, -> { strict_loading }, class_name: "AuditLog"
+  has_many :strict_loading_opt_audit_logs, strict_loading: true, class_name: "AuditLog"
   has_many :contracts
-  has_many :firms, :through => :contracts, :source => :firm
+  has_many :firms, through: :contracts, source: :firm
   has_many :comments, ->(developer) { where(body: "I'm #{developer.name}") }
   has_many :ratings, through: :comments
+
   has_one :ship, dependent: :nullify
+  has_one :strict_loading_ship, strict_loading: true, class_name: "Ship"
 
   belongs_to :firm
   has_many :contracted_projects, class_name: "Project"
 
-  scope :jamises, -> { where(:name => 'Jamis') }
+  scope :jamises, -> { where(name: "Jamis") }
 
-  validates_inclusion_of :salary, :in => 50000..200000
-  validates_length_of    :name, :within => 3..20
+  validates_inclusion_of :salary, in: 50000..200000
+  validates_length_of    :name, within: 3..20
 
   before_create do |developer|
-    developer.audit_logs.build :message => "Computer created"
+    developer.audit_logs.build message: "Computer created"
   end
 
-  attr_accessor :last_name
-  define_attribute_method 'last_name'
+  attribute :last_name
 
   def log=(message)
-    audit_logs.build :message => message
+    audit_logs.build message: message
   end
 
   after_find :track_instance_count
@@ -83,28 +110,36 @@ class Developer < ActiveRecord::Base
     self.class.instance_count += 1
   end
   private :track_instance_count
-
 end
 
 class SubDeveloper < Developer
 end
 
+class SpecialDeveloper < ActiveRecord::Base
+  self.table_name = "developers"
+  has_many :special_contracts, foreign_key: "developer_id"
+end
+
 class SymbolIgnoredDeveloper < ActiveRecord::Base
   self.table_name = "developers"
   self.ignored_columns = [:first_name, :last_name]
 
-  attr_accessor :last_name
-  define_attribute_method "last_name"
+  attribute :last_name
 end
 
 class AuditLog < ActiveRecord::Base
-  belongs_to :developer, :validate => true
-  belongs_to :unvalidated_developer, :class_name => 'Developer'
+  belongs_to :developer, validate: true
+  belongs_to :unvalidated_developer, class_name: "Developer"
+end
+
+class AuditLogRequired < ActiveRecord::Base
+  self.table_name = "audit_logs"
+  belongs_to :developer, required: true
 end
 
 class DeveloperWithBeforeDestroyRaise < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, :join_table => 'developers_projects', :foreign_key => 'developer_id'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, join_table: "developers_projects", foreign_key: "developer_id"
   before_destroy :raise_if_projects_empty!
 
   def raise_if_projects_empty!
@@ -113,63 +148,65 @@ class DeveloperWithBeforeDestroyRaise < ActiveRecord::Base
 end
 
 class DeveloperWithSelect < ActiveRecord::Base
-  self.table_name = 'developers'
-  default_scope { select('name') }
+  self.table_name = "developers"
+  default_scope { select("name") }
 end
 
 class DeveloperWithIncludes < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_many :audit_logs, :foreign_key => :developer_id
+  self.table_name = "developers"
+  has_many :audit_logs, foreign_key: :developer_id
   default_scope { includes(:audit_logs) }
 end
 
 class DeveloperFilteredOnJoins < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
   def self.default_scope
-    joins(:projects).where(:projects => { :name => 'Active Controller' })
+    joins(:projects).where(projects: { name: "Active Controller" })
   end
 end
 
 class DeveloperOrderedBySalary < ActiveRecord::Base
-  self.table_name = 'developers'
-  default_scope { order('salary DESC') }
+  include Developer::TimestampAliases
+
+  self.table_name = "developers"
+  default_scope { order("salary DESC") }
 
-  scope :by_name, -> { order('name DESC') }
+  scope :by_name, -> { order("name DESC") }
 end
 
 class DeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
   default_scope { where("name = 'David'") }
 end
 
 class LazyLambdaDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
-  default_scope lambda { where(:name => 'David') }
+  self.table_name = "developers"
+  default_scope lambda { where(name: "David") }
 end
 
 class LazyBlockDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
-  default_scope { where(:name => 'David') }
+  self.table_name = "developers"
+  default_scope { where(name: "David") }
 end
 
 class CallableDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
-  default_scope OpenStruct.new(:call => where(:name => 'David'))
+  self.table_name = "developers"
+  default_scope OpenStruct.new(call: where(name: "David"))
 end
 
 class ClassMethodDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   def self.default_scope
-    where(:name => 'David')
+    where(name: "David")
   end
 end
 
 class ClassMethodReferencingScopeDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
-  scope :david, -> { where(:name => 'David') }
+  self.table_name = "developers"
+  scope :david, -> { where(name: "David") }
 
   def self.default_scope
     david
@@ -177,61 +214,64 @@ class ClassMethodReferencingScopeDeveloperCalledDavid < ActiveRecord::Base
 end
 
 class LazyBlockReferencingScopeDeveloperCalledDavid < ActiveRecord::Base
-  self.table_name = 'developers'
-  scope :david, -> { where(:name => 'David') }
+  self.table_name = "developers"
+  scope :david, -> { where(name: "David") }
   default_scope { david }
 end
 
 class DeveloperCalledJamis < ActiveRecord::Base
-  self.table_name = 'developers'
+  include Developer::TimestampAliases
+
+  self.table_name = "developers"
 
-  default_scope { where(:name => 'Jamis') }
-  scope :poor, -> { where('salary < 150000') }
+  default_scope { where(name: "Jamis") }
+  scope :poor, -> { where("salary < 150000") }
   scope :david, -> { where name: "David" }
   scope :david2, -> { unscoped.where name: "David" }
 end
 
 class PoorDeveloperCalledJamis < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
-  default_scope -> { where(:name => 'Jamis', :salary => 50000) }
+  default_scope -> { where(name: "Jamis", salary: 50000) }
 end
 
 class InheritedPoorDeveloperCalledJamis < DeveloperCalledJamis
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
-  default_scope -> { where(:salary => 50000) }
+  default_scope -> { where(salary: 50000) }
 end
 
 class MultiplePoorDeveloperCalledJamis < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
-  default_scope -> { where(:name => 'Jamis') }
-  default_scope -> { where(:salary => 50000) }
+  default_scope { }
+  default_scope -> { where(name: "Jamis") }
+  default_scope -> { where(salary: 50000) }
 end
 
 module SalaryDefaultScope
   extend ActiveSupport::Concern
 
-  included { default_scope { where(:salary => 50000) } }
+  included { default_scope { where(salary: 50000) } }
 end
 
 class ModuleIncludedPoorDeveloperCalledJamis < DeveloperCalledJamis
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   include SalaryDefaultScope
 end
 
 class EagerDeveloperWithDefaultScope < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
   default_scope { includes(:projects) }
 end
 
 class EagerDeveloperWithClassMethodDefaultScope < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
   def self.default_scope
     includes(:projects)
@@ -239,36 +279,63 @@ class EagerDeveloperWithClassMethodDefaultScope < ActiveRecord::Base
 end
 
 class EagerDeveloperWithLambdaDefaultScope < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
   default_scope lambda { includes(:projects) }
 end
 
 class EagerDeveloperWithBlockDefaultScope < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
   default_scope { includes(:projects) }
 end
 
 class EagerDeveloperWithCallableDefaultScope < ActiveRecord::Base
-  self.table_name = 'developers'
-  has_and_belongs_to_many :projects, -> { order('projects.id') }, :foreign_key => 'developer_id', :join_table => 'developers_projects'
+  self.table_name = "developers"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
-  default_scope OpenStruct.new(:call => includes(:projects))
+  default_scope OpenStruct.new(call: includes(:projects))
 end
 
 class ThreadsafeDeveloper < ActiveRecord::Base
-  self.table_name = 'developers'
+  self.table_name = "developers"
 
   def self.default_scope
-    sleep 0.05 if Thread.current[:long_default_scope]
+    Thread.current[:default_scope_delay].call
     limit(1)
   end
 end
 
 class CachedDeveloper < ActiveRecord::Base
+  include Developer::TimestampAliases
+
   self.table_name = "developers"
   self.cache_timestamp_format = :number
 end
+
+class DeveloperWithIncorrectlyOrderedHasManyThrough < ActiveRecord::Base
+  self.table_name = "developers"
+  has_many :companies, through: :contracts
+  has_many :contracts, foreign_key: :developer_id
+end
+
+class DeveloperName < ActiveRecord::Type::String
+  def deserialize(value)
+    "Developer: #{value}"
+  end
+end
+
+class AttributedDeveloper < ActiveRecord::Base
+  self.table_name = "developers"
+
+  attribute :name, DeveloperName.new
+
+  self.ignored_columns += ["name"]
+end
+
+class ColumnNamesCachedDeveloper < ActiveRecord::Base
+  self.table_name = "developers"
+  self.ignored_columns += ["name"] if column_names.include?("name")
+end

data/test/models/dl_keyed_belongs_to.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class DlKeyedBelongsTo < ActiveRecord::Base
+  self.primary_key = "belongs_key"
+  belongs_to :destroy_async_parent,
+    dependent: :destroy_async,
+    foreign_key: :destroy_async_parent_id,
+    primary_key: :parent_id,
+    class_name: "DestroyAsyncParent"
+  belongs_to :destroy_async_parent_soft_delete,
+    dependent: :destroy_async,
+    ensuring_owner_was: :deleted?, class_name: "DestroyAsyncParentSoftDelete"
+end

data/test/models/dl_keyed_belongs_to_soft_delete.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "models/destroy_async_parent_soft_delete"
+
+class DlKeyedBelongsToSoftDelete < ActiveRecord::Base
+  belongs_to :destroy_async_parent_soft_delete,
+    dependent: :destroy_async,
+    ensuring_owner_was: :deleted?,
+    class_name: "DestroyAsyncParentSoftDelete"
+
+  def deleted?
+    deleted
+  end
+
+  def destroy
+    update(deleted: true)
+    run_callbacks(:destroy)
+  end
+end

data/test/models/dl_keyed_has_many.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class DlKeyedHasMany < ActiveRecord::Base
+  self.primary_key = "many_key"
+end

data/test/models/dl_keyed_has_many_through.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class DlKeyedHasManyThrough < ActiveRecord::Base
+  self.primary_key = :through_key
+end

data/test/models/dl_keyed_has_one.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class DlKeyedHasOne < ActiveRecord::Base
+  self.primary_key = "has_one_key"
+end

data/test/models/dl_keyed_join.rb

@@ -0,0 +1,10 @@
+ # frozen_string_literal: true
+
+ class DlKeyedJoin < ActiveRecord::Base
+   self.primary_key = "joins_key"
+
+   belongs_to :destroy_async_parent,
+     primary_key: :parent_id
+   belongs_to :dl_keyed_has_many_through,
+     primary_key: :through_key
+ end

data/test/models/dog.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Dog < ActiveRecord::Base
   belongs_to :breeder, class_name: "DogLover", counter_cache: :bred_dogs_count
   belongs_to :trainer, class_name: "DogLover", counter_cache: :trained_dogs_count

data/test/models/dog_lover.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DogLover < ActiveRecord::Base
   has_many :trained_dogs, class_name: "Dog", foreign_key: :trainer_id, dependent: :destroy
   has_many :bred_dogs, class_name: "Dog", foreign_key: :breeder_id

data/test/models/doubloon.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AbstractDoubloon < ActiveRecord::Base
   # This has functionality that might be shared by multiple classes.
 
@@ -8,5 +10,5 @@ end
 class Doubloon < AbstractDoubloon
   # This uses an abstract class that defines attributes and associations.
 
-  self.table_name = 'doubloons'
+  self.table_name = "doubloons"
 end

data/test/models/drink_designer.rb

@@ -1,3 +1,20 @@
+# frozen_string_literal: true
+
 class DrinkDesigner < ActiveRecord::Base
   has_one :chef, as: :employable
 end
+
+class DrinkDesignerWithPolymorphicDependentNullifyChef < ActiveRecord::Base
+  self.table_name = "drink_designers"
+
+  has_one :chef, as: :employable, dependent: :nullify
+end
+
+class DrinkDesignerWithPolymorphicTouchChef < ActiveRecord::Base
+  self.table_name = "drink_designers"
+
+  has_one :chef, as: :employable, touch: true
+end
+
+class MocktailDesigner < DrinkDesigner
+end

data/test/models/edge.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 # This class models an edge in a directed graph.
 class Edge < ActiveRecord::Base
-  belongs_to :source, :class_name => 'Vertex', :foreign_key => 'source_id'
-  belongs_to :sink,   :class_name => 'Vertex', :foreign_key => 'sink_id'
+  belongs_to :source, class_name: "Vertex", foreign_key: "source_id"
+  belongs_to :sink,   class_name: "Vertex", foreign_key: "sink_id"
 end

data/test/models/electron.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Electron < ActiveRecord::Base
   belongs_to :molecule
 

data/test/models/engine.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
+
 class Engine < ActiveRecord::Base
-  belongs_to :my_car, :class_name => 'Car', :foreign_key => 'car_id',  :counter_cache => :engines_count
+  belongs_to :my_car, class_name: "Car", foreign_key: "car_id",  counter_cache: :engines_count
 end
-

data/test/models/entrant.rb

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

data/test/models/entry.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Entry < ActiveRecord::Base
+  delegated_type :entryable, types: %w[ Message Comment ]
+end

data/test/models/essay.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 class Essay < ActiveRecord::Base
-  belongs_to :writer, :primary_key => :name, :polymorphic => true
-  belongs_to :category, :primary_key => :name
-  has_one :owner, :primary_key => :name
+  belongs_to :author
+  belongs_to :writer, primary_key: :name, polymorphic: true
+  belongs_to :category, primary_key: :name
+  has_one :owner, primary_key: :name
 end

data/test/models/essay_destroy_async.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class EssayDestroyAsync < ActiveRecord::Base
+  self.table_name = "essays"
+  belongs_to :book, dependent: :destroy_async, class_name: "BookDestroyAsync"
+end
+
+class LongEssayDestroyAsync < EssayDestroyAsync
+end
+
+class ShortEssayDestroyAsync < EssayDestroyAsync
+end

data/test/models/event.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Event < ActiveRecord::Base
   validates_uniqueness_of :title
-end
+end

data/test/models/eye.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Eye < ActiveRecord::Base
   attr_reader :after_create_callbacks_stack
   attr_reader :after_update_callbacks_stack
@@ -15,19 +17,19 @@ class Eye < ActiveRecord::Base
   after_create :trace_after_create2
   after_update :trace_after_update2
   after_save   :trace_after_save2
-  
+
   def trace_after_create
     (@after_create_callbacks_stack ||= []) << !iris.persisted?
   end
   alias trace_after_create2 trace_after_create
 
   def trace_after_update
-    (@after_update_callbacks_stack ||= []) << iris.changed?
+    (@after_update_callbacks_stack ||= []) << iris.has_changes_to_save?
   end
   alias trace_after_update2 trace_after_update
 
   def trace_after_save
-    (@after_save_callbacks_stack ||= []) << iris.changed?
+    (@after_save_callbacks_stack ||= []) << iris.has_changes_to_save?
   end
   alias trace_after_save2 trace_after_save
 end