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

data/test/models/post.rb

@@ -1,13 +1,20 @@
+# frozen_string_literal: true
+
 class Post < ActiveRecord::Base
   class CategoryPost < ActiveRecord::Base
     self.table_name = "categories_posts"
+    belongs_to :group, foreign_key: :category_id, class_name: "Category"
     belongs_to :category
     belongs_to :post
   end
 
   module NamedExtension
     def author
-      'lifo'
+      "lifo"
+    end
+
+    def greeting
+      super + " :)"
     end
   end
 
@@ -17,27 +24,33 @@ class Post < ActiveRecord::Base
     end
   end
 
+  alias_attribute :text, :body
+  alias_attribute :comments_count, :legacy_comments_count
+
   scope :containing_the_letter_a, -> { where("body LIKE '%a%'") }
   scope :titled_with_an_apostrophe, -> { where("title LIKE '%''%'") }
-  scope :ranked_by_comments,      -> { order("comments_count DESC") }
+  scope :ranked_by_comments, -> { order(table[:comments_count].desc) }
 
-  scope :limit_by, lambda {|l| limit(l) }
+  scope :limit_by, lambda { |l| limit(l) }
+  scope :locked, -> { lock }
 
   belongs_to :author
   belongs_to :readonly_author, -> { readonly }, class_name: "Author", foreign_key: :author_id
 
-  belongs_to :author_with_posts, -> { includes(:posts) }, :class_name => "Author", :foreign_key => :author_id
-  belongs_to :author_with_address, -> { includes(:author_address) }, :class_name => "Author", :foreign_key => :author_id
+  belongs_to :author_with_posts, -> { includes(:posts) }, class_name: "Author", foreign_key: :author_id
+  belongs_to :author_with_address, -> { includes(:author_address) }, class_name: "Author", foreign_key: :author_id
+  belongs_to :author_with_select, -> { select(:id) }, class_name: "Author", foreign_key: :author_id
 
   def first_comment
     super.body
   end
-  has_one :first_comment, -> { order('id ASC') }, :class_name => 'Comment'
-  has_one :last_comment, -> { order('id desc') }, :class_name => 'Comment'
+  has_one :first_comment, -> { order("id ASC") }, class_name: "Comment"
+  has_one :last_comment, -> { order("id desc") }, class_name: "Comment"
 
-  scope :with_special_comments, -> { joins(:comments).where(:comments => {:type => 'SpecialComment'}) }
-  scope :with_very_special_comments, -> { joins(:comments).where(:comments => {:type => 'VerySpecialComment'}) }
-  scope :with_post, ->(post_id) { joins(:comments).where(:comments => { :post_id => post_id }) }
+  scope :no_comments, -> { left_joins(:comments).where(comments: { id: nil }) }
+  scope :with_special_comments, -> { joins(:comments).where(comments: { type: "SpecialComment" }) }
+  scope :with_very_special_comments, -> { joins(:comments).where(comments: { type: "VerySpecialComment" }) }
+  scope :with_post, ->(post_id) { joins(:comments).where(comments: { post_id: post_id }) }
 
   scope :with_comments, -> { preload(:comments) }
   scope :with_tags, -> { preload(:taggings) }
@@ -47,7 +60,7 @@ class Post < ActiveRecord::Base
 
   scope :typographically_interesting, -> { containing_the_letter_a.or(titled_with_an_apostrophe) }
 
-  has_many   :comments do
+  has_many :comments do
     def find_most_recent
       order("id DESC").first
     end
@@ -59,6 +72,10 @@ class Post < ActiveRecord::Base
     def the_association
       proxy_association
     end
+
+    def with_content(content)
+      self.detect { |comment| comment.body == content }
+    end
   end
 
   has_many :comments_with_extend, extend: NamedExtension, class_name: "Comment", foreign_key: "post_id" do
@@ -69,92 +86,98 @@ class Post < ActiveRecord::Base
 
   has_many :comments_with_extend_2, extend: [NamedExtension, NamedExtension2], class_name: "Comment", foreign_key: "post_id"
 
-  has_many :author_favorites, :through => :author
-  has_many :author_categorizations, :through => :author, :source => :categorizations
-  has_many :author_addresses, :through => :author
+  has_many :author_favorites, through: :author
+  has_many :author_favorites_with_scope, through: :author, class_name: "AuthorFavoriteWithScope", source: "author_favorites"
+  has_many :author_categorizations, through: :author, source: :categorizations
+  has_many :author_addresses, through: :author
   has_many :author_address_extra_with_address,
     through: :author_with_address,
     source: :author_address_extra
 
   has_one  :very_special_comment
