Added vendor/ directory for Composer's installed files

vendor/illuminate/database/Connectors/ConnectionFactory.php

@@ -0,0 +1,231 @@
+<?php namespace Illuminate\Database\Connectors;
+
+use PDO;
+use InvalidArgumentException;
+use Illuminate\Database\MySqlConnection;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Database\PostgresConnection;
+use Illuminate\Database\SqlServerConnection;
+use Illuminate\Contracts\Container\Container;
+
+class ConnectionFactory {
+
+	/**
+	 * The IoC container instance.
+	 *
+	 * @var \Illuminate\Contracts\Container\Container
+	 */
+	protected $container;
+
+	/**
+	 * Create a new connection factory instance.
+	 *
+	 * @param  \Illuminate\Contracts\Container\Container  $container
+	 * @return void
+	 */
+	public function __construct(Container $container)
+	{
+		$this->container = $container;
+	}
+
+	/**
+	 * Establish a PDO connection based on the configuration.
+	 *
+	 * @param  array   $config
+	 * @param  string  $name
+	 * @return \Illuminate\Database\Connection
+	 */
+	public function make(array $config, $name = null)
+	{
+		$config = $this->parseConfig($config, $name);
+
+		if (isset($config['read']))
+		{
+			return $this->createReadWriteConnection($config);
+		}
+
+		return $this->createSingleConnection($config);
+	}
+
+	/**
+	 * Create a single database connection instance.
+	 *
+	 * @param  array  $config
+	 * @return \Illuminate\Database\Connection
+	 */
+	protected function createSingleConnection(array $config)
+	{
+		$pdo = $this->createConnector($config)->connect($config);
+
+		return $this->createConnection($config['driver'], $pdo, $config['database'], $config['prefix'], $config);
+	}
+
+	/**
+	 * Create a single database connection instance.
+	 *
+	 * @param  array  $config
+	 * @return \Illuminate\Database\Connection
+	 */
+	protected function createReadWriteConnection(array $config)
+	{
+		$connection = $this->createSingleConnection($this->getWriteConfig($config));
+
+		return $connection->setReadPdo($this->createReadPdo($config));
+	}
+
+	/**
+	 * Create a new PDO instance for reading.
+	 *
+	 * @param  array  $config
+	 * @return \PDO
+	 */
+	protected function createReadPdo(array $config)
+	{
+		$readConfig = $this->getReadConfig($config);
+
+		return $this->createConnector($readConfig)->connect($readConfig);
+	}
+
+	/**
+	 * Get the read configuration for a read / write connection.
+	 *
+	 * @param  array  $config
+	 * @return array
+	 */
+	protected function getReadConfig(array $config)
+	{
+		$readConfig = $this->getReadWriteConfig($config, 'read');
+
+		return $this->mergeReadWriteConfig($config, $readConfig);
+	}
+
+	/**
+	 * Get the read configuration for a read / write connection.
+	 *
+	 * @param  array  $config
+	 * @return array
+	 */
+	protected function getWriteConfig(array $config)
+	{
+		$writeConfig = $this->getReadWriteConfig($config, 'write');
+
+		return $this->mergeReadWriteConfig($config, $writeConfig);
+	}
+
+	/**
+	 * Get a read / write level configuration.
+	 *
+	 * @param  array   $config
+	 * @param  string  $type
+	 * @return array
+	 */
+	protected function getReadWriteConfig(array $config, $type)
+	{
+		if (isset($config[$type][0]))
+		{
+			return $config[$type][array_rand($config[$type])];
+		}
+
+		return $config[$type];
+	}
+
+	/**
+	 * Merge a configuration for a read / write connection.
+	 *
+	 * @param  array  $config
+	 * @param  array  $merge
+	 * @return array
+	 */
+	protected function mergeReadWriteConfig(array $config, array $merge)
+	{
+		return array_except(array_merge($config, $merge), array('read', 'write'));
+	}
+
+	/**
+	 * Parse and prepare the database configuration.
+	 *
+	 * @param  array   $config
+	 * @param  string  $name
+	 * @return array
+	 */
+	protected function parseConfig(array $config, $name)
+	{
+		return array_add(array_add($config, 'prefix', ''), 'name', $name);
+	}
+
+	/**
+	 * Create a connector instance based on the configuration.
+	 *
+	 * @param  array  $config
+	 * @return \Illuminate\Database\Connectors\ConnectorInterface
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function createConnector(array $config)
+	{
+		if ( ! isset($config['driver']))
+		{
+			throw new InvalidArgumentException("A driver must be specified.");
+		}
+
+		if ($this->container->bound($key = "db.connector.{$config['driver']}"))
+		{
+			return $this->container->make($key);
+		}
+
+		switch ($config['driver'])
+		{
+			case 'mysql':
+				return new MySqlConnector;
+
+			case 'pgsql':
+				return new PostgresConnector;
+
+			case 'sqlite':
+				return new SQLiteConnector;
+
+			case 'sqlsrv':
+				return new SqlServerConnector;
+		}
+
+		throw new InvalidArgumentException("Unsupported driver [{$config['driver']}]");
+	}
+
+	/**
+	 * Create a new connection instance.
+	 *
+	 * @param  string   $driver
+	 * @param  \PDO     $connection
+	 * @param  string   $database
+	 * @param  string   $prefix
+	 * @param  array    $config
+	 * @return \Illuminate\Database\Connection
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	protected function createConnection($driver, PDO $connection, $database, $prefix = '', array $config = array())
+	{
+		if ($this->container->bound($key = "db.connection.{$driver}"))
+		{
+			return $this->container->make($key, array($connection, $database, $prefix, $config));
+		}
+
+		switch ($driver)
+		{
+			case 'mysql':
+				return new MySqlConnection($connection, $database, $prefix, $config);
+
+			case 'pgsql':
+				return new PostgresConnection($connection, $database, $prefix, $config);
+
+			case 'sqlite':
+				return new SQLiteConnection($connection, $database, $prefix, $config);
+
+			case 'sqlsrv':
+				return new SqlServerConnection($connection, $database, $prefix, $config);
+		}
+
+		throw new InvalidArgumentException("Unsupported driver [$driver]");
+	}
+
+}

vendor/illuminate/database/Connectors/Connector.php

@@ -0,0 +1,71 @@
+<?php namespace Illuminate\Database\Connectors;
+
+use PDO;
+
+class Connector {
+
+	/**
+	 * The default PDO connection options.
+	 *
+	 * @var array
+	 */
+	protected $options = array(
+		PDO::ATTR_CASE => PDO::CASE_NATURAL,
+		PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
+		PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
+		PDO::ATTR_STRINGIFY_FETCHES => false,
+		PDO::ATTR_EMULATE_PREPARES => false,
+	);
+
+	/**
+	 * Get the PDO options based on the configuration.
+	 *
+	 * @param  array  $config
+	 * @return array
+	 */
+	public function getOptions(array $config)
+	{
+		$options = array_get($config, 'options', array());
+
+		return array_diff_key($this->options, $options) + $options;
+	}
+
+	/**
+	 * Create a new PDO connection.
+	 *
+	 * @param  string  $dsn
+	 * @param  array   $config
+	 * @param  array   $options
+	 * @return \PDO
+	 */
+	public function createConnection($dsn, array $config, array $options)
+	{
+		$username = array_get($config, 'username');
+
+		$password = array_get($config, 'password');
+
+		return new PDO($dsn, $username, $password, $options);
+	}
+
+	/**
+	 * Get the default PDO connection options.
+	 *
+	 * @return array
+	 */
+	public function getDefaultOptions()
+	{
+		return $this->options;
+	}
+
+	/**
+	 * Set the default PDO connection options.
+	 *
+	 * @param  array  $options
+	 * @return void
+	 */
+	public function setDefaultOptions(array $options)
+	{
+		$this->options = $options;
+	}
+
+}

