praxis 2.0.pre.2 → 2.0.pre.7

data/spec/praxis/extensions/support/spec_resources_active_model.rb

@@ -0,0 +1,173 @@
+require 'active_record'
+
+require 'praxis/mapper/active_model_compat'
+
+# Creates a new in-memory DB, and the necessary tables (and mini-seeds) for the  models in this file
+def create_tables
+
+  ActiveRecord::Base.establish_connection(
+      adapter:  'sqlite3',
+      dbfile:  ':memory:',
+      database: ':memory:'
+  )
+  
+  ActiveRecord::Schema.define do
+    ActiveRecord::Migration.suppress_messages do
+      create_table :active_books do |table|
+        table.column :simple_name, :string
+        table.column :added_column, :string
+        table.column :category_uuid, :string
+        table.column :author_id, :integer
+      end
+  
+      create_table :active_authors do |table|
+        table.column :name, :string
+      end
+  
+      create_table :active_categories do |table|
+        table.column :uuid, :string
+        table.column :name, :string
+      end
+  
+      create_table :active_tags do |table|
+        table.column :name, :string
+      end
+  
+      create_table :active_taggings do |table|
+        table.column :book_id, :integer
+        table.column :tag_id, :integer
+        table.column :label, :string, null: true
+      end
+    end
+  end
+end
+
+create_tables
+
+class ActiveBook < ActiveRecord::Base
+  include Praxis::Mapper::ActiveModelCompat
+
+  belongs_to :category, class_name: 'ActiveCategory', foreign_key: :category_uuid, primary_key: :uuid
+  belongs_to :author, class_name: 'ActiveAuthor'
+
+  has_many :taggings, class_name: 'ActiveTagging', foreign_key: :book_id
+  has_many :primary_taggings, lambda { where(label: 'primary')}, class_name: 'ActiveTagging', foreign_key: :book_id
+
+  has_many :tags, class_name: 'ActiveTag', through: :taggings
+  has_many :primary_tags, class_name: 'ActiveTag', through: :primary_taggings, source: :tag
+end
+
+class ActiveAuthor < ActiveRecord::Base
+  include Praxis::Mapper::ActiveModelCompat
+  has_many :books, class_name: 'ActiveBook', foreign_key: :author_id
+end
+
+class ActiveCategory < ActiveRecord::Base
+  include Praxis::Mapper::ActiveModelCompat
+  has_many :books, class_name: 'ActiveBook', primary_key: :uuid, foreign_key: :category_uuid
+end
+
+class ActiveTag < ActiveRecord::Base
+  include Praxis::Mapper::ActiveModelCompat
+  has_many :taggings, class_name: 'ActiveTagging', foreign_key: :tag_id
+  has_many :books, class_name: 'ActiveBook', through: :taggings, source: :book
+end
+
+class ActiveTagging < ActiveRecord::Base
+  include Praxis::Mapper::ActiveModelCompat
+  belongs_to :book, class_name: 'ActiveBook', foreign_key: :book_id
+  belongs_to :tag, class_name: 'ActiveTag', foreign_key: :tag_id
+end
+
+
+# A set of resource classes for use in specs
+class ActiveBaseResource < Praxis::Mapper::Resource
+end
+
+class ActiveAuthorResource < ActiveBaseResource
+  model ActiveAuthor
+
+  property :display_name, dependencies: [:name]
+end
+
+class ActiveCategoryResource < ActiveBaseResource
+  model ActiveCategory
+end
+
+class ActiveTagResource < ActiveBaseResource
+  model ActiveTag
+end
+
+class ActiveBookResource < ActiveBaseResource
+  model ActiveBook
+
+  filters_mapping(
+    id: :id,
+    category_uuid: :category_uuid,
+    'fake_nested.name': 'simple_name',
+    'name': 'simple_name',
+    'name_is_not': lambda do |spec| # Silly way to use a proc, but good enough for testing
+      { name: :simple_name, value: spec[:value] , op: '!=' } # Can be an array for multiple conditions as well
+      end,
+    'author.id': 'author.id',
+    'author.name': 'author.name',
+    'taggings.label': 'taggings.label',
+    'taggings.tag_id': 'taggings.tag_id',
+    'taggings.tag.taggings.tag_id': 'taggings.tag.taggings.tag_id',
+    'tags.name': 'tags.name',
+    'primary_tags.name': 'primary_tags.name',
+    'category.name': 'category.name',
+    'category.books.name': 'category.books.simple_name',
+    'category.books.taggings.tag_id': 'category.books.taggings.tag_id',
+    'category.books.taggings.label': 'category.books.taggings.label',
+  )
+  # Forces to add an extra column (added_column)...and yet another (author_id) that will serve
+  # to check that if that's already automatically added due to an association, it won't interfere or duplicate
+  property :author, dependencies: [:author, :added_column, :author_id]
+
+  property :name, dependencies: [:simple_name]
+end
+
+
+def seed_data
+  cat1 = ActiveCategory.create( id: 1 , uuid: 'deadbeef1', name: 'cat1' )
+  cat2 = ActiveCategory.create( id: 2 , uuid: 'deadbeef2', name: 'cat2' )
+  
+  author1 = ActiveAuthor.create(  id: 11, name: 'author1' )
+  author2 = ActiveAuthor.create(  id: 22, name: 'author2' )
+  author3 = ActiveAuthor.create(  id: 33, name: nil )
+  
+  tag_blue = ActiveTag.create(id: 1 , name: 'blue' )
+  tag_red = ActiveTag.create(id: 2 , name: 'red' )
+  tag_green = ActiveTag.create(id: 3 , name: 'green' )
+
+  book1 = ActiveBook.create( id: 1 , simple_name: 'Book1', category_uuid: 'deadbeef1')
+  book1.author = author1
+  book1.category = cat1
+  book1.save
+  ActiveTagging.create(book: book1, tag: tag_blue, label: 'primary')
+  ActiveTagging.create(book: book1, tag: tag_red)
+  ActiveTagging.create(book: book1, tag: tag_green, label: 'primary')
+  
+
+  book2 = ActiveBook.create( id: 2 , simple_name: 'Book2', category_uuid: 'deadbeef1')
+  book2.author = author2
+  book2.category = cat2
+  book2.save
+  ActiveTagging.create(book: book2, tag: tag_red, label: 'primary')
+
+  book3 = ActiveBook.create( id: 3 , simple_name: 'Book3', category_uuid: 'deadbeef1')
+  book3.author = author3
+  book3.save
+  ActiveTagging.create(book: book3, tag: tag_red, label: 'primary')
+
+  # More stuff
+
+  10.times do |i|
+    bid = 1000+i
+    ActiveBook.create( id: bid , simple_name: "Book#{bid}")
+  end
+
+end
+
+seed_data

