Fix MorphTo bug

src/Jenssegers/Eloquent/Model.php

@@ -7,6 +7,7 @@ use Illuminate\Database\Eloquent\Relations\MorphMany;
 use Illuminate\Database\Eloquent\Relations\Relation;
 use Jenssegers\Mongodb\Relations\BelongsTo;
 use Jenssegers\Mongodb\Relations\BelongsToMany;
+use Jenssegers\Mongodb\Relations\MorphTo;
 use Jenssegers\Mongodb\Query\Builder as QueryBuilder;
 
 abstract class Model extends \Illuminate\Database\Eloquent\Model {
@@ -169,6 +170,51 @@ abstract class Model extends \Illuminate\Database\Eloquent\Model {
         return new BelongsTo($query, $this, $foreignKey, $otherKey, $relation);
     }
 
+    /**
+     * Define a polymorphic, inverse one-to-one or many relationship.
+     *
+     * @param  string  $name
+     * @param  string  $type
+     * @param  string  $id
+     * @return \Illuminate\Database\Eloquent\Relations\MorphTo
+     */
+    public function morphTo($name = null, $type = null, $id = null)
+    {
+        // If no name is provided, we will use the backtrace to get the function name
+        // since that is most likely the name of the polymorphic interface. We can
+        // use that to get both the class and foreign key that will be utilized.
+        if (is_null($name))
+        {
+            list(, $caller) = debug_backtrace(false);
+
+            $name = snake_case($caller['function']);
+        }
+
+        list($type, $id) = $this->getMorphs($name, $type, $id);
+
+        // If the type value is null it is probably safe to assume we're eager loading
+        // the relationship. When that is the case we will pass in a dummy query as
+        // there are multiple types in the morph and we can't use single queries.
+        if (is_null($class = $this->$type))
+        {
+            return new MorphTo(
+                $this->newQuery(), $this, $id, null, $type, $name
+            );
+        }
+
+        // If we are not eager loading the relatinship, we will essentially treat this
+        // as a belongs-to style relationship since morph-to extends that class and
+        // we will pass in the appropriate values so that it behaves as expected.
+        else
+        {
+            $instance = new $class;
+
+            return new MorphTo(
+                with($instance)->newQuery(), $this, $id, $instance->getKeyName(), $type, $name
+            );
+        }
+    }
+
     /**
      * Define a many-to-many relationship.
      *

src/Jenssegers/Mongodb/Relations/MorphTo.php

+<?php namespace Jenssegers\Mongodb\Relations;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Support\Collection as BaseCollection;
+
+class MorphTo extends BelongsTo {
+
+	/**
+	 * The type of the polymorphic relation.
+	 *
+	 * @var string
+	 */
+	protected $morphType;
+
+	/**
+	 * The models whose relations are being eager loaded.
+	 *
+	 * @var \Illuminate\Database\Eloquent\Collection
+	 */
+	protected $models;
+
+	/**
+	 * All of the models keyed by ID.
+	 *
+	 * @var array
+	 */
+	protected $dictionary = array();
+
+	/**
+	 * Create a new belongs to relationship instance.
+	 *
+	 * @param  \Illuminate\Database\Eloquent\Builder  $query
+	 * @param  \Illuminate\Database\Eloquent\Model  $parent
+	 * @param  string  $foreignKey
+	 * @param  string  $otherKey
+	 * @param  string  $type
+	 * @param  string  $relation
+	 * @return void
+	 */
+	public function __construct(Builder $query, Model $parent, $foreignKey, $otherKey, $type, $relation)
+	{
+		$this->morphType = $type;
+
+		parent::__construct($query, $parent, $foreignKey, $otherKey, $relation);
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array  $models
+	 * @return void
+	 */
+	public function addEagerConstraints(array $models)
+	{
+		$this->buildDictionary($this->models = Collection::make($models));
+	}
+
+	/**
+	 * Buiild a dictionary with the models.
+	 *
+	 * @param  \Illuminate\Database\Eloquent\Models  $models
+	 * @return void
+	 */
+	protected function buildDictionary(Collection $models)
+	{
+		foreach ($models as $model)
+		{
+			if ($model->{$this->morphType})
+			{
+				$this->dictionary[$model->{$this->morphType}][$model->{$this->foreignKey}][] = $model;
+			}
+		}
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array   $models
+	 * @param  \Illuminate\Database\Eloquent\Collection  $results
+	 * @param  string  $relation
+	 * @return array
+	 */
+	public function match(array $models, Collection $results, $relation)
+	{
+		return $models;
+	}
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * Called via eager load method of Eloquent query builder.
+	 *
+	 * @return mixed
+	 */
+	public function getEager()
+	{
+		foreach (array_keys($this->dictionary) as $type)
+		{
+			$this->matchToMorphParents($type, $this->getResultsByType($type));
+		}
+
+		return $this->models;
+	}
+
+	/**
+	 * Match the results for a given type to their parents.
+	 *
+	 * @param  string  $type
+	 * @param  \Illuminate\Database\Eloquent\Collection  $results
+	 * @return void
+	 */
+	protected function matchToMorphParents($type, Collection $results)
+	{
+		foreach ($results as $result)
+		{
+			if (isset($this->dictionary[$type][$result->getKey()]))
+			{
+				foreach ($this->dictionary[$type][$result->getKey()] as $model)
+				{
+					$model->setRelation($this->relation, $result);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Get all of the relation results for a type.
+	 *
+	 * @param  string  $type
+	 * @return \Illuminate\Database\Eloquent\Collection
+	 */
+	protected function getResultsByType($type)
+	{
+		$instance = $this->createModelByType($type);
+
+		$key = $instance->getKeyName();
+
+		return $instance->whereIn($key, $this->gatherKeysByType($type)->all())->get();
+	}
+
+	/**
+	 * Gather all of the foreign keys for a given type.
+	 *
+	 * @param  string  $type
+	 * @return array
+	 */
+	protected function gatherKeysByType($type)
+	{
+		$foreign = $this->foreignKey;
+
+		return BaseCollection::make($this->dictionary[$type])->map(function($models) use ($foreign)
+		{
+			return head($models)->{$foreign};
+
+		})->unique();
+	}
+
+	/**
+	 * Create a new model instance by type.
+	 *
+	 * @param  string  $type
+	 * @return \Illuminate\Database\Eloquent\Model
+	 */
+	public function createModelByType($type)
+	{
+		return new $type;
+	}
+
+	/**
+	 * Get the dictionary used by the relationship.
+	 *
+	 * @return array
+	 */
+	public function getDictionary()
+	{
+		return $this->dictionary;
+	}
+
+}

tests/RelationsTest.php

@@ -274,8 +274,17 @@ class RelationsTest extends PHPUnit_Framework_TestCase {
         $this->assertEquals(1, $user->photos->count());
         $this->assertEquals($photo->id, $user->photos->first()->id);
 
+        $user = User::find($user->_id);
+        $this->assertEquals(1, $user->photos->count());
+        $this->assertEquals($photo->id, $user->photos->first()->id);
+
         $photo = Photo::create(array('url' => 'http://graph.facebook.com/john.doe/picture'));
         $client->photos()->save($photo);
+
+        $this->assertEquals(1, $client->photos->count());
+        $this->assertEquals($photo->id, $client->photos->first()->id);
+
+        $client = Client::find($client->_id);
         $this->assertEquals(1, $client->photos->count());
         $this->assertEquals($photo->id, $client->photos->first()->id);