OrmConnection::assignOption() - Code Metrics - maikgreubel/caribu-orm - Measure and Improve Code Quality continuously with Scrutinizer

OrmConnection::assignOption() C
last analyzed 2017-08-16 22:17 UTC

↳ Parent: OrmConnection

Complexity

Conditions	8
Paths	8

Size

Total Lines	35
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	23
CRAP Score	8.0046

Importance

Changes

Metric	Value
dl	0
loc	35
ccs	23
cts	24
cp	0.9583
rs	5.3846
c	0
b	0
f	0
cc	8
eloc	25
nc	8
nop	2
crap	8.0046

<?php
namespace Nkey\Caribu\Orm;

/**
 * Connection related functionality for the ORM
 *
 * This class is part of Caribu package
 *
 * @author Maik Greubel <[email protected]>
 */
trait OrmConnection
{
    /**
     * Include logging facility
     */
    use \Generics\Logger\LoggerTrait;

    /**
     * The database connection
     *
     * @var \PDO
     */
    private $connection = null;

    /**
     * The concrete database type
     *
     * @var string
     */
    private $type = null;

    /**
     * The database schema
     *
     * @var string
     */
    private $schema = null;

    /**
     * Database connection user
     *
     * @var string
     */
    private $user = null;

    /**
     * Database connection password
     *
     * @var string
     */
    private $password = null;

    /**
     * Database connection host
     *
     * @var string
     */
    private $host = null;

    /**
     * Database connection port
     *
     * @var int
     */
    private $port = null;

    /**
     * Embedded database file
     *
     * @var string
     */
    private $file = null;

    /**
     * Settings to use for connection
     *
     * @var array
     */
    private $settings = null;

    /**
     * Database type
     *
     * @var \Nkey\Caribu\Type\IType
     */
    private $dbType = null;

    /**
     * Configure the Orm
     *
     * @param array $options
     *            Various options to use for configuration. See documentation for details.
     */
    public static function configure($options = array())
    {
        self::parseOptions($options);
    }

    /**
     * Assign the option to local configuration
     *
     * @param string $option
     *            The option to assign
     * @param mixed $value
     *            The value to assign to option
     */
    private static function assignOption(string $option, $value)
    {
        switch ($option) {
            case 'type':
                self::getInstance()->type = $value;
                break;
            
            case 'schema':
                self::getInstance()->schema = $value;
                break;
            
            case 'user':
                self::getInstance()->user = $value;
                break;
            
            case 'password':
                self::getInstance()->password = $value;
                break;
            
            case 'host':
                self::getInstance()->host = $value;
                break;
            
            case 'port':
                self::getInstance()->port = $value;
                break;
            
            case 'file':
                self::getInstance()->file = $value;
                break;
            
            default:
                self::getInstance()->settings[$option] = $value;
        }
    }

    /**
     * Parse the options
     *
     * @param array $options
     *            The options to parse
     */
    private static function parseOptions($options)
    {
        foreach ($options as $option => $value) {
            self::assignOption($option, $value);
        }
    }

    /**
     * Retrieve the database type
     *
     * @return \Nkey\Caribu\Type\IType
     */
    public function getDbType()
    {
        if (null == $this->dbType) {
            $this->dbType = \Nkey\Caribu\Type\TypeFactory::create($this);
        }
        return $this->dbType;
    }

    /**
     * Create a new database connection
     *
     * @throws OrmException
     */
    private function createConnection()
    {
        $dsn = $this->getDbType()->getDsn();
        
        $dsn = self::interpolate($dsn, array(
            'host' => $this->host,
            'port' => ($this->port ? $this->port : $this->dbType->getDefaultPort()),
            'schema' => $this->schema,
            'file' => $this->file
        ));
        
        try {
            $this->connection = new \PDO($dsn, $this->user, $this->password, $this->settings);
            $this->connection->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
            $this->getLog()->info("New instance of PDO connection established");
        } catch (\PDOException $exception) {
            throw OrmException::fromPrevious($exception, $exception->getMessage(), $exception->getCode());
        }
    }

    /**
     * Retrieve the database connection
     *
     * @return \PDO The database connection
     *        
     * @throws OrmException
     */
    public function getConnection()
    {
        if (null == $this->connection) {
            $this->createConnection();
        }
        
        return $this->connection;
    }

    /**
     * Retrieve the selected schema of the connection
     *
     * @return string The name of schema
     */
    public function getSchema()
    {
        return $this->schema;
    }

    /**
     * Retrieve the type of database
     *
     * @return string The type of database
     */
    public function getType()
    {
        return self::getInstance()->type;
    }

    /**
     * Detach connection
     */
    private function passivateConnection()
    {
        unset($this->connection);
    }
}


