goldiloader 0.0.9 → 2.1.2

data/spec/db/schema.rb

@@ -1,173 +0,0 @@
-# encoding: UTF-8
-
-ActiveRecord::Schema.define(:version => 0) do
-
-  create_table(:blogs, force: true) do |t|
-    t.string :name
-  end
-
-  create_table(:posts, force: true) do |t|
-    t.string :title
-    t.integer :blog_id
-    t.integer :author_id
-    t.string :owner_type
-    t.integer :owner_id
-  end
-
-  create_table(:users, force: true) do |t|
-    t.string :name
-  end
-
-  create_table(:addresses, force: true) do |t|
-    t.string :city
-    t.integer :user_id
-  end
-
-  create_table(:groups, force: true) do |t|
-    t.string :name
-  end
-
-  create_table(:tags, force: true) do |t|
-    t.string :name
-    t.integer :parent_id
-    t.string :owner_type
-    t.integer :owner_id
-  end
-
-  create_table(:post_tags, force: true) do |t|
-    t.integer :post_id
-    t.integer :tag_id
-  end
-end
-
-class Tag < ActiveRecord::Base
-  belongs_to :parent, class_name: 'Tag'
-  has_many :children, class_name: 'Tag', foreign_key: :parent_id
-
-  belongs_to :owner, polymorphic: true
-  has_many :post_tags
-  has_many :posts, through: :post_tags
-
-  if Goldiloader::Compatibility.mass_assignment_security_enabled?
-    attr_accessible :name
-  end
-end
-
-class PostTag < ActiveRecord::Base
-  belongs_to :post
-  belongs_to :tag
-end
-
-class Blog < ActiveRecord::Base
-  has_many :posts
-  has_many :posts_without_auto_include, auto_include: false, class_name: 'Post'
-  has_many :posts_fully_load, fully_load: true, class_name: 'Post'
-
-  if ActiveRecord::VERSION::MAJOR >= 4
-    has_many :read_only_posts, -> { readonly }, class_name: 'Post'
-    has_many :limited_posts, -> { limit(2) }, class_name: 'Post'
-    has_many :grouped_posts, -> { group(:blog_id) }, class_name: 'Post'
-    has_many :offset_posts, -> { offset(2) }, class_name: 'Post'
-    has_many :from_posts, -> { from('(select distinct blog_id from posts) as posts') }, class_name: 'Post'
-    has_many :instance_dependent_posts, ->(instance) { Post.where(blog_id: instance.id) }, class_name: 'Post'
-
-    has_many :posts_ordered_by_author, -> { joins(:author).order('users.name') }, class_name: 'Post'
-
-    has_many :authors_with_join, -> { joins(:address).order('addresses.city') }, through: :posts, source: :author
-  else
-    has_many :read_only_posts, readonly: true, class_name: 'Post'
-    has_many :limited_posts, limit: 2, class_name: 'Post'
-    has_many :grouped_posts, group: :blog_id, class_name: 'Post'
-    has_many :offset_posts, offset: 2, class_name: 'Post'
-
-    has_many :posts_ordered_by_author, include: :author, order: 'users.name', class_name: 'Post'
-  end
-
-  if Goldiloader::Compatibility.association_finder_sql_enabled?
-    has_many :finder_sql_posts, finder_sql: Proc.new { "select distinct blog_id from posts where blog_id = #{self.id}" },
-             class_name: 'Post'
-  end
-
-  has_many :posts_overridden, class_name: 'Post'
-  has_many :authors, through: :posts
-  has_many :addresses, through: :authors
-
-  if Goldiloader::Compatibility.mass_assignment_security_enabled?
-    attr_accessible :name
-  end
-
-  def posts_overridden
-    'boom'
-  end
-end
-
-class Post < ActiveRecord::Base
-  belongs_to :blog
-  belongs_to :blog_without_auto_include, auto_include: false, class_name: 'Blog', foreign_key: :blog_id
-  belongs_to :author, class_name: 'User'
-  has_many :post_tags
-  has_many :tags, through: :post_tags
-
-  belongs_to :owner, polymorphic: true
-
-  if ActiveRecord::VERSION::MAJOR >= 4
-    has_many :unique_tags, -> { distinct }, through: :post_tags, source: :tag, class_name: 'Tag'
-  else
-    has_many :unique_tags, through: :post_tags, source: :tag, uniq: true, class_name: 'Tag'
-  end
-
-  if ActiveRecord::VERSION::MAJOR < 4
-    has_and_belongs_to_many :unique_tags_has_and_belongs, join_table: :post_tags, class_name: 'Tag', uniq: true
-  end
-
-  after_destroy :after_post_destroy
-
-  if Goldiloader::Compatibility.mass_assignment_security_enabled?
-    attr_accessible :title
-  end
-
-  def after_post_destroy
-    # Hook for tests
-  end
-end
-
-class User < ActiveRecord::Base
-  has_many :posts, foreign_key: :author_id
-  has_many :tags, as: :owner
-  has_one :address
-  has_one :address_without_auto_include, auto_include: false, class_name: 'Address'
-
-  if Goldiloader::Compatibility.unscope_query_method_enabled?
-    has_one :scoped_address_with_default_scope_remove, -> { unscope(where: :city) }, class_name: 'ScopedAddress'
-  end
-
-  if Goldiloader::Compatibility.mass_assignment_security_enabled?
-    attr_accessible :name
-  end
-end
-
-class Address < ActiveRecord::Base
-  belongs_to :user
-
-  if Goldiloader::Compatibility.mass_assignment_security_enabled?
-    attr_accessible :city
-  end
-end
-
-class ScopedAddress < ActiveRecord::Base
-  self.table_name = 'addresses'
-  default_scope { where(city: ['Philadelphia'])}
-  belongs_to :user
-
-  if Goldiloader::Compatibility.mass_assignment_security_enabled?
-    attr_accessible :city
-  end
-end
-
-class Group < ActiveRecord::Base
-  has_many :tags, as: :owner
-
-  if Goldiloader::Compatibility.mass_assignment_security_enabled?
-    attr_accessible :name
-  end
-end