vendor/illuminate/database/Connectors/ConnectorInterface.php

@@ -0,0 +1,13 @@
+<?php namespace Illuminate\Database\Connectors;
+
+interface ConnectorInterface {
+
+	/**
+	 * Establish a database connection.
+	 *
+	 * @param  array  $config
+	 * @return \PDO
+	 */
+	public function connect(array $config);
+
+}

vendor/illuminate/database/Connectors/MySqlConnector.php

@@ -0,0 +1,112 @@
+<?php namespace Illuminate\Database\Connectors;
+
+class MySqlConnector extends Connector implements ConnectorInterface {
+
+	/**
+	 * Establish a database connection.
+	 *
+	 * @param  array  $config
+	 * @return \PDO
+	 */
+	public function connect(array $config)
+	{
+		$dsn = $this->getDsn($config);
+
+		$options = $this->getOptions($config);
+
+		// We need to grab the PDO options that should be used while making the brand
+		// new connection instance. The PDO options control various aspects of the
+		// connection's behavior, and some might be specified by the developers.
+		$connection = $this->createConnection($dsn, $config, $options);
+
+		if (isset($config['unix_socket']))
+		{
+			$connection->exec("use `{$config['database']}`;");
+		}
+
+		$collation = $config['collation'];
+
+		// Next we will set the "names" and "collation" on the clients connections so
+		// a correct character set will be used by this client. The collation also
+		// is set on the server but needs to be set here on this client objects.
+		$charset = $config['charset'];
+
+		$names = "set names '$charset'".
+			( ! is_null($collation) ? " collate '$collation'" : '');
+
+		$connection->prepare($names)->execute();
+
+		// Next, we will check to see if a timezone has been specified in this config
+		// and if it has we will issue a statement to modify the timezone with the
+		// database. Setting this DB timezone is an optional configuration item.
+		if (isset($config['timezone']))
+		{
+			$connection->prepare(
+				'set time_zone="'.$config['timezone'].'"'
+			)->execute();
+		}
+
+		// If the "strict" option has been configured for the connection we'll enable
+		// strict mode on all of these tables. This enforces some extra rules when
+		// using the MySQL database system and is a quicker way to enforce them.
+		if (isset($config['strict']) && $config['strict'])
+		{
+			$connection->prepare("set session sql_mode='STRICT_ALL_TABLES'")->execute();
+		}
+
+		return $connection;
+	}
+
+	/**
+	 * Create a DSN string from a configuration.
+	 *
+	 * Chooses socket or host/port based on the 'unix_socket' config value.
+	 *
+	 * @param  array   $config
+	 * @return string
+	 */
+	protected function getDsn(array $config)
+	{
+		return $this->configHasSocket($config) ? $this->getSocketDsn($config) : $this->getHostDsn($config);
+	}
+
+	/**
+	 * Determine if the given configuration array has a UNIX socket value.
+	 *
+	 * @param  array  $config
+	 * @return bool
+	 */
+	protected function configHasSocket(array $config)
+	{
+		return isset($config['unix_socket']) && ! empty($config['unix_socket']);
+	}
+
+	/**
+	 * Get the DSN string for a socket configuration.
+	 *
+	 * @param  array  $config
+	 * @return string
+	 */
+	protected function getSocketDsn(array $config)
+	{
+		extract($config);
+
+		return "mysql:unix_socket={$config['unix_socket']};dbname={$database}";
+	}
+
+	/**
+	 * Get the DSN string for a host / port configuration.
+	 *
+	 * @param  array  $config
+	 * @return string
+	 */
+	protected function getHostDsn(array $config)
+	{
+		extract($config);
+
+		return isset($config['port'])
+                        ? "mysql:host={$host};port={$port};dbname={$database}"
+                        : "mysql:host={$host};dbname={$database}";
+	}
+
+}

