EloquentCriteria::first() - Code Metrics - anomalylabs/streams-platform - Measure and Improve Code Quality continuously with Scrutinizer

EloquentCriteria::first() A
last analyzed 2017-05-11 19:17 UTC

↳ Parent: EloquentCriteria

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
c	0
b	0
f	0
rs	10
cc	1
eloc	2
nc	1
nop	1

<?php namespace Anomaly\Streams\Platform\Model;

use Anomaly\Streams\Platform\Entry\Contract\EntryInterface;
use Anomaly\Streams\Platform\Entry\EntryPresenter;
use Anomaly\Streams\Platform\Search\SearchCriteria;
use Anomaly\Streams\Platform\Support\Collection;
use Anomaly\Streams\Platform\Support\Decorator;
use Anomaly\Streams\Platform\Support\Presenter;
use Anomaly\Streams\Platform\Traits\Hookable;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Foundation\Bus\DispatchesJobs;

/**
 * Class EloquentCriteria
 *
 * @link   http://pyrocms.com/
 * @author PyroCMS, Inc. <[email protected]>
 * @author Ryan Thompson <[email protected]>
 */
class EloquentCriteria
{

    use Hookable;
    use DispatchesJobs;

    /**
     * Additional available methods.
     *
     * @var array
     */
    protected $available = [
        'whereBetween',
        'whereNotBetween',
        'whereIn',
        'whereNotIn',
        'whereNull',
        'whereNotNull',
        'whereDate',
        'whereMonth',
        'whereDay',
        'whereYear',
        'whereColumn',
    ];

    /**
     * Safe builder methods.
     *
     * @var array
     */
    private $disabled = [
        'delete',
        'update',
    ];

    /**
     * The query builder.
     *
     * @var Builder|\Illuminate\Database\Query\Builder
     */
    protected $query;

    /**
     * Set the get method.
     *
     * @var string
     */
    protected $method;

    /**
     * Create a new EntryCriteria instance.
     *
     * @param Builder $query
     * @param string  $method
     */
    public function __construct(Builder $query, $method = 'get')
    {
        $this->query  = $query;
        $this->method = $method;
    }

    /**
     * Get the paginated entries.
     *
     * @param int    $perPage
     * @param array  $columns
     * @param string $pageName
     * @return array|\ArrayAccess|\IteratorAggregate|Presenter
     */
    public function paginate($perPage = 15, array $columns = ['*'], $pageName = 'page')
    {
        return (new Decorator())->decorate($this->query->paginate($perPage, $columns, $pageName));
    }

    /**
     * Return a new search criteria.
     *
     * @param  string $term
     * @return SearchCriteria
     */
    public function search($term)
    {
        return new SearchCriteria(
            $this->query->getModel()->search($term),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $this->query->getModel()
        );
    }

    /**
     * Get the entries.
     *
     * @param  array $columns
     * @return Collection|Presenter|EntryPresenter
     */
    public function get(array $columns = ['*'])
    {
        return (new Decorator())->decorate($this->query->{$this->method}($columns));
    }

