Analogue\ORM\EntityMap

Complexity

Total Complexity

103

Size/Duplication

Total Lines	1285
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Importance

Changes

0

64 Methods

Rating	Name	Duplication	Size	Complexity
A	getAttributes()	0	4	1
A	setAttributes()	0	4	1
A	getCompiledAttributes()	0	12	1
A	setDateFormat()	0	4	1
A	getDateFormat()	0	4	1
A	setDriver()	0	4	1
A	getDriver()	0	4	1
A	setConnection()	0	4	1
A	getConnection()	0	4	1
A	getTable()	0	8	2
A	setTable()	0	4	1
A	getSequence()	0	8	2
A	getClass()	0	4	2
A	setClass()	0	4	1
A	getEmbeddables()	0	4	1
A	setEmbeddables()	0	4	1
A	getRelationships()	0	4	1
A	getRelationshipsWithoutProxy()	0	4	1
A	getSingleRelationships()	0	4	1
A	getManyRelationships()	0	4	1
A	getLocalRelationships()	0	4	1
A	getLocalKeys()	0	4	2
A	getForeignRelationships()	0	4	1
A	getPivotRelationships()	0	4	1
A	getTargettedClass()	0	4	1
A	addRelationshipMethod()	0	4	1
A	getDynamicRelationships()	0	4	1
A	getEagerloadedRelationships()	0	4	1
A	getKeyName()	0	4	1
A	setKeyName()	0	4	1
A	getQualifiedKeyName()	0	4	1
A	getPerPage()	0	4	1
A	setPerPage()	0	4	1
A	usesTimestamps()	0	4	1
A	usesSoftDeletes()	0	4	1
A	getCreatedAtColumn()	0	4	1
A	getUpdatedAtColumn()	0	4	1
A	getQualifiedDeletedAtColumn()	0	4	1
A	getForeignKey()	0	4	1
A	getInheritanceType()	0	4	1
A	getDiscriminatorColumn()	0	4	1
A	getDiscriminatorColumnMap()	0	4	1
A	useDependencyInjection()	0	4	1
B	hasOne()	0	26	4
B	morphOne()	0	26	3
B	belongsTo()	0	24	3
A	morphTo()	0	54	3
A	hasMany()	0	19	3
A	hasManyThrough()	0	22	3
A	morphMany()	0	22	2
B	belongsToMany()	0	30	4
B	morphToMany()	0	23	4
A	morphedByMany()	0	18	3
A	joiningTable()	0	18	1
A	getMorphs()	0	8	3
A	getMorphClass()	0	5	2
A	newCollection()	0	5	1
A	initialize()	0	14	3
A	boot()	0	6	2
A	getCustomMethods()	0	8	1
B	parseMethodsForRelationship()	0	25	6
A	sortRelationshipsByType()	0	11	2
A	activator()	0	4	1
A	__call()	0	11	2

<?php

namespace Analogue\ORM;

use Analogue\ORM\Exceptions\MappingException;
use Exception;
use ReflectionClass;
use Analogue\ORM\System\Manager;
use Analogue\ORM\System\Wrappers\Factory;
use Analogue\ORM\Relationships\BelongsTo;
use Analogue\ORM\Relationships\BelongsToMany;
use Analogue\ORM\Relationships\HasMany;
use Analogue\ORM\Relationships\HasManyThrough;
use Analogue\ORM\Relationships\HasOne;
use Analogue\ORM\Relationships\MorphMany;
use Analogue\ORM\Relationships\MorphOne;
use Analogue\ORM\Relationships\MorphTo;
use Analogue\ORM\Relationships\MorphToMany;

/**
 * The Entity Map defines the Mapping behaviour of an Entity,
 * including relationships.
 */
class EntityMap
{
    /**
     * The mapping driver to use with this entity
     *
     * @var  string
     */
    protected $driver = 'illuminate';

    /**
     * The Database Connection name for the model.
     *
     * @var string
     */
    protected $connection;

    /**
     * The table associated with the entity.
     *
     * @var string|null
     */
    protected $table = null;

    /**
     * The primary key for the model.
     *
     * @var string
     */
    protected $primaryKey = 'id';

    /**
     * Name of the entity's array property that should
     * contain the attributes
     * 
     * @var string
     */
    protected $arrayName = 'attributes';