-  has_one  :very_special_comment_with_post, -> { includes(:post) }, :class_name => "VerySpecialComment"
-  has_one :very_special_comment_with_post_with_joins, -> { joins(:post).order('posts.id') }, class_name: "VerySpecialComment"
+  has_one  :very_special_comment_with_post, -> { includes(:post) }, class_name: "VerySpecialComment"
+  has_one :very_special_comment_with_post_with_joins, -> { joins(:post).order("posts.id") }, class_name: "VerySpecialComment"
   has_many :special_comments
-  has_many :nonexistent_comments, -> { where 'comments.id < 0' }, :class_name => 'Comment'
+  has_many :nonexistent_comments, -> { where "comments.id < 0" }, class_name: "Comment"
 
-  has_many :special_comments_ratings, :through => :special_comments, :source => :ratings
-  has_many :special_comments_ratings_taggings, :through => :special_comments_ratings, :source => :taggings
+  has_many :special_comments_ratings, through: :special_comments, source: :ratings
+  has_many :special_comments_ratings_taggings, through: :special_comments_ratings, source: :taggings
 
-  has_many :category_posts, :class_name => 'CategoryPost'
+  has_many :category_posts, class_name: "CategoryPost"
   has_many :scategories, through: :category_posts, source: :category
+  has_many :hmt_special_categories, -> { where.not(name: nil) },  through: :category_posts, source: :category, class_name: "SpecialCategory"
   has_and_belongs_to_many :categories
-  has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => 'category_id'
+  has_and_belongs_to_many :special_categories, join_table: "categories_posts", association_foreign_key: "category_id"
 
-  has_many :taggings, :as => :taggable, :counter_cache => :tags_count
-  has_many :tags, :through => :taggings do
+  has_many :taggings, as: :taggable, counter_cache: :tags_count
+  has_many :tags, through: :taggings do
     def add_joins_and_select
-      select('tags.*, authors.id as author_id')
-        .joins('left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id')
+      select("tags.*, authors.id as author_id")
+        .joins("left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id")
         .to_a
     end
   end
 
-  has_many :taggings_with_delete_all, :class_name => 'Tagging', :as => :taggable, :dependent => :delete_all, counter_cache: :taggings_with_delete_all_count
-  has_many :taggings_with_destroy, :class_name => 'Tagging', :as => :taggable, :dependent => :destroy, counter_cache: :taggings_with_destroy_count
+  has_many :indestructible_taggings, as: :taggable, counter_cache: :indestructible_tags_count
+  has_many :indestructible_tags, through: :indestructible_taggings, source: :tag
+
+  has_many :taggings_with_delete_all, class_name: "Tagging", as: :taggable, dependent: :delete_all, counter_cache: :taggings_with_delete_all_count
+  has_many :taggings_with_destroy, class_name: "Tagging", as: :taggable, dependent: :destroy, counter_cache: :taggings_with_destroy_count
 
-  has_many :tags_with_destroy, :through => :taggings, :source => :tag, :dependent => :destroy, counter_cache: :tags_with_destroy_count
-  has_many :tags_with_nullify, :through => :taggings, :source => :tag, :dependent => :nullify, counter_cache: :tags_with_nullify_count
+  has_many :tags_with_destroy, through: :taggings, source: :tag, dependent: :destroy, counter_cache: :tags_with_destroy_count
+  has_many :tags_with_nullify, through: :taggings, source: :tag, dependent: :nullify, counter_cache: :tags_with_nullify_count
 
-  has_many :misc_tags, -> { where :tags => { :name => 'Misc' } }, :through => :taggings, :source => :tag
-  has_many :funky_tags, :through => :taggings, :source => :tag
-  has_many :super_tags, :through => :taggings
-  has_many :tags_with_primary_key, :through => :taggings, :source => :tag_with_primary_key
-  has_one :tagging, :as => :taggable
+  has_many :misc_tags, -> { where tags: { name: "Misc" } }, through: :taggings, source: :tag
+  has_many :funky_tags, through: :taggings, source: :tag
+  has_many :super_tags, through: :taggings
+  has_many :ordered_tags, through: :taggings
+  has_many :tags_with_primary_key, through: :taggings, source: :tag_with_primary_key
+  has_one :tagging, as: :taggable
 