    /**
     * Get the entry count.
     *
     * @param  array $columns
     * @return int
     */
    public function count(array $columns = ['*'])
    {
        return (new Decorator())->decorate($this->query->count($columns));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Get the aggregate sum.
     *
     * @param  $column
     * @return int
     */
    public function sum($column)
    {
        return (new Decorator())->decorate($this->query->sum($column));
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Get the aggregate max.
     *
     * @param  $column
     * @return int
     */
    public function max($column)
    {
        return (new Decorator())->decorate($this->query->max($column));
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Get the aggregate min.
     *
     * @param  $column
     * @return int
     */
    public function min($column)
    {
        return (new Decorator())->decorate($this->query->min($column));
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Get the aggregate avg.
     *
     * @param  $column
     * @return int
     */
    public function avg($column)
    {
        return (new Decorator())->decorate($this->query->avg($column));
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Find an entry.
     *
     * @param                           $identifier
     * @param  array                    $columns
     * @return Presenter|EntryPresenter
     */
    public function find($identifier, array $columns = ['*'])
    {
        return (new Decorator())->decorate($this->query->find($identifier, $columns));
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Find an entry by column value.
     *
     * @param                           $column
     * @param                           $value
     * @param  array                    $columns
     * @return Presenter|EntryPresenter
     */
    public function findBy($column, $value, array $columns = ['*'])
    {
        $this->query->where($column, $value);

        return (new Decorator())->decorate($this->query->first($columns));
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Return the first entry.
     *
     * @param  array $columns
     * @return EloquentModel|EntryInterface
     */
    public function first(array $columns = ['*'])
    {
        return (new Decorator())->decorate($this->query->first($columns));
    }

    /**
     * Return whether the method is safe or not.
     *
     * @param $name
     * @return bool
     */
    protected function methodIsSafe($name)
    {
        return (!in_array($name, $this->disabled));
    }

    /**
     * Return whether the method
     * exists on the query or not.
     *
     * @param $name
     * @return bool
     */
    protected function methodExists($name)
    {
        return method_exists($this->query->getQuery(), $name) || method_exists($this->query, $name);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Route through __call.
     *
     * @param $name
     * @return Builder|null
     */
    public function __get($name)
    {
        return $this->__call($name, []);
    }

    /**
     * Call the method on the query.
     *
     * @param $name
     * @param $arguments
     * @return Builder|null
     */
    public function __call($name, $arguments)
    {
        if ($this->hasHook($name)) {
            return $this->call($name, $arguments);
        }

        if ($this->methodExists($name) && $this->methodIsSafe($name)) {

            call_user_func_array([$this->query, $name], $arguments);

            return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        if (starts_with($name, 'findBy') && $column = snake_case(substr($name, 6))) {


            call_user_func_array([$this->query, 'where'], array_merge([$column], $arguments));

            return $this->first();
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        if (starts_with($name, 'where') && $column = snake_case(substr($name, 5))) {


            call_user_func_array([$this->query, 'where'], array_merge([$column], $arguments));

            return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Return the string.
     *
     * @return string
     */
    public function __toString()
    {
        return '';
    }
}


EloquentCriteria::first() A
last analyzed 2017-05-11 19:17 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php namespace Anomaly\Streams\Platform\Model;
2
3			use Anomaly\Streams\Platform\Entry\Contract\EntryInterface;
4			use Anomaly\Streams\Platform\Entry\EntryPresenter;
5			use Anomaly\Streams\Platform\Search\SearchCriteria;
6			use Anomaly\Streams\Platform\Support\Collection;
7			use Anomaly\Streams\Platform\Support\Decorator;
8			use Anomaly\Streams\Platform\Support\Presenter;
9			use Anomaly\Streams\Platform\Traits\Hookable;
10			use Illuminate\Database\Eloquent\Builder;
11			use Illuminate\Foundation\Bus\DispatchesJobs;
12
13			/**
14			* Class EloquentCriteria
15			*
16			* @link http://pyrocms.com/
17			* @author PyroCMS, Inc. <[email protected]>
18			* @author Ryan Thompson <[email protected]>
19			*/
20			class EloquentCriteria
21			{
22
23			use Hookable;
24			use DispatchesJobs;
25
26			/**
27			* Additional available methods.
28			*
29			* @var array
30			*/
31			protected $available = [
32			'whereBetween',
33			'whereNotBetween',
34			'whereIn',
35			'whereNotIn',
36			'whereNull',
37			'whereNotNull',
38			'whereDate',
39			'whereMonth',
40			'whereDay',

anomalylabs / streams-platform

EloquentCriteria::first() A last analyzed 2017-05-11 19:17 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

EloquentCriteria::first() A
last analyzed 2017-05-11 19:17 UTC