    /**
     * Array containing the list of database columns to be mapped
     * in the attributes array of the entity. 
     *
     * @var array
     */
    protected $attributes = [];

    /**
     * Array containing the list of database columns to be mapped
     * to the entity's class properties. 
     *
     * @var array
     */
    protected $properties = [];

    /**
     * The Custom Domain Class to use with this mapping
     *
     * @var string|null
     */
    protected $class = null;

    /**
     * Embedded Value Objects
     * 
     * @var array
     */
    protected $embeddables = [];

    /**
     * Determine the relationships method used on the entity.
     * If not set, mapper will autodetect them
     *
     * @var array
     */
    private $relationships = [];

    /**
     * Relationships that should be treated as collection.
     *
     * @var array
     */
    private $manyRelations = [];

    /**
     * Relationships that should be treated as single entity.
     *
     * @var array
     */
    private $singleRelations = [];

    /**
     * Relationships for which the key is stored in the Entity itself
     *
     * @var array
     */
    private $localRelations = [];

    /** 
     * List of local keys associated to local relation methods
     * 
     * @var array
     */
    private $localForeignKeys = [];

    /**
     * Relationships for which the key is stored in the Related Entity
     *
     * @var array
     */
    private $foreignRelations = [];

    /**
     * Relationships which use a pivot record.
     *
     * @var array
     */
    private $pivotRelations = [];

    /**
     * Dynamic relationships
     *
     * @var array
     */
    private $dynamicRelationships = [];

    /**
     * Targetted class for the relationship method. value is set to `null` for
     * polymorphic relations. 
     * 
     * @var array
     */
    private $relatedClasses = [];

    /** 
     * Some relation methods like embedded objects, or HasOne and MorphOne,
     * will never have a proxy loaded on them. 
     * 
     * @var  array
     */
    private $nonProxyRelationships = [];

    /**
     * The number of models to return for pagination.
     *
     * @var int
     */
    protected $perPage = 15;

    /**
     * The relations to eager load on every query.
     *
     * @var array
     */
    protected $with = [];

    /**
     * The class name to be used in polymorphic relations.
     *
     * @var string
     */
    protected $morphClass;

    /**
     * Sequence name, to be used with postgreSql
     * defaults to %table_name%_id_seq
     *
     * @var string|null
     */
    protected $sequence = null;

    /**
     * Indicates if the entity should be timestamped.
     *
     * @var bool
     */
    public $timestamps = false;

    /**
     * The name of the "created at" column.
     *
     * @var string
     */
    protected $createdAtColumn = 'created_at';

    /**
     * The name of the "updated at" column.
     *
     * @var string
     */
    protected $updatedAtColumn = 'updated_at';

    /**
     * Indicates if the entity uses softdeletes
     *
     * @var boolean
     */
    public $softDeletes = false;

    /**
     * The name of the "deleted at" column.
     *
     * @var string
     */
    protected $deletedAtColumn = 'deleted_at';

    /**
     * The date format to use with the current database connection
     *
     * @var string
     */
    protected $dateFormat;

    /**
     * Set this property to true if the entity should be instantiated
     * using the IoC Container
     * 
     * @var boolean
     */
    protected $dependencyInjection = false;

    /**
     * Set the usage of inheritance, possible values are :
     * "single_table"
     * null
     * 
     * @var string | null
     */
    protected $inheritanceType = null;

    /**
     * Discriminator column name
     * 
     * @var string
     */
    protected $discriminatorColumn = "type";

    /**
     * Allow using a string to define which entity type should be instantiated.
     * If not set, analogue will uses entity's FQDN
     * 
     * @var array
     */
    protected $discriminatorColumnMap = [];

    /**
     * Return Domain class attributes, useful when mapping to a Plain PHP Object
     *
     * @return array
     */
    public function getAttributes()
    {
        return $this->attributes;
    }

    /**
     * Set the domain class attributes
     *
     * @param array $attributeNames
     */
    public function setAttributes(array $attributeNames)
    {
        $this->attributes = $attributeNames;
    }