-  has_many :first_taggings, -> { where :taggings => { :comment => 'first' } }, :as => :taggable, :class_name => 'Tagging'
-  has_many :first_blue_tags, -> { where :tags => { :name => 'Blue' } }, :through => :first_taggings, :source => :tag
+  has_many :first_taggings, -> { where taggings: { comment: "first" } }, as: :taggable, class_name: "Tagging"
+  has_many :first_blue_tags, -> { where tags: { name: "Blue" } }, through: :first_taggings, source: :tag
 
-  has_many :first_blue_tags_2, -> { where :taggings => { :comment => 'first' } }, :through => :taggings, :source => :blue_tag
+  has_many :first_blue_tags_2, -> { where taggings: { comment: "first" } }, through: :taggings, source: :blue_tag
 
-  has_many :invalid_taggings, -> { where 'taggings.id < 0' }, :as => :taggable, :class_name => "Tagging"
-  has_many :invalid_tags, :through => :invalid_taggings, :source => :tag
+  has_many :invalid_taggings, -> { where "taggings.id < 0" }, as: :taggable, class_name: "Tagging"
+  has_many :invalid_tags, through: :invalid_taggings, source: :tag
 
-  has_many :categorizations, :foreign_key => :category_id
-  has_many :authors, :through => :categorizations
+  has_many :categorizations, foreign_key: :category_id
+  has_many :authors, through: :categorizations
 
-  has_many :categorizations_using_author_id, :primary_key => :author_id, :foreign_key => :post_id, :class_name => 'Categorization'
-  has_many :authors_using_author_id, :through => :categorizations_using_author_id, :source => :author
+  has_many :categorizations_using_author_id, primary_key: :author_id, foreign_key: :post_id, class_name: "Categorization"
+  has_many :authors_using_author_id, through: :categorizations_using_author_id, source: :author
 
-  has_many :taggings_using_author_id, :primary_key => :author_id, :as => :taggable, :class_name => 'Tagging'
-  has_many :tags_using_author_id, :through => :taggings_using_author_id, :source => :tag
+  has_many :taggings_using_author_id, primary_key: :author_id, as: :taggable, class_name: "Tagging"
+  has_many :tags_using_author_id, through: :taggings_using_author_id, source: :tag
 
-  has_many :images, :as => :imageable, :foreign_key => :imageable_identifier, :foreign_type => :imageable_class
-  has_one :main_image, :as => :imageable, :foreign_key => :imageable_identifier, :foreign_type => :imageable_class, :class_name => 'Image'
+  has_many :images, as: :imageable, foreign_key: :imageable_identifier, foreign_type: :imageable_class
+  has_one :main_image, as: :imageable, foreign_key: :imageable_identifier, foreign_type: :imageable_class, class_name: "Image"
 
-  has_many :standard_categorizations, :class_name => 'Categorization', :foreign_key => :post_id
-  has_many :author_using_custom_pk,  :through => :standard_categorizations
-  has_many :authors_using_custom_pk, :through => :standard_categorizations
-  has_many :named_categories, :through => :standard_categorizations
+  has_many :standard_categorizations, class_name: "Categorization", foreign_key: :post_id
+  has_many :author_using_custom_pk,  through: :standard_categorizations
+  has_many :authors_using_custom_pk, through: :standard_categorizations
+  has_many :named_categories, through: :standard_categorizations
 
   has_many :readers
   has_many :secure_readers
-  has_many :readers_with_person, -> { includes(:person) }, :class_name => "Reader"
-  has_many :people, :through => :readers
-  has_many :single_people, :through => :readers
-  has_many :people_with_callbacks, :source=>:person, :through => :readers,
-              :before_add    => lambda {|owner, reader| log(:added,   :before, reader.first_name) },
-              :after_add     => lambda {|owner, reader| log(:added,   :after,  reader.first_name) },
-              :before_remove => lambda {|owner, reader| log(:removed, :before, reader.first_name) },
-              :after_remove  => lambda {|owner, reader| log(:removed, :after,  reader.first_name) }
-  has_many :skimmers, -> { where :skimmer => true }, :class_name => 'Reader'
-  has_many :impatient_people, :through => :skimmers, :source => :person
+  has_many :readers_with_person, -> { includes(:person) }, class_name: "Reader"
+  has_many :people, through: :readers
+  has_many :single_people, through: :readers
+  has_many :people_with_callbacks, source: :person, through: :readers,
+              before_add: lambda { |owner, reader| log(:added,   :before, reader.first_name) },
+              after_add: lambda { |owner, reader| log(:added,   :after,  reader.first_name) },
+              before_remove: lambda { |owner, reader| log(:removed, :before, reader.first_name) },
+              after_remove: lambda { |owner, reader| log(:removed, :after,  reader.first_name) }
+  has_many :skimmers, -> { where skimmer: true }, class_name: "Reader"
+  has_many :impatient_people, through: :skimmers, source: :person
 
   has_many :lazy_readers
