analogueorm / analogue

src/Relationships/MorphTo.php

Spacing +1 added lines, -1 removed lines

@@ -163,7 +163,7 @@
     {
         $foreign = $this->foreignKey;
 
-        return BaseCollection::make($this->dictionary[$type])->map(function ($entities) use ($foreign) {
+        return BaseCollection::make($this->dictionary[$type])->map(function($entities) use ($foreign) {
             return head($entities)->{$foreign};
 
         })->unique();

Indentation +212 added lines, -212 removed lines

@@ -8,216 +8,216 @@
 
 class MorphTo extends BelongsTo
 {
-    /**
-     * The type of the polymorphic relation.
-     *
-     * @var string
-     */
-    protected $morphType;
-
-    /**
-     * The entities whose relations are being eager loaded.
-     *
-     * @var EntityCollection
-     */
-    protected $entities;
-
-    /**
-     * All of the models keyed by ID.
-     *
-     * @var array
-     */
-    protected $dictionary = [];
-
-    /**
-     * Indicates if soft-deleted model instances should be fetched.
-     *
-     * @var bool
-     */
-    protected $withTrashed = false;
-
-    /**
-     * Indicate if the parent entity hold the key for the relation.
-     *
-     * @var boolean
-     */
-    protected static $ownForeignKey = true;
-
-    /**
-     * Create a new belongs to relationship instance.
-     *
-     * @param Mapper                 $mapper
-     * @param \Analogue\ORM\Mappable $parent
-     * @param string                 $foreignKey
-     * @param string                 $otherKey
-     * @param string                 $type
-     * @param string                 $relation
-     */
-    public function __construct(Mapper $mapper, $parent, $foreignKey, $otherKey, $type, $relation)
-    {
-        $this->morphType = $type;
-
-        parent::__construct($mapper, $parent, $foreignKey, $otherKey, $relation);
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    public function addEagerConstraints(array $entities)
-    {
-        $this->buildDictionary($this->entities = EntityCollection::make($entities));
-    }
-
-    /**
-     * Build a dictionary with the entities
-     *
-     * @param  EntityCollection $entities
-     * @return void
-     */
-    protected function buildDictionary(EntityCollection $entities)
-    {
-        foreach ($entities as $entity) {
-            if ($entity->getEntityAttribute($this->morphType)) {
-                $this->dictionary[$entity->getEntityAttribute($this->morphType)][$entity->getEntityAttribute($this->foreignKey)][] = $entity;
-            }
-        }
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    public function match(array $entities, EntityCollection $results, $relation)
-    {
-        return $entities;
-    }
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     * @return EntityCollection
-     */
-    public function getEager()
-    {
-        foreach (array_keys($this->dictionary) as $type) {
-            $this->matchToMorphParents($type, $this->getResultsByType($type));
-        }
-
-        return $this->entities;
-    }
-
-    /**
-     * Match the results for a given type to their parents.
-     *
-     * @param  string           $type
-     * @param  EntityCollection $results
-     * @return void
-     */
-    protected function matchToMorphParents($type, EntityCollection $results)
-    {
-        $mapper = $this->relatedMapper->getManager()->mapper($type);
-        $keyName = $mapper->getEntityMap()->getKeyName();
-
-        foreach ($results as $result) {
-            $key = $result->{$keyName};
-
-            if (isset($this->dictionary[$type][$key])) {
-                foreach ($this->dictionary[$type][$key] as $entity) {
-                    $entity->setEntityAttribute($this->relation, $result);
-                }
-            }
-        }
-    }
-
-    /**
-     * Get all of the relation results for a type.
-     *
-     * @param  string $type
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     * @return EntityCollection
-     */
-    protected function getResultsByType($type)
-    {
-        $mapper = $this->relatedMapper->getManager()->mapper($type);
-
-        $key = $mapper->getEntityMap()->getKeyName();
-
-        $query = $mapper->getQuery();
-
-        return $query->whereIn($key, $this->gatherKeysByType($type)->all())->get();
-    }
-
-    /**
-     * Gather all of the foreign keys for a given type.
-     *
-     * @param  string $type
-     * @return BaseCollection
-     */
-    protected function gatherKeysByType($type)
-    {
-        $foreign = $this->foreignKey;
-
-        return BaseCollection::make($this->dictionary[$type])->map(function ($entities) use ($foreign) {
-            return head($entities)->{$foreign};
-
-        })->unique();
-    }
-
-    /**
-     * Associate the model instance to the given parent.
-     *
-     * @param  mixed $entity
-     * @return void
-     */
-    public function associate($entity)
-    {
-        // The Mapper will retrieve this association within the object model, we won't be using
-        // the foreign key attribute inside the parent Entity.
-        //
-        //$this->parent->setEntityAttribute($this->foreignKey, $entity->getEntityAttribute($this->otherKey));
-        //
-        // Instead, we'll just add the object to the Entity's attribute
-
-        $this->parent->setEntityAttribute($this->relation, $entity);
-    }
-
-    /**
-     * Get the foreign key value pair for a related object
-     *
-     * @var mixed $related
-     *
-     * @return array
-     */
-    public function getForeignKeyValuePair($related)
-    {
-        $foreignKey = $this->getForeignKey();
-
-        if ($related) {
-            $wrapper = $this->factory->make($related);
-
-            $relatedKey = $this->relatedMap->getKeyName();
-
-            return [$foreignKey => $wrapper->getEntityAttribute($relatedKey)];
-        } else {
-            return [$foreignKey => null];
-        }
-    }
-
-    /**
-     * Get the dictionary used by the relationship.
-     *
-     * @return array
-     */
-    public function getDictionary()
-    {
-        return $this->dictionary;
-    }
+	/**
+	 * The type of the polymorphic relation.
+	 *
+	 * @var string
+	 */
+	protected $morphType;
+
+	/**
+	 * The entities whose relations are being eager loaded.
+	 *
+	 * @var EntityCollection
+	 */
+	protected $entities;
+
+	/**
+	 * All of the models keyed by ID.
+	 *
+	 * @var array
+	 */
+	protected $dictionary = [];
+
+	/**
+	 * Indicates if soft-deleted model instances should be fetched.
+	 *
+	 * @var bool
+	 */
+	protected $withTrashed = false;
+
+	/**
+	 * Indicate if the parent entity hold the key for the relation.
+	 *
+	 * @var boolean
+	 */
+	protected static $ownForeignKey = true;
+
+	/**
+	 * Create a new belongs to relationship instance.
+	 *
+	 * @param Mapper                 $mapper
+	 * @param \Analogue\ORM\Mappable $parent
+	 * @param string                 $foreignKey
+	 * @param string                 $otherKey
+	 * @param string                 $type
+	 * @param string                 $relation
+	 */
+	public function __construct(Mapper $mapper, $parent, $foreignKey, $otherKey, $type, $relation)
+	{
+		$this->morphType = $type;
+
+		parent::__construct($mapper, $parent, $foreignKey, $otherKey, $relation);
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	public function addEagerConstraints(array $entities)
+	{
+		$this->buildDictionary($this->entities = EntityCollection::make($entities));
+	}
+
+	/**
+	 * Build a dictionary with the entities
+	 *
+	 * @param  EntityCollection $entities
+	 * @return void
+	 */
+	protected function buildDictionary(EntityCollection $entities)
+	{
+		foreach ($entities as $entity) {
+			if ($entity->getEntityAttribute($this->morphType)) {
+				$this->dictionary[$entity->getEntityAttribute($this->morphType)][$entity->getEntityAttribute($this->foreignKey)][] = $entity;
+			}
+		}
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	public function match(array $entities, EntityCollection $results, $relation)
+	{
+		return $entities;
+	}
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 * @return EntityCollection
+	 */
+	public function getEager()
+	{
+		foreach (array_keys($this->dictionary) as $type) {
+			$this->matchToMorphParents($type, $this->getResultsByType($type));
+		}
+
+		return $this->entities;
+	}
+
+	/**
+	 * Match the results for a given type to their parents.
+	 *
+	 * @param  string           $type
+	 * @param  EntityCollection $results
+	 * @return void
+	 */
+	protected function matchToMorphParents($type, EntityCollection $results)
+	{
+		$mapper = $this->relatedMapper->getManager()->mapper($type);
+		$keyName = $mapper->getEntityMap()->getKeyName();
+
+		foreach ($results as $result) {
+			$key = $result->{$keyName};
+
+			if (isset($this->dictionary[$type][$key])) {
+				foreach ($this->dictionary[$type][$key] as $entity) {
+					$entity->setEntityAttribute($this->relation, $result);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Get all of the relation results for a type.
+	 *
+	 * @param  string $type
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 * @return EntityCollection
+	 */
+	protected function getResultsByType($type)
+	{
+		$mapper = $this->relatedMapper->getManager()->mapper($type);
+
+		$key = $mapper->getEntityMap()->getKeyName();
+
+		$query = $mapper->getQuery();
+
+		return $query->whereIn($key, $this->gatherKeysByType($type)->all())->get();
+	}
+
+	/**
+	 * Gather all of the foreign keys for a given type.
+	 *
+	 * @param  string $type
+	 * @return BaseCollection
+	 */
+	protected function gatherKeysByType($type)
+	{
+		$foreign = $this->foreignKey;
+
+		return BaseCollection::make($this->dictionary[$type])->map(function ($entities) use ($foreign) {
+			return head($entities)->{$foreign};
+
+		})->unique();
+	}
+
+	/**
+	 * Associate the model instance to the given parent.
+	 *
+	 * @param  mixed $entity
+	 * @return void
+	 */
+	public function associate($entity)
+	{
+		// The Mapper will retrieve this association within the object model, we won't be using
+		// the foreign key attribute inside the parent Entity.
+		//
+		//$this->parent->setEntityAttribute($this->foreignKey, $entity->getEntityAttribute($this->otherKey));
+		//
+		// Instead, we'll just add the object to the Entity's attribute
+
+		$this->parent->setEntityAttribute($this->relation, $entity);
+	}
+
+	/**
+	 * Get the foreign key value pair for a related object
+	 *
+	 * @var mixed $related
+	 *
+	 * @return array
+	 */
+	public function getForeignKeyValuePair($related)
+	{
+		$foreignKey = $this->getForeignKey();
+
+		if ($related) {
+			$wrapper = $this->factory->make($related);
+
+			$relatedKey = $this->relatedMap->getKeyName();
+
+			return [$foreignKey => $wrapper->getEntityAttribute($relatedKey)];
+		} else {
+			return [$foreignKey => null];
+		}
+	}
+
+	/**
+	 * Get the dictionary used by the relationship.
+	 *
+	 * @return array
+	 */
+	public function getDictionary()
+	{
+		return $this->dictionary;
+	}
 }

src/System/InternallyMappable.php

Indentation +30 added lines, -30 removed lines

@@ -3,38 +3,38 @@
 interface InternallyMappable
 {
 
-    /**
-     * Set the object attribute raw values (hydration)
-     *
-     * @param array $attributes
-     */
-    public function setEntityAttributes(array $attributes);
+	/**
+	 * Set the object attribute raw values (hydration)
+	 *
+	 * @param array $attributes
+	 */
+	public function setEntityAttributes(array $attributes);
 
-    /**
-     * Get the raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes();
+	/**
+	 * Get the raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes();
 
-    /**
-     * Set the raw entity attributes
-     * @param string $key
-     * @param string $value
-     */
-    public function setEntityAttribute($key, $value);
+	/**
+	 * Set the raw entity attributes
+	 * @param string $key
+	 * @param string $value
+	 */
+	public function setEntityAttribute($key, $value);
 
-    /**
-     * Return the entity's attribute
-     * @param  string $key
-     * @return mixed
-     */
-    public function getEntityAttribute($key);
+	/**
+	 * Return the entity's attribute
+	 * @param  string $key
+	 * @return mixed
+	 */
+	public function getEntityAttribute($key);
 
-    /**
-     * Does the entity posses the given attribute
-     * @param  string  $key
-     * @return boolean
-     */
-    public function hasAttribute($key);
+	/**
+	 * Does the entity posses the given attribute
+	 * @param  string  $key
+	 * @return boolean
+	 */
+	public function hasAttribute($key);
 }

src/AnalogueFacade.php

Indentation +9 added lines, -9 removed lines

@@ -8,13 +8,13 @@
 class AnalogueFacade extends Facade
 {
 
-    /**
-     * Get the registered name of the component.
-     *
-     * @return string
-     */
-    protected static function getFacadeAccessor()
-    {
-        return 'analogue';
-    }
+	/**
+	 * Get the registered name of the component.
+	 *
+	 * @return string
+	 */
+	protected static function getFacadeAccessor()
+	{
+		return 'analogue';
+	}
 }

src/Plugins/SoftDeletes/SoftDeletingScope.php

Spacing +2 added lines, -2 removed lines

@@ -73,7 +73,7 @@ 
      */
     protected function addWithTrashed(Query $query)
     {
-        $query->macro('withTrashed', function (Query $query) {
+        $query->macro('withTrashed', function(Query $query) {
             $this->remove($query);
 
             return $query;
@@ -88,7 +88,7 @@ 
      */
     protected function addOnlyTrashed(Query $query)
     {
-        $query->macro('onlyTrashed', function (Query $query) {
+        $query->macro('onlyTrashed', function(Query $query) {
             $this->remove($query);
 
             $query->getQuery()->whereNotNull($query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn());

Doc Comments +1 added lines, -1 removed lines

@@ -32,7 +32,7 @@
     /**
      * Remove the scope from the given Analogue query builder.
      *
-     * @param  mixed $query
+     * @param  Query $query
      * @return void
      */
     public function remove(Query $query)

Indentation +102 added lines, -102 removed lines

@@ -7,106 +7,106 @@
 
 class SoftDeletingScope implements ScopeInterface
 {
-    /**
-     * All of the extensions to be added to the builder.
-     *
-     * @var array
-     */
-    protected $extensions = ['WithTrashed', 'OnlyTrashed'];
-
-    /**
-     * Apply the scope to a given Analogue query builder.
-     *
-     * @param  \Analogue\ORM\System\Query $query
-     * @return void
-     */
-    public function apply(Query $query)
-    {
-        $entityMap = $query->getMapper()->getEntityMap();
-
-        $query->whereNull($entityMap->getQualifiedDeletedAtColumn());
-
-        $this->extend($query);
-    }
-
-    /**
-     * Remove the scope from the given Analogue query builder.
-     *
-     * @param  mixed $query
-     * @return void
-     */
-    public function remove(Query $query)
-    {
-        $column = $query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn();
-
-        $query = $query->getQuery();
-
-        foreach ((array) $query->wheres as $key => $where) {
-            // If the where clause is a soft delete date constraint, we will remove it from
-            // the query and reset the keys on the wheres. This allows this developer to
-            // include deleted model in a relationship result set that is lazy loaded.
-            if ($this->isSoftDeleteConstraint($where, $column)) {
-                unset($query->wheres[$key]);
-
-                $query->wheres = array_values($query->wheres);
-            }
-        }
-    }
-
-    /**
-     * Extend the query builder with the needed functions.
-     *
-     * @param  \Analogue\ORM\System\Query $query
-     * @return void
-     */
-    public function extend(Query $query)
-    {
-        foreach ($this->extensions as $extension) {
-            $this->{"add{$extension}"}($query);
-        }
-    }
-
-    /**
-     * Add the with-trashed extension to the builder.
-     *
-     * @param  \Analogue\ORM\System\Query $query
-     * @return void
-     */
-    protected function addWithTrashed(Query $query)
-    {
-        $query->macro('withTrashed', function (Query $query) {
-            $this->remove($query);
-
-            return $query;
-        });
-    }
-
-    /**
-     * Add the only-trashed extension to the builder.
-     *
-     * @param  \Analogue\ORM\System\Query $query
-     * @return void
-     */
-    protected function addOnlyTrashed(Query $query)
-    {
-        $query->macro('onlyTrashed', function (Query $query) {
-            $this->remove($query);
-
-            $query->getQuery()->whereNotNull($query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn());
-
-            return $query;
-        });
-    }
-
-    /**
-     * Determine if the given where clause is a soft delete constraint.
-     *
-     * @param  array  $where
-     * @param  string $column
-     * @return bool
-     */
-    protected function isSoftDeleteConstraint(array $where, $column)
-    {
-        return $where['type'] == 'Null' && $where['column'] == $column;
-    }
+	/**
+	 * All of the extensions to be added to the builder.
+	 *
+	 * @var array
+	 */
+	protected $extensions = ['WithTrashed', 'OnlyTrashed'];
+
+	/**
+	 * Apply the scope to a given Analogue query builder.
+	 *
+	 * @param  \Analogue\ORM\System\Query $query
+	 * @return void
+	 */
+	public function apply(Query $query)
+	{
+		$entityMap = $query->getMapper()->getEntityMap();
+
+		$query->whereNull($entityMap->getQualifiedDeletedAtColumn());
+
+		$this->extend($query);
+	}
+
+	/**
+	 * Remove the scope from the given Analogue query builder.
+	 *
+	 * @param  mixed $query
+	 * @return void
+	 */
+	public function remove(Query $query)
+	{
+		$column = $query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn();
+
+		$query = $query->getQuery();
+
+		foreach ((array) $query->wheres as $key => $where) {
+			// If the where clause is a soft delete date constraint, we will remove it from
+			// the query and reset the keys on the wheres. This allows this developer to
+			// include deleted model in a relationship result set that is lazy loaded.
+			if ($this->isSoftDeleteConstraint($where, $column)) {
+				unset($query->wheres[$key]);
+
+				$query->wheres = array_values($query->wheres);
+			}
+		}
+	}
+
+	/**
+	 * Extend the query builder with the needed functions.
+	 *
+	 * @param  \Analogue\ORM\System\Query $query
+	 * @return void
+	 */
+	public function extend(Query $query)
+	{
+		foreach ($this->extensions as $extension) {
+			$this->{"add{$extension}"}($query);
+		}
+	}
+
+	/**
+	 * Add the with-trashed extension to the builder.
+	 *
+	 * @param  \Analogue\ORM\System\Query $query
+	 * @return void
+	 */
+	protected function addWithTrashed(Query $query)
+	{
+		$query->macro('withTrashed', function (Query $query) {
+			$this->remove($query);
+
+			return $query;
+		});
+	}
+
+	/**
+	 * Add the only-trashed extension to the builder.
+	 *
+	 * @param  \Analogue\ORM\System\Query $query
+	 * @return void
+	 */
+	protected function addOnlyTrashed(Query $query)
+	{
+		$query->macro('onlyTrashed', function (Query $query) {
+			$this->remove($query);
+
+			$query->getQuery()->whereNotNull($query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn());
+
+			return $query;
+		});
+	}
+
+	/**
+	 * Determine if the given where clause is a soft delete constraint.
+	 *
+	 * @param  array  $where
+	 * @param  string $column
+	 * @return bool
+	 */
+	protected function isSoftDeleteConstraint(array $where, $column)
+	{
+		return $where['type'] == 'Null' && $where['column'] == $column;
+	}
 }

src/Plugins/AnaloguePluginInterface.php

Indentation +12 added lines, -12 removed lines

@@ -3,17 +3,17 @@
 interface AnaloguePluginInterface
 {
 
-    /**
-     * Boot the plugin
-     *
-     * @return void
-     */
-    public function register();
+	/**
+	 * Boot the plugin
+	 *
+	 * @return void
+	 */
+	public function register();
 
-    /**
-     * Get custom events provided by the plugin
-     *
-     * @return array
-     */
-    public function getCustomEvents();
+	/**
+	 * Get custom events provided by the plugin
+	 *
+	 * @return array
+	 */
+	public function getCustomEvents();
 }

src/AnalogueServiceProvider.php

Indentation +38 added lines, -38 removed lines

@@ -12,53 +12,53 @@
 class AnalogueServiceProvider extends ServiceProvider
 {
 
-    /**
-     * Indicates if loading of the provider is deferred.
-     *
-     * @var bool
-     */
-    protected $defer = false;
+	/**
+	 * Indicates if loading of the provider is deferred.
+	 *
+	 * @var bool
+	 */
+	protected $defer = false;
 
-    public function boot()
-    {
-        $manager = $this->app->make('analogue');
+	public function boot()
+	{
+		$manager = $this->app->make('analogue');
 
-        $manager->registerPlugin('Analogue\ORM\Plugins\Timestamps\TimestampsPlugin');
-        $manager->registerPlugin('Analogue\ORM\Plugins\SoftDeletes\SoftDeletesPlugin');
-    }
+		$manager->registerPlugin('Analogue\ORM\Plugins\Timestamps\TimestampsPlugin');
+		$manager->registerPlugin('Analogue\ORM\Plugins\SoftDeletes\SoftDeletesPlugin');
+	}
 
-    /**
-     * Register the service provider.
-     *
-     * @return void
-     */
-    public function register()
-    {
-        $this->app->singleton('analogue', function ($app) {
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->app->singleton('analogue', function ($app) {
 
-            $db = $app['db'];
+			$db = $app['db'];
 
-            $connectionProvider = new IlluminateConnectionProvider($db);
+			$connectionProvider = new IlluminateConnectionProvider($db);
 
-            $illuminate = new IlluminateDriver($connectionProvider);
+			$illuminate = new IlluminateDriver($connectionProvider);
 
-            $driverManager = new DriverManager;
+			$driverManager = new DriverManager;
 
-            $driverManager->addDriver($illuminate);
+			$driverManager->addDriver($illuminate);
 
-            $event = $app->make('events');
+			$event = $app->make('events');
 
-            return new Manager($driverManager, $event);
-        });
-    }
+			return new Manager($driverManager, $event);
+		});
+	}
     
-    /**
-     * Get the services provided by the provider.
-     *
-     * @return array
-     */
-    public function provides()
-    {
-        return ['analogue'];
-    }
+	/**
+	 * Get the services provided by the provider.
+	 *
+	 * @return array
+	 */
+	public function provides()
+	{
+		return ['analogue'];
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -34,7 +34,7 @@
      */
     public function register()
     {
-        $this->app->singleton('analogue', function ($app) {
+        $this->app->singleton('analogue', function($app) {
 
             $db = $app['db'];
 

src/Relationships/BelongsToMany.php

Doc Comments +1 added lines

@@ -383,6 +383,7 @@
      * Set the join clause for the relation query.
      *
      * @param  \Analogue\ORM\Query|null
+     * @param Query $query
      * @return $this
      */
     protected function setJoin($query = null)

Spacing +10 added lines, -10 removed lines

@@ -145,7 +145,7 @@ 
      */
     public function wherePivot($column, $operator = null, $value = null, $boolean = 'and')
     {
-        return $this->where($this->table . '.' . $column, $operator, $value, $boolean);
+        return $this->where($this->table.'.'.$column, $operator, $value, $boolean);
     }
 
     /**
@@ -326,11 +326,11 @@ 
 
         $tablePrefix = $this->query->getQuery()->getConnection()->getTablePrefix();
 
-        $query->from($this->table . ' as ' . $tablePrefix . $hash = $this->getRelationCountHash());
+        $query->from($this->table.' as '.$tablePrefix.$hash = $this->getRelationCountHash());
 
         $key = $this->wrap($this->getQualifiedParentKeyName());
 
-        return $query->where($hash . '.' . $this->foreignKey, '=', new Expression($key));
+        return $query->where($hash.'.'.$this->foreignKey, '=', new Expression($key));
     }
 
     /**
@@ -340,7 +340,7 @@ 
      */
     public function getRelationCountHash()
     {
-        return 'self_' . md5(microtime(true));
+        return 'self_'.md5(microtime(true));
     }
 
     /**
@@ -352,7 +352,7 @@ 
     protected function getSelectColumns(array $columns = ['*'])
     {
         if ($columns == ['*']) {
-            $columns = [$this->relatedMap->getTable() . '.*'];
+            $columns = [$this->relatedMap->getTable().'.*'];
         }
 
         return array_merge($columns, $this->getAliasedPivotColumns());
@@ -373,7 +373,7 @@ 
         $columns = [];
 
         foreach (array_merge($defaults, $this->pivotColumns) as $column) {
-            $columns[] = $this->table . '.' . $column . ' as pivot_' . $column;
+            $columns[] = $this->table.'.'.$column.' as pivot_'.$column;
         }
 
         return array_unique($columns);
@@ -394,7 +394,7 @@ 
         // model instance. Then we can set the "where" for the parent models.
         $baseTable = $this->relatedMap->getTable();
 
-        $key = $baseTable . '.' . $this->relatedMap->getKeyName();
+        $key = $baseTable.'.'.$this->relatedMap->getKeyName();
 
         $query->join($this->table, $key, '=', $this->getOtherKey());
 
@@ -752,7 +752,7 @@ 
     {
         $keyName = $this->relatedMap->getKeyName();
 
-        return array_map(function ($m) use ($keyName) {
+        return array_map(function($m) use ($keyName) {
             return $m->$keyName;
         }, $entities);
     }
@@ -902,7 +902,7 @@ 
      */
     public function getForeignKey()
     {
-        return $this->table . '.' . $this->foreignKey;
+        return $this->table.'.'.$this->foreignKey;
     }
 
     /**
@@ -912,7 +912,7 @@ 
      */
     public function getOtherKey()
     {
-        return $this->table . '.' . $this->otherKey;
+        return $this->table.'.'.$this->otherKey;
     }
 
     /**

Indentation +927 added lines, -927 removed lines

@@ -12,936 +12,936 @@
 
 class BelongsToMany extends Relationship
 {
-    /**
-     * The intermediate table for the relation.
-     *
-     * @var string
-     */
-    protected $table;
-
-    /**
-     * The foreign key of the parent model.
-     *
-     * @var string
-     */
-    protected $foreignKey;
-
-    /**
-     * The associated key of the relation.
-     *
-     * @var string
-     */
-    protected $otherKey;
-
-    /**
-     * The "name" of the relationship.
-     *
-     * @var string
-     */
-    protected $relationName;
-
-    /**
-     * The pivot table columns to retrieve.
-     *
-     * @var array
-     */
-    protected $pivotColumns = [];
-
-    /**
-     * This relationship has pivot attributes
-     *
-     * @var boolean
-     */
-    protected static $hasPivot = true;
-
-    /**
-     * Create a new has many relationship instance.
-     *
-     * @param Mapper   $mapper
-     * @param Mappable $parent
-     * @param string   $table
-     * @param string   $foreignKey
-     * @param string   $otherKey
-     * @param string   $relationName
-     */
-    public function __construct(Mapper $mapper, $parent, $table, $foreignKey, $otherKey, $relationName = null)
-    {
-        $this->table = $table;
-        $this->otherKey = $otherKey;
-        $this->foreignKey = $foreignKey;
-        $this->relationName = $relationName;
-
-        parent::__construct($mapper, $parent);
-    }
-
-    /**
-     * @param  $related
-     * @return mixed
-     */
-    public function attachTo($related)
-    {
-    }
-
-    /**
-     * @param  $related
-     * @return mixed
-     */
-    public function detachFrom($related)
-    {
-        $ids = $this->getIdsFromHashes([$related]);
-
-        $this->detach($ids);
-    }
-
-    /**
-     * @param $related
-     */
-    public function detachMany($related)
-    {
-        $ids = $this->getIdsFromHashes($related);
-
-        $this->detach($ids);
-    }
-
-    /**
-     * @param array $hashes
-     * @return array
-     */
-    protected function getIdsFromHashes(array $hashes)
-    {
-        $ids = [];
-
-        foreach ($hashes as $hash) {
-            $split = explode('.', $hash);
-            $ids[] = $split[1];
-        }
-        return $ids;
-    }
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @param $relation
-     *
-     * @return EntityCollection
-     */
-    public function getResults($relation)
-    {
-        $results = $this->get();
-
-        $this->cacheRelation($results, $relation);
-
-        return $results;
-    }
-
-    /**
-     * Set a where clause for a pivot table column.
-     *
-     * @param  string $column
-     * @param  string $operator
-     * @param  mixed  $value
-     * @param  string $boolean
-     * @return self
-     */
-    public function wherePivot($column, $operator = null, $value = null, $boolean = 'and')
-    {
-        return $this->where($this->table . '.' . $column, $operator, $value, $boolean);
-    }
-
-    /**
-     * Set an or where clause for a pivot table column.
-     *
-     * @param  string $column
-     * @param  string $operator
-     * @param  mixed  $value
-     * @return self
-     */
-    public function orWherePivot($column, $operator = null, $value = null)
-    {
-        return $this->wherePivot($column, $operator, $value, 'or');
-    }
-
-    /**
-     * Return Pivot attributes when available on a relationship
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return $this->pivotColumns;
-    }
-
-    /**
-     * Execute the query and get the first result.
-     *
-     * @param  array $columns
-     * @return mixed
-     */
-    public function first($columns = ['*'])
-    {
-        $results = $this->take(1)->get($columns);
-
-        return count($results) > 0 ? $results->first() : null;
-    }
-
-    /**
-     * Execute the query and get the first result or throw an exception.
-     *
-     * @param  array $columns
-     *
-     * @throws EntityNotFoundException
-     *
-     * @return Mappable|self
-     */
-    public function firstOrFail($columns = ['*'])
-    {
-        if (!is_null($entity = $this->first($columns))) {
-            return $entity;
-        }
-
-        throw new EntityNotFoundException;
-    }
-
-    /**
-     * Execute the query as a "select" statement.
-     *
-     * @param  array $columns
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function get($columns = ['*'])
-    {
-        // 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.
-        $columns = $this->query->getQuery()->columns ? [] : $columns;
-
-        $select = $this->getSelectColumns($columns);
-
-        $entities = $this->query->addSelect($select)->getEntities();
-
-        $this->hydratePivotRelation($entities);
-
-        // 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($entities) > 0) {
-            $entities = $this->query->eagerLoadRelations($entities);
-        }
-
-        return $this->relatedMap->newCollection($entities);
-    }
-
-    /**
-     * Hydrate the pivot table relationship on the models.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    protected function hydratePivotRelation(array $entities)
-    {
-        // To hydrate the pivot relationship, we will just gather the pivot attributes
-        // and create a new Pivot model, which is basically a dynamic model that we
-        // will set the attributes, table, and connections on so it they be used.
-
-        foreach ($entities as $entity) {
-            $entityWrapper = $this->factory->make($entity);
-
-            $pivot = $this->newExistingPivot($this->cleanPivotAttributes($entityWrapper));
-
-            $entityWrapper->setEntityAttribute('pivot', $pivot);
-        }
-    }
-
-    /**
-     * Get the pivot attributes from a model.
-     *
-     * @param  $entity
-     * @return array
-     */
-    protected function cleanPivotAttributes(InternallyMappable $entity)
-    {
-        $values = [];
-
-        $attributes = $entity->getEntityAttributes();
-
-        foreach ($attributes as $key => $value) {
-            // To get the pivots attributes we will just take any of the attributes which
-            // begin with "pivot_" and add those to this arrays, as well as unsetting
-            // them from the parent's models since they exist in a different table.
-            if (strpos($key, 'pivot_') === 0) {
-                $values[substr($key, 6)] = $value;
-
-                unset($attributes[$key]);
-            }
-        }
-
-        // Rehydrate Entity with cleaned array.
-        $entity->setEntityAttributes($attributes);
-
-        return $values;
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    public function addConstraints()
-    {
-        $this->setJoin();
-
-        if (static::$constraints) {
-            $this->setWhere();
-        }
-    }
-
-    /**
-     * Add the constraints for a relationship count query.
-     *
-     * @param  Query $query
-     * @param  Query $parent
-     * @return Query
-     */
-    public function getRelationCountQuery(Query $query, Query $parent)
-    {
-        if ($parent->getQuery()->from == $query->getQuery()->from) {
-            return $this->getRelationCountQueryForSelfJoin($query, $parent);
-        }
-
-        $this->setJoin($query);
-
-        return parent::getRelationCountQuery($query, $parent);
-    }
-
-    /**
-     * Add the constraints for a relationship count query on the same table.
-     *
-     * @param  Query $query
-     * @param  Query $parent
-     * @return Query
-     */
-    public function getRelationCountQueryForSelfJoin(Query $query, Query $parent)
-    {
-        $query->select(new Expression('count(*)'));
-
-        $tablePrefix = $this->query->getQuery()->getConnection()->getTablePrefix();
-
-        $query->from($this->table . ' as ' . $tablePrefix . $hash = $this->getRelationCountHash());
-
-        $key = $this->wrap($this->getQualifiedParentKeyName());
-
-        return $query->where($hash . '.' . $this->foreignKey, '=', new Expression($key));
-    }
-
-    /**
-     * Get a relationship join table hash.
-     *
-     * @return string
-     */
-    public function getRelationCountHash()
-    {
-        return 'self_' . md5(microtime(true));
-    }
-
-    /**
-     * Set the select clause for the relation query.
-     *
-     * @param  array $columns
-     * @return \Analogue\ORM\Relationships\BelongsToMany
-     */
-    protected function getSelectColumns(array $columns = ['*'])
-    {
-        if ($columns == ['*']) {
-            $columns = [$this->relatedMap->getTable() . '.*'];
-        }
-
-        return array_merge($columns, $this->getAliasedPivotColumns());
-    }
-
-    /**
-     * Get the pivot columns for the relation.
-     *
-     * @return array
-     */
-    protected function getAliasedPivotColumns()
-    {
-        $defaults = [$this->foreignKey, $this->otherKey];
-
-        // We need to alias all of the pivot columns with the "pivot_" prefix so we
-        // can easily extract them out of the models and put them into the pivot
-        // relationships when they are retrieved and hydrated into the models.
-        $columns = [];
-
-        foreach (array_merge($defaults, $this->pivotColumns) as $column) {
-            $columns[] = $this->table . '.' . $column . ' as pivot_' . $column;
-        }
-
-        return array_unique($columns);
-    }
-
-    /**
-     * Set the join clause for the relation query.
-     *
-     * @param  \Analogue\ORM\Query|null
-     * @return $this
-     */
-    protected function setJoin($query = null)
-    {
-        $query = $query ?: $this->query;
-
-        // We need to join to the intermediate table on the related model's primary
-        // key column with the intermediate table's foreign key for the related
-        // model instance. Then we can set the "where" for the parent models.
-        $baseTable = $this->relatedMap->getTable();
-
-        $key = $baseTable . '.' . $this->relatedMap->getKeyName();
-
-        $query->join($this->table, $key, '=', $this->getOtherKey());
-
-        return $this;
-    }
-
-    /**
-     * Set the where clause for the relation query.
-     *
-     * @return $this
-     */
-    protected function setWhere()
-    {
-        $foreign = $this->getForeignKey();
-
-        $parentKey = $this->parentMap->getKeyName();
-
-        $this->query->where($foreign, '=', $this->parent->getEntityAttribute($parentKey));
-
-        return $this;
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    public function addEagerConstraints(array $entities)
-    {
-        $this->query->whereIn($this->getForeignKey(), $this->getKeys($entities));
-    }
-
-    /**
-     * Initialize the relation on a set of eneities.
-     *
-     * @param  array  $entities
-     * @param  string $relation
-     * @return array
-     */
-    public function initRelation(array $entities, $relation)
-    {
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-
-            $entity->setEntityAttribute($relation, $this->relatedMap->newCollection());
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    public function match(array $entities, EntityCollection $results, $relation)
-    {
-        $dictionary = $this->buildDictionary($results);
-
-        $keyName = $this->relatedMap->getKeyName();
-
-        $cache = $this->parentMapper->getEntityCache();
-
-        // Once we have an array dictionary of child objects we can easily match the
-        // children back to their parent using the dictionary and the keys on the
-        // the parent models. Then we will return the hydrated models back out.
-        foreach ($entities as $entity) {
-            $wrapper = $this->factory->make($entity);
-
-            if (isset($dictionary[$key = $wrapper->getEntityAttribute($keyName)])) {
-                $collection = $this->relatedMap->newCollection($dictionary[$key]);
-
-                $wrapper->setEntityAttribute($relation, $collection);
-
-                $cache->cacheLoadedRelationResult($entity, $relation, $collection, $this);
-            }
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Build model dictionary keyed by the relation's foreign key.
-     *
-     * @param  EntityCollection $results
-     * @return array
-     */
-    protected function buildDictionary(EntityCollection $results)
-    {
-        $foreign = $this->foreignKey;
-
-        // First we will build a dictionary of child models keyed by the foreign key
-        // of the relation so that we will easily and quickly match them to their
-        // parents without having a possibly slow inner loops for every models.
-        $dictionary = [];
-
-        foreach ($results as $entity) {
-            $wrapper = $this->factory->make($entity);
-
-            $dictionary[$wrapper->getEntityAttribute('pivot')->$foreign][] = $entity;
-        }
-
-        return $dictionary;
-    }
-
-    /**
-     * Get all of the IDs for the related models.
-     *
-     * @return array
-     */
-    public function getRelatedIds()
-    {
-        $fullKey = $this->relatedMap->getQualifiedKeyName();
-
-        return $this->getQuery()->select($fullKey)->lists($this->relatedMap->getKeyName());
-    }
-
-    /**
-     * Update Pivot
-     *
-     * @param  \Analogue\ORM\Entity $entity
-     * @return void
-     */
-    public function updatePivot($entity)
-    {
-        $keyName = $this->relatedMap->getKeyName();
-
-        $this->updateExistingPivot(
-            $entity->getEntityAttribute($keyName),
-            $entity->getEntityAttribute('pivot')->getEntityAttributes()
-        );
-    }
-
-    /**
-     * Update Multiple pivot
-     *
-     * @param  $relatedEntities
-     * @return void
-     */
-    public function updatePivots($relatedEntities)
-    {
-        foreach ($relatedEntities as $entity) {
-            $this->updatePivot($entity);
-        }
-    }
-
-    /**
-     * Create Pivot Records
-     *
-     * @param \Analogue\ORM\Entity[] $relatedEntities
-     * @return void
-     */
-    public function createPivots($relatedEntities)
-    {
-        $keys = [];
-        $attributes = [];
-
-        $keyName = $this->relatedMap->getKeyName();
-
-        foreach ($relatedEntities as $entity) {
-            $keys[] = $entity->getEntityAttribute($keyName);
-        }
-
-        $records = $this->createAttachRecords($keys, $attributes);
-
-        $this->query->getQuery()->from($this->table)->insert($records);
-    }
-
-    /**
-     * Update an existing pivot record on the table.
-     *
-     * @param  mixed $id
-     * @param  array $attributes
-     * @throws \InvalidArgumentException
-     * @return integer
-     */
-    public function updateExistingPivot($id, array $attributes)
-    {
-        if (in_array($this->updatedAt(), $this->pivotColumns)) {
-            $attributes = $this->setTimestampsOnAttach($attributes, true);
-        }
-
-        return $this->newPivotStatementForId($id)->update($attributes);
-    }
-
-    /**
-     * Attach a model to the parent.
-     *
-     * @param  mixed $id
-     * @param  array $attributes
-     * @return void
-     */
-    public function attach($id, array $attributes = [])
-    {
-        $query = $this->newPivotStatement();
-
-        $query->insert($this->createAttachRecords((array) $id, $attributes));
-    }
-
-    /**
-     * @param  array $entities
-     *
-     * @throws \InvalidArgumentException
-     */
-    public function sync(array $entities)
-    {
-        $this->detachExcept($entities);
-    }
-
-    /**
-     * Detach related entities that are not in $id
-     *
-     * @param  array $entities
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function detachExcept(array $entities = [])
-    {
-        $query = $this->newPivotQuery();
-
-        if (count($entities) > 0) {
-            $keys = $this->getKeys($entities);
-
-            $query->whereNotIn($this->otherKey, $keys);
-        }
-        $parentKey = $this->parentMap->getKeyName();
-
-        $query->where($this->foreignKey, '=', $this->parent->getEntityAttribute($parentKey));
+	/**
+	 * The intermediate table for the relation.
+	 *
+	 * @var string
+	 */
+	protected $table;
+
+	/**
+	 * The foreign key of the parent model.
+	 *
+	 * @var string
+	 */
+	protected $foreignKey;
+
+	/**
+	 * The associated key of the relation.
+	 *
+	 * @var string
+	 */
+	protected $otherKey;
+
+	/**
+	 * The "name" of the relationship.
+	 *
+	 * @var string
+	 */
+	protected $relationName;
+
+	/**
+	 * The pivot table columns to retrieve.
+	 *
+	 * @var array
+	 */
+	protected $pivotColumns = [];
+
+	/**
+	 * This relationship has pivot attributes
+	 *
+	 * @var boolean
+	 */
+	protected static $hasPivot = true;
+
+	/**
+	 * Create a new has many relationship instance.
+	 *
+	 * @param Mapper   $mapper
+	 * @param Mappable $parent
+	 * @param string   $table
+	 * @param string   $foreignKey
+	 * @param string   $otherKey
+	 * @param string   $relationName
+	 */
+	public function __construct(Mapper $mapper, $parent, $table, $foreignKey, $otherKey, $relationName = null)
+	{
+		$this->table = $table;
+		$this->otherKey = $otherKey;
+		$this->foreignKey = $foreignKey;
+		$this->relationName = $relationName;
+
+		parent::__construct($mapper, $parent);
+	}
+
+	/**
+	 * @param  $related
+	 * @return mixed
+	 */
+	public function attachTo($related)
+	{
+	}
+
+	/**
+	 * @param  $related
+	 * @return mixed
+	 */
+	public function detachFrom($related)
+	{
+		$ids = $this->getIdsFromHashes([$related]);
+
+		$this->detach($ids);
+	}
+
+	/**
+	 * @param $related
+	 */
+	public function detachMany($related)
+	{
+		$ids = $this->getIdsFromHashes($related);
+
+		$this->detach($ids);
+	}
+
+	/**
+	 * @param array $hashes
+	 * @return array
+	 */
+	protected function getIdsFromHashes(array $hashes)
+	{
+		$ids = [];
+
+		foreach ($hashes as $hash) {
+			$split = explode('.', $hash);
+			$ids[] = $split[1];
+		}
+		return $ids;
+	}
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param $relation
+	 *
+	 * @return EntityCollection
+	 */
+	public function getResults($relation)
+	{
+		$results = $this->get();
+
+		$this->cacheRelation($results, $relation);
+
+		return $results;
+	}
+
+	/**
+	 * Set a where clause for a pivot table column.
+	 *
+	 * @param  string $column
+	 * @param  string $operator
+	 * @param  mixed  $value
+	 * @param  string $boolean
+	 * @return self
+	 */
+	public function wherePivot($column, $operator = null, $value = null, $boolean = 'and')
+	{
+		return $this->where($this->table . '.' . $column, $operator, $value, $boolean);
+	}
+
+	/**
+	 * Set an or where clause for a pivot table column.
+	 *
+	 * @param  string $column
+	 * @param  string $operator
+	 * @param  mixed  $value
+	 * @return self
+	 */
+	public function orWherePivot($column, $operator = null, $value = null)
+	{
+		return $this->wherePivot($column, $operator, $value, 'or');
+	}
+
+	/**
+	 * Return Pivot attributes when available on a relationship
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return $this->pivotColumns;
+	}
+
+	/**
+	 * Execute the query and get the first result.
+	 *
+	 * @param  array $columns
+	 * @return mixed
+	 */
+	public function first($columns = ['*'])
+	{
+		$results = $this->take(1)->get($columns);
+
+		return count($results) > 0 ? $results->first() : null;
+	}
+
+	/**
+	 * Execute the query and get the first result or throw an exception.
+	 *
+	 * @param  array $columns
+	 *
+	 * @throws EntityNotFoundException
+	 *
+	 * @return Mappable|self
+	 */
+	public function firstOrFail($columns = ['*'])
+	{
+		if (!is_null($entity = $this->first($columns))) {
+			return $entity;
+		}
+
+		throw new EntityNotFoundException;
+	}
+
+	/**
+	 * Execute the query as a "select" statement.
+	 *
+	 * @param  array $columns
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function get($columns = ['*'])
+	{
+		// 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.
+		$columns = $this->query->getQuery()->columns ? [] : $columns;
+
+		$select = $this->getSelectColumns($columns);
+
+		$entities = $this->query->addSelect($select)->getEntities();
+
+		$this->hydratePivotRelation($entities);
+
+		// 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($entities) > 0) {
+			$entities = $this->query->eagerLoadRelations($entities);
+		}
+
+		return $this->relatedMap->newCollection($entities);
+	}
+
+	/**
+	 * Hydrate the pivot table relationship on the models.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	protected function hydratePivotRelation(array $entities)
+	{
+		// To hydrate the pivot relationship, we will just gather the pivot attributes
+		// and create a new Pivot model, which is basically a dynamic model that we
+		// will set the attributes, table, and connections on so it they be used.
+
+		foreach ($entities as $entity) {
+			$entityWrapper = $this->factory->make($entity);
+
+			$pivot = $this->newExistingPivot($this->cleanPivotAttributes($entityWrapper));
+
+			$entityWrapper->setEntityAttribute('pivot', $pivot);
+		}
+	}
+
+	/**
+	 * Get the pivot attributes from a model.
+	 *
+	 * @param  $entity
+	 * @return array
+	 */
+	protected function cleanPivotAttributes(InternallyMappable $entity)
+	{
+		$values = [];
+
+		$attributes = $entity->getEntityAttributes();
+
+		foreach ($attributes as $key => $value) {
+			// To get the pivots attributes we will just take any of the attributes which
+			// begin with "pivot_" and add those to this arrays, as well as unsetting
+			// them from the parent's models since they exist in a different table.
+			if (strpos($key, 'pivot_') === 0) {
+				$values[substr($key, 6)] = $value;
+
+				unset($attributes[$key]);
+			}
+		}
+
+		// Rehydrate Entity with cleaned array.
+		$entity->setEntityAttributes($attributes);
+
+		return $values;
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	public function addConstraints()
+	{
+		$this->setJoin();
+
+		if (static::$constraints) {
+			$this->setWhere();
+		}
+	}
+
+	/**
+	 * Add the constraints for a relationship count query.
+	 *
+	 * @param  Query $query
+	 * @param  Query $parent
+	 * @return Query
+	 */
+	public function getRelationCountQuery(Query $query, Query $parent)
+	{
+		if ($parent->getQuery()->from == $query->getQuery()->from) {
+			return $this->getRelationCountQueryForSelfJoin($query, $parent);
+		}
+
+		$this->setJoin($query);
+
+		return parent::getRelationCountQuery($query, $parent);
+	}
+
+	/**
+	 * Add the constraints for a relationship count query on the same table.
+	 *
+	 * @param  Query $query
+	 * @param  Query $parent
+	 * @return Query
+	 */
+	public function getRelationCountQueryForSelfJoin(Query $query, Query $parent)
+	{
+		$query->select(new Expression('count(*)'));
+
+		$tablePrefix = $this->query->getQuery()->getConnection()->getTablePrefix();
+
+		$query->from($this->table . ' as ' . $tablePrefix . $hash = $this->getRelationCountHash());
+
+		$key = $this->wrap($this->getQualifiedParentKeyName());
+
+		return $query->where($hash . '.' . $this->foreignKey, '=', new Expression($key));
+	}
+
+	/**
+	 * Get a relationship join table hash.
+	 *
+	 * @return string
+	 */
+	public function getRelationCountHash()
+	{
+		return 'self_' . md5(microtime(true));
+	}
+
+	/**
+	 * Set the select clause for the relation query.
+	 *
+	 * @param  array $columns
+	 * @return \Analogue\ORM\Relationships\BelongsToMany
+	 */
+	protected function getSelectColumns(array $columns = ['*'])
+	{
+		if ($columns == ['*']) {
+			$columns = [$this->relatedMap->getTable() . '.*'];
+		}
+
+		return array_merge($columns, $this->getAliasedPivotColumns());
+	}
+
+	/**
+	 * Get the pivot columns for the relation.
+	 *
+	 * @return array
+	 */
+	protected function getAliasedPivotColumns()
+	{
+		$defaults = [$this->foreignKey, $this->otherKey];
+
+		// We need to alias all of the pivot columns with the "pivot_" prefix so we
+		// can easily extract them out of the models and put them into the pivot
+		// relationships when they are retrieved and hydrated into the models.
+		$columns = [];
+
+		foreach (array_merge($defaults, $this->pivotColumns) as $column) {
+			$columns[] = $this->table . '.' . $column . ' as pivot_' . $column;
+		}
+
+		return array_unique($columns);
+	}
+
+	/**
+	 * Set the join clause for the relation query.
+	 *
+	 * @param  \Analogue\ORM\Query|null
+	 * @return $this
+	 */
+	protected function setJoin($query = null)
+	{
+		$query = $query ?: $this->query;
+
+		// We need to join to the intermediate table on the related model's primary
+		// key column with the intermediate table's foreign key for the related
+		// model instance. Then we can set the "where" for the parent models.
+		$baseTable = $this->relatedMap->getTable();
+
+		$key = $baseTable . '.' . $this->relatedMap->getKeyName();
+
+		$query->join($this->table, $key, '=', $this->getOtherKey());
+
+		return $this;
+	}
+
+	/**
+	 * Set the where clause for the relation query.
+	 *
+	 * @return $this
+	 */
+	protected function setWhere()
+	{
+		$foreign = $this->getForeignKey();
+
+		$parentKey = $this->parentMap->getKeyName();
+
+		$this->query->where($foreign, '=', $this->parent->getEntityAttribute($parentKey));
+
+		return $this;
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	public function addEagerConstraints(array $entities)
+	{
+		$this->query->whereIn($this->getForeignKey(), $this->getKeys($entities));
+	}
+
+	/**
+	 * Initialize the relation on a set of eneities.
+	 *
+	 * @param  array  $entities
+	 * @param  string $relation
+	 * @return array
+	 */
+	public function initRelation(array $entities, $relation)
+	{
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+
+			$entity->setEntityAttribute($relation, $this->relatedMap->newCollection());
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	public function match(array $entities, EntityCollection $results, $relation)
+	{
+		$dictionary = $this->buildDictionary($results);
+
+		$keyName = $this->relatedMap->getKeyName();
+
+		$cache = $this->parentMapper->getEntityCache();
+
+		// Once we have an array dictionary of child objects we can easily match the
+		// children back to their parent using the dictionary and the keys on the
+		// the parent models. Then we will return the hydrated models back out.
+		foreach ($entities as $entity) {
+			$wrapper = $this->factory->make($entity);
+
+			if (isset($dictionary[$key = $wrapper->getEntityAttribute($keyName)])) {
+				$collection = $this->relatedMap->newCollection($dictionary[$key]);
+
+				$wrapper->setEntityAttribute($relation, $collection);
+
+				$cache->cacheLoadedRelationResult($entity, $relation, $collection, $this);
+			}
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Build model dictionary keyed by the relation's foreign key.
+	 *
+	 * @param  EntityCollection $results
+	 * @return array
+	 */
+	protected function buildDictionary(EntityCollection $results)
+	{
+		$foreign = $this->foreignKey;
+
+		// First we will build a dictionary of child models keyed by the foreign key
+		// of the relation so that we will easily and quickly match them to their
+		// parents without having a possibly slow inner loops for every models.
+		$dictionary = [];
+
+		foreach ($results as $entity) {
+			$wrapper = $this->factory->make($entity);
+
+			$dictionary[$wrapper->getEntityAttribute('pivot')->$foreign][] = $entity;
+		}
+
+		return $dictionary;
+	}
+
+	/**
+	 * Get all of the IDs for the related models.
+	 *
+	 * @return array
+	 */
+	public function getRelatedIds()
+	{
+		$fullKey = $this->relatedMap->getQualifiedKeyName();
+
+		return $this->getQuery()->select($fullKey)->lists($this->relatedMap->getKeyName());
+	}
+
+	/**
+	 * Update Pivot
+	 *
+	 * @param  \Analogue\ORM\Entity $entity
+	 * @return void
+	 */
+	public function updatePivot($entity)
+	{
+		$keyName = $this->relatedMap->getKeyName();
+
+		$this->updateExistingPivot(
+			$entity->getEntityAttribute($keyName),
+			$entity->getEntityAttribute('pivot')->getEntityAttributes()
+		);
+	}
+
+	/**
+	 * Update Multiple pivot
+	 *
+	 * @param  $relatedEntities
+	 * @return void
+	 */
+	public function updatePivots($relatedEntities)
+	{
+		foreach ($relatedEntities as $entity) {
+			$this->updatePivot($entity);
+		}
+	}
+
+	/**
+	 * Create Pivot Records
+	 *
+	 * @param \Analogue\ORM\Entity[] $relatedEntities
+	 * @return void
+	 */
+	public function createPivots($relatedEntities)
+	{
+		$keys = [];
+		$attributes = [];
+
+		$keyName = $this->relatedMap->getKeyName();
+
+		foreach ($relatedEntities as $entity) {
+			$keys[] = $entity->getEntityAttribute($keyName);
+		}
+
+		$records = $this->createAttachRecords($keys, $attributes);
+
+		$this->query->getQuery()->from($this->table)->insert($records);
+	}
+
+	/**
+	 * Update an existing pivot record on the table.
+	 *
+	 * @param  mixed $id
+	 * @param  array $attributes
+	 * @throws \InvalidArgumentException
+	 * @return integer
+	 */
+	public function updateExistingPivot($id, array $attributes)
+	{
+		if (in_array($this->updatedAt(), $this->pivotColumns)) {
+			$attributes = $this->setTimestampsOnAttach($attributes, true);
+		}
+
+		return $this->newPivotStatementForId($id)->update($attributes);
+	}
+
+	/**
+	 * Attach a model to the parent.
+	 *
+	 * @param  mixed $id
+	 * @param  array $attributes
+	 * @return void
+	 */
+	public function attach($id, array $attributes = [])
+	{
+		$query = $this->newPivotStatement();
+
+		$query->insert($this->createAttachRecords((array) $id, $attributes));
+	}
+
+	/**
+	 * @param  array $entities
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function sync(array $entities)
+	{
+		$this->detachExcept($entities);
+	}
+
+	/**
+	 * Detach related entities that are not in $id
+	 *
+	 * @param  array $entities
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function detachExcept(array $entities = [])
+	{
+		$query = $this->newPivotQuery();
+
+		if (count($entities) > 0) {
+			$keys = $this->getKeys($entities);
+
+			$query->whereNotIn($this->otherKey, $keys);
+		}
+		$parentKey = $this->parentMap->getKeyName();
+
+		$query->where($this->foreignKey, '=', $this->parent->getEntityAttribute($parentKey));
         
-        $query->delete();
-
-        $query = $this->newPivotQuery();
-    }
-
-
-    /**
-     * Create an array of records to insert into the pivot table.
-     *
-     * @param  array $ids
-     * @param  array $attributes
-     * @return array
-     */
-    protected function createAttachRecords($ids, array $attributes)
-    {
-        $records = [];
-
-        $timed = in_array($this->createdAt(), $this->pivotColumns);
-
-        // To create the attachment records, we will simply spin through the IDs given
-        // and create a new record to insert for each ID. Each ID may actually be a
-        // key in the array, with extra attributes to be placed in other columns.
-        foreach ($ids as $key => $value) {
-            $records[] = $this->attacher($key, $value, $attributes, $timed);
-        }
+		$query->delete();
+
+		$query = $this->newPivotQuery();
+	}
+
+
+	/**
+	 * Create an array of records to insert into the pivot table.
+	 *
+	 * @param  array $ids
+	 * @param  array $attributes
+	 * @return array
+	 */
+	protected function createAttachRecords($ids, array $attributes)
+	{
+		$records = [];
+
+		$timed = in_array($this->createdAt(), $this->pivotColumns);
+
+		// To create the attachment records, we will simply spin through the IDs given
+		// and create a new record to insert for each ID. Each ID may actually be a
+		// key in the array, with extra attributes to be placed in other columns.
+		foreach ($ids as $key => $value) {
+			$records[] = $this->attacher($key, $value, $attributes, $timed);
+		}
         
-        return $records;
-    }
-
-    /**
-     * Create a full attachment record payload.
-     *
-     * @param  int   $key
-     * @param  mixed $value
-     * @param  array $attributes
-     * @param  bool  $timed
-     * @return array
-     */
-    protected function attacher($key, $value, $attributes, $timed)
-    {
-        list($id, $extra) = $this->getAttachId($key, $value, $attributes);
+		return $records;
+	}
+
+	/**
+	 * Create a full attachment record payload.
+	 *
+	 * @param  int   $key
+	 * @param  mixed $value
+	 * @param  array $attributes
+	 * @param  bool  $timed
+	 * @return array
+	 */
+	protected function attacher($key, $value, $attributes, $timed)
+	{
+		list($id, $extra) = $this->getAttachId($key, $value, $attributes);
         
-        // To create the attachment records, we will simply spin through the IDs given
-        // and create a new record to insert for each ID. Each ID may actually be a
-        // key in the array, with extra attributes to be placed in other columns.
-        $record = $this->createAttachRecord($id, $timed);
-
-        return array_merge($record, $extra);
-    }
-
-    /**
-     * Get the attach record ID and extra attributes.
-     *
-     * @param  int   $key
-     * @param  mixed $value
-     * @param  array $attributes
-     * @return array
-     */
-    protected function getAttachId($key, $value, array $attributes)
-    {
-        if (is_array($value)) {
-            return [$key, array_merge($value, $attributes)];
-        }
-
-        return [$value, $attributes];
-    }
-
-    /**
-     * Create a new pivot attachment record.
-     *
-     * @param  int  $id
-     * @param  bool $timed
-     * @return array
-     */
-    protected function createAttachRecord($id, $timed)
-    {
-        $parentKey = $this->parentMap->getKeyName();
-
-        $record = [];
-
-        $record[$this->foreignKey] = $this->parent->getEntityAttribute($parentKey);
-
-        $record[$this->otherKey] = $id;
-
-        // If the record needs to have creation and update timestamps, we will make
-        // them by calling the parent model's "freshTimestamp" method which will
-        // provide us with a fresh timestamp in this model's preferred format.
-        if ($timed) {
-            $record = $this->setTimestampsOnAttach($record);
-        }
-
-        return $record;
-    }
-
-    /**
-     * Set the creation and update timestamps on an attach record.
-     *
-     * @param  array $record
-     * @param  bool  $exists
-     * @return array
-     */
-    protected function setTimestampsOnAttach(array $record, $exists = false)
-    {
-        $fresh = $this->freshTimestamp();
-
-        if (!$exists) {
-            $record[$this->createdAt()] = $fresh;
-        }
-
-        $record[$this->updatedAt()] = $fresh;
-
-        return $record;
-    }
-
-    /**
-     * @param EntityCollection $entities
-     * @return array
-     */
-    protected function getModelKeysFromCollection(EntityCollection $entities)
-    {
-        $keyName = $this->relatedMap->getKeyName();
-
-        return array_map(function ($m) use ($keyName) {
-            return $m->$keyName;
-        }, $entities);
-    }
-
-    /**
-     * Detach models from the relationship.
-     *
-     * @param  int|array $ids
-     * @throws \InvalidArgumentException
-     * @return int
-     */
-    public function detach($ids = [])
-    {
-        if ($ids instanceof EntityCollection) {
-            $ids = (array) $ids->modelKeys();
-        }
-
-        $query = $this->newPivotQuery();
-
-        // If associated IDs were passed to the method we will only delete those
-        // associations, otherwise all of the association ties will be broken.
-        // We'll return the numbers of affected rows when we do the deletes.
-        $ids = (array) $ids;
-
-        if (count($ids) > 0) {
-            $query->whereIn($this->otherKey, (array) $ids);
-        }
-
-        // Once we have all of the conditions set on the statement, we are ready
-        // to run the delete on the pivot table. Then, if the touch parameter
-        // is true, we will go ahead and touch all related models to sync.
-        return $query->delete();
-    }
+		// To create the attachment records, we will simply spin through the IDs given
+		// and create a new record to insert for each ID. Each ID may actually be a
+		// key in the array, with extra attributes to be placed in other columns.
+		$record = $this->createAttachRecord($id, $timed);
+
+		return array_merge($record, $extra);
+	}
+
+	/**
+	 * Get the attach record ID and extra attributes.
+	 *
+	 * @param  int   $key
+	 * @param  mixed $value
+	 * @param  array $attributes
+	 * @return array
+	 */
+	protected function getAttachId($key, $value, array $attributes)
+	{
+		if (is_array($value)) {
+			return [$key, array_merge($value, $attributes)];
+		}
+
+		return [$value, $attributes];
+	}
+
+	/**
+	 * Create a new pivot attachment record.
+	 *
+	 * @param  int  $id
+	 * @param  bool $timed
+	 * @return array
+	 */
+	protected function createAttachRecord($id, $timed)
+	{
+		$parentKey = $this->parentMap->getKeyName();
+
+		$record = [];
+
+		$record[$this->foreignKey] = $this->parent->getEntityAttribute($parentKey);
+
+		$record[$this->otherKey] = $id;
+
+		// If the record needs to have creation and update timestamps, we will make
+		// them by calling the parent model's "freshTimestamp" method which will
+		// provide us with a fresh timestamp in this model's preferred format.
+		if ($timed) {
+			$record = $this->setTimestampsOnAttach($record);
+		}
+
+		return $record;
+	}
+
+	/**
+	 * Set the creation and update timestamps on an attach record.
+	 *
+	 * @param  array $record
+	 * @param  bool  $exists
+	 * @return array
+	 */
+	protected function setTimestampsOnAttach(array $record, $exists = false)
+	{
+		$fresh = $this->freshTimestamp();
+
+		if (!$exists) {
+			$record[$this->createdAt()] = $fresh;
+		}
+
+		$record[$this->updatedAt()] = $fresh;
+
+		return $record;
+	}
+
+	/**
+	 * @param EntityCollection $entities
+	 * @return array
+	 */
+	protected function getModelKeysFromCollection(EntityCollection $entities)
+	{
+		$keyName = $this->relatedMap->getKeyName();
+
+		return array_map(function ($m) use ($keyName) {
+			return $m->$keyName;
+		}, $entities);
+	}
+
+	/**
+	 * Detach models from the relationship.
+	 *
+	 * @param  int|array $ids
+	 * @throws \InvalidArgumentException
+	 * @return int
+	 */
+	public function detach($ids = [])
+	{
+		if ($ids instanceof EntityCollection) {
+			$ids = (array) $ids->modelKeys();
+		}
+
+		$query = $this->newPivotQuery();
+
+		// If associated IDs were passed to the method we will only delete those
+		// associations, otherwise all of the association ties will be broken.
+		// We'll return the numbers of affected rows when we do the deletes.
+		$ids = (array) $ids;
+
+		if (count($ids) > 0) {
+			$query->whereIn($this->otherKey, (array) $ids);
+		}
+
+		// Once we have all of the conditions set on the statement, we are ready
+		// to run the delete on the pivot table. Then, if the touch parameter
+		// is true, we will go ahead and touch all related models to sync.
+		return $query->delete();
+	}
     
-    /**
-     * Create a new query builder for the pivot table.
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    protected function newPivotQuery()
-    {
-        $query = $this->newPivotStatement();
-
-        $parentKey = $this->parentMap->getKeyName();
-
-        return $query->where($this->foreignKey, $this->parent->getEntityAttribute($parentKey));
-    }
-
-    /**
-     * Get a new plain query builder for the pivot table.
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    public function newPivotStatement()
-    {
-        return $this->query->getQuery()->newQuery()->from($this->table);
-    }
-
-    /**
-     * Get a new pivot statement for a given "other" ID.
-     *
-     * @param  mixed $id
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    public function newPivotStatementForId($id)
-    {
-        $pivot = $this->newPivotStatement();
-
-        $parentKeyName = $this->parentMap->getKeyName();
-
-        $key = $this->parent->getEntityAttribute($parentKeyName);
-
-        return $pivot->where($this->foreignKey, $key)->where($this->otherKey, $id);
-    }
-
-    /**
-     * Create a new pivot model instance.
-     *
-     * @param  array $attributes
-     * @param  bool  $exists
-     * @return \Analogue\ORM\Relationships\Pivot
-     */
-    public function newPivot(array $attributes = [], $exists = false)
-    {
-        $pivot = new Pivot($this->parent, $this->parentMap, $attributes, $this->table, $exists);
+	/**
+	 * Create a new query builder for the pivot table.
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	protected function newPivotQuery()
+	{
+		$query = $this->newPivotStatement();
+
+		$parentKey = $this->parentMap->getKeyName();
+
+		return $query->where($this->foreignKey, $this->parent->getEntityAttribute($parentKey));
+	}
+
+	/**
+	 * Get a new plain query builder for the pivot table.
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	public function newPivotStatement()
+	{
+		return $this->query->getQuery()->newQuery()->from($this->table);
+	}
+
+	/**
+	 * Get a new pivot statement for a given "other" ID.
+	 *
+	 * @param  mixed $id
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	public function newPivotStatementForId($id)
+	{
+		$pivot = $this->newPivotStatement();
+
+		$parentKeyName = $this->parentMap->getKeyName();
+
+		$key = $this->parent->getEntityAttribute($parentKeyName);
+
+		return $pivot->where($this->foreignKey, $key)->where($this->otherKey, $id);
+	}
+
+	/**
+	 * Create a new pivot model instance.
+	 *
+	 * @param  array $attributes
+	 * @param  bool  $exists
+	 * @return \Analogue\ORM\Relationships\Pivot
+	 */
+	public function newPivot(array $attributes = [], $exists = false)
+	{
+		$pivot = new Pivot($this->parent, $this->parentMap, $attributes, $this->table, $exists);
         
-        return $pivot->setPivotKeys($this->foreignKey, $this->otherKey);
-    }
-
-    /**
-     * Create a new existing pivot model instance.
-     *
-     * @param  array $attributes
-     * @return \Analogue\ORM\Relationships\Pivot
-     */
-    public function newExistingPivot(array $attributes = [])
-    {
-        return $this->newPivot($attributes, true);
-    }
-
-    /**
-     * Set the columns on the pivot table to retrieve.
-     *
-     * @param  array $columns
-     * @return $this
-     */
-    public function withPivot($columns)
-    {
-        $columns = is_array($columns) ? $columns : func_get_args();
-
-        $this->pivotColumns = array_merge($this->pivotColumns, $columns);
-
-        return $this;
-    }
-
-    /**
-     * Specify that the pivot table has creation and update timestamps.
-     *
-     * @param  mixed $createdAt
-     * @param  mixed $updatedAt
-     * @return \Analogue\ORM\Relationships\BelongsToMany
-     */
-    public function withTimestamps($createdAt = null, $updatedAt = null)
-    {
-        return $this->withPivot($createdAt ?: $this->createdAt(), $updatedAt ?: $this->updatedAt());
-    }
-
-    /**
-     * Get the key for comparing against the parent key in "has" query.
-     *
-     * @return string
-     */
-    public function getHasCompareKey()
-    {
-        return $this->getForeignKey();
-    }
-
-    /**
-     * Get the fully qualified foreign key for the relation.
-     *
-     * @return string
-     */
-    public function getForeignKey()
-    {
-        return $this->table . '.' . $this->foreignKey;
-    }
-
-    /**
-     * Get the fully qualified "other key" for the relation.
-     *
-     * @return string
-     */
-    public function getOtherKey()
-    {
-        return $this->table . '.' . $this->otherKey;
-    }
-
-    /**
-     * Get the fully qualified parent key name.
-     *
-     * @return string
-     */
-    protected function getQualifiedParentKeyName()
-    {
-        return $this->parentMap->getQualifiedKeyName();
-    }
-
-    /**
-     * Get the intermediate table for the relationship.
-     *
-     * @return string
-     */
-    public function getTable()
-    {
-        return $this->table;
-    }
-
-    /**
-     * Get the relationship name for the relationship.
-     *
-     * @return string
-     */
-    public function getRelationName()
-    {
-        return $this->relationName;
-    }
+		return $pivot->setPivotKeys($this->foreignKey, $this->otherKey);
+	}
+
+	/**
+	 * Create a new existing pivot model instance.
+	 *
+	 * @param  array $attributes
+	 * @return \Analogue\ORM\Relationships\Pivot
+	 */
+	public function newExistingPivot(array $attributes = [])
+	{
+		return $this->newPivot($attributes, true);
+	}
+
+	/**
+	 * Set the columns on the pivot table to retrieve.
+	 *
+	 * @param  array $columns
+	 * @return $this
+	 */
+	public function withPivot($columns)
+	{
+		$columns = is_array($columns) ? $columns : func_get_args();
+
+		$this->pivotColumns = array_merge($this->pivotColumns, $columns);
+
+		return $this;
+	}
+
+	/**
+	 * Specify that the pivot table has creation and update timestamps.
+	 *
+	 * @param  mixed $createdAt
+	 * @param  mixed $updatedAt
+	 * @return \Analogue\ORM\Relationships\BelongsToMany
+	 */
+	public function withTimestamps($createdAt = null, $updatedAt = null)
+	{
+		return $this->withPivot($createdAt ?: $this->createdAt(), $updatedAt ?: $this->updatedAt());
+	}
+
+	/**
+	 * Get the key for comparing against the parent key in "has" query.
+	 *
+	 * @return string
+	 */
+	public function getHasCompareKey()
+	{
+		return $this->getForeignKey();
+	}
+
+	/**
+	 * Get the fully qualified foreign key for the relation.
+	 *
+	 * @return string
+	 */
+	public function getForeignKey()
+	{
+		return $this->table . '.' . $this->foreignKey;
+	}
+
+	/**
+	 * Get the fully qualified "other key" for the relation.
+	 *
+	 * @return string
+	 */
+	public function getOtherKey()
+	{
+		return $this->table . '.' . $this->otherKey;
+	}
+
+	/**
+	 * Get the fully qualified parent key name.
+	 *
+	 * @return string
+	 */
+	protected function getQualifiedParentKeyName()
+	{
+		return $this->parentMap->getQualifiedKeyName();
+	}
+
+	/**
+	 * Get the intermediate table for the relationship.
+	 *
+	 * @return string
+	 */
+	public function getTable()
+	{
+		return $this->table;
+	}
+
+	/**
+	 * Get the relationship name for the relationship.
+	 *
+	 * @return string
+	 */
+	public function getRelationName()
+	{
+		return $this->relationName;
+	}
 }

src/ValueMap.php

Indentation +55 added lines, -55 removed lines

@@ -4,67 +4,67 @@
 
 class ValueMap
 {
-    /**
-     * @var string
-     */
-    protected $name;
+	/**
+	 * @var string
+	 */
+	protected $name;
 
-    /**
-     * @var string
-     */
-    protected $class;
+	/**
+	 * @var string
+	 */
+	protected $class;
 
-    /**
-     * @var array
-     */
-    protected $embeddables = [];
+	/**
+	 * @var array
+	 */
+	protected $embeddables = [];
 
-    /**
-     * @var array
-     */
-    protected $attributes = [];
+	/**
+	 * @var array
+	 */
+	protected $attributes = [];
 
-    /**
-     * @return array
-     */
-    public function getAttributes()
-    {
-        return $this->attributes;
-    }
+	/**
+	 * @return array
+	 */
+	public function getAttributes()
+	{
+		return $this->attributes;
+	}
 
-    /**
-     * @return array
-     */
-    public function getEmbeddables()
-    {
-        return $this->embeddables;
-    }
+	/**
+	 * @return array
+	 */
+	public function getEmbeddables()
+	{
+		return $this->embeddables;
+	}
 
-    /**
-     * @param $class
-     */
-    public function setClass($class)
-    {
-        $this->class = $class;
-    }
+	/**
+	 * @param $class
+	 */
+	public function setClass($class)
+	{
+		$this->class = $class;
+	}
 
-    /**
-     * @return mixed
-     */
-    public function getClass()
-    {
-        return $this->class;
-    }
+	/**
+	 * @return mixed
+	 */
+	public function getClass()
+	{
+		return $this->class;
+	}
 
-    /**
-     * @return string
-     */
-    public function getName()
-    {
-        if (isset($this->name)) {
-            return $this->name;
-        } else {
-            return class_basename($this);
-        }
-    }
+	/**
+	 * @return string
+	 */
+	public function getName()
+	{
+		if (isset($this->name)) {
+			return $this->name;
+		} else {
+			return class_basename($this);
+		}
+	}
 }

src/Drivers/IlluminateQueryAdapter.php

Indentation +21 added lines, -21 removed lines

@@ -12,27 +12,27 @@
  */
 class IlluminateQueryAdapter implements QueryAdapter
 {
-    /**
-     * @var Builder
-     */
-    protected $query;
+	/**
+	 * @var Builder
+	 */
+	protected $query;
 
-    /**
-     * IlluminateQueryAdapter constructor.
-     * @param Builder $query
-     */
-    public function __construct(Builder $query)
-    {
-        $this->query = $query;
-    }
+	/**
+	 * IlluminateQueryAdapter constructor.
+	 * @param Builder $query
+	 */
+	public function __construct(Builder $query)
+	{
+		$this->query = $query;
+	}
 
-    /**
-     * @param $method
-     * @param $parameters
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        return call_user_func_array([$this->query, $method], $parameters);
-    }
+	/**
+	 * @param $method
+	 * @param $parameters
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		return call_user_func_array([$this->query, $method], $parameters);
+	}
 }