Slimming down the BelongsToMany class

src/Jenssegers/Mongodb/Relations/BelongsToMany.php

 <?php namespace Jenssegers\Mongodb\Relations;
+
 use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Model;
@@ -7,31 +8,16 @@ use Illuminate\Database\Eloquent\Relations\BelongsToMany as EloquentBelongsToMan
 class BelongsToMany extends EloquentBelongsToMany {
 
 	/**
-	 * Execute the query as a "select" statement.
+	 * Hydrate the pivot table relationship on the models.
 	 *
-	 * @param  array  $columns
-	 * @return \Illuminate\Database\Eloquent\Collection
+	 * @param  array  $models
+	 * @return void
 	 */
-	public function get($columns = array('*'))
+	protected function hydratePivotRelation(array $models)
 	{
-		// First we'll add the proper select columns onto the query so it is run with
-		// the proper columns. Then, we will get the results and hydrate out pivot
-		// models with the result of those columns as a separate model relation.
-		$select = $this->getSelectColumns($columns);
-
-		$models = $this->query->addSelect($select)->getModels();
-
-		// If we actually found models we will also eager load any relationships that
-		// have been specified as needing to be eager loaded. This will solve the
-		// n + 1 query problem for the developer and also increase performance.
-		if (count($models) > 0)
-		{
-			$models = $this->query->eagerLoadRelations($models);
-		}
-
-		return $this->related->newCollection($models);
+		// Do nothing
 	}
-	
+
 	/**
 	 * Set the select clause for the relation query.
 	 *
@@ -42,26 +28,6 @@ class BelongsToMany extends EloquentBelongsToMany {
 		return $columns;
 	}
 
-	/**
-	 * Get a paginator for the "select" statement.
-	 *
-	 * @param  int    $perPage
-	 * @param  array  $columns
-	 * @return \Illuminate\Pagination\Paginator
-	 */
-	public function paginate($perPage = null, $columns = array('*'))
-	{
-		$this->query->addSelect($this->getSelectColumns($columns));
-
-		// When paginating results, we need to add the pivot columns to the query and
-		// then hydrate into the pivot objects once the results have been gathered
-		// from the database since this isn't performed by the Eloquent builder.
-		$pager = $this->query->paginate($perPage, $columns);
-
-		return $pager;
-	}
-
-
 	/**
 	 * Set the base constraints on the relation query.
 	 *
@@ -69,7 +35,7 @@ class BelongsToMany extends EloquentBelongsToMany {
 	 */
 	public function addConstraints()
 	{
-		if (static::$constraints) 
+		if (static::$constraints)
 		{
 			// Make sure that the primary key of the parent
 			// is in the relationship array of keys
@@ -77,55 +43,6 @@ class BelongsToMany extends EloquentBelongsToMany {
 		}
 	}
 
-	/**
-	 * Set the constraints for an eager load of the relation.
-	 *
-	 * @param  array  $models
-	 * @return void
-	 */
-	public function addEagerConstraints(array $models)
-	{
-		$this->query->whereIn($this->getForeignKey(), $this->getKeys($models));
-	}
-
-	/**
-	 * Save a new model and attach it to the parent model.
-	 *
-	 * @param  \Illuminate\Database\Eloquent\Model  $model
-	 * @param  array  $joining
-	 * @param  bool   $touch
-	 * @return \Illuminate\Database\Eloquent\Model
-	 */
-	public function save(Model $model, array $joining = array(), $touch = true)
-	{
-		$model->save(array('touch' => false));
-
-		$this->attach($model->getKey(), $joining, $touch);
-		
-		return $model;
-	}
-
-	/**
-	 * Create a new instance of the related model.
-	 *
-	 * @param  array  $attributes
-	 * @param  array  $joining
-	 * @param  bool   $touch
-	 * @return \Illuminate\Database\Eloquent\Model
-	 */
-	public function create(array $attributes, array $joining = array(), $touch = true)
-	{
-		$instance = $this->related->newInstance($attributes);
-
-		// Save the new instance before we attach it to other models	
-		$instance->save(array('touch' => false));
-		
-		// Attach to the parent instance
-		$this->attach($instance->_id, $attributes, $touch);
-
-		return $instance;
-	}
-
 	/**
 	 * Sync the intermediate tables with a list of IDs.
 	 *
@@ -139,13 +56,13 @@ class BelongsToMany extends EloquentBelongsToMany {
 		// in this joining table. We'll spin through the given IDs, checking to see
 		// if they exist in the array of current ones, and if not we will insert.
 		$current = $this->parent->{$this->otherKey};
-		
+
 		// Check if the current array exists or not on the parent model and create it
 		// if it does not exist
 		if (is_null($current)) $current = array();
 
 		$records = $this->formatSyncList($ids);
-		
+
 		$detach = array_diff($current, array_keys($records));
 
 		// Next, we will take the differences of the currents and given IDs and detach
@@ -164,29 +81,6 @@ class BelongsToMany extends EloquentBelongsToMany {
 		$this->touchIfTouching();
 	}
 
-	/**
-	 * Format the sync list so that it is keyed by ID.
-	 *
-	 * @param  array  $records
-	 * @return array
-	 */
-	protected function formatSyncList(array $records)
-	{
-		$results = array();
-
-		foreach ($records as $id => $attributes)
-		{
-			if ( ! is_array($attributes))
-			{
-				list($id, $attributes) = array($attributes, array());
-			}
-
-			$results[$id] = $attributes;
-		}
-
-		return $results;
-	}
-
 	/**
 	 * Attach all of the IDs that aren't in the current array.
 	 *
@@ -220,25 +114,25 @@ class BelongsToMany extends EloquentBelongsToMany {
 	public function attach($id, array $attributes = array(), $touch = true)
 	{
 		if ($id instanceof Model) $id = $id->getKey();
-		
+
 		// Generate a new parent query instance
 		$parent = $this->newParentQuery();
-		
+
 		// Generate a new related query instance
 		$related = $this->related->newInstance();
-		
+
 		// Set contraints on the related query
 		$related = $related->where($this->related->getKeyName(), $id);
 
 		$records = $this->createAttachRecords((array) $id, $attributes);
-		
+
 		// Get the ID's to attach to the two documents
 		$otherIds = array_pluck($records, $this->otherKey);
 		$foreignIds = array_pluck($records, $this->foreignKey);
 
 		// Attach to the parent model
 		$parent->push($this->otherKey, $otherIds[0])->update(array());
-		
+
 		// Attach to the related model
 		$related->push($this->foreignKey, $foreignIds[0])->update(array());
 	}
@@ -296,54 +190,22 @@ class BelongsToMany extends EloquentBelongsToMany {
 		{
 			$query->pull($this->otherKey, $id);
 		}
-		
-		return count($ids);
-	}
-
-	/**
-	 * If we're touching the parent model, touch.
-	 *
-	 * @return void
-	 */
-	public function touchIfTouching()
-	{ 
-	 	if ($this->touchingParent()) $this->getParent()->touch();
 
-	 	if ($this->getParent()->touches($this->relationName)) $this->touch();
-	}
-
-	/**
-	 * Determine if we should touch the parent on sync.
-	 *
-	 * @return bool
-	 */
-	protected function touchingParent()
-	{
-		return $this->getRelated()->touches($this->guessInverseRelation());
-	}
-
-	/**
-	 * Attempt to guess the name of the inverse of the relation.
-	 *
-	 * @return string
-	 */
-	protected function guessInverseRelation()
-	{
-		return strtolower(str_plural(class_basename($this->getParent())));
+		return count($ids);
 	}
 
 	/**
 	 * Create a new query builder for the parent
-	 * 
+	 *
 	 * @return Jenssegers\Mongodb\Builder
 	 */
 	protected function newParentQuery()
 	{
 		$query = $this->parent->newQuery();
-		
+
 		return $query->where($this->parent->getKeyName(), '=', $this->parent->getKey());
 	}
-	
+
 	/**
 	 * Build model dictionary keyed by the relation's foreign key.
 	 *
@@ -370,16 +232,6 @@ class BelongsToMany extends EloquentBelongsToMany {
 		return $dictionary;
 	}
 
-	/**
-	 * Get the related model's updated at column name.
-	 *
-	 * @return string
-	 */
-	public function getRelatedFreshUpdate()
-	{
-		return array($this->related->getUpdatedAtColumn() => $this->related->freshTimestamp());
-	}
-
 	/**
 	 * Get the fully qualified foreign key for the relation.
 	 *
@@ -399,4 +251,4 @@ class BelongsToMany extends EloquentBelongsToMany {
 	{
 		return $this->otherKey;
 	}
-}
+}
\ No newline at end of file

tests/RelationsTest.php

@@ -2,214 +2,214 @@
 
 class RelationsTest extends PHPUnit_Framework_TestCase {
 
-	public function setUp() {
+    public function setUp() {
     }
 
     public function tearDown()
     {
-            User::truncate();
-            Book::truncate();
-            Item::truncate();
-            Role::truncate();
-			Client::truncate();
+        User::truncate();
+        Book::truncate();
+        Item::truncate();
+        Role::truncate();
+        Client::truncate();
     }
 
     public function testHasMany()
     {
-            $author = User::create(array('name' => 'George R. R. Martin'));
-            Book::create(array('title' => 'A Game of Thrones', 'author_id' => $author->_id));
-            Book::create(array('title' => 'A Clash of Kings', 'author_id' => $author->_id));
+        $author = User::create(array('name' => 'George R. R. Martin'));
+        Book::create(array('title' => 'A Game of Thrones', 'author_id' => $author->_id));
+        Book::create(array('title' => 'A Clash of Kings', 'author_id' => $author->_id));
 
-            $books = $author->books;
-            $this->assertEquals(2, count($books));
+        $books = $author->books;
+        $this->assertEquals(2, count($books));
 
-            $user = User::create(array('name' => 'John Doe'));
-            Item::create(array('type' => 'knife', 'user_id' => $user->_id));
-            Item::create(array('type' => 'shield', 'user_id' => $user->_id));
-            Item::create(array('type' => 'sword', 'user_id' => $user->_id));
-            Item::create(array('type' => 'bag', 'user_id' => null));
+        $user = User::create(array('name' => 'John Doe'));
+        Item::create(array('type' => 'knife', 'user_id' => $user->_id));
+        Item::create(array('type' => 'shield', 'user_id' => $user->_id));
+        Item::create(array('type' => 'sword', 'user_id' => $user->_id));
+        Item::create(array('type' => 'bag', 'user_id' => null));
 
-            $items = $user->items;
-            $this->assertEquals(3, count($items));
-    }
+        $items = $user->items;
+        $this->assertEquals(3, count($items));
+}
 
     public function testBelongsTo()
     {
-            $user = User::create(array('name' => 'George R. R. Martin'));
-            Book::create(array('title' => 'A Game of Thrones', 'author_id' => $user->_id));
-            $book = Book::create(array('title' => 'A Clash of Kings', 'author_id' => $user->_id));
+        $user = User::create(array('name' => 'George R. R. Martin'));
+        Book::create(array('title' => 'A Game of Thrones', 'author_id' => $user->_id));
+        $book = Book::create(array('title' => 'A Clash of Kings', 'author_id' => $user->_id));
 
-            $author = $book->author;
-            $this->assertEquals('George R. R. Martin', $author->name);
+        $author = $book->author;
+        $this->assertEquals('George R. R. Martin', $author->name);
 
-            $user = User::create(array('name' => 'John Doe'));
-            $item = Item::create(array('type' => 'sword', 'user_id' => $user->_id));
+        $user = User::create(array('name' => 'John Doe'));
+        $item = Item::create(array('type' => 'sword', 'user_id' => $user->_id));
 
-            $owner = $item->user;
-            $this->assertEquals('John Doe', $owner->name);
+        $owner = $item->user;
+        $this->assertEquals('John Doe', $owner->name);
     }
 
     public function testHasOne()
     {
-            $user = User::create(array('name' => 'John Doe'));
-            Role::create(array('type' => 'admin', 'user_id' => $user->_id));
+        $user = User::create(array('name' => 'John Doe'));
+        Role::create(array('type' => 'admin', 'user_id' => $user->_id));
 
-            $role = $user->role;
-            $this->assertEquals('admin', $role->type);
+        $role = $user->role;
+        $this->assertEquals('admin', $role->type);
     }
 
     public function testWithBelongsTo()
     {
-            $user = User::create(array('name' => 'John Doe'));
-            Item::create(array('type' => 'knife', 'user_id' => $user->_id));
-            Item::create(array('type' => 'shield', 'user_id' => $user->_id));
-            Item::create(array('type' => 'sword', 'user_id' => $user->_id));
-            Item::create(array('type' => 'bag', 'user_id' => null));
-
-            $items = Item::with('user')->get();
-
-            $user = $items[0]->getRelation('user');
-            $this->assertInstanceOf('User', $user);
-            $this->assertEquals('John Doe', $user->name);
-            $this->assertEquals(1, count($items[0]->getRelations()));
-            $this->assertEquals(null, $items[3]->getRelation('user'));
+        $user = User::create(array('name' => 'John Doe'));
+        Item::create(array('type' => 'knife', 'user_id' => $user->_id));
+        Item::create(array('type' => 'shield', 'user_id' => $user->_id));
+        Item::create(array('type' => 'sword', 'user_id' => $user->_id));
+        Item::create(array('type' => 'bag', 'user_id' => null));
+
+        $items = Item::with('user')->get();
+
+        $user = $items[0]->getRelation('user');
+        $this->assertInstanceOf('User', $user);
+        $this->assertEquals('John Doe', $user->name);
+        $this->assertEquals(1, count($items[0]->getRelations()));
+        $this->assertEquals(null, $items[3]->getRelation('user'));
     }
 
     public function testWithHashMany()
     {
-            $user = User::create(array('name' => 'John Doe'));
-            Item::create(array('type' => 'knife', 'user_id' => $user->_id));
-            Item::create(array('type' => 'shield', 'user_id' => $user->_id));
-            Item::create(array('type' => 'sword', 'user_id' => $user->_id));
-            Item::create(array('type' => 'bag', 'user_id' => null));
+        $user = User::create(array('name' => 'John Doe'));
+        Item::create(array('type' => 'knife', 'user_id' => $user->_id));
+        Item::create(array('type' => 'shield', 'user_id' => $user->_id));
+        Item::create(array('type' => 'sword', 'user_id' => $user->_id));
+        Item::create(array('type' => 'bag', 'user_id' => null));
 
-            $user = User::with('items')->find($user->_id);
+        $user = User::with('items')->find($user->_id);
 
-            $items = $user->getRelation('items');
-            $this->assertEquals(3, count($items));
-            $this->assertInstanceOf('Item', $items[0]);
+        $items = $user->getRelation('items');
+        $this->assertEquals(3, count($items));
+        $this->assertInstanceOf('Item', $items[0]);
     }
 
     public function testWithHasOne()
     {
-            $user = User::create(array('name' => 'John Doe'));
-            Role::create(array('type' => 'admin', 'user_id' => $user->_id));
-            Role::create(array('type' => 'guest', 'user_id' => $user->_id));
+        $user = User::create(array('name' => 'John Doe'));
+        Role::create(array('type' => 'admin', 'user_id' => $user->_id));
+        Role::create(array('type' => 'guest', 'user_id' => $user->_id));
 
-            $user = User::with('role')->find($user->_id);
+        $user = User::with('role')->find($user->_id);
 
-            $role = $user->getRelation('role');
-            $this->assertInstanceOf('Role', $role);
-            $this->assertEquals('admin', $role->type);
+        $role = $user->getRelation('role');
+        $this->assertInstanceOf('Role', $role);
+        $this->assertEquals('admin', $role->type);
     }
 
     public function testEasyRelation()
     {
-            // Has Many
-            $user = User::create(array('name' => 'John Doe'));
-            $item = Item::create(array('type' => 'knife'));
-            $user->items()->save($item);
-
-            $user = User::find($user->_id);
-            $items = $user->items;
-            $this->assertEquals(1, count($items));
-            $this->assertInstanceOf('Item', $items[0]);
-
-            // Has one
-            $user = User::create(array('name' => 'John Doe'));
-            $role = Role::create(array('type' => 'admin'));
-            $user->role()->save($role);
-
-            $user = User::find($user->_id);
-            $role = $user->role;
-            $this->assertInstanceOf('Role', $role);
-            $this->assertEquals('admin', $role->type);
+        // Has Many
+        $user = User::create(array('name' => 'John Doe'));
+        $item = Item::create(array('type' => 'knife'));
+        $user->items()->save($item);
+
+        $user = User::find($user->_id);
+        $items = $user->items;
+        $this->assertEquals(1, count($items));
+        $this->assertInstanceOf('Item', $items[0]);
+
+        // Has one
+        $user = User::create(array('name' => 'John Doe'));
+        $role = Role::create(array('type' => 'admin'));
+        $user->role()->save($role);
+
+        $user = User::find($user->_id);
+        $role = $user->role;
+        $this->assertInstanceOf('Role', $role);
+        $this->assertEquals('admin', $role->type);
+    }
+
+    public function testHasManyAndBelongsTo()
+    {
+        $user = User::create(array('name' => 'John Doe'));
+
+        $user->clients()->save(new Client(array('name' => 'Pork Pies Ltd.')));
+        $user->clients()->create(array('name' => 'Buffet Bar Inc.'));
+
+        $user = User::with('clients')->find($user->_id);
+
+        $client = Client::with('users')->first();
+
+        $clients = $client->getRelation('users');
+        $users = $user->getRelation('clients');
+
+        $this->assertInstanceOf('Illuminate\Database\Eloquent\Collection', $users);
+        $this->assertInstanceOf('Illuminate\Database\Eloquent\Collection', $clients);
+        $this->assertInstanceOf('Client', $users[0]);
+        $this->assertInstanceOf('User', $clients[0]);
+        $this->assertCount(2, $user->clients);
+        $this->assertCount(1, $client->users);
+
+        // Now create a new user to an existing client
+        $client->users()->create(array('name' => 'Jane Doe'));
+
+        $otherClient = User::where('name', '=', 'Jane Doe')->first()->clients()->get();
+
+        $this->assertInstanceOf('Illuminate\Database\Eloquent\Collection', $otherClient);
+        $this->assertInstanceOf('Client', $otherClient[0]);
+        $this->assertCount(1, $otherClient);
+
+        // Now attach an existing client to an existing user
+        $user = User::where('name', '=', 'Jane Doe')->first();
+        $client = Client::Where('name', '=', 'Buffet Bar Inc.')->first();
+
+        // Check the models are what they should be
+        $this->assertInstanceOf('Client', $client);
+        $this->assertInstanceOf('User', $user);
+
+        // Assert they are not attached
+        $this->assertFalse(in_array($client->_id, $user->client_ids));
+        $this->assertFalse(in_array($user->_id, $client->user_ids));
+
+        // Attach the client to the user
+        $user->clients()->attach($client);
+
+        // Get the new user model
+        $user = User::where('name', '=', 'Jane Doe')->first();
+        $client = Client::Where('name', '=', 'Buffet Bar Inc.')->first();
+
+        // Assert they are attached
+        $this->assertTrue(in_array($client->_id, $user->client_ids));
+        $this->assertTrue(in_array($user->_id, $client->user_ids));
+    }
+
+    public function testHasManyAndBelongsToAttachesExistingModels()
+    {
+        $user = User::create(array('name' => 'John Doe', 'client_ids' => array('1234523')));
+
+        $clients = array(
+            Client::create(array('name' => 'Pork Pies Ltd.'))->_id,
+            Client::create(array('name' => 'Buffet Bar Inc.'))->_id
+        );
+
+        $moreClients = array(
+            Client::create(array('name' => 'Boloni Ltd.'))->_id,
+            Client::create(array('name' => 'Meatballs Inc.'))->_id
+        );
+
+        // Sync multiple records
+        $user->clients()->sync($clients);
+
+        $user = User::with('clients')->find($user->_id);
+
+        // Assert non attached ID's are detached succesfully
+        $this->assertFalse(in_array('1234523', $user->client_ids));
+
+        // Assert there are two client objects in the relationship
+        $this->assertCount(2, $user->clients);
+
+        $user->clients()->sync($moreClients);
+
+        $user = User::with('clients')->find($user->_id);
+
+        // Assert there are now 4 client objects in the relationship
+        $this->assertCount(4, $user->clients);
     }
-	
-	public function testHasManyAndBelongsTo()
-	{
-		$user = User::create(array('name' => 'John Doe'));
-		
-		$user->clients()->save(new Client(array('name' => 'Pork Pies Ltd.')));
-		$user->clients()->create(array('name' => 'Buffet Bar Inc.'));
-		
-		$user = User::with('clients')->find($user->_id);
-		
-		$client = Client::with('users')->first();
-		
-		$clients = $client->getRelation('users');
-		$users = $user->getRelation('clients');
-		
-		$this->assertInstanceOf('Illuminate\Database\Eloquent\Collection', $users);
-		$this->assertInstanceOf('Illuminate\Database\Eloquent\Collection', $clients);
-		$this->assertInstanceOf('Client', $users[0]);
-		$this->assertInstanceOf('User', $clients[0]);
-		$this->assertCount(2, $user->clients);
-		$this->assertCount(1, $client->users);
-		
-		// Now create a new user to an existing client
-		$client->users()->create(array('name' => 'Jane Doe'));
-		
-		$otherClient = User::where('name', '=', 'Jane Doe')->first()->clients()->get();
-		
-		$this->assertInstanceOf('Illuminate\Database\Eloquent\Collection', $otherClient);
-		$this->assertInstanceOf('Client', $otherClient[0]);
-		$this->assertCount(1, $otherClient);
-		
-		// Now attach an existing client to an existing user
-		$user = User::where('name', '=', 'Jane Doe')->first();
-		$client = Client::Where('name', '=', 'Buffet Bar Inc.')->first();
-		
-		// Check the models are what they should be
-		$this->assertInstanceOf('Client', $client);
-		$this->assertInstanceOf('User', $user);
-		
-		// Assert they are not attached
-		$this->assertFalse(in_array($client->_id, $user->client_ids));
-		$this->assertFalse(in_array($user->_id, $client->user_ids));
-
-		// Attach the client to the user
-		$user->clients()->attach($client);
-		
-		// Get the new user model
-		$user = User::where('name', '=', 'Jane Doe')->first();
-		$client = Client::Where('name', '=', 'Buffet Bar Inc.')->first();
-
-		// Assert they are attached
-		$this->assertTrue(in_array($client->_id, $user->client_ids));
-		$this->assertTrue(in_array($user->_id, $client->user_ids));
-	}
-
-	public function testHasManyAndBelongsToAttachesExistingModels()
-	{
-		$user = User::create(array('name' => 'John Doe', 'client_ids' => array('1234523')));
-		
-		$clients = array(
-			Client::create(array('name' => 'Pork Pies Ltd.'))->_id,
-			Client::create(array('name' => 'Buffet Bar Inc.'))->_id
-		);
-		
-		$moreClients = array(
-			Client::create(array('name' => 'Boloni Ltd.'))->_id,
-			Client::create(array('name' => 'Meatballs Inc.'))->_id
-		);
-		
-		// Sync multiple records
-		$user->clients()->sync($clients);
-		
-		$user = User::with('clients')->find($user->_id);
-		
-		// Assert non attached ID's are detached succesfully
-		$this->assertFalse(in_array('1234523', $user->client_ids));
-		
-		// Assert there are two client objects in the relationship
-		$this->assertCount(2, $user->clients);
-		
-		$user->clients()->sync($moreClients);
-		
-		$user = User::with('clients')->find($user->_id);
-		
-		// Assert there are now 4 client objects in the relationship
-		$this->assertCount(4, $user->clients);
-	}
 }