-  has_many :lazy_readers_skimmers_or_not, -> { where(skimmer: [ true, false ]) }, :class_name => 'LazyReader'
+  has_many :lazy_readers_skimmers_or_not, -> { where(skimmer: [ true, false ]) }, class_name: "LazyReader"
 
-  has_many :lazy_people, :through => :lazy_readers, :source => :person
-  has_many :lazy_readers_unscope_skimmers, -> { skimmers_or_not }, :class_name => 'LazyReader'
-  has_many :lazy_people_unscope_skimmers, :through => :lazy_readers_unscope_skimmers, :source => :person
+  has_many :lazy_people, through: :lazy_readers, source: :person
+  has_many :lazy_readers_unscope_skimmers, -> { skimmers_or_not }, class_name: "LazyReader"
+  has_many :lazy_people_unscope_skimmers, through: :lazy_readers_unscope_skimmers, source: :person
 
   def self.top(limit)
     ranked_by_comments.limit_by(limit)
@@ -168,7 +191,7 @@ class Post < ActiveRecord::Base
     @log = []
   end
 
-  def self.log(message=nil, side=nil, new_record=nil)
+  def self.log(message = nil, side = nil, new_record = nil)
     return @log if message.nil?
     @log << [message, side, new_record]
   end
@@ -177,66 +200,88 @@ end
 class SpecialPost < Post; end
 
 class StiPost < Post
+  has_one :special_comment, class_name: "SpecialComment"
+end
+
+class AbstractStiPost < Post
   self.abstract_class = true
-  has_one :special_comment, :class_name => "SpecialComment"
 end
 
 class SubStiPost < StiPost
   self.table_name = Post.table_name
 end
 
+class SubAbstractStiPost < AbstractStiPost; end
+
+class NullPost < Post
+  default_scope { none }
+end
+
 class FirstPost < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
-  default_scope { where(:id => 1) }
+  self.table_name = "posts"
+  default_scope { where(id: 1) }
+
+  has_many :comments, foreign_key: :post_id
+  has_one  :comment,  foreign_key: :post_id
+end
+
+class PostWithDefaultSelect < ActiveRecord::Base
+  self.table_name = "posts"
 
-  has_many :comments, :foreign_key => :post_id
-  has_one  :comment,  :foreign_key => :post_id
+  default_scope { select(:author_id) }
+end
+
+class TaggedPost < Post
+  has_many :taggings, -> { rewhere(taggable_type: "TaggedPost") }, as: :taggable
+  has_many :tags, through: :taggings
 end
 
 class PostWithDefaultInclude < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   default_scope { includes(:comments) }
-  has_many :comments, :foreign_key => :post_id
+  has_many :comments, foreign_key: :post_id
 end
 
 class PostWithSpecialCategorization < Post
-  has_many :categorizations, :foreign_key => :post_id
-  default_scope { where(:type => 'PostWithSpecialCategorization').joins(:categorizations).where(:categorizations => { :special => true }) }
+  has_many :categorizations, foreign_key: :post_id
+  default_scope { where(type: "PostWithSpecialCategorization").joins(:categorizations).where(categorizations: { special: true }) }
 end
 
 class PostWithDefaultScope < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   default_scope { order(:title) }
 end
 
 class PostWithPreloadDefaultScope < ActiveRecord::Base
-  self.table_name = 'posts'
+  self.table_name = "posts"
 
-  has_many :readers, foreign_key: 'post_id'
+  has_many :readers, foreign_key: "post_id"
 
   default_scope { preload(:readers) }
 end
 
 class PostWithIncludesDefaultScope < ActiveRecord::Base
-  self.table_name = 'posts'
+  self.table_name = "posts"
 
-  has_many :readers, foreign_key: 'post_id'
+  has_many :readers, foreign_key: "post_id"
 
   default_scope { includes(:readers) }
 end
 
 class SpecialPostWithDefaultScope < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