    /**
     * Get all the attribute names for the class, including relationships, embeddables and primary key.
     *
     * @return array
     */
    public function getCompiledAttributes()
    {
        $key = $this->getKeyName();

        $embeddables = array_keys($this->getEmbeddables());

        $relationships = $this->getRelationships();

        $attributes = $this->getAttributes();

        return array_merge([$key], $embeddables, $relationships, $attributes);
    }

    /**
     * Set the date format to use with the current database connection
     *
     * @param string $format
     */
    public function setDateFormat($format)
    {
        $this->dateFormat = $format;
    }

    /**
     * Get the date format to use with the current database connection
     *
     *  @return string
     */
    public function getDateFormat()
    {
        return $this->dateFormat;
    }

    /**
     * Set the Driver for this mapping
     *
     * @param string $driver
     */
    public function setDriver($driver)
    {
        $this->driver = $driver;
    }

    /**
     * Get the Driver for this mapping.
     *
     * @return string
     */
    public function getDriver()
    {
        return $this->driver;
    }

    /**
     * Set the db connection to use on the table
     *
     * @param $connection
     */
    public function setConnection($connection)
    {
        $this->connection = $connection;
    }

    /**
     * Get the Database connection the Entity is stored on.
     *
     * @return string
     */
    public function getConnection()
    {
        return $this->connection;
    }

    /**
     * Get the table associated with the entity.
     *
     * @return string
     */
    public function getTable()
    {
        if (!is_null($this->table)) {
            return $this->table;
        }

        return str_replace('\\', '', snake_case(str_plural(class_basename($this->getClass()))));
    }

    /**
     * Set the database table name
     *
     * @param  string $table
     */
    public function setTable($table)
    {
        $this->table = $table;
    }

    /**
     * Get the pgSql sequence name
     *
     * @return string
     */
    public function getSequence()
    {
        if (!is_null($this->sequence)) {
            return $this->sequence;
        } else {
            return $this->getTable() . '_id_seq';
        }
    }

    /**
     * Get the custom entity class
     *
     * @return string namespaced class name
     */
    public function getClass()
    {
        return isset($this->class) ? $this->class : null;
    }

    /**
     * Set the custom entity class
     *
     * @param string $class namespaced class name
     */
    public function setClass($class)
    {
        $this->class = $class;
    }

    /**
     * Get the embedded Value Objects
     *
     * @return array
     */
    public function getEmbeddables()
    {
        return $this->embeddables;
    }

    /**
     * Set the embedded Value Objects
     *
     * @param array $embeddables
     */
    public function setEmbeddables(array $embeddables)
    {
        $this->embeddables = $embeddables;
    }

    /**
     * Get the relationships to map on a custom domain
     * class.
     *
     * @return array
     */
    public function getRelationships()
    {
        return $this->relationships;
    }

    /**  
     * Get the relationships that will not have a proxy
     * set on them
     * 
     * @return array
     */
    public function getRelationshipsWithoutProxy()
    {
        return $this->nonProxyRelationships;
    }

    /**
     * Relationships of the Entity type
     *
     * @return array
     */
    public function getSingleRelationships()
    {
        return $this->singleRelations;
    }

    /**
     * Relationships of type Collection
     *
     * @return array
     */
    public function getManyRelationships()
    {
        return $this->manyRelations;
    }

    /**
     * Relationships with foreign key in the mapped entity record.
     *
     * @return array
     */
    public function getLocalRelationships()
    {
        return $this->localRelations;
    }

    /**  
     * Return the local keys associated to the relationship
     * 
     * @param  string $relation
     * @return string | array | null
     */
    public function getLocalKeys($relation)
    {
        return isset($this->localForeignKeys[$relation]) ? $this->localForeignKeys[$relation] : null;
    }

    /**
     * Relationships with foreign key in the related Entity record
     *
     * @return array
     */
    public function getForeignRelationships()
    {
        return $this->foreignRelations;
    }

    /**
     * Relationships which keys are stored in a pivot record
     *
     * @return array
     */
    public function getPivotRelationships()
    {
        return $this->pivotRelations;
    }

    /**  
     * Get the targetted type for a relationship. Return null if polymorphic
     * 
     * @param  string  $relation
     * @return string | null
     */
    public function getTargettedClass($relation)
    {
        return $this->relatedClasses[$relation];
    }