vendor/illuminate/database/Connectors/PostgresConnector.php

@@ -0,0 +1,96 @@
+<?php namespace Illuminate\Database\Connectors;
+
+use PDO;
+
+class PostgresConnector extends Connector implements ConnectorInterface {
+
+	/**
+	 * The default PDO connection options.
+	 *
+	 * @var array
+	 */
+	protected $options = array(
+		PDO::ATTR_CASE => PDO::CASE_NATURAL,
+		PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
+		PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
+		PDO::ATTR_STRINGIFY_FETCHES => false,
+	);
+
+	/**
+	 * Establish a database connection.
+	 *
+	 * @param  array  $config
+	 * @return \PDO
+	 */
+	public function connect(array $config)
+	{
+		// First we'll create the basic DSN and connection instance connecting to the
+		// using the configuration option specified by the developer. We will also
+		// set the default character set on the connections to UTF-8 by default.
+		$dsn = $this->getDsn($config);
+
+		$options = $this->getOptions($config);
+
+		$connection = $this->createConnection($dsn, $config, $options);
+
+		$charset = $config['charset'];
+
+		$connection->prepare("set names '$charset'")->execute();
+
+		// Next, we will check to see if a timezone has been specified in this config
+		// and if it has we will issue a statement to modify the timezone with the
+		// database. Setting this DB timezone is an optional configuration item.
+		if (isset($config['timezone']))
+		{
+			$timezone = $config['timezone'];
+
+			$connection->prepare("set time zone '$timezone'")->execute();
+		}
+
+		// Unlike MySQL, Postgres allows the concept of "schema" and a default schema
+		// may have been specified on the connections. If that is the case we will
+		// set the default schema search paths to the specified database schema.
+		if (isset($config['schema']))
+		{
+			$schema = $config['schema'];
+
+			$connection->prepare("set search_path to \"{$schema}\"")->execute();
+		}
+
+		return $connection;
+	}
+
+	/**
+	 * Create a DSN string from a configuration.
+	 *
+	 * @param  array   $config
+	 * @return string
+	 */
+	protected function getDsn(array $config)
+	{
+		// First we will create the basic DSN setup as well as the port if it is in
+		// in the configuration options. This will give us the basic DSN we will
+		// need to establish the PDO connections and return them back for use.
+		extract($config);
+
+		$host = isset($host) ? "host={$host};" : '';
+
+		$dsn = "pgsql:{$host}dbname={$database}";
+
+		// If a port was specified, we will add it to this Postgres DSN connections
+		// format. Once we have done that we are ready to return this connection
+		// string back out for usage, as this has been fully constructed here.
+		if (isset($config['port']))
+		{
+			$dsn .= ";port={$port}";
+		}
+
+		if (isset($config['sslmode']))
+		{
+			$dsn .= ";sslmode={$sslmode}";
+		}
+
+		return $dsn;
+	}
+
+}