-  default_scope { where(:id => [1, 5,6]) }
+  self.table_name = "posts"
+  default_scope { where(id: [1, 5, 6]) }
+  scope :unscoped_all, -> { unscoped { all } }
+  scope :authorless, -> { unscoped { where(author_id: 0) } }
 end
 
 class PostThatLoadsCommentsInAnAfterSaveHook < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   has_many :comments, class_name: "CommentThatAutomaticallyAltersPostBody", foreign_key: :post_id
 
   after_save do |post|
@@ -246,8 +291,9 @@ end
 
 class PostWithAfterCreateCallback < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   has_many :comments, foreign_key: :post_id
+  has_and_belongs_to_many :categories, foreign_key: :post_id
 
   after_create do |post|
     update_attribute(:author_id, comments.first.id)
@@ -256,7 +302,7 @@ end
 
 class PostWithCommentWithDefaultScopeReferencesAssociation < ActiveRecord::Base
   self.inheritance_column = :disabled
-  self.table_name = 'posts'
+  self.table_name = "posts"
   has_many :comment_with_default_scope_references_associations, foreign_key: :post_id
   has_one :first_comment, class_name: "CommentWithDefaultScopeReferencesAssociation", foreign_key: :post_id
 end
@@ -266,8 +312,60 @@ class SerializedPost < ActiveRecord::Base
 end
 
 class ConditionalStiPost < Post
-  default_scope { where(title: 'Untitled') }
+  default_scope { where(title: "Untitled") }
 end
 
 class SubConditionalStiPost < ConditionalStiPost
 end
+
+class FakeKlass
+  extend ActiveRecord::Delegation::DelegateCache
+
+  class << self
+    def connection
+      Post.connection
+    end
+
+    def table_name
+      "posts"
+    end
+
+    def attribute_aliases
+      {}
+    end
+
+    def sanitize_sql(sql)
+      sql
+    end
+
+    def sanitize_sql_for_order(sql)
+      sql
+    end
+
+    def disallow_raw_sql!(*args)
+      # noop
+    end
+
+    def columns_hash
+      { "name" => nil }
+    end
+
+    def arel_table
+      Post.arel_table
+    end
+
+    def predicate_builder
+      Post.predicate_builder
+    end
+
+    def finder_needs_type_condition?
+      false
+    end
+
+    def base_class?
+      true
+    end
+  end
+
+  inherited self
+end

data/test/models/price_estimate.rb

@@ -1,4 +1,14 @@
+# frozen_string_literal: true
+
 class PriceEstimate < ActiveRecord::Base
-  belongs_to :estimate_of, :polymorphic => true
+  include ActiveSupport::NumberHelper
+
+  belongs_to :estimate_of, polymorphic: true
   belongs_to :thing, polymorphic: true
+
+  validates_numericality_of :price
+
+  def price
+    number_to_currency super
+  end
 end

data/test/models/professor.rb

@@ -1,4 +1,6 @@
-require_dependency 'models/arunit2_model'
+# frozen_string_literal: true
+
+require "models/arunit2_model"
 
 class Professor < ARUnit2Model
   has_and_belongs_to_many :courses

data/test/models/project.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 class Project < ActiveRecord::Base
   belongs_to :mentor