    /**
     * Add a Dynamic Relationship method at runtime. This has to be done
     * by hooking the 'initializing' event, before entityMap is initialized.
     *
     * @param string  $name         Relation name
     * @param \Closure $relationship
     *
     * @return void
     */
    public function addRelationshipMethod($name, \Closure $relationship)
    {
        $this->dynamicRelationships[$name] = $relationship;
    }

    /**
     * Get the dynamic relationship method names.
     *
     * @return array
     */
    public function getDynamicRelationships()
    {
        return array_keys($this->dynamicRelationships);
    }

    /**
     * Get the relationships that have to be eager loaded
     * on each request.
     *
     * @return array
     */
    public function getEagerloadedRelationships()
    {
        return $this->with;
    }

    /**
     * Get the primary key for the entity.
     *
     * @return string
     */
    public function getKeyName()
    {
        return $this->primaryKey;
    }

    /**
     * Set the primary key for the entity.
     *
     * @param $key
     * @return void
     */
    public function setKeyName($key)
    {
        $this->primaryKey = $key;
    }

    /**
     * Get the table qualified key name.
     *
     * @return string
     */
    public function getQualifiedKeyName()
    {
        return $this->getTable() . '.' . $this->getKeyName();
    }

    /**
     * Get the number of models to return per page.
     *
     * @return int
     */
    public function getPerPage()
    {
        return $this->perPage;
    }

    /**
     * Set the number of models to return per page.
     *
     * @param  int $perPage
     * @return void
     */
    public function setPerPage($perPage)
    {
        $this->perPage = $perPage;
    }

    /**
     * Determine if the entity uses get.
     *
     * @return bool
     */
    public function usesTimestamps()
    {
        return $this->timestamps;
    }

    /**
     * Determine if the entity uses soft deletes
     *
     * @return bool
     */
    public function usesSoftDeletes()
    {
        return $this->softDeletes;
    }

    /**
     * Get the 'created_at' column name
     *
     * @return string
     */
    public function getCreatedAtColumn()
    {
        return $this->createdAtColumn;
    }

    /**
     * Get the 'updated_at' column name
     *
     * @return string
     */
    public function getUpdatedAtColumn()
    {
        return $this->updatedAtColumn;
    }

    /**
     * Get the deleted_at column
     *
     * @return string
     */
    public function getQualifiedDeletedAtColumn()
    {
        return $this->deletedAtColumn;
    }

    /**
     * Get the default foreign key name for the model.
     *
     * @return string
     */
    public function getForeignKey()
    {
        return snake_case(class_basename($this->getClass())) . '_id';
    }

    /**
     * Return the inheritance type used by the entity.
     *
     * @return string|null
     */
    public function getInheritanceType()
    {
        return $this->inheritanceType;
    }

    /**
     * Return the discriminator column name on the entity that's
     * used for table inheritance.
     *
     * @return string
     */
    public function getDiscriminatorColumn()
    {
        return $this->discriminatorColumn;
    }

    /**
     * Return the mapping of discriminator column values to
     * entity class names that are used for table inheritance.
     *
     * @return array
     */
    public function getDiscriminatorColumnMap()
    {
        return $this->discriminatorColumnMap;
    }

    /**
     * Return true if the entity should be instanciated using
     * the IoC Container
     * 
     * @return boolean
     */
    public function useDependencyInjection()
    {
        return $this->dependencyInjection;
    }

    /**
     * Define a one-to-one relationship.
     *
     * @param  mixed  $entity
     * @param  string $related entity class
     * @param  string $foreignKey
     * @param  string $localKey
     * @throws MappingException
     * @return \Analogue\ORM\Relationships\HasOne
     */
    public function hasOne($entity, $related, $foreignKey = null, $localKey = null)
    {
        $foreignKey = $foreignKey ?: $this->getForeignKey();

        $relatedMapper = Manager::getInstance()->mapper($related);

        $relatedMap = $relatedMapper->getEntityMap();

        $localKey = $localKey ?: $this->getKeyName();

        // Add the relation to the definition in map
        list(, $caller) = debug_backtrace(false);
        $relation = $caller['function'];
        $this->relatedClasses[$relation] = $related;
        $this->singleRelations[] = $relation;
        $this->foreignRelations[] = $relation;
        $this->nonProxyRelationships[] = $relation;

        // This relationship will always be eager loaded, as proxying it would
        // mean having an object that doesn't actually exists.
        if(! in_array($relation, $this->with)) {
            $this->with[] = $relation;
        }

        return new HasOne($relatedMapper, $entity, $relatedMap->getTable() . '.' . $foreignKey, $localKey);
    }

