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

data/test/models/binary.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Binary < ActiveRecord::Base
-end
+end

data/test/models/binary_field.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class BinaryField < ActiveRecord::Base
+  serialize :normal_blob
+  serialize :normal_text
+end

data/test/models/bird.rb

@@ -1,12 +1,24 @@
+# frozen_string_literal: true
+
 class Bird < ActiveRecord::Base
   belongs_to :pirate
   validates_presence_of :name
 
   accepts_nested_attributes_for :pirate
 
+  before_save do
+    # force materialize_transactions
+    self.class.connection.materialize_transactions
+  end
+
   attr_accessor :cancel_save_from_callback
-  before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
+  before_save :cancel_save_callback_method, if: :cancel_save_from_callback
   def cancel_save_callback_method
     throw(:abort)
   end
+
+  attr_accessor :total_count, :enable_count
+  after_initialize do
+    self.total_count = Bird.count if enable_count
+  end
 end

data/test/models/book.rb

@@ -1,23 +1,33 @@
+# frozen_string_literal: true
+
 class Book < ActiveRecord::Base
-  has_many :authors
+  belongs_to :author
 
-  has_many :citations, :foreign_key => 'book1_id'
+  has_many :citations, foreign_key: "book1_id", inverse_of: :book
   has_many :references, -> { distinct }, through: :citations, source: :reference_of
 
   has_many :subscriptions
   has_many :subscribers, through: :subscriptions
 
   enum status: [:proposed, :written, :published]
-  enum read_status: {unread: 0, reading: 2, read: 3}
+  enum last_read: { unread: 0, reading: 2, read: 3, forgotten: nil }
   enum nullable_status: [:single, :married]
   enum language: [:english, :spanish, :french], _prefix: :in
   enum author_visibility: [:visible, :invisible], _prefix: true
   enum illustrator_visibility: [:visible, :invisible], _prefix: true
   enum font_size: [:small, :medium, :large], _prefix: :with, _suffix: true
-  enum cover: { hard: 'hard', soft: 'soft' }
+  enum difficulty: [:easy, :medium, :hard], _suffix: :to_read
+  enum cover: { hard: "hard", soft: "soft" }
+  enum boolean_status: { enabled: true, disabled: false }
 
   def published!
     super
     "do publish work..."
   end
 end
+
+class PublishedBook < ActiveRecord::Base
+  self.table_name = "books"
+
+  validates_uniqueness_of :isbn
+end

data/test/models/book_destroy_async.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class BookDestroyAsync < ActiveRecord::Base
+  self.table_name = "books"
+
+  has_many :taggings, as: :taggable, class_name: "Tagging"
+  has_many :tags, through: :taggings, dependent: :destroy_async
+  has_many :essays, dependent: :destroy_async, class_name: "EssayDestroyAsync", foreign_key: "book_id"
+  has_one :content, dependent: :destroy_async
+
+  enum status: [:proposed, :written, :published]
+
+  def published!
+    super
+    "do publish work..."
+  end
+end
+
+class BookDestroyAsyncWithScopedTags < ActiveRecord::Base
+  self.table_name = "books"
+
+  has_many :taggings, as: :taggable, class_name: "Tagging"
+  has_many :tags, -> { where name: "Der be rum" }, through: :taggings, dependent: :destroy_async
+end

data/test/models/boolean.rb

@@ -1,2 +1,7 @@
+# frozen_string_literal: true
+
 class Boolean < ActiveRecord::Base
+  def has_fun
+    super
+  end
 end

data/test/models/bulb.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class Bulb < ActiveRecord::Base
-  default_scope { where(:name => 'defaulty') }
-  belongs_to :car, :touch => true
+  default_scope { where(name: "defaulty") }
+  belongs_to :car, touch: true
   scope :awesome, -> { where(frickinawesome: true) }
 
-  attr_reader :scope_after_initialize, :attributes_after_initialize
+  attr_reader :scope_after_initialize, :attributes_after_initialize, :count_after_create
 
   after_initialize :record_scope_after_initialize
   def record_scope_after_initialize
@@ -15,6 +17,13 @@ class Bulb < ActiveRecord::Base
     @attributes_after_initialize = attributes.dup
   end
 
+  after_create :record_count_after_create
+  def record_count_after_create
+    @count_after_create = Bulb.unscoped do
+      car&.bulbs&.count
+    end
+  end
+
   def color=(color)
     self[:color] = color.upcase + "!"
   end