data/spec/goldiloader/auto_include_context_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-
-describe Goldiloader::AutoIncludeContext do
-  describe ".register_models" do
-    context "when included_associations is an array of symbols" do
-      let!(:roots) do
-        [
-          create_mock_model(cars: cars.take(2), fruit: fruits.first),
-          create_mock_model(cars: cars.drop(2).take(2), fruit: fruits.last)
-        ]
-      end
-      let!(:cars) { create_mock_models(4) }
-      let!(:fruits) { create_mock_models(2) }
-
-      before do
-        Goldiloader::AutoIncludeContext.register_models(roots, [:cars, :fruit])
-      end
-
-      it "sets the AutoIncludeContext for roots" do
-        expect(roots.map(&:auto_include_context).uniq.size).to eq 1
-        expect(roots.first.auto_include_context.models).to match_array(roots)
-      end
-
-      it "sets the AutoIncludeContext for singluar nested associations" do
-        expect(fruits.map(&:auto_include_context).uniq.size).to eq 1
-        expect(fruits.first.auto_include_context.models).to match_array(fruits)
-      end
-
-      it "sets the AutoIncludeContext for collection nested associations" do
-        expect(cars.map(&:auto_include_context).uniq.size).to eq 1
-        expect(cars.first.auto_include_context.models).to match_array(cars)
-      end
-    end
-
-    context "when included_associations is a hash" do
-      let!(:roots) do
-        [
-          create_mock_model(car: cars.first),
-          create_mock_model(car: cars.last)
-        ]
-      end
-
-      let!(:cars) do
-        [
-          create_mock_model(wheels: wheels.take(4)),
-          create_mock_model(wheels: wheels.drop(4).take(4))
-        ]
-      end
-
-      let!(:wheels) { create_mock_models(8) }
-
-      before do
-        Goldiloader::AutoIncludeContext.register_models(roots, car: :wheels)
-      end
-
-      it "sets the AutoIncludeContext for roots" do
-        expect(roots.map(&:auto_include_context).uniq.size).to eq 1
-        expect(roots.first.auto_include_context.models).to match_array(roots)
-      end
-
-      it "sets the AutoIncludeContext for child nested associations" do
-        expect(cars.map(&:auto_include_context).uniq.size).to eq 1
-        expect(cars.first.auto_include_context.models).to match_array(cars)
-      end
-
-      it "sets the AutoIncludeContext for grandchild nested associations" do
-        expect(wheels.map(&:auto_include_context).uniq.size).to eq 1
-        expect(wheels.first.auto_include_context.models).to match_array(wheels)
-      end
-    end
-
-    context "when included_associations is an array that mixes hashes and symbols" do
-      let!(:roots) do
-        [
-          create_mock_model(car: cars.first, person: people.first),
-          create_mock_model(car: cars.last, person: people.last)
-        ]
-      end
-
-      let!(:people) { create_mock_models(2) }
-
-      let!(:cars) do
-        [
-          create_mock_model(wheels: wheels.take(4)),
-          create_mock_model(wheels: wheels.drop(4).take(4))
-        ]
-      end
-
-      let!(:wheels) { create_mock_models(8) }
-
-      before do
-        Goldiloader::AutoIncludeContext.register_models(roots, [:person, car: :wheels])
-      end
-
-      it "sets the AutoIncludeContext for roots" do
-        expect(roots.map(&:auto_include_context).uniq.size).to eq 1
-        expect(roots.first.auto_include_context.models).to match_array(roots)
-      end
-
-      it "sets the AutoIncludeContext for child nested associations specified with a symbol" do
-        expect(people.map(&:auto_include_context).uniq.size).to eq 1
-        expect(people.first.auto_include_context.models).to match_array(people)
-      end
-
-      it "sets the AutoIncludeContext for child nested associations specified with a hash" do
-        expect(cars.map(&:auto_include_context).uniq.size).to eq 1
-        expect(cars.first.auto_include_context.models).to match_array(cars)
-      end
-
-      it "sets the AutoIncludeContext for grandchild nested associations" do
-        expect(wheels.map(&:auto_include_context).uniq.size).to eq 1
-        expect(wheels.first.auto_include_context.models).to match_array(wheels)
-      end
-    end
-
-    context "when nested associations are nil" do
-      let!(:roots) do
-        [
-            create_mock_model(car: cars.first),
-            create_mock_model(car: nil),
-            create_mock_model(car: cars.last)
-        ]
-      end
-
-      let!(:cars) do
-        [
-            create_mock_model,
-            create_mock_model
-        ]
-      end
-
-      before do
-        Goldiloader::AutoIncludeContext.register_models(roots, :car)
-      end
-
-      it "sets the AutoIncludeContext for roots" do
-        expect(roots.map(&:auto_include_context).uniq.size).to eq 1
-        expect(roots.first.auto_include_context.models).to match_array(roots)
-      end
-
-      it "sets the AutoIncludeContext for child nested associations" do
-        expect(cars.map(&:auto_include_context).uniq.size).to eq 1
-        expect(cars.first.auto_include_context.models).to match_array(cars)
-      end
-    end
-
-    def create_mock_models(num)
-      num.times.map { create_mock_model }
-    end
-
-    def create_mock_model(associations = {})
-      model = AutoIncludeContextMockModel.new
-      associations.each do |association, models|
-        allow(model).to receive(:association).with(association) do
-          OpenStruct.new(target: models)
-        end
-      end
-      model
-    end
-
-    AutoIncludeContextMockModel = Struct.new(:auto_include_context)
-  end
-end