data/spec/praxis/extensions/support/spec_resources_sequel.rb

@@ -0,0 +1,106 @@
+require 'sequel'
+
+require 'praxis/mapper/sequel_compat'
+
+
+# Creates a new in-memory DB, and the necessary tables (and mini-seeds) for the sequel models in this file
+def create_and_seed_tables
+    sequeldb = Sequel.sqlite 
+    # sequeldb.loggers = [Logger.new($stdout)] # Uncomment to see sequel logs
+
+    sequeldb.create_table! :sequel_simple_models do
+      primary_key :id
+      String :simple_name
+      Integer :parent_id
+      String :parent_uuid
+      Integer :other_model_id
+      String :added_column
+  end
+    sequeldb.create_table! :sequel_other_models do
+      primary_key :id
+    end
+    sequeldb.create_table! :sequel_parent_models do
+      primary_key :id
+      String :uuid
+    end
+    sequeldb.create_table! :sequel_tag_models do
+      primary_key :id
+      String :tag_name
+    end
+    sequeldb.create_table! :sequel_simple_models_sequel_tag_models do
+      Integer :sequel_simple_model_id
+      Integer :tag_id
+    end
+
+    sequeldb[:sequel_parent_models] << { id: 1 , uuid: 'deadbeef1'}
+    sequeldb[:sequel_parent_models] << { id: 2 , uuid: 'deadbeef2'}
+    
+    sequeldb[:sequel_other_models] << { id: 11 }
+    sequeldb[:sequel_other_models] << { id: 22 }
+
+    sequeldb[:sequel_tag_models] << { id: 1 , tag_name: 'blue' }
+    sequeldb[:sequel_tag_models] << { id: 2 , tag_name: 'red' }
+
+    # Simple model 1 is tagged as blue and red
+    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 1, tag_id: 1 }
+    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 1, tag_id: 2 }
+    # Simple model 2 is tagged as red
+    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 2, tag_id: 2 }
+
+    # It's weird to have a parent id and parent uuid (which points to different actual parents)
+    # But it allows us to check pointing to both PKs and not PK columns
+    sequeldb[:sequel_simple_models] << { id: 1 , simple_name: 'Simple1', parent_id: 1, other_model_id: 11, parent_uuid: 'deadbeef1'}
+    sequeldb[:sequel_simple_models] << { id: 2 , simple_name: 'Simple2', parent_id: 2, other_model_id: 22, parent_uuid: 'deadbeef1'}
+end
+
+create_and_seed_tables
+
+class SequelSimpleModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+
+  many_to_one :parent, class: 'SequelParentModel'
+  many_to_one :other_model, class: 'SequelOtherModel'
+  many_to_many :tags, class: 'SequelTagModel'
+end
+
+class SequelOtherModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+end
+
+class SequelParentModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+  one_to_many :children, class: 'SequelSimpleModel', primary_key: :uuid, key: :parent_uuid
+end
+
+class SequelTagModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+end
+
+
+# A set of resource classes for use in specs
+class SequelBaseResource < Praxis::Mapper::Resource
+end
+
+class SequelOtherResource < SequelBaseResource
+  model SequelOtherModel
+
+  property :display_name, dependencies: [:name]
+end
+
+class SequelParentResource < SequelBaseResource
+  model SequelParentModel
+end
+
+class SequelTagResource < SequelBaseResource
+  model SequelTagModel
+end
+
+class SequelSimpleResource < SequelBaseResource
+  model SequelSimpleModel
+
+  # Forces to add an extra column (added_column)...and yet another (parent_id) that will serve
+  # to check that if that's already automatically added due to an association, it won't interfere or duplicate
+  property :parent, dependencies: [:parent, :added_column, :parent_id]
+
+  property :name, dependencies: [:simple_name]
+end