    /**
     * Define a polymorphic one-to-one relationship.
     *
     * @param  mixed       $entity
     * @param  string      $related
     * @param  string      $name
     * @param  string|null $type
     * @param  string|null $id
     * @param  string|null $localKey
     * @throws MappingException
     * @return \Analogue\ORM\Relationships\MorphOne
     */
    public function morphOne($entity, $related, $name, $type = null, $id = null, $localKey = null)
    {
        list($type, $id) = $this->getMorphs($name, $type, $id);

        $localKey = $localKey ?: $this->getKeyName();

        $relatedMapper = Manager::getInstance()->mapper($related);

        $table = $relatedMapper->getEntityMap()->getTable();

        // Add the relation to the definition in map
        list(, $caller) = debug_backtrace(false);
        $relation = $caller['function'];
        $this->relatedClasses[$relation] = $related;
        $this->singleRelations[] = $relation;
        $this->foreignRelations[] = $relation;
        $this->nonProxyRelationships[] = $relation;

        // This relationship will always be eager loaded, as proxying it would
        // mean having an object that doesn't actually exists.
        if(! in_array($relation, $this->with)) {
            $this->with[] = $relation;
        }
        
        return new MorphOne($relatedMapper, $entity, $table . '.' . $type, $table . '.' . $id, $localKey);
    }

    /**
     * Define an inverse one-to-one or many relationship.
     *
     * @param  mixed       $entity
     * @param  string      $related
     * @param  string|null $foreignKey
     * @param  string|null $otherKey
     * @param  string|null $relation

There is no parameter named $relation. Was it maybe removed?

     * @throws MappingException
     * @return \Analogue\ORM\Relationships\BelongsTo
     */
    public function belongsTo($entity, $related, $foreignKey = null, $otherKey = null)
    {
        // Add the relation to the definition in map
        list(, $caller) = debug_backtrace(false);
        $relation = $caller['function'];
        $this->relatedClasses[$relation] = $related;
        $this->singleRelations[] = $relation;
        $this->localRelations[] = $relation;

        // If no foreign key was supplied, we can use a backtrace to guess the proper
        // foreign key name by using the name of the relationship function, which
        // when combined with an "_id" should conventionally match the columns.
        if (is_null($foreignKey)) {
            $foreignKey = snake_case($relation) . '_id';
        }

        $this->localForeignKeys[$relation] = $foreignKey;

        $relatedMapper = Manager::getInstance()->mapper($related);

        $otherKey = $otherKey ?: $relatedMapper->getEntityMap()->getKeyName();

        return new BelongsTo($relatedMapper, $entity, $foreignKey, $otherKey, $relation);
    }

    /**
     * Define a polymorphic, inverse one-to-one or many relationship.
     *
     * @param  mixed       $entity
     * @param  string|null $name
     * @param  string|null $type
     * @param  string|null $id
     * @throws MappingException
     * @return \Analogue\ORM\Relationships\MorphTo
     */
    public function morphTo($entity, $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']);
        }
        $this->singleRelations[] = $name;
        $this->localRelations[] = $relation;

The variable $relation does not exist. Did you forget to declare it?

        $this->foreignRelations[] = $relation;
        $this->relatedClass[$relation] = null;

The property relatedClass does not seem to exist. Did you mean relatedClasses?

        list($type, $id) = $this->getMorphs($name, $type, $id);

        // Store the foreign key in the entity map. 
        // We might want to store the (key, type) as we might need it
        // to build a MorphTo proxy
        $this->localForeignKeys[$name] = [
            "id" => $id,
            "type" => $type
        ];
        

        $mapper = Manager::getInstance()->mapper(get_class($entity));

        // 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.
        $factory = new Factory;
        $wrapper = $factory->make($entity);

        if (is_null($class = $wrapper->getEntityAttribute($type))) {
            return new MorphTo(
                $mapper, $entity, $id, null, $type, $name
            );
        }