@@ -35,7 +44,7 @@ class CustomBulb < Bulb
   after_initialize :set_awesomeness
 
   def set_awesomeness
-    self.frickinawesome = true if name == 'Dude'
+    self.frickinawesome = true if name == "Dude"
   end
 end
 

data/test/models/cake_designer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CakeDesigner < ActiveRecord::Base
   has_one :chef, as: :employable
 end

data/test/models/car.rb

@@ -1,29 +1,36 @@
+# frozen_string_literal: true
+
 class Car < ActiveRecord::Base
   has_many :bulbs
-  has_many :all_bulbs, -> { unscope where: :name }, class_name: "Bulb"
-  has_many :funky_bulbs, class_name: 'FunkyBulb', dependent: :destroy
-  has_many :failed_bulbs, class_name: 'FailedBulb', dependent: :destroy
-  has_many :foo_bulbs, -> { where(:name => 'foo') }, :class_name => "Bulb"
+  has_many :all_bulbs, -> { unscope(where: :name) }, class_name: "Bulb"
+  has_many :all_bulbs2, -> { unscope(:where) }, class_name: "Bulb"
+  has_many :other_bulbs, -> { unscope(where: :name).where(name: "other") }, class_name: "Bulb"
+  has_many :old_bulbs, -> { rewhere(name: "old") }, class_name: "Bulb"
+  has_many :funky_bulbs, class_name: "FunkyBulb", dependent: :destroy
+  has_many :failed_bulbs, class_name: "FailedBulb", dependent: :destroy
+  has_many :foo_bulbs, -> { where(name: "foo") }, class_name: "Bulb"
   has_many :awesome_bulbs, -> { awesome }, class_name: "Bulb"
 
   has_one :bulb
 
   has_many :tyres
-  has_many :engines, :dependent => :destroy, inverse_of: :my_car
-  has_many :wheels, :as => :wheelable, :dependent => :destroy
+  has_many :engines, dependent: :destroy, inverse_of: :my_car
+  has_many :wheels, as: :wheelable, dependent: :destroy
 
-  has_many :price_estimates, :as => :estimate_of
+  has_many :price_estimates, as: :estimate_of
 
   scope :incl_tyres, -> { includes(:tyres) }
   scope :incl_engines, -> { includes(:engines) }
 
-  scope :order_using_new_style,  -> { order('name asc') }
+  scope :order_using_new_style,  -> { order("name asc") }
+
+  attribute :wheels_owned_at, :datetime, default: -> { Time.now }
 end
 
 class CoolCar < Car
-  default_scope { order('name desc') }
+  default_scope { order("name desc") }
 end
 
 class FastCar < Car
-  default_scope { order('name desc') }
+  default_scope { order("name desc") }
 end

data/test/models/carrier.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 class Carrier < ActiveRecord::Base
 end

data/test/models/cart.rb

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

data/test/models/cat.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Cat < ActiveRecord::Base
   self.abstract_class = true
 

data/test/models/categorization.rb

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 class Categorization < ActiveRecord::Base
   belongs_to :post
   belongs_to :category, counter_cache: true
-  belongs_to :named_category, :class_name => 'Category', :foreign_key => :named_category_name, :primary_key => :name
+  belongs_to :named_category, class_name: "Category", foreign_key: :named_category_name, primary_key: :name
   belongs_to :author
 
-  has_many :post_taggings, :through => :author, :source => :taggings
+  has_many :post_taggings, through: :author, source: :taggings
 
-  belongs_to :author_using_custom_pk,  :class_name => 'Author', :foreign_key => :author_id, :primary_key => :author_address_extra_id
-  has_many   :authors_using_custom_pk, :class_name => 'Author', :foreign_key => :id,        :primary_key => :category_id
+  belongs_to :author_using_custom_pk,  class_name: "Author", foreign_key: :author_id, primary_key: :author_address_extra_id
+  has_many   :authors_using_custom_pk, class_name: "Author", foreign_key: :id,        primary_key: :category_id
 end
 
 class SpecialCategorization < ActiveRecord::Base
-  self.table_name = 'categorizations'
-  default_scope { where(:special => true) }
+  self.table_name = "categorizations"
+  default_scope { where(special: true) }
 
   belongs_to :author
   belongs_to :category

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