ColumnComposer::column() - Code Metrics - Inspection of "Extract the collection provider a bit." - OpenSkill/Datatable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#36)

by Tim

created 2016-03-07 12:32 UTC

ColumnComposer::column() B

↳ Parent: ColumnComposer

Complexity

Conditions	5
Paths	9

Size

Total Lines	28
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	0	Features	2

Metric	Value
c	6
b	0
f	2
dl	0
loc	28
rs	8.439
cc	5
eloc	14
nc	9
nop	4

<?php

namespace OpenSkill\Datatable\Composers;

use Illuminate\Contracts\Config\Repository;
use Illuminate\Contracts\View\Factory;
use OpenSkill\Datatable\Columns\ColumnConfiguration;
use OpenSkill\Datatable\Columns\ColumnConfigurationBuilder;
use OpenSkill\Datatable\Columns\Orderable\Orderable;
use OpenSkill\Datatable\Columns\Searchable\Searchable;
use OpenSkill\Datatable\DatatableService;
use OpenSkill\Datatable\Providers\Provider;
use OpenSkill\Datatable\Versions\VersionEngine;

/**
 * Class ColumnComposer
 * @package OpenSkill\Datatable\Composers
 *
 * The composer is responsible to collect all column configuration as well as view configurations and to pass them
 * to the DTProvider when the data needs to be collected.
 */
class ColumnComposer
{
    /**
     * @var Provider The Provider for the underlying data.
     */
    private $provider;

    /**
     * @var VersionEngine The version engine that will parse the request parameter.
     */
    private $version;

    /**
     * @var ColumnConfiguration[] An array of the configurations of the columns
     */
    private $columnConfiguration = [];

    /**
     * @var Factory
     */
    private $viewFactory;

    /**
     * @var Repository
     */
    private $configRepository;

    /**
     * Will create a new datatable composer instance with the given provider
     * @param Provider $provider the provider that will process the underlying data
     * @param VersionEngine $versionEngine The version engine to handle the request data
     * @param Factory $viewFactory The factory providing the views
     * @param Repository $configRepository The repository providing the user defined options
     */
    public function __construct(

        Provider $provider,
        VersionEngine $versionEngine,
        Factory $viewFactory,
        Repository $configRepository
    ) {
        $this->provider = $provider;
        $this->version = $versionEngine;
        $this->viewFactory = $viewFactory;
        $this->configRepository = $configRepository;
    }

    /**
     * Will return the Provider for the underlying data.
     * @return Provider
     */
    public function getProvider()
    {
        return $this->provider;
    }

    /**
     * Will return the internal column configurations that are registered with the current composer.
     *
     * @return ColumnConfiguration[]
     */
    public function getColumnConfiguration()
    {
        return $this->columnConfiguration;
    }

    /**
     * Will create a new ColumnConfiguration with all defaults but allows overriding of all properties through the method.
     *
     * @param string $name The name of the configuration, required for the configuration
     * @param string|callable $callable The function to execute, defaults to null which means the default will be set.
     * @param Searchable $searchable If the column should be searchable or not
     * @param Orderable $orderable If the column should be orderable or not
     * @return $this
     */
    public function column($name, $callable = null, Searchable $searchable = null, Orderable $orderable = null)
    {
        /**
         * @var ColumnConfigurationBuilder
         */
        $config = ColumnConfigurationBuilder::create();

        if (is_string($name)) {
            $config->name($name);
        } else {
            throw new \InvalidArgumentException('$name must be a string');
        }

        if (!is_null($callable)) {
            $this->setCallableColumn($config, $callable);
        }

        if (is_null($searchable)) {
            $config->searchable(Searchable::NORMAL());
        }

        if (is_null($orderable)) {
            $config->orderable(Orderable::BOTH());
        }

        $this->columnConfiguration[] = $config->build();
        return $this;
    }

    /**
     * This method will add the given ColumnConfiguration to the composer.
     *
     * @param ColumnConfiguration $configuration the configuration to add to the composer
     *
     * @return $this
     */
    public function add(ColumnConfiguration $configuration)
    {
        $this->columnConfiguration[] = $configuration;
        return $this;
    }

    /**
     * @return DatatableService Will return the fully built DatatableService that will contain the ColumnConfiguration
     */
    public function build()
    {
        return new DatatableService(
            $this->provider,
            $this->columnConfiguration,
            $this->version,
            $this->viewFactory,
            $this->configRepository
        );
    }

    /**
     * Determine a sane configuration value for a column's callable function
     * @param $config
     * @param $callable
     */
    private function setCallableColumn($config, $callable)
    {
        if (is_callable($callable)) {
            $config->withCallable($callable);
        } elseif (is_string($callable)) {
            $config->withCallable(function () use ($callable) {
                return $callable;
            });
        }
    }
}