data/spec/praxis/mapper/selector_generator_spec.rb

@@ -1,301 +1,325 @@
-# require 'spec_helper'
+require 'spec_helper'
 
-# describe Praxis::Mapper::SelectorGenerator do
-#   let(:properties) { {} }
-#   let(:resource) { BlogResource }
-#   subject(:generator) {Praxis::Mapper::SelectorGenerator.new }
 
-#   before do
-#     generator.add(resource,properties)
-#   end
+describe Praxis::Mapper::SelectorGenerator do
+  let(:resource) { SimpleResource }
+  subject(:generator) {described_class.new }
 
-#   let(:expected_selectors) { {} }
+  context '#add' do
+    let(:resource) { SimpleResource }
+    shared_examples 'a proper selector' do
+      it { expect(generator.add(resource, fields).dump).to be_deep_equal selectors }
+    end
+    
+    context 'basic combos' do
+      context 'direct column fields' do
+        let(:fields) { {id: true, foobar: true} }
+        let(:selectors) do 
+          {
+            model: SimpleModel,
+            columns: [:id, :foobar]
+          } 
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#   context 'for a simple field' do
-#     let(:properties) { {id: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:id]),
-#           track: Set.new()
-#         }
-#       }
-#     end
+      context 'aliased column fields' do
+        let(:fields) { {id: true, name: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:id, :simple_name]
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+      context 'pure associations without recursion' do
+        let(:fields) { {other_model: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id], # FK of the other_model association
+            tracks: {
+              other_model: { 
+                columns: [:id], # joining key for the association
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#   context 'for a simple property' do
-#     let(:properties) { {display_name: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:name]),
-#           track: Set.new()
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+      context 'aliased associations without recursion' do
+        let(:fields) { {other_resource: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id], # FK of the other_model association
+            tracks: {
+              other_model: { 
+                columns: [:id], # joining key for the association
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+      context 'aliased associations without recursion (that map to columns and other associations)' do
+        let(:fields) { {aliased_method: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:column1, :other_model_id], # other_model_id => because of the association
+            tracks: {
+              other_model: { 
+                columns: [:id], # joining key for the association
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#   context 'for an association' do
-#     let(:properties) { {owner: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:owner_id]),
-#           track: Set.new([:owner])
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
+      context 'redefined associations that add some extra columns (would need both the underlying association AND the columns in place)' do
+        let(:fields) { {parent: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:parent_id, :added_column],
+            tracks: {
+              parent: { 
+                columns: [:id],
+                model: ParentModel
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#     context 'that is many_to_many' do
-#       let(:properties) { {commented_posts: true} }
-#       let(:resource) { UserResource }
-#       let(:expected_selectors) do
-#         {
-#           CommentModel => {
-#             select: Set.new([:author_id, :post_id]),
-#             track: Set.new([:post])
-#           },
-#           UserModel => {
-#             select: Set.new([]),
-#             track: Set.new([:comments])
-#           }
-#         }
-#       end
-#       it 'generates the correct set of selectors' do
-#         generator.selectors.should eq expected_selectors
-#       end
-#     end
+      context 'a simple property that requires all fields' do
+        let(:fields) { {everything: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:*],
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#     context 'that is many_to_many without a :through option' do
-#       let(:properties) { {other_commented_posts: { id: true} } }
-#       let(:resource) { UserResource }
-#       let(:expected_selectors) do
-#         {
-#           PostModel => {
-#             select: Set.new([:id]),
-#             track: Set.new([])
-#           },
-#           UserModel => {
-#             select: Set.new([]),
-#             track: Set.new([:other_commented_posts])
-#           }
-#         }
-#       end
-#       it 'generates the correct set of selectors' do
-#         generator.selectors.should eq expected_selectors
-#       end
-#     end
+      context 'a simple property that requires itself' do
+        let(:fields) { {circular_dep: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:circular_dep, :column1], #allows to "expand" the dependency into itself + others
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
+      context 'a simple property without dependencies' do
+        let(:fields) { {no_deps: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#     context 'that uses a composite key' do
-#       let(:properties) { {composite_model: {id: true, type: true} } }
-#       let(:resource) { OtherResource }
-#       let(:expected_selectors) do
-#         {
-#           OtherModel => {
-#             select: Set.new([:composite_id,:composite_type]),
-#             track: Set.new([:composite_model])
-#           },
-#           CompositeIdModel => {
-#             select: Set.new([:id,:type]),
-#             track: Set.new
-#           }
-#         }
-#       end
-#       it 'generates the correct set of selectors' do
-#         generator.selectors.should eq expected_selectors
-#       end
-#     end
-#   end
+    end
 
-#   context 'for a property that specifies a field from an association' do
-#     let(:properties) { {owner_email: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:owner_id]),
-#           track: Set.new([:owner])
-#         },
-#         UserModel => {
-#           select: Set.new([:email]),
-#           track: Set.new()
-#         }
-#       }
-#     end
+    context 'nested tracking' do
+      context 'pure associations follow the nested fields' do
+        let(:fields) do
+          { 
+            other_model: {
+              id: true
+            }
+          }
+        end
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+      context 'Aliased resources disregard any nested fields...' do
+        let(:fields) do
+          {
+            other_resource: {
+              id: true
+            }
+          }
+        end
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#   context 'for a simple property that requires all fields' do
-#     let(:properties) { {everything: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: true,
-#           track: Set.new()
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+      context 'merging multiple tracks with the same name within a node' do
+        let(:fields) do
+          { # Both everything_from_parent and parent will track the underlying 'parent' assoc
+            # ...and the final respective fields and tracks will need to be merged together.
+            # columns will be merged by just *, and tracks will merge true with simple children
+            everything_from_parent: true,
+            parent: {
+              simple_children: true
+            }
+          }
+        end
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:parent_id, :added_column],
+            tracks: {
+              parent: {
+                model: ParentModel,
+                columns: [:*],
+                tracks: {
+                  simple_children: {
+                    model: SimpleModel,
+                    columns: [:parent_id]
+                  }
+                }
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+    end
 
-#   context 'for property that uses an associated property' do
-#     let(:properties) { {owner_full_name: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:owner_id]),
-#           track: Set.new([:owner])
-#         },
-#         UserModel => {
-#           select: Set.new([:first_name, :last_name]),
-#           track: Set.new()
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+    context 'string associations' do
+      context 'that specify a direct existing colum in the target dependency' do
+        let(:fields) { { direct_other_name: true } }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id, :name]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
+      context 'that specify an aliased property in the target dependency' do
+        let(:fields) { { aliased_other_name: true } }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id, :name]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#   context 'for a property that requires all fields from an association' do
-#     let(:properties) { {everything_from_owner: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:owner_id]),
-#           track: Set.new([:owner])
-#         },
-#         UserModel => {
-#           select: true,
-#           track: Set.new()
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+      context 'for a property that requires all fields from an association' do
+        let(:fields) { {everything_from_parent: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:parent_id],
+            tracks: {
+              parent: { 
+                model: ParentModel,
+                columns: [:*]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+    end
 
-#   context 'using a property that specifies a :through option' do
-#     let(:properties) { {recent_posts: {author: {full_name: true}}} }
-#     let(:resource) { UserResource }
-#     let(:expected_selectors) do
-#       {
-#         PostModel => {
-#           select: Set.new([:author_id, :created_at]),
-#           track: Set.new([:author])
-#         },
-#         UserModel => {
-#           select: Set.new([:first_name, :last_name]),
-#           track: Set.new([:posts])
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+    context 'required extra select fields due to associations' do
+      context 'many_to_one' do
+        let(:fields) { {other_model: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id], # FK of the other_model association
+            tracks: {
+              other_model: { 
+                columns: [:id],
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+      context 'one_to_many' do
+        let(:resource) { ParentResource }
+        let(:fields) { {simple_children: true} }
+        let(:selectors) do
+          {
+            model: ParentModel,
+            columns: [:id], # No FKs in the source model for one_to_many
+            tracks: {
+              simple_children: { 
+                columns: [:parent_id],
+                model: SimpleModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end      
+      context 'many_to_many' do
+        let(:resource) { OtherResource }
+        let(:fields) { {simple_models: true} }
+        let(:selectors) do
+          {
+            model: OtherModel,
+            columns: [:id], #join key in the source model for many_to_many (where the middle table points to)
+            tracks: {
+              simple_models: { 
+                columns: [:id], #join key in the target model for many_to_many (where the middle table points to)
+                model: SimpleModel
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end      
 
-#   context 'with a property with a circular definition (ie, includes its own field)' do
-#     let(:resource) { PostResource }
-
-#     let(:properties) { {id: true, slug: true} }
-#     let(:expected_selectors) do
-#       {
-#         PostModel => {
-#           select: Set.new([:id, :slug, :title]),
-#           track: Set.new
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
-
-#   context 'with a property without the :through option' do
-#     let(:resource) { UserResource }
-#     let(:properties) { {blogs_summary: {size: true}} }
-#     let(:expected_selectors) do
-#      {
-#        BlogModel => {
-#          select: Set.new([:owner_id]),
-#          track: Set.new()
-#        },
-#        UserModel => {
-#          select: Set.new([:id]),
-#          track: Set.new([:blogs])
-#        }
-#      }
-#     end
-#     it 'ignores any subsequent fields when generating selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
-
-#   context 'for a property with no dependencies' do
-#     let(:properties) { {id: true, kind: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:id]),
-#           track: Set.new()
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
-
-#   context 'with large set of properties' do
-
-#     let(:properties) do
-#       {
-#         display_name: true,
-#         owner: {
-#           id: true,
-#           full_name: true,
-#           blogs_summary: {href: true, size: true},
-#           main_blog: {id: true},
-#         },
-#         administrator: {id: true, full_name: true}
-#       }
-#     end
-
-#     let(:expected_selectors) do
-#       {
-#         BlogModel=> {
-#           select: Set.new([:id, :name, :owner_id, :administrator_id]),
-#           track: Set.new([:owner, :administrator])
-#         },
-#         UserModel=> {
-#           select: Set.new([:id, :first_name, :last_name, :main_blog_id]),
-#           track: Set.new([:blogs, :main_blog])
-#         }
-#       }
-#     end
-
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq(expected_selectors)
-#     end
-
-#   end
-
-# end
+    end
+  end
+end