Reedware\LaravelBlueprints\Concerns\BelongsTo

Complexity

Total Complexity

19

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	belongsToForeign()	0	24	5
A	belongsToColumn()	0	7	2
A	dropBelongsTo()	0	12	2
A	dropBelongsToColumn()	0	3	1
A	bigBelongsToColumn()	0	3	1
A	belongsTo()	0	15	2
A	dropBelongsToForeign()	0	22	4
A	bigBelongsTo()	0	15	2

<?php

namespace Reedware\LaravelBlueprints\Concerns;

use Illuminate\Support\Str;

trait BelongsTo
{
    /**
	 * Defines a Belongs To Column and Relationship.
	 *
     * @param  string       $table
     * @param  string|null  $foreign
     * @param  string|null  $local
     * @param  string|null  $name
     * @param  string|null  $onUpdate
     * @param  string|null  $onDelete
     *
     * @return \Illuminate\Support\Fluent
	 */
    public function belongsTo($table, $foreign = null, $local = null, $name = null, $onUpdate = null, $onDelete = null)
    {
    	// Determine the Name of the Foreign Key
    	if(is_null($foreign)) {
    		$foreign = Str::singular($table) . '_id';
    	}

    	// Define the Column
    	$column = $this->belongsToColumn($foreign);

    	// Define the Relation
    	$this->belongsToForeign($table, $foreign, $local, $name, $onUpdate, $onDelete);

    	// Return the Column
    	return $column;
    }

    /**
	 * Defines a Belongs To Column and Relationship using a Big Integer.
	 *
     * @param  string       $table
     * @param  string|null  $foreign
     * @param  string|null  $local
     * @param  string|null  $name
     * @param  string|null  $onUpdate
     * @param  string|null  $onDelete
     *
     * @return \Illuminate\Support\Fluent
	 */
    public function bigBelongsTo($table, $foreign = null, $local = null, $name = null, $onUpdate = null, $onDelete = null)
    {
    	// Determine the Name of the Foreign Key
    	if(is_null($foreign)) {
    		$foreign = Str::singular($table) . '_id';
    	}

    	// Define the Column
    	$column = $this->bigBelongsToColumn($foreign);

    	// Define the Relation
        $this->belongsToForeign($table, $foreign, $local, $name, $onUpdate, $onDelete);

    	// Return the Column
    	return $column;
    }

    /**
     * Defines a Belongs To Column.
     *
     * @param  string   $foreign
     * @param  boolean  $big
     *
     * @return \Illuminate\Support\Fluent
     */
    public function belongsToColumn($foreign, $big = false)
    {
        // Determine the Column Method
        $method = $big ? 'bigInteger' : 'integer';

        // Define the Column
        return $this->{$method}($foreign)->unsigned();
    }

    /**
     * Defines a Belongs To Column using a Big Integer.
     *
     * @param  string  $foreign
     *
     * @return \Illuminate\Support\Fluent
     */
    public function bigBelongsToColumn($foreign)
    {
        return $this->belongsToColumn($foreign, true);
    }

    /**
     * Defines a Belongs To Foreign Key.
     *
     * @param  string       $table
     * @param  string|null  $foreign
     * @param  string|null  $local
     * @param  string|null  $name
     * @param  string|null  $onUpdate
     * @param  string|null  $onDelete
     *
     * @return \Illuminate\Support\Fluent
     */
    public function belongsToForeign($table, $foreign = null, $local = null, $name = null, $onUpdate = null, $onDelete = null)
    {
        // Determine the Name of the Foreign Key
        if(is_null($foreign)) {
            $foreign = Str::singular($table) . '_id';
        }

        // Determine the Name of the Local Key
        if(is_null($local)) {
            $local = 'id';
        }

        // Determine the Update Constraint
        if(is_null($onUpdate)) {
            $onUpdate = $this->getConfig('belongsTo.onUpdate');

It seems like getConfig() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        // Determine the Delete Constraint
        if(is_null($onDelete)) {
            $onDelete = $this->getConfig('belongsTo.onDelete');
        }

        // Define the Reference
        return $this->foreign($foreign, $name, $table)->references($local)->onUpdate($onUpdate)->onDelete($onDelete);

It seems like foreign() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Drops a Belongs To Relationship.
     *
     * @param  string       $table
     * @param  string|null  $foreign
     * @param  string|null  $local
     * @param  string|null  $name
     *
     * @return \Illuminate\Support\Fluent
     */
    public function dropBelongsTo($table, $foreign = null, $local = null, $name = null)
    {
        // Determine the Name of the Foreign Key
        if(is_null($foreign)) {
            $foreign = Str::singular($table) . '_id';
        }

        // Drop the Relation
        $this->dropBelongsToForeign($table, $foreign, $local, $name);

        // Drop the Column
        return $this->dropBelongsToColumn($foreign);
    }

    /**
     * Drops a Belongs To Column.
     *
     * @param  string  $foreign
     *
     * @return \Illuminate\Support\Fluent
     */
    public function dropBelongsToColumn($foreign)
    {
        $this->dropColumn($foreign);

It seems like dropColumn() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Drops a Belongs To Foreign Key.
     *
     * @param  string       $table
     * @param  string|null  $foreign
     * @param  string|null  $local
     * @param  string|null  $name
     *
     * @return \Illuminate\Support\Fluent
     */
    public function dropBelongsToForeign($table, $foreign = null, $local = null, $name = null)
    {
        // Check for a Name
        if(!is_null($name)) {
            return $this->dropForeign($name);

It seems like dropForeign() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        // Determine the Name of the Foreign Key
        if(is_null($foreign)) {
            $foreign = Str::singular($table) . '_id';
        }

        // Determine the Name of the Local Key
        if(is_null($local)) {
            $local = 'id';

The assignment to $local is dead and can be removed.

        }

        // Determine the Name of the Foreign Key
        $name = $this->createIndexName('foreign', [$foreign], $table);

It seems like createIndexName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        // Drop the Reference
        return $this->dropForeign($name);
    }
}