1		<?php
2
3		namespace OpenSkill\Datatable\Composers;
4
5		use Illuminate\Contracts\Config\Repository;
6		use Illuminate\Contracts\View\Factory;
7		use OpenSkill\Datatable\Columns\ColumnConfiguration;
8		use OpenSkill\Datatable\Columns\ColumnConfigurationBuilder;
9		use OpenSkill\Datatable\Columns\Orderable\Orderable;
10		use OpenSkill\Datatable\Columns\Searchable\Searchable;
11		use OpenSkill\Datatable\DatatableService;
12		use OpenSkill\Datatable\Providers\Provider;
13		use OpenSkill\Datatable\Versions\VersionEngine;
14
15		/**
16		* Class ColumnComposer
17		* @package OpenSkill\Datatable\Composers
18		*
19		* The composer is responsible to collect all column configuration as well as view configurations and to pass them
20		* to the DTProvider when the data needs to be collected.
21		*/
22		class ColumnComposer
23		{
24		/**
25		* @var Provider The Provider for the underlying data.
26		*/
27		private $provider;
28
29		/**
30		* @var VersionEngine The version engine that will parse the request parameter.
31		*/
32		private $version;
33
34		/**
35		* @var ColumnConfiguration[] An array of the configurations of the columns
36		*/
37		private $columnConfiguration = [];
38
39		/**
40		* @var Factory
41		*/
42		private $viewFactory;
43
44		/**
45		* @var Repository
46		*/
47		private $configRepository;
48
49		/**
50		* Will create a new datatable composer instance with the given provider
51		* @param Provider $provider the provider that will process the underlying data
52		* @param VersionEngine $versionEngine The version engine to handle the request data
53		* @param Factory $viewFactory The factory providing the views
54		* @param Repository $configRepository The repository providing the user defined options
55		*/
56	View Code Duplication	public function __construct(
		0 ignored issues – show Duplication introduced 2016-03-03 01:59 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
57		Provider $provider,
58		VersionEngine $versionEngine,
59		Factory $viewFactory,
60		Repository $configRepository
61		) {
62		$this->provider = $provider;
63		$this->version = $versionEngine;
64		$this->viewFactory = $viewFactory;
65		$this->configRepository = $configRepository;
66		}
67
68		/**
69		* Will return the Provider for the underlying data.
70		* @return Provider
71		*/
72		public function getProvider()
73		{
74		return $this->provider;
75		}
76
77		/**
78		* Will return the internal column configurations that are registered with the current composer.
79		*
80		* @return ColumnConfiguration[]
81		*/
82		public function getColumnConfiguration()
83		{
84		return $this->columnConfiguration;
85		}
86
87		/**
88		* Will create a new ColumnConfiguration with all defaults but allows overriding of all properties through the method.
89		*
90		* @param string $name The name of the configuration, required for the configuration
91		* @param string\|callable $callable The function to execute, defaults to null which means the default will be set.
92		* @param Searchable $searchable If the column should be searchable or not
93		* @param Orderable $orderable If the column should be orderable or not
94		* @return $this
95		*/
96		public function column($name, $callable = null, Searchable $searchable = null, Orderable $orderable = null)
97		{
98		/**
99		* @var ColumnConfigurationBuilder
100		*/
101		$config = ColumnConfigurationBuilder::create();
102
103		if (is_string($name)) {
104		$config->name($name);
105		} else {
106		throw new \InvalidArgumentException('$name must be a string');
107		}
108
109		if (!is_null($callable)) {
110		$this->setCallableColumn($config, $callable);
111		}
112
113		if (is_null($searchable)) {
114		$config->searchable(Searchable::NORMAL());
115		}
116
117		if (is_null($orderable)) {
118		$config->orderable(Orderable::BOTH());
119		}
120
121		$this->columnConfiguration[] = $config->build();
122		return $this;
123		}
124
125		/**
126		* This method will add the given ColumnConfiguration to the composer.
127		*
128		* @param ColumnConfiguration $configuration the configuration to add to the composer
129		*
130		* @return $this
131		*/
132		public function add(ColumnConfiguration $configuration)
133		{
134		$this->columnConfiguration[] = $configuration;
135		return $this;
136		}
137
138		/**
139		* @return DatatableService Will return the fully built DatatableService that will contain the ColumnConfiguration
140		*/
141		public function build()
142		{
143		return new DatatableService(
144		$this->provider,
145		$this->columnConfiguration,
146		$this->version,
147		$this->viewFactory,
148		$this->configRepository
149		);
150		}
151
152		/**
153		* Determine a sane configuration value for a column's callable function
154		* @param $config
155		* @param $callable
156		*/
157		private function setCallableColumn($config, $callable)
158		{
159		if (is_callable($callable)) {
160		$config->withCallable($callable);
161		} elseif (is_string($callable)) {
162		$config->withCallable(function () use ($callable) {
163		return $callable;
164		});
165		}
166		}
167		}

OpenSkill / Datatable

Pull Request — master (#36)

ColumnComposer::column() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like