vendor/illuminate/database/Connectors/SQLiteConnector.php

@@ -0,0 +1,40 @@
+<?php namespace Illuminate\Database\Connectors;
+
+use InvalidArgumentException;
+
+class SQLiteConnector extends Connector implements ConnectorInterface {
+
+	/**
+	 * Establish a database connection.
+	 *
+	 * @param  array  $config
+	 * @return \PDO
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function connect(array $config)
+	{
+		$options = $this->getOptions($config);
+
+		// SQLite supports "in-memory" databases that only last as long as the owning
+		// connection does. These are useful for tests or for short lifetime store
+		// querying. In-memory databases may only have a single open connection.
+		if ($config['database'] == ':memory:')
+		{
+			return $this->createConnection('sqlite::memory:', $config, $options);
+		}
+
+		$path = realpath($config['database']);
+
+		// Here we'll verify that the SQLite database exists before going any further
+		// as the developer probably wants to know if the database exists and this
+		// SQLite driver will not throw any exception if it does not by default.
+		if ($path === false)
+		{
+			throw new InvalidArgumentException("Database does not exist.");
+		}
+
+		return $this->createConnection("sqlite:{$path}", $config, $options);
+	}
+
+}

vendor/illuminate/database/Connectors/SqlServerConnector.php

@@ -0,0 +1,142 @@
+<?php namespace Illuminate\Database\Connectors;
+
+use PDO;
+
+class SqlServerConnector extends Connector implements ConnectorInterface {
+
+	/**
+	 * The PDO connection options.
+	 *
+	 * @var array
+	 */
+	protected $options = array(
+		PDO::ATTR_CASE => PDO::CASE_NATURAL,
+		PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
+		PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
+		PDO::ATTR_STRINGIFY_FETCHES => false,
+	);
+
+	/**
+	 * Establish a database connection.
+	 *
+	 * @param  array  $config
+	 * @return \PDO
+	 */
+	public function connect(array $config)
+	{
+		$options = $this->getOptions($config);
+
+		return $this->createConnection($this->getDsn($config), $config, $options);
+	}
+
+	/**
+	 * Create a DSN string from a configuration.
+	 *
+	 * @param  array   $config
+	 * @return string
+	 */
+	protected function getDsn(array $config)
+	{
+		// First we will create the basic DSN setup as well as the port if it is in
+		// in the configuration options. This will give us the basic DSN we will
+		// need to establish the PDO connections and return them back for use.
+		if (in_array('dblib', $this->getAvailableDrivers()))
+		{
+			return $this->getDblibDsn($config);
+		}
+		else
+		{
+			return $this->getSqlSrvDsn($config);
+		}
+	}
+
+	/**
+	 * Get the DSN string for a DbLib connection.
+	 *
+	 * @param  array  $config
+	 * @return string
+	 */
+	protected function getDblibDsn(array $config)
+	{
+		$arguments = array(
+			'host' => $this->buildHostString($config, ':'),
+			'dbname' => $config['database']
+		);
+
+		$arguments = array_merge(
+			$arguments, array_only($config, ['appname', 'charset'])
+		);
+
+		return $this->buildConnectString('dblib', $arguments);
+	}
+
+	/**
+	 * Get the DSN string for a SqlSrv connection.
+	 *
+	 * @param  array  $config
+	 * @return string
+	 */
+	protected function getSqlSrvDsn(array $config)
+	{
+		$arguments = array(
+			'Server' => $this->buildHostString($config, ',')
+		);
+
+		if (isset($config['database'])) {
+			$arguments['Database'] = $config['database'];
+		}
+
+		if (isset($config['appname'])) {
+			$arguments['APP'] = $config['appname'];
+		}
+
+		return $this->buildConnectString('sqlsrv', $arguments);
+	}
+
+	/**
+	 * Build a connection string from the given arguments.
+	 *
+	 * @param  string  $driver
+	 * @param  array  $arguments
+	 * @return string
+	 */
+	protected function buildConnectString($driver, array $arguments)
+	{
+		$options = array_map(function($key) use ($arguments)
+		{
+			return sprintf("%s=%s", $key, $arguments[$key]);
+		}, array_keys($arguments));
+
+		return $driver.":".implode(';', $options);
+	}
+
+	/**
+	 * Build a host string from the given configuration.
+	 *
+	 * @param  array  $config
+	 * @param  string  $separator
+	 * @return string
+	 */
+	protected function buildHostString(array $config, $separator)
+	{
+		if(isset($config['port']))
+		{
+			return $config['host'].$separator.$config['port'];
+		}
+		else
+		{
+			return $config['host'];
+		}
+	}
+
+	/**
+	 * Get the available PDO drivers.
+	 *
+	 * @return array
+	 */
+	protected function getAvailableDrivers()
+	{
+		return PDO::getAvailableDrivers();
+	}
+
+}