        // If we are not eager loading the relationship 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 {
            $class = Manager::getInstance()->getInverseMorphMap($class);
            $relatedMapper = Manager::getInstance()->mapper($class);

            $foreignKey = $relatedMapper->getEntityMap()->getKeyName();

            return new MorphTo(
                $relatedMapper, $entity, $id, $foreignKey, $type, $name
            );
        }
    }

    /**
     * Define a one-to-many relationship.
     *
     * @param  mixed       $entity
     * @param  string      $related
     * @param  string|null $foreignKey
     * @param  string|null $localKey
     * @throws MappingException
     * @return \Analogue\ORM\Relationships\HasMany
     */
    public function hasMany($entity, $related, $foreignKey = null, $localKey = null)
    {
        $foreignKey = $foreignKey ?: $this->getForeignKey();

        $relatedMapper = Manager::getInstance()->mapper($related);

        $table = $relatedMapper->getEntityMap()->getTable() . '.' . $foreignKey;

        $localKey = $localKey ?: $this->getKeyName();

        // Add the relation to the definition in map
        list(, $caller) = debug_backtrace(false);
        $relation = $caller['function'];
        $this->relatedClasses[$relation] = $related;
        $this->manyRelations[] = $relation;
        $this->foreignRelations[] = $relation;

        return new HasMany($relatedMapper, $entity, $table, $localKey);
    }

    /**
     * Define a has-many-through relationship.
     *
     * @param  mixed       $entity
     * @param  string      $related
     * @param  string      $through
     * @param  string|null $firstKey
     * @param  string|null $secondKey
     * @throws MappingException
     * @return \Analogue\ORM\Relationships\HasManyThrough
     */
    public function hasManyThrough($entity, $related, $through, $firstKey = null, $secondKey = null)
    {
        $relatedMapper = Manager::getInstance()->mapper($related);

        $throughMapper = Manager::getInstance()->mapper($through);


        $firstKey = $firstKey ?: $this->getForeignKey();

        $throughMap = $throughMapper->getEntityMap();

        $secondKey = $secondKey ?: $throughMap->getForeignKey();

        // Add the relation to the definition in map
        list(, $caller) = debug_backtrace(false);
        $relation = $caller['function'];
        $this->relatedClasses[$relation] = $related;
        $this->manyRelations[] = $relation;
        $this->foreignRelations[] = $relation;

        return new HasManyThrough($relatedMapper, $entity, $throughMap, $firstKey, $secondKey);
    }

    /**
     * Define a polymorphic one-to-many relationship.
     *
     * @param  mixed       $entity
     * @param  string      $related
     * @param  string      $name
     * @param  string|null $type
     * @param  string|null $id
     * @param  string|null $localKey
     * @return \Analogue\ORM\Relationships\MorphMany
     */
    public function morphMany($entity, $related, $name, $type = null, $id = null, $localKey = null)
    {
        // Here we will gather up the morph type and ID for the relationship so that we
        // can properly query the intermediate table of a relation. Finally, we will
        // get the table and create the relationship instances for the developers.
        list($type, $id) = $this->getMorphs($name, $type, $id);

        $relatedMapper = Manager::getInstance()->mapper($related);

        $table = $relatedMapper->getEntityMap()->getTable();

        $localKey = $localKey ?: $this->getKeyName();

        // Add the relation to the definition in map
        list(, $caller) = debug_backtrace(false);
        $relation = $caller['function'];
        $this->relatedClasses[$relation] = $related;
        $this->manyRelations[] = $relation;
        $this->foreignRelations[] = $relation;

        return new MorphMany($relatedMapper, $entity, $table . '.' . $type, $table . '.' . $id, $localKey);
    }

    /**
     * Define a many-to-many relationship.
     *
     * @param  mixed       $entity
     * @param  string      $relatedClass

There is no parameter named $relatedClass. Did you maybe mean $related?

     * @param  string|null $table
     * @param  string|null $foreignKey
     * @param  string|null $otherKey
     * @param  string|null $relation

There is no parameter named $relation. Was it maybe removed?

     * @throws MappingException
     * @return \Analogue\ORM\Relationships\BelongsToMany
     */
    public function belongsToMany($entity, $related, $table = null, $foreignKey = null, $otherKey = null)
    {
        // Add the relation to the definition in map
        list(, $caller) = debug_backtrace(false);
        $relation = $caller['function'];
        $this->relatedClasses[$relation] = $related;
        $this->manyRelations[] = $relation;
        $this->foreignRelations[] = $relation;
        $this->pivotRelations[] = $relation;

        // First, we'll need to determine the foreign key and "other key" for the
        // relationship. Once we have determined the keys we'll make the query
        // instances as well as the relationship instances we need for this.
        $foreignKey = $foreignKey ?: $this->getForeignKey();

        $relatedMapper = Manager::getInstance()->mapper($related);

        $relatedMap = $relatedMapper->getEntityMap();

        $otherKey = $otherKey ?: $relatedMap->getForeignKey();

        // If no table name was provided, we can guess it by concatenating the two
        // models using underscores in alphabetical order. The two model names
        // are transformed to snake case from their default CamelCase also.
        if (is_null($table)) {
            $table = $this->joiningTable($relatedMap);
        }

        return new BelongsToMany($relatedMapper, $entity, $table, $foreignKey, $otherKey, $relation);
    }

    /**
     * Define a polymorphic many-to-many relationship.
     *
     * @param  mixed       $entity
     * @param  string      $related
     * @param  string      $name
     * @param  string|null $table
     * @param  string|null $foreignKey
     * @param  string|null $otherKey
     * @param  bool        $inverse
     * @throws MappingException
     * @return \Analogue\ORM\Relationships\MorphToMany
     */
    public function morphToMany($entity, $related, $name, $table = null, $foreignKey = null, $otherKey = null, $inverse = false)
    {
        // Add the relation to the definition in map
        list(, $caller) = debug_backtrace(false);
        $relation = $caller['function'];
        $this->relatedClasses[$relation] = $related;
        $this->manyRelations[] = $relation;
        $this->foreignRelations[] = $relation;
        $this->pivotRelations[] = $relation;

        // First, we will need to determine the foreign key and "other key" for the
        // relationship. Once we have determined the keys we will make the query
        // instances, as well as the relationship instances we need for these.
        $foreignKey = $foreignKey ?: $name . '_id';

        $relatedMapper = Manager::getInstance()->mapper($related);

        $otherKey = $otherKey ?: $relatedMapper->getEntityMap()->getForeignKey();

        $table = $table ?: str_plural($name);

        return new MorphToMany($relatedMapper, $entity, $name, $table, $foreignKey, $otherKey, $caller, $inverse);
    }

    /**
     * Define a polymorphic, inverse many-to-many relationship.
     *
     * @param  mixed       $entity
     * @param  string      $related
     * @param  string      $name
     * @param  string|null $table
     * @param  string|null $foreignKey
     * @param  string|null $otherKey
     * @throws MappingException
     * @return \Analogue\ORM\Relationships\MorphToMany
     */
    public function morphedByMany($entity, $related, $name, $table = null, $foreignKey = null, $otherKey = null)
    {
        // Add the relation to the definition in map
        list(, $caller) = debug_backtrace(false);
        $relation = $caller['function'];
        $this->relatedClasses[$relation] = $related;
        $this->manyRelations[] = $relation;
        $this->foreignRelations[] = $relation;

        $foreignKey = $foreignKey ?: $this->getForeignKey();

        // For the inverse of the polymorphic many-to-many relations, we will change
        // the way we determine the foreign and other keys, as it is the opposite
        // of the morph-to-many method since we're figuring out these inverses.
        $otherKey = $otherKey ?: $name . '_id';

        return $this->morphToMany($entity, $related, $name, $table, $foreignKey, $otherKey, true);
    }

    /**
     * Get the joining table name for a many-to-many relation.
     *
     * @param  EntityMap $relatedMap
     * @return string
     */
    public function joiningTable($relatedMap)
    {
        // The joining table name, by convention, is simply the snake cased models
        // sorted alphabetically and concatenated with an underscore, so we can
        // just sort the models and join them together to get the table name.
        $base = $this->getTable();

        $related = $relatedMap->getTable();

        $tables = [$related, $base];

        // Now that we have the model names in an array we can just sort them and
        // use the implode function to join them together with an underscores,
        // which is typically used by convention within the database system.
        sort($tables);

        return strtolower(implode('_', $tables));
    }

    /**
     * Get the polymorphic relationship columns.
     *
     * @param  string $name
     * @param  string $type
     * @param  string $id
     * @return string[]
     */
    protected function getMorphs($name, $type, $id)
    {
        $type = $type ?: $name . '_type';

        $id = $id ?: $name . '_id';

        return [$type, $id];
    }

    /**
     * Get the class name for polymorphic relations.
     *
     * @return string
     */
    public function getMorphClass()
    {
        $morphClass = Manager::getInstance()->getMorphMap($this->getClass());
        return $this->morphClass ?: $morphClass;
    }

    /**
     * Create a new Entity Collection instance.
     *
     * @param  array $entities
     * @return \Analogue\ORM\EntityCollection
     */
    public function newCollection(array $entities = [])
    {
        $collection = new EntityCollection($entities, $this);
        return $collection->keyBy($this->getKeyName());
    }

    /**
     * Process EntityMap parsing at initialization time
     *
     * @return void
     */
    public function initialize()
    {
        $userMethods = $this->getCustomMethods();

        // Parse EntityMap for method based relationship
        if (count($userMethods) > 0) {
            $this->relationships = $this->parseMethodsForRelationship($userMethods);
        }

        // Parse EntityMap for dynamic relationships
        if (count($this->dynamicRelationships) > 0) {
            $this->relationships = $this->relationships + $this->getDynamicRelationships();
        }
    }

    /**
     * Parse every relationships on the EntityMap and sort
     * them by type.
     *
     * @return void
     */
    public function boot()
    {
        if (count($this->relationships > 0)) {
            $this->sortRelationshipsByType();
        }
    }

    /**
     * Get Methods that has been added in the child class.
     *
     * @return array
     */
    protected function getCustomMethods()
    {
        $mapMethods = get_class_methods($this);

        $parentsMethods = get_class_methods('Analogue\ORM\EntityMap');

        return array_diff($mapMethods, $parentsMethods);
    }

    /**
     * Parse user's class methods for relationships
     *
     * @param  array $customMethods
     * @return array
     */
    protected function parseMethodsForRelationship(array $customMethods)
    {
        $relationships = [];

        $class = new ReflectionClass(get_class($this));

        // Get the mapped Entity class, as we will detect relationships
        // methods by testing that the first argument is type-hinted to
        // the same class as the mapped Entity.
        $entityClass = $this->getClass();

        foreach ($customMethods as $methodName) {
            $method = $class->getMethod($methodName);

            if ($method->getNumberOfParameters() > 0) {
                $params = $method->getParameters();

                if ($params[0]->getClass() && ($params[0]->getClass()->name == $entityClass || is_subclass_of($entityClass, $params[0]->getClass()->name))) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if $params[0]->getClass()->name can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

                    $relationships[] = $methodName;
                }
            }
        }

        return $relationships;
    }

    /**
     * Sort Relationships methods by type
     * 
     * TODO : replace this by direclty setting these value
     * in the corresponding methods, so we won't need
     * the correpondancy tabble
     * 
     * @return void
     */
    protected function sortRelationshipsByType()
    {
        $entityClass = $this->getClass();

        // Instantiate a dummy entity which we will pass to relationship methods.
        $entity = unserialize(sprintf('O:%d:"%s":0:{}', strlen($entityClass), $entityClass));

        foreach ($this->relationships as $relation) {
            $this->$relation($entity);
        }
    }

    /**
     * Override this method for custom entity instantiation
     *
     * @return null
     */
    public function activator()
    {
        return null;
    }

    /**
     * Call dynamic relationship, if it exists
     *
     * @param  string $method
     * @param  array  $parameters
     * @throws Exception
     * @return mixed
     */
    public function __call($method, $parameters)
    {
        if (!array_key_exists($method, $this->dynamicRelationships)) {
            throw new Exception(get_class($this) . " has no method $method");
        }

        // Add $this to parameters so the closure can call relationship method on the map.
        $parameters[] = $this;

        return  call_user_func_array([$this->dynamicRelationships[$method], $parameters]);
    }
}