1		<?php
2		namespace Nkey\Caribu\Orm;
3
4		/**
5		* Connection related functionality for the ORM
6		*
7		* This class is part of Caribu package
8		*
9		* @author Maik Greubel <[email protected]>
10		*/
11		trait OrmConnection
12		{
13		/**
14		* Include logging facility
15		*/
16		use \Generics\Logger\LoggerTrait;
17
18		/**
19		* The database connection
20		*
21		* @var \PDO
22		*/
23		private $connection = null;
24
25		/**
26		* The concrete database type
27		*
28		* @var string
29		*/
30		private $type = null;
31
32		/**
33		* The database schema
34		*
35		* @var string
36		*/
37		private $schema = null;
38
39		/**
40		* Database connection user
41		*
42		* @var string
43		*/
44		private $user = null;
45
46		/**
47		* Database connection password
48		*
49		* @var string
50		*/
51		private $password = null;
52
53		/**
54		* Database connection host
55		*
56		* @var string
57		*/
58		private $host = null;
59
60		/**
61		* Database connection port
62		*
63		* @var int
64		*/
65		private $port = null;
66
67		/**
68		* Embedded database file
69		*
70		* @var string
71		*/
72		private $file = null;
73
74		/**
75		* Settings to use for connection
76		*
77		* @var array
78		*/
79		private $settings = null;
80
81		/**
82		* Database type
83		*
84		* @var \Nkey\Caribu\Type\IType
85		*/
86		private $dbType = null;
87
88		/**
89		* Configure the Orm
90		*
91		* @param array $options
92		* Various options to use for configuration. See documentation for details.
93		*/
94	34	public static function configure($options = array())
95		{
96	34	self::parseOptions($options);
97	34	}
98
99		/**
100		* Assign the option to local configuration
101		*
102		* @param string $option
103		* The option to assign
104		* @param mixed $value
105		* The value to assign to option
106		*/
107	34	private static function assignOption(string $option, $value)
108		{
109		switch ($option) {
110	34	case 'type':
111	34	self::getInstance()->type = $value;
112	34	break;
113
114	33	case 'schema':
115	10	self::getInstance()->schema = $value;
116	10	break;
117
118	33	case 'user':
119	10	self::getInstance()->user = $value;
120	10	break;
121
122	33	case 'password':
123	10	self::getInstance()->password = $value;
124	10	break;
125
126	33	case 'host':
127	10	self::getInstance()->host = $value;
128	10	break;
129
130	24	case 'port':
131	1	self::getInstance()->port = $value;
132	1	break;
133
134	23	case 'file':
135	23	self::getInstance()->file = $value;
136	23	break;
137
138		default:
139		self::getInstance()->settings[$option] = $value;
140		}
141	34	}
142
143		/**
144		* Parse the options
145		*
146		* @param array $options
147		* The options to parse
148		*/
149	34	private static function parseOptions($options)
150		{
151	34	foreach ($options as $option => $value) {
152	34	self::assignOption($option, $value);
153		}
154	34	}
155
156		/**
157		* Retrieve the database type
158		*
159		* @return \Nkey\Caribu\Type\IType
160		*/
161	34	public function getDbType()
162		{
163	34	if (null == $this->dbType) {
164	34	$this->dbType = \Nkey\Caribu\Type\TypeFactory::create($this);
165		}
166	32	return $this->dbType;
167		}
168
169		/**
170		* Create a new database connection
171		*
172		* @throws OrmException
173		*/
174	33	private function createConnection()
175		{
176	33	$dsn = $this->getDbType()->getDsn();
177
178	32	$dsn = self::interpolate($dsn, array(
179	32	'host' => $this->host,
180	32	'port' => ($this->port ? $this->port : $this->dbType->getDefaultPort()),
181	32	'schema' => $this->schema,
182	32	'file' => $this->file
183		));
184
185		try {
186	32	$this->connection = new \PDO($dsn, $this->user, $this->password, $this->settings);
187	32	$this->connection->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
188	32	$this->getLog()->info("New instance of PDO connection established");
189		} catch (\PDOException $exception) {
190		throw OrmException::fromPrevious($exception, $exception->getMessage(), $exception->getCode());
191		}
192	32	}
193
194		/**
195		* Retrieve the database connection
196		*
197		* @return \PDO The database connection
198		*
199		* @throws OrmException
200		*/
201	34	public function getConnection()
202		{
203	34	if (null == $this->connection) {
204	33	$this->createConnection();
205		}
206
207	33	return $this->connection;
208		}
209
210		/**
211		* Retrieve the selected schema of the connection
212		*
213		* @return string The name of schema
214		*/
215	6	public function getSchema()
216		{
217	6	return $this->schema;
218		}
219
220		/**
221		* Retrieve the type of database
222		*
223		* @return string The type of database
224		*/
225	34	public function getType()
226		{
227	34	return self::getInstance()->type;
228		}
229
230		/**
231		* Detach connection
232		*/
233	33	private function passivateConnection()
234		{
235	33	unset($this->connection);
236	33	}
237		}
238

maikgreubel / caribu-orm

OrmConnection::assignOption() C last analyzed 2017-08-16 22:17 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

OrmConnection::assignOption() C
last analyzed 2017-08-16 22:17 UTC