-  has_and_belongs_to_many :developers, -> { distinct.order 'developers.name desc, developers.id desc' }
-  has_and_belongs_to_many :readonly_developers, -> { readonly }, :class_name => "Developer"
-  has_and_belongs_to_many :non_unique_developers, -> { order 'developers.name desc, developers.id desc' }, :class_name => 'Developer'
-  has_and_belongs_to_many :limited_developers, -> { limit 1 }, :class_name => "Developer"
-  has_and_belongs_to_many :developers_named_david, -> { where("name = 'David'").distinct }, :class_name => "Developer"
-  has_and_belongs_to_many :developers_named_david_with_hash_conditions, -> { where(:name => 'David').distinct }, :class_name => "Developer"
-  has_and_belongs_to_many :salaried_developers, -> { where "salary > 0" }, :class_name => "Developer"
-  has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
-                            :after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
-                            :before_remove => Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},
-                            :after_remove => Proc.new {|o, r| o.developers_log << "after_removing#{r.id}"}
-  has_and_belongs_to_many :well_payed_salary_groups, -> { group("developers.salary").having("SUM(salary) > 10000").select("SUM(salary) as salary") }, :class_name => "Developer"
+  has_and_belongs_to_many :developers, -> { distinct.order "developers.name desc, developers.id desc" }
+  has_and_belongs_to_many :readonly_developers, -> { readonly }, class_name: "Developer"
+  has_and_belongs_to_many :non_unique_developers, -> { order "developers.name desc, developers.id desc" }, class_name: "Developer"
+  has_and_belongs_to_many :limited_developers, -> { limit 1 }, class_name: "Developer"
+  has_and_belongs_to_many :developers_named_david, -> { where("name = 'David'").distinct }, class_name: "Developer"
+  has_and_belongs_to_many :developers_named_david_with_hash_conditions, -> { where(name: "David").distinct }, class_name: "Developer"
+  has_and_belongs_to_many :salaried_developers, -> { where "salary > 0" }, class_name: "Developer"
+  has_and_belongs_to_many :developers_with_callbacks, class_name: "Developer", before_add: Proc.new { |o, r| o.developers_log << "before_adding#{r.id || '<new>'}" },
+                            after_add: Proc.new { |o, r| o.developers_log << "after_adding#{r.id || '<new>'}" },
+                            before_remove: Proc.new { |o, r| o.developers_log << "before_removing#{r.id}" },
+                            after_remove: Proc.new { |o, r| o.developers_log << "after_removing#{r.id}" }
+  has_and_belongs_to_many :well_paid_salary_groups, -> { group("developers.salary").having("SUM(salary) > 10000").select("SUM(salary) as salary") }, class_name: "Developer"
   belongs_to :firm
   has_one :lead_developer, through: :firm, inverse_of: :contracted_projects
 

data/test/models/publisher/article.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Publisher::Article < ActiveRecord::Base
   has_and_belongs_to_many :magazines
   has_and_belongs_to_many :tags

data/test/models/publisher/magazine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Publisher::Magazine < ActiveRecord::Base
   has_and_belongs_to_many :articles
 end

data/test/models/publisher.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 module Publisher
 end

data/test/models/randomly_named_c1.rb

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

data/test/models/rating.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 class Rating < ActiveRecord::Base
   belongs_to :comment
-  has_many :taggings, :as => :taggable
+  has_many :taggings, as: :taggable
+  has_many :taggings_without_tag, -> { left_joins(:tag).where("tags.id": [nil, 0]) }, as: :taggable, class_name: "Tagging"
+  has_many :taggings_with_no_tag, -> { joins("LEFT OUTER JOIN tags ON tags.id = taggings.tag_id").where("tags.id": nil) }, as: :taggable, class_name: "Tagging"
 end

data/test/models/reader.rb

@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 class Reader < ActiveRecord::Base
   belongs_to :post
-  belongs_to :person, :inverse_of => :readers
-  belongs_to :single_person, :class_name => 'Person', :foreign_key => :person_id, :inverse_of => :reader
+  belongs_to :person, inverse_of: :readers
+  belongs_to :single_person, class_name: "Person", foreign_key: :person_id, inverse_of: :reader
   belongs_to :first_post, -> { where(id: [2, 3]) }
 end
 
 class SecureReader < ActiveRecord::Base
   self.table_name = "readers"
 
-  belongs_to :secure_post, :class_name => "Post", :foreign_key => "post_id"
-  belongs_to :secure_person, :inverse_of => :secure_readers, :class_name => "Person", :foreign_key => "person_id"
+  belongs_to :secure_post, class_name: "Post", foreign_key: "post_id"
+  belongs_to :secure_person, inverse_of: :secure_readers, class_name: "Person", foreign_key: "person_id"
 end
 
 class LazyReader < ActiveRecord::Base
   self.table_name = "readers"
   default_scope -> { where(skimmer: true) }
 
-  scope :skimmers_or_not, -> { unscope(:where => :skimmer) }
+  scope :skimmers_or_not, -> { unscope(where: :skimmer) }
 
   belongs_to :post
   belongs_to :person

data/test/models/recipe.rb

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

data/test/models/record.rb

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

data/test/models/reference.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 class Reference < ActiveRecord::Base
   belongs_to :person
   belongs_to :job
 
-  has_many :agents_posts_authors, :through => :person
+  has_many :ideal_jobs, class_name: "Job", foreign_key: :ideal_reference_id
+  has_many :agents_posts_authors, through: :person
 
   class << self; attr_accessor :make_comments; end
   self.make_comments = false
@@ -17,6 +20,6 @@ class Reference < ActiveRecord::Base
 end
 
 class BadReference < ActiveRecord::Base
-  self.table_name = 'references'
-  default_scope { where(:favourite => false) }
+  self.table_name = "references"
+  default_scope { where(favourite: false) }
 end