+
+
+
+
+
- We couldn't find the page you requested on our servers. We're really sorry - about that. It's our fault, not yours. We'll work hard to get this page - back online as soon as possible. -
- -- Perhaps you would like to go to our ? -
-- Something went wrong on our servers while we were processing your request. - We're really sorry about this, and will work hard to get this resolved as - soon as possible. -
- -- Perhaps you would like to go to our ? -
-- You have successfully installed the Laravel framework. Laravel is a simple framework - that helps web artisans create beautiful, creative applications using elegant, expressive - syntax. You'll love using it. -
- -- You've landed yourself on our default home page. The route that - is generating this page lives at: -
- -APP_PATH/routes.phpAnd the view sitting before you can be found at:
- -APP_PATH/views/home/index.php- Now that you're up and running, it's time to start creating! - Here are some links to help you get started: -
- - -
- * // Call the "styles" method on the default container
- * echo Asset::styles();
- *
- * // Call the "add" method on the default container
- * Asset::add('jquery', 'js/jquery.js');
- *
- */
- public static function __callStatic($method, $parameters)
- {
- return call_user_func_array(array(static::container(), $method), $parameters);
- }
-
-}
-
-class Asset_Container {
-
- /**
- * The asset container name.
- *
- * @var string
- */
- public $name;
-
- /**
- * The bundle that the assets belong to.
- *
- * @var string
- */
- public $bundle = DEFAULT_BUNDLE;
-
- /**
- * All of the registered assets.
- *
- * @var array
- */
- public $assets = array();
-
- /**
- * Create a new asset container instance.
- *
- * @param string $name
- * @return void
- */
- public function __construct($name)
- {
- $this->name = $name;
- }
-
- /**
- * Add an asset to the container.
- *
- * The extension of the asset source will be used to determine the type of
- * asset being registered (CSS or JavaScript). When using a non-standard
- * extension, the style/script methods may be used to register assets.
- *
- *
- * // Add an asset to the container
- * Asset::container()->add('jquery', 'js/jquery.js');
- *
- * // Add an asset that has dependencies on other assets
- * Asset::add('jquery', 'js/jquery.js', 'jquery-ui');
- *
- * // Add an asset that should have attributes applied to its tags
- * Asset::add('jquery', 'js/jquery.js', null, array('defer'));
- *
- *
- * @param string $name
- * @param string $source
- * @param array $dependencies
- * @param array $attributes
- * @return void
- */
- public function add($name, $source, $dependencies = array(), $attributes = array())
- {
- $type = (pathinfo($source, PATHINFO_EXTENSION) == 'css') ? 'style' : 'script';
-
- return $this->$type($name, $source, $dependencies, $attributes);
- }
-
- /**
- * Add a CSS file to the registered assets.
- *
- * @param string $name
- * @param string $source
- * @param array $dependencies
- * @param array $attributes
- * @return Asset_Container
- */
- public function style($name, $source, $dependencies = array(), $attributes = array())
- {
- if ( ! array_key_exists('media', $attributes))
- {
- $attributes['media'] = 'all';
- }
-
- $this->register('style', $name, $source, $dependencies, $attributes);
-
- return $this;
- }
-
- /**
- * Add a JavaScript file to the registered assets.
- *
- * @param string $name
- * @param string $source
- * @param array $dependencies
- * @param array $attributes
- * @return Asset_Container
- */
- public function script($name, $source, $dependencies = array(), $attributes = array())
- {
- $this->register('script', $name, $source, $dependencies, $attributes);
-
- return $this;
- }
-
- /**
- * Returns the full-path for an asset.
- *
- * @param string $source
- * @return string
- */
- public function path($source)
- {
- return Bundle::assets($this->bundle).$source;
- }
-
- /**
- * Set the bundle that the container's assets belong to.
- *
- * @param string $bundle
- * @return Asset_Container
- */
- public function bundle($bundle)
- {
- $this->bundle = $bundle;
- return $this;
- }
-
- /**
- * Add an asset to the array of registered assets.
- *
- * @param string $type
- * @param string $name
- * @param string $source
- * @param array $dependencies
- * @param array $attributes
- * @return void
- */
- protected function register($type, $name, $source, $dependencies, $attributes)
- {
- $dependencies = (array) $dependencies;
-
- $attributes = (array) $attributes;
-
- $this->assets[$type][$name] = compact('source', 'dependencies', 'attributes');
- }
-
- /**
- * Get the links to all of the registered CSS assets.
- *
- * @return string
- */
- public function styles()
- {
- return $this->group('style');
- }
-
- /**
- * Get the links to all of the registered JavaScript assets.
- *
- * @return string
- */
- public function scripts()
- {
- return $this->group('script');
- }
-
- /**
- * Get all of the registered assets for a given type / group.
- *
- * @param string $group
- * @return string
- */
- protected function group($group)
- {
- if ( ! isset($this->assets[$group]) or count($this->assets[$group]) == 0) return '';
-
- $assets = '';
-
- foreach ($this->arrange($this->assets[$group]) as $name => $data)
- {
- $assets .= $this->asset($group, $name);
- }
-
- return $assets;
- }
-
- /**
- * Get the HTML link to a registered asset.
- *
- * @param string $group
- * @param string $name
- * @return string
- */
- protected function asset($group, $name)
- {
- if ( ! isset($this->assets[$group][$name])) return '';
-
- $asset = $this->assets[$group][$name];
-
- // If the bundle source is not a complete URL, we will go ahead and prepend
- // the bundle's asset path to the source provided with the asset. This will
- // ensure that we attach the correct path to the asset.
- if (filter_var($asset['source'], FILTER_VALIDATE_URL) === false)
- {
- $asset['source'] = $this->path($asset['source']);
- }
-
- return HTML::$group($asset['source'], $asset['attributes']);
- }
-
- /**
- * Sort and retrieve assets based on their dependencies
- *
- * @param array $assets
- * @return array
- */
- protected function arrange($assets)
- {
- list($original, $sorted) = array($assets, array());
-
- while (count($assets) > 0)
- {
- foreach ($assets as $asset => $value)
- {
- $this->evaluate_asset($asset, $value, $original, $sorted, $assets);
- }
- }
-
- return $sorted;
- }
-
- /**
- * Evaluate an asset and its dependencies.
- *
- * @param string $asset
- * @param string $value
- * @param array $original
- * @param array $sorted
- * @param array $assets
- * @return void
- */
- protected function evaluate_asset($asset, $value, $original, &$sorted, &$assets)
- {
- // If the asset has no more dependencies, we can add it to the sorted list
- // and remove it from the array of assets. Otherwise, we will not verify
- // the asset's dependencies and determine if they've been sorted.
- if (count($assets[$asset]['dependencies']) == 0)
- {
- $sorted[$asset] = $value;
-
- unset($assets[$asset]);
- }
- else
- {
- foreach ($assets[$asset]['dependencies'] as $key => $dependency)
- {
- if ( ! $this->dependency_is_valid($asset, $dependency, $original, $assets))
- {
- unset($assets[$asset]['dependencies'][$key]);
-
- continue;
- }
-
- // If the dependency has not yet been added to the sorted list, we can not
- // remove it from this asset's array of dependencies. We'll try again on
- // the next trip through the loop.
- if ( ! isset($sorted[$dependency])) continue;
-
- unset($assets[$asset]['dependencies'][$key]);
- }
- }
- }
-
- /**
- * Verify that an asset's dependency is valid.
- *
- * A dependency is considered valid if it exists, is not a circular reference, and is
- * not a reference to the owning asset itself. If the dependency doesn't exist, no
- * error or warning will be given. For the other cases, an exception is thrown.
- *
- * @param string $asset
- * @param string $dependency
- * @param array $original
- * @param array $assets
- * @return bool
- */
- protected function dependency_is_valid($asset, $dependency, $original, $assets)
- {
- if ( ! isset($original[$dependency]))
- {
- return false;
- }
- elseif ($dependency === $asset)
- {
- throw new \Exception("Asset [$asset] is dependent on itself.");
- }
- elseif (isset($assets[$dependency]) and in_array($asset, $assets[$dependency]['dependencies']))
- {
- throw new \Exception("Assets [$asset] and [$dependency] have a circular dependency.");
- }
-
- return true;
- }
-
-}
diff --git a/laravel/auth.php b/laravel/auth.php
deleted file mode 100644
index bacd0863f72..00000000000
--- a/laravel/auth.php
+++ /dev/null
@@ -1,216 +0,0 @@
-
- * // Get the current user of the application
- * $user = Auth::user();
- *
- * // Access a property on the current user of the application
- * $email = Auth::user()->email;
- *
- *
- * @return object|null
- */
- public static function user()
- {
- if ( ! is_null(static::$user)) return static::$user;
-
- $id = Session::get(Auth::user_key);
-
- // To retrieve the user, we'll first attempt to use the "user" Closure
- // defined in the auth configuration file, passing in the ID. The user
- // Closure gives the developer a ton of freedom surrounding how the
- // user is actually retrieved.
- $config = Config::get('auth');
-
- static::$user = call_user_func($config['user'], $id);
-
- // If the user wasn't found in the database but a "remember me" cookie
- // exists, we'll attempt to recall the user based on the cookie value.
- // Since all cookies contain a fingerprint hash verifying that they
- // haven't changed, we can trust it.
- $recaller = Cookie::get($config['cookie']);
-
- if (is_null(static::$user) and ! is_null($recaller))
- {
- static::$user = static::recall($recaller);
- }
-
- return static::$user;
- }
-
- /**
- * Attempt to login a user based on a long-lived "remember me" cookie.
- *
- * @param string $recaller
- * @return mixed
- */
- protected static function recall($recaller)
- {
- $recaller = explode('|', Crypter::decrypt($recaller));
-
- // We'll pass the ID that was stored in the cookie into the same user
- // Closure that is used by the "user" method. If the method returns
- // a user, we will log them into the application.
- $user = call_user_func(Config::get('auth.user'), $recaller[0]);
-
- if ( ! is_null($user))
- {
- static::login($user);
-
- return $user;
- }
- }
-
- /**
- * Attempt to log a user into the application.
- *
- *
- * // Attempt to log a user into the application
- * $success = Auth::attempt('username', 'password');
- *
- * // Attempt to login a user and set the "remember me" cookie
- * Auth::attempt('username', 'password', true);
- *
- *
- * @param string $username
- * @param string $password
- * @param bool $remember
- * @return bool
- */
- public static function attempt($username, $password = null, $remember = false)
- {
- $config = Config::get('auth');
-
- // When attempting to login the user, we will call the "attempt" closure
- // from the configuration file. This gives the developer the freedom to
- // authenticate based on the needs of their application, even allowing
- // the user of third-party providers.
- $user = call_user_func($config['attempt'], $username, $password);
-
- if (is_null($user)) return false;
-
- static::login($user, $remember);
-
- return true;
- }
-
- /**
- * Log a user into the application.
- *
- *
- * // Login the user with an ID of 15
- * Auth::login(15);
- *
- * // Login a user by passing a user object
- * Auth::login($user);
- *
- * // Login a user and set a "remember me" cookie
- * Auth::login($user, true);
- *
- *
- * @param object|int $user
- * @param bool $remember
- * @return void
- */
- public static function login($user, $remember = false)
- {
- $id = (is_object($user)) ? $user->id : (int) $user;
-
- if ($remember) static::remember($id);
-
- Session::put(Auth::user_key, $id);
- }
-
- /**
- * Set a cookie so that the user is "remembered".
- *
- * @param string $id
- * @return void
- */
- protected static function remember($id)
- {
- $recaller = Crypter::encrypt($id.'|'.Str::random(40));
-
- // This method assumes the "remember me" cookie should have the same
- // configuration as the session cookie. Since this cookie, like the
- // session cookie, should be kept very secure, it's probably safe.
- // to assume the cookie settings are the same.
- $config = Config::get('session');
-
- extract($config, EXTR_SKIP);
-
- $cookie = Config::get('auth.cookie');
-
- Cookie::forever($cookie, $recaller, $path, $domain, $secure);
- }
-
- /**
- * Log the current user out of the application.
- *
- * @return void
- */
- public static function logout()
- {
- // We will call the "logout" closure first, which gives the developer
- // the chance to do any clean-up or before the user is logged out of
- // the application. No action is taken by default.
- call_user_func(Config::get('auth.logout'), static::user());
-
- static::$user = null;
-
- $config = Config::get('session');
-
- extract($config, EXTR_SKIP);
-
- // When forgetting the cookie, we need to also pass in the path and
- // domain that would have been used when the cookie was originally
- // set by the framework, otherwise it will not be deleted.
- $cookie = Config::get('auth.cookie');
-
- Cookie::forget($cookie, $path, $domain, $secure);
-
- Session::forget(Auth::user_key);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/autoloader.php b/laravel/autoloader.php
deleted file mode 100644
index 20634fea043..00000000000
--- a/laravel/autoloader.php
+++ /dev/null
@@ -1,242 +0,0 @@
- $directory)
- {
- if (starts_with($class, $namespace))
- {
- return static::load_namespaced($class, $namespace, $directory);
- }
- }
-
- // If the class uses PEAR-ish style underscores for indicating its
- // directory structure we'll load the class using PSR-0 standards
- // standards from that directory, trimming the root.
- foreach (static::$underscored as $prefix => $directory)
- {
- if (starts_with($class, $prefix))
- {
- return static::load_namespaced($class, $prefix, $directory);
- }
- }
-
- // If all else fails we will just iterator through the mapped
- // PSR-0 directories looking for the class. This is the last
- // resort and slowest loading option for the class.
- static::load_psr($class);
- }
-
- /**
- * Load a namespaced class from a given directory.
- *
- * @param string $class
- * @param string $namespace
- * @param string $directory
- * @return void
- */
- protected static function load_namespaced($class, $namespace, $directory)
- {
- return static::load_psr(substr($class, strlen($namespace)), $directory);
- }
-
- /**
- * Attempt to resolve a class using the PSR-0 standard.
- *
- * @param string $class
- * @param string $directory
- * @return void
- */
- protected static function load_psr($class, $directory = null)
- {
- // The PSR-0 standard indicates that class namespaces and underscores
- // shoould be used to indcate the directory tree in which the class
- // resides, so we'll convert them to slashes.
- $file = str_replace(array('\\', '_'), '/', $class);
-
- $directories = $directory ?: static::$directories;
-
- $lower = strtolower($file);
-
- // Once we have formatted the class name, we'll simply spin through
- // the registered PSR-0 directories and attempt to locate and load
- // the class file into the script.
- foreach ((array) $directories as $directory)
- {
- if (file_exists($path = $directory.$lower.EXT))
- {
- return require $path;
- }
- elseif (file_exists($path = $directory.$file.EXT))
- {
- return require $path;
- }
- }
- }
-
- /**
- * Register an array of class to path mappings.
- *
- * @param array $mappings
- * @return void
- */
- public static function map($mappings)
- {
- static::$mappings = array_merge(static::$mappings, $mappings);
- }
-
- /**
- * Register a class alias with the auto-loader.
- *
- * @param string $class
- * @param string $alias
- * @return void
- */
- public static function alias($class, $alias)
- {
- static::$aliases[$alias] = $class;
- }
-
- /**
- * Register directories to be searched as a PSR-0 library.
- *
- * @param string|array $directory
- * @return void
- */
- public static function directories($directory)
- {
- $directories = static::format($directory);
-
- static::$directories = array_unique(array_merge(static::$directories, $directories));
- }
-
- /**
- * Register underscored "namespaces" to directory mappings.
- *
- * @param array $mappings
- * @return void
- */
- public static function underscored($mappings)
- {
- $mappings = static::format_mappings($mappings, '_');
-
- static::$underscored = array_merge($mappings, static::$underscored);
- }
-
- /**
- * Map namespaces to directories.
- *
- * @param array $mappings
- * @return void
- */
- public static function namespaces($mappings)
- {
- $mappings = static::format_mappings($mappings, '\\');
-
- static::$namespaces = array_merge($mappings, static::$namespaces);
- }
-
- /**
- * Format an array of namespace to directory mappings.
- *
- * @param array $mappings
- * @param string $append
- * @return array
- */
- protected static function format_mappings($mappings, $append)
- {
- foreach ($mappings as $namespace => $directory)
- {
- // When adding new namespaces to the mappings, we will unset the previously
- // mapped value if it existed. This allows previously registered spaces to
- // be mapped to new directories on the fly.
- $namespace = trim($namespace, $append).$append;
-
- unset(static::$namespaces[$namespace]);
-
- $namespaces[$namespace] = head(static::format($directory));
- }
-
- return $namespaces;
- }
-
- /**
- * Format an array of directories with the proper trailing slashes.
- *
- * @param array $directories
- * @return array
- */
- protected static function format($directories)
- {
- return array_map(function($directory)
- {
- return rtrim($directory, DS).DS;
-
- }, (array) $directories);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/blade.php b/laravel/blade.php
deleted file mode 100644
index 7e6d33c9eb4..00000000000
--- a/laravel/blade.php
+++ /dev/null
@@ -1,373 +0,0 @@
-path, BLADE_EXT))
- {
- return false;
- }
-
- $compiled = path('storage').'views/'.md5($view->path);
-
- // If the view doesn't exist or has been modified since the last time it
- // was compiled, we will recompile the view into pure PHP from it's
- // Blade representation, writing it to cached storage.
- if ( ! file_exists($compiled) or Blade::expired($view->view, $view->path))
- {
- file_put_contents($compiled, Blade::compile($view));
- }
-
- $view->path = $compiled;
-
- // Once the view has been compiled, we can simply set the path to the
- // compiled view on the view instance and call the typical "get"
- // method on the view to evaluate the compiled PHP view.
- return $view->get();
- });
- }
-
- /**
- * Determine if a view is "expired" and needs to be re-compiled.
- *
- * @param string $view
- * @param string $path
- * @param string $compiled
- * @return bool
- */
- public static function expired($view, $path)
- {
- $compiled = static::compiled($path);
-
- return filemtime($path) > filemtime(static::compiled($path));
- }
-
- /**
- * Compiles the specified file containing Blade pseudo-code into valid PHP.
- *
- * @param string $path
- * @return string
- */
- public static function compile($view)
- {
- return static::compile_string(file_get_contents($view->path), $view);
- }
-
- /**
- * Compiles the given string containing Blade pseudo-code into valid PHP.
- *
- * @param string $value
- * @param View $view
- * @return string
- */
- public static function compile_string($value, $view = null)
- {
- foreach (static::$compilers as $compiler)
- {
- $method = "compile_{$compiler}";
-
- $value = static::$method($value, $view);
- }
-
- return $value;
- }
-
- /**
- * Rewrites Blade "@layout" expressions into valid PHP.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_layouts($value)
- {
- // If the Blade template is not using "layouts", we'll just return it
- // it unchanged since there is nothing to do with layouts and we'll
- // just let the other Blade compilers handle the rest.
- if ( ! starts_with($value, '@layout'))
- {
- return $value;
- }
-
- // First we'll split out the lines of the template so we can get the
- // the layout from the top of the template. By convention it must
- // be located on the first line of the template contents.
- $lines = preg_split("/(\r?\n)/", $value);
-
- $pattern = static::matcher('layout');
-
- $lines[] = preg_replace($pattern, '$1@include$2', $lines[0]);
-
- // We will add a "render" statement to the end of the templates and
- // and then slice off the @layout shortcut from the start so the
- // sections register before the parent template renders.
- return implode(CRLF, array_slice($lines, 1));
- }
-
- /**
- * Extract a variable value out of a Blade expression.
- *
- * @param string $value
- * @return string
- */
- protected static function extract($value, $expression)
- {
- preg_match('/@layout(\s*\(.*\))(\s*)/', $value, $matches);
-
- return str_replace(array("('", "')"), '', $matches[1]);
- }
-
- /**
- * Rewrites Blade echo statements into PHP echo statements.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_echos($value)
- {
- return preg_replace('/\{\{(.+?)\}\}/', '', $value);
- }
-
- /**
- * Rewrites Blade "for else" statements into valid PHP.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_forelse($value)
- {
- preg_match_all('/(\s*)@forelse(\s*\(.*\))(\s*)/', $value, $matches);
-
- foreach ($matches[0] as $forelse)
- {
- preg_match('/\$[^\s]*/', $forelse, $variable);
-
- // Once we have extracted the variable being looped against, we can add
- // an if statmeent to the start of the loop that checks if the count
- // of the variable being looped against is greater than zero.
- $if = " 0): ?>";
-
- $search = '/(\s*)@forelse(\s*\(.*\))/';
-
- $replace = '$1'.$if.'';
-
- $blade = preg_replace($search, $replace, $forelse);
-
- // Finally, once we have the check prepended to the loop we'll replace
- // all instances of this "forelse" syntax in the view content of the
- // view being compiled to Blade syntax with real syntax.
- $value = str_replace($forelse, $blade, $value);
- }
-
- return $value;
- }
-
- /**
- * Rewrites Blade "empty" statements into valid PHP.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_empty($value)
- {
- return str_replace('@empty', '', $value);
- }
-
- /**
- * Rewrites Blade "forelse" endings into valid PHP.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_endforelse($value)
- {
- return str_replace('@endforelse', '', $value);
- }
-
- /**
- * Rewrites Blade structure openings into PHP structure openings.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_structure_openings($value)
- {
- $pattern = '/(\s*)@(if|elseif|foreach|for|while)(\s*\(.*\))/';
-
- return preg_replace($pattern, '$1', $value);
- }
-
- /**
- * Rewrites Blade structure closings into PHP structure closings.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_structure_closings($value)
- {
- $pattern = '/(\s*)@(endif|endforeach|endfor|endwhile)(\s*)/';
-
- return preg_replace($pattern, '$1$3', $value);
- }
-
- /**
- * Rewrites Blade else statements into PHP else statements.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_else($value)
- {
- return preg_replace('/(\s*)@(else)(\s*)/', '$1$3', $value);
- }
-
- /**
- * Rewrites Blade @include statements into valid PHP.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_includes($value)
- {
- $pattern = static::matcher('include');
-
- return preg_replace($pattern, '$1with(get_defined_vars()); ?>', $value);
- }
-
- /**
- * Rewrites Blade @render statements into valid PHP.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_render($value)
- {
- $pattern = static::matcher('render');
-
- return preg_replace($pattern, '$1', $value);
- }
-
- /**
- * Rewrites Blade @render_each statements into valid PHP.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_render_each($value)
- {
- $pattern = static::matcher('render_each');
-
- return preg_replace($pattern, '$1', $value);
- }
-
- /**
- * Rewrites Blade @yield statements into Section statements.
- *
- * The Blade @yield statement is a shortcut to the Section::yield method.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_yields($value)
- {
- $pattern = static::matcher('yield');
-
- return preg_replace($pattern, '$1', $value);
- }
-
- /**
- * Rewrites Blade yield section statements into valid PHP.
- *
- * @return string
- */
- protected static function compile_yield_sections($value)
- {
- $replace = '';
-
- return str_replace('@yield_section', $replace, $value);
- }
-
- /**
- * Rewrites Blade @section statements into Section statements.
- *
- * The Blade @section statement is a shortcut to the Section::start method.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_section_start($value)
- {
- $pattern = static::matcher('section');
-
- return preg_replace($pattern, '$1', $value);
- }
-
- /**
- * Rewrites Blade @endsection statements into Section statements.
- *
- * The Blade @endsection statement is a shortcut to the Section::stop method.
- *
- * @param string $value
- * @return string
- */
- protected static function compile_section_end($value)
- {
- return preg_replace('/@endsection/', '', $value);
- }
-
- /**
- * Get the regular expression for a generic Blade function.
- *
- * @param string $function
- * @return string
- */
- protected static function matcher($function)
- {
- return '/(\s*)@'.$function.'(\s*\(.*\))/';
- }
-
- /**
- * Get the fully qualified path for a compiled view.
- *
- * @param string $view
- * @return string
- */
- public static function compiled($path)
- {
- return path('storage').'views/'.md5($path);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/bundle.php b/laravel/bundle.php
deleted file mode 100644
index dd582138874..00000000000
--- a/laravel/bundle.php
+++ /dev/null
@@ -1,444 +0,0 @@
- null, 'auto' => false);
-
- // If the given configuration is actually a string, we will assume it is a
- // location and set the bundle name to match it. This is common for most
- // bundles who simply live in the root bundle directory.
- if (is_string($config))
- {
- $bundle = $config;
-
- $config = array('location' => $bundle);
- }
-
- // If no location is set, we will set the location to match the name of
- // the bundle. This is for bundles who are installed to the root of
- // the bundle directory so a location was not set.
- if ( ! isset($config['location']))
- {
- $config['location'] = $bundle;
- }
-
- static::$bundles[$bundle] = array_merge($defaults, $config);
-
- // It is possible for the develoepr to specify auto-loader mappings
- // directly on the bundle registration. This provides a convenient
- // way to register mappings withuot a bootstrap.
- if (isset($config['autoloads']))
- {
- static::autoloads($bundle, $config);
- }
- }
-
- /**
- * Load a bundle by running it's start-up script.
- *
- * If the bundle has already been started, no action will be taken.
- *
- * @param string $bundle
- * @return void
- */
- public static function start($bundle)
- {
- if (static::started($bundle)) return;
-
- if ( ! static::exists($bundle))
- {
- throw new \Exception("Bundle [$bundle] has not been installed.");
- }
-
- // Each bundle may have a start script which is responsible for preparing
- // the bundle for use by the application. The start script may register
- // any classes the bundle uses with the auto-loader, etc.
- if (file_exists($path = static::path($bundle).'start'.EXT))
- {
- require $path;
- }
-
- // Each bundle may also have a "routes" file which is responsible for
- // registering the bundle's routes. This is kept separate from the
- // start script for reverse routing efficiency purposes.
- static::routes($bundle);
-
- Event::fire("laravel.started: {$bundle}");
-
- static::$started[] = strtolower($bundle);
- }
-
- /**
- * Load the "routes" file for a given bundle.
- *
- * @param string $bundle
- * @return void
- */
- public static function routes($bundle)
- {
- if (static::routed($bundle)) return;
-
- $path = static::path($bundle).'routes'.EXT;
-
- // By setting the bundle property on the router the router knows what
- // value to replace the (:bundle) place-holder with when the bundle
- // routes are added, keeping the routes flexible.
- Router::$bundle = static::option($bundle, 'handles');
-
- if ( ! static::routed($bundle) and file_exists($path))
- {
- static::$routed[] = $bundle;
-
- require $path;
- }
- }
-
- /**
- * Register the auto-loading configuration for a bundle.
- *
- * @param string $bundle
- * @param array $config
- * @return void
- */
- protected static function autoloads($bundle, $config)
- {
- $path = rtrim(Bundle::path($bundle), DS);
-
- foreach ($config['autoloads'] as $type => $mappings)
- {
- // When registering each type of mapping we'll replace the (:bundle)
- // place-holder with the path to the bundle's root directory, so
- // the developer may dryly register the mappings.
- $mappings = array_map(function($mapping) use ($path)
- {
- return str_replace('(:bundle)', $path, $mapping);
-
- }, $mappings);
-
- // Once the mappings are formatted, we will call the Autoloader
- // function matching the mapping type and pass in the array of
- // mappings so they can be registered and used.
- Autoloader::$type($mappings);
- }
- }
-
- /**
- * Disable a bundle for the current request.
- *
- * @param string $bundle
- * @return void
- */
- public static function disable($bundle)
- {
- unset(static::$bundles[$bundle]);
- }
-
- /**
- * Determine which bundle handles the given URI.
- *
- * The default bundle is returned if no other bundle is assigned.
- *
- * @param string $uri
- * @return string
- */
- public static function handles($uri)
- {
- $uri = rtrim($uri, '/').'/';
-
- foreach (static::$bundles as $key => $value)
- {
- if (isset($value['handles']) and starts_with($uri, $value['handles'].'/'))
- {
- return $key;
- }
- }
-
- return DEFAULT_BUNDLE;
- }
-
- /**
- * Deteremine if a bundle exists within the bundles directory.
- *
- * @param string $bundle
- * @return bool
- */
- public static function exists($bundle)
- {
- return $bundle == DEFAULT_BUNDLE or in_array(strtolower($bundle), static::names());
- }
-
- /**
- * Determine if a given bundle has been started for the request.
- *
- * @param string $bundle
- * @return void
- */
- public static function started($bundle)
- {
- return in_array(strtolower($bundle), static::$started);
- }
-
- /**
- * Determine if a given bundle has its routes file loaded.
- *
- * @param string $bundle
- * @return void
- */
- public static function routed($bundle)
- {
- return in_array(strtolower($bundle), static::$routed);
- }
-
- /**
- * Get the identifier prefix for the bundle.
- *
- * @param string $bundle
- * @return string
- */
- public static function prefix($bundle)
- {
- return ($bundle !== DEFAULT_BUNDLE) ? "{$bundle}::" : '';
- }
-
- /**
- * Get the class prefix for a given bundle.
- *
- * @param string $bundle
- * @return string
- */
- public static function class_prefix($bundle)
- {
- return ($bundle !== DEFAULT_BUNDLE) ? Str::classify($bundle).'_' : '';
- }
-
- /**
- * Return the root bundle path for a given bundle.
- *
- *
- * // Returns the bundle path for the "admin" bundle
- * $path = Bundle::path('admin');
- *
- * // Returns the path('app') constant as the default bundle
- * $path = Bundle::path('application');
- *
- *
- * @param string $bundle
- * @return string
- */
- public static function path($bundle)
- {
- if (is_null($bundle) or $bundle === DEFAULT_BUNDLE)
- {
- return path('app');
- }
- else if ($location = array_get(static::$bundles, $bundle.'.location'))
- {
- return str_finish(path('bundle').$location, DS);
- }
- }
-
- /**
- * Return the root asset path for the given bundle.
- *
- * @param string $bundle
- * @return string
- */
- public static function assets($bundle)
- {
- if (is_null($bundle)) return static::assets(DEFAULT_BUNDLE);
-
- return ($bundle != DEFAULT_BUNDLE) ? URL::base()."/bundles/{$bundle}/" : URL::base().'/';
- }
-
- /**
- * Get the bundle name from a given identifier.
- *
- *
- * // Returns "admin" as the bundle name for the identifier
- * $bundle = Bundle::name('admin::home.index');
- *
- *
- * @param string $identifier
- * @return string
- */
- public static function name($identifier)
- {
- list($bundle, $element) = static::parse($identifier);
-
- return $bundle;
- }
-
- /**
- * Get the element name from a given identifier.
- *
- *
- * // Returns "home.index" as the element name for the identifier
- * $bundle = Bundle::bundle('admin::home.index');
- *
- *
- * @param string $identifier
- * @return string
- */
- public static function element($identifier)
- {
- list($bundle, $element) = static::parse($identifier);
-
- return $element;
- }
-
- /**
- * Reconstruct an identifier from a given bundle and element.
- *
- *
- * // Returns "admin::home.index"
- * $identifier = Bundle::identifier('admin', 'home.index');
- *
- * // Returns "home.index"
- * $identifier = Bundle::identifier('application', 'home.index');
- *
- *
- * @param string $bundle
- * @param string $element
- * @return string
- */
- public static function identifier($bundle, $element)
- {
- return (is_null($bundle) or $bundle == DEFAULT_BUNDLE) ? $element : $bundle.'::'.$element;
- }
-
- /**
- * Return the bundle name if it exists, else return the default bundle.
- *
- * @param string $bundle
- * @return string
- */
- public static function resolve($bundle)
- {
- return (static::exists($bundle)) ? $bundle : DEFAULT_BUNDLE;
- }
-
- /**
- * Parse a element identifier and return the bundle name and element.
- *
- *
- * // Returns array(null, 'admin.user')
- * $element = Bundle::parse('admin.user');
- *
- * // Parses "admin::user" and returns array('admin', 'user')
- * $element = Bundle::parse('admin::user');
- *
- *
- * @param string $identifier
- * @return array
- */
- public static function parse($identifier)
- {
- // The parsed elements are cached so we don't have to reparse them on each
- // subsequent request for the parsed element. So, if we've already parsed
- // the given element, we'll just return the cached copy.
- if (isset(static::$elements[$identifier]))
- {
- return static::$elements[$identifier];
- }
-
- if (strpos($identifier, '::') !== false)
- {
- $element = explode('::', strtolower($identifier));
- }
- // If no bundle is in the identifier, we will insert the default bundle
- // since classes like Config and Lang organize their items by bundle.
- // The "application" folder essentially behaves as a bundle.
- else
- {
- $element = array(DEFAULT_BUNDLE, strtolower($identifier));
- }
-
- return static::$elements[$identifier] = $element;
- }
-
- /**
- * Get the information for a given bundle.
- *
- * @param string $bundle
- * @return object
- */
- public static function get($bundle)
- {
- return array_get(static::$bundles, $bundle);
- }
-
- /**
- * Get an option for a given bundle.
- *
- * @param string $bundle
- * @param string $option
- * @return mixed
- */
- public static function option($bundle, $option)
- {
- $bundle = static::get($bundle);
-
- if ( ! is_null($bundle)) return array_get($bundle, $option);
- }
-
- /**
- * Get all of the installed bundles for the application.
- *
- * @return array
- */
- public static function all()
- {
- return static::$bundles;
- }
-
- /**
- * Get all of the installed bundle names.
- *
- * @return array
- */
- public static function names()
- {
- return array_keys(static::$bundles);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cache.php b/laravel/cache.php
deleted file mode 100644
index 723aa6eb797..00000000000
--- a/laravel/cache.php
+++ /dev/null
@@ -1,89 +0,0 @@
-
- * // Get the default cache driver instance
- * $driver = Cache::driver();
- *
- * // Get a specific cache driver instance by name
- * $driver = Cache::driver('memcached');
- *
- *
- * @param string $driver
- * @return Cache\Drivers\Driver
- */
- public static function driver($driver = null)
- {
- if (is_null($driver)) $driver = Config::get('cache.driver');
-
- if ( ! isset(static::$drivers[$driver]))
- {
- static::$drivers[$driver] = static::factory($driver);
- }
-
- return static::$drivers[$driver];
- }
-
- /**
- * Create a new cache driver instance.
- *
- * @param string $driver
- * @return Cache\Drivers\Driver
- */
- protected static function factory($driver)
- {
- switch ($driver)
- {
- case 'apc':
- return new Cache\Drivers\APC(Config::get('cache.key'));
-
- case 'file':
- return new Cache\Drivers\File(path('storage').'cache'.DS);
-
- case 'memcached':
- return new Cache\Drivers\Memcached(Memcached::connection(), Config::get('cache.key'));
-
- case 'memory':
- return new Cache\Drivers\Memory;
-
- case 'redis':
- return new Cache\Drivers\Redis(Redis::db());
-
- case 'database':
- return new Cache\Drivers\Database(Config::get('cache.key'));
-
- default:
- throw new \Exception("Cache driver {$driver} is not supported.");
- }
- }
-
- /**
- * Magic Method for calling the methods on the default cache driver.
- *
- *
- * // Call the "get" method on the default cache driver
- * $name = Cache::get('name');
- *
- * // Call the "put" method on the default cache driver
- * Cache::put('name', 'Taylor', 15);
- *
- */
- public static function __callStatic($method, $parameters)
- {
- return call_user_func_array(array(static::driver(), $method), $parameters);
- }
-
-}
diff --git a/laravel/cache/drivers/apc.php b/laravel/cache/drivers/apc.php
deleted file mode 100644
index 2fade423980..00000000000
--- a/laravel/cache/drivers/apc.php
+++ /dev/null
@@ -1,89 +0,0 @@
-key = $key;
- }
-
- /**
- * Determine if an item exists in the cache.
- *
- * @param string $key
- * @return bool
- */
- public function has($key)
- {
- return ( ! is_null($this->get($key)));
- }
-
- /**
- * Retrieve an item from the cache driver.
- *
- * @param string $key
- * @return mixed
- */
- protected function retrieve($key)
- {
- if (($cache = apc_fetch($this->key.$key)) !== false)
- {
- return $cache;
- }
- }
-
- /**
- * Write an item to the cache for a given number of minutes.
- *
- *
- * // Put an item in the cache for 15 minutes
- * Cache::put('name', 'Taylor', 15);
- *
- *
- * @param string $key
- * @param mixed $value
- * @param int $minutes
- * @return void
- */
- public function put($key, $value, $minutes)
- {
- apc_store($this->key.$key, $value, $minutes * 60);
- }
-
- /**
- * Write an item to the cache that lasts forever.
- *
- * @param string $key
- * @param mixed $value
- * @return void
- */
- public function forever($key, $value)
- {
- return $this->put($key, $value, 0);
- }
-
- /**
- * Delete an item from the cache.
- *
- * @param string $key
- * @return void
- */
- public function forget($key)
- {
- apc_delete($this->key.$key);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cache/drivers/database.php b/laravel/cache/drivers/database.php
deleted file mode 100644
index 3983e93ceba..00000000000
--- a/laravel/cache/drivers/database.php
+++ /dev/null
@@ -1,125 +0,0 @@
-key = $key;
- }
-
- /**
- * Determine if an item exists in the cache.
- *
- * @param string $key
- * @return bool
- */
- public function has($key)
- {
- return ( ! is_null($this->get($key)));
- }
-
- /**
- * Retrieve an item from the cache driver.
- *
- * @param string $key
- * @return mixed
- */
- protected function retrieve($key)
- {
- $cache = $this->table()->where('key', '=', $this->key.$key)->first();
-
- if ( ! is_null($cache))
- {
- if (time() >= $cache->expiration) return $this->forget($key);
-
- return unserialize($cache->value);
- }
- }
-
- /**
- * Write an item to the cache for a given number of minutes.
- *
- *
- * // Put an item in the cache for 15 minutes
- * Cache::put('name', 'Taylor', 15);
- *
- *
- * @param string $key
- * @param mixed $value
- * @param int $minutes
- * @return void
- */
- public function put($key, $value, $minutes)
- {
- $key = $this->key.$key;
-
- $value = serialize($value);
-
- $expiration = $this->expiration($minutes);
-
- // To update the value, we'll first attempt an insert against the
- // database and if we catch an exception, we'll assume that the
- // primary key already exists in the table and update.
- try
- {
- $this->table()->insert(compact('key', 'value', 'expiration'));
- }
- catch (\Exception $e)
- {
- $this->table()->where('key', '=', $key)->update(compact('value', 'expiration'));
- }
- }
-
- /**
- * Write an item to the cache for five years.
- *
- * @param string $key
- * @param mixed $value
- * @return void
- */
- public function forever($key, $value)
- {
- return $this->put($key, $value, 2628000);
- }
-
- /**
- * Delete an item from the cache.
- *
- * @param string $key
- * @return void
- */
- public function forget($key)
- {
- $this->table()->where('key', '=', $this->key.$key)->delete();
- }
-
- /**
- * Get a query builder for the database table.
- *
- * @return Laravel\Database\Query
- */
- protected function table()
- {
- $connection = DB::connection(Config::get('cache.database.connection'));
-
- return $connection->table(Config::get('cache.database.table'));
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cache/drivers/driver.php b/laravel/cache/drivers/driver.php
deleted file mode 100644
index b74ebe0a75e..00000000000
--- a/laravel/cache/drivers/driver.php
+++ /dev/null
@@ -1,100 +0,0 @@
-
- * // Get an item from the cache driver
- * $name = Cache::driver('name');
- *
- * // Return a default value if the requested item isn't cached
- * $name = Cache::get('name', 'Taylor');
- *
- *
- * @param string $key
- * @param mixed $default
- * @return mixed
- */
- public function get($key, $default = null)
- {
- return ( ! is_null($item = $this->retrieve($key))) ? $item : value($default);
- }
-
- /**
- * Retrieve an item from the cache driver.
- *
- * @param string $key
- * @return mixed
- */
- abstract protected function retrieve($key);
-
- /**
- * Write an item to the cache for a given number of minutes.
- *
- *
- * // Put an item in the cache for 15 minutes
- * Cache::put('name', 'Taylor', 15);
- *
- *
- * @param string $key
- * @param mixed $value
- * @param int $minutes
- * @return void
- */
- abstract public function put($key, $value, $minutes);
-
- /**
- * Get an item from the cache, or cache and return the default value.
- *
- *
- * // Get an item from the cache, or cache a value for 15 minutes
- * $name = Cache::remember('name', 'Taylor', 15);
- *
- * // Use a closure for deferred execution
- * $count = Cache::remember('count', function() { return User::count(); }, 15);
- *
- *
- * @param string $key
- * @param mixed $default
- * @param int $minutes
- * @return mixed
- */
- public function remember($key, $default, $minutes)
- {
- if ( ! is_null($item = $this->get($key, null))) return $item;
-
- $this->put($key, $default = value($default), $minutes);
-
- return $default;
- }
-
- /**
- * Delete an item from the cache.
- *
- * @param string $key
- * @return void
- */
- abstract public function forget($key);
-
- /**
- * Get the expiration time as a UNIX timestamp.
- *
- * @param int $minutes
- * @return int
- */
- protected function expiration($minutes)
- {
- return time() + ($minutes * 60);
- }
-
-}
diff --git a/laravel/cache/drivers/file.php b/laravel/cache/drivers/file.php
deleted file mode 100644
index ee54aa3de0d..00000000000
--- a/laravel/cache/drivers/file.php
+++ /dev/null
@@ -1,99 +0,0 @@
-path = $path;
- }
-
- /**
- * Determine if an item exists in the cache.
- *
- * @param string $key
- * @return bool
- */
- public function has($key)
- {
- return ( ! is_null($this->get($key)));
- }
-
- /**
- * Retrieve an item from the cache driver.
- *
- * @param string $key
- * @return mixed
- */
- protected function retrieve($key)
- {
- if ( ! file_exists($this->path.$key)) return null;
-
- // File based caches store have the expiration timestamp stored in
- // UNIX format prepended to their contents. This timestamp is then
- // extracted and removed when the cache is read to determine if
- // the file is still valid.
- if (time() >= substr($cache = file_get_contents($this->path.$key), 0, 10))
- {
- return $this->forget($key);
- }
-
- return unserialize(substr($cache, 10));
- }
-
- /**
- * Write an item to the cache for a given number of minutes.
- *
- *
- * // Put an item in the cache for 15 minutes
- * Cache::put('name', 'Taylor', 15);
- *
- *
- * @param string $key
- * @param mixed $value
- * @param int $minutes
- * @return void
- */
- public function put($key, $value, $minutes)
- {
- $value = $this->expiration($minutes).serialize($value);
-
- file_put_contents($this->path.$key, $value, LOCK_EX);
- }
-
- /**
- * Write an item to the cache for five years.
- *
- * @param string $key
- * @param mixed $value
- * @return void
- */
- public function forever($key, $value)
- {
- return $this->put($key, $value, 2628000);
- }
-
- /**
- * Delete an item from the cache.
- *
- * @param string $key
- * @return void
- */
- public function forget($key)
- {
- if (file_exists($this->path.$key)) @unlink($this->path.$key);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cache/drivers/memcached.php b/laravel/cache/drivers/memcached.php
deleted file mode 100644
index 4601e3851f7..00000000000
--- a/laravel/cache/drivers/memcached.php
+++ /dev/null
@@ -1,97 +0,0 @@
-key = $key;
- $this->memcache = $memcache;
- }
-
- /**
- * Determine if an item exists in the cache.
- *
- * @param string $key
- * @return bool
- */
- public function has($key)
- {
- return ( ! is_null($this->get($key)));
- }
-
- /**
- * Retrieve an item from the cache driver.
- *
- * @param string $key
- * @return mixed
- */
- protected function retrieve($key)
- {
- if (($cache = $this->memcache->get($this->key.$key)) !== false)
- {
- return $cache;
- }
- }
-
- /**
- * Write an item to the cache for a given number of minutes.
- *
- *
- * // Put an item in the cache for 15 minutes
- * Cache::put('name', 'Taylor', 15);
- *
- *
- * @param string $key
- * @param mixed $value
- * @param int $minutes
- * @return void
- */
- public function put($key, $value, $minutes)
- {
- $this->memcache->set($this->key.$key, $value, 0, $minutes * 60);
- }
-
- /**
- * Write an item to the cache that lasts forever.
- *
- * @param string $key
- * @param mixed $value
- * @return void
- */
- public function forever($key, $value)
- {
- return $this->put($key, $value, 0);
- }
-
- /**
- * Delete an item from the cache.
- *
- * @param string $key
- * @return void
- */
- public function forget($key)
- {
- $this->memcache->delete($this->key.$key);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cache/drivers/memory.php b/laravel/cache/drivers/memory.php
deleted file mode 100644
index 3e23334887b..00000000000
--- a/laravel/cache/drivers/memory.php
+++ /dev/null
@@ -1,88 +0,0 @@
-get($key)));
- }
-
- /**
- * Retrieve an item from the cache driver.
- *
- * @param string $key
- * @return mixed
- */
- protected function retrieve($key)
- {
- if (array_key_exists($key, $this->storage))
- {
- return $this->storage[$key];
- }
- }
-
- /**
- * Write an item to the cache for a given number of minutes.
- *
- *
- * // Put an item in the cache for 15 minutes
- * Cache::put('name', 'Taylor', 15);
- *
- *
- * @param string $key
- * @param mixed $value
- * @param int $minutes
- * @return void
- */
- public function put($key, $value, $minutes)
- {
- $this->storage[$key] = $value;
- }
-
- /**
- * Write an item to the cache that lasts forever.
- *
- * @param string $key
- * @param mixed $value
- * @return void
- */
- public function forever($key, $value)
- {
- $this->put($key, $value, 0);
- }
-
- /**
- * Delete an item from the cache.
- *
- * @param string $key
- * @return void
- */
- public function forget($key)
- {
- unset($this->storage[$key]);
- }
-
- /**
- * Flush the entire cache.
- *
- * @return void
- */
- public function flush()
- {
- $this->storage = array();
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cache/drivers/redis.php b/laravel/cache/drivers/redis.php
deleted file mode 100644
index 3195566c276..00000000000
--- a/laravel/cache/drivers/redis.php
+++ /dev/null
@@ -1,91 +0,0 @@
-redis = $redis;
- }
-
- /**
- * Determine if an item exists in the cache.
- *
- * @param string $key
- * @return bool
- */
- public function has($key)
- {
- return ( ! is_null($this->redis->get($key)));
- }
-
- /**
- * Retrieve an item from the cache driver.
- *
- * @param string $key
- * @return mixed
- */
- protected function retrieve($key)
- {
- if ( ! is_null($cache = $this->redis->get($key)))
- {
- return unserialize($cache);
- }
- }
-
- /**
- * Write an item to the cache for a given number of minutes.
- *
- *
- * // Put an item in the cache for 15 minutes
- * Cache::put('name', 'Taylor', 15);
- *
- *
- * @param string $key
- * @param mixed $value
- * @param int $minutes
- * @return void
- */
- public function put($key, $value, $minutes)
- {
- $this->forever($key, $value);
-
- $this->redis->expire($key, $minutes * 60);
- }
-
- /**
- * Write an item to the cache that lasts forever.
- *
- * @param string $key
- * @param mixed $value
- * @return void
- */
- public function forever($key, $value)
- {
- $this->redis->set($key, serialize($value));
- }
-
- /**
- * Delete an item from the cache.
- *
- * @param string $key
- * @return void
- */
- public function forget($key)
- {
- $this->redis->del($key);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/artisan.php b/laravel/cli/artisan.php
deleted file mode 100644
index a838f8e0fe4..00000000000
--- a/laravel/cli/artisan.php
+++ /dev/null
@@ -1,47 +0,0 @@
-getMessage();
-}
-
-echo PHP_EOL;
\ No newline at end of file
diff --git a/laravel/cli/command.php b/laravel/cli/command.php
deleted file mode 100644
index 7b4ae3af2cd..00000000000
--- a/laravel/cli/command.php
+++ /dev/null
@@ -1,198 +0,0 @@
-
- * // Call the migrate artisan task
- * Command::run(array('migrate'));
- *
- * // Call the migrate task with some arguments
- * Command::run(array('migrate:rollback', 'bundle-name'))
- *
- *
- * @param array $arguments
- * @return void
- */
- public static function run($arguments = array())
- {
- static::validate($arguments);
-
- list($bundle, $task, $method) = static::parse($arguments[0]);
-
- // If the task exists within a bundle, we will start the bundle so that any
- // dependencies can be registered in the application IoC container. If the
- // task is registered in the container, we'll resolve it.
- if (Bundle::exists($bundle))
- {
- Bundle::start($bundle);
- }
-
- $task = static::resolve($bundle, $task);
-
- // Once the bundle has been resolved, we'll make sure we could actually
- // find that task, and then verify that the method exists on the task
- // so we can successfully call it without a problem.
- if (is_null($task))
- {
- throw new \Exception("Sorry, I can't find that task.");
- }
-
- if (is_callable(array($task, $method)))
- {
- $task->$method(array_slice($arguments, 1));
- }
- else
- {
- throw new \Exception("Sorry, I can't find that method!");
- }
- }
-
- /**
- * Determine if the given command arguments are valid.
- *
- * @param array $arguments
- * @return void
- */
- protected static function validate($arguments)
- {
- if ( ! isset($arguments[0]))
- {
- throw new \Exception("You forgot to provide the task name.");
- }
- }
-
- /**
- * Parse the task name to extract the bundle, task, and method.
- *
- * @param string $task
- * @return array
- */
- protected static function parse($task)
- {
- list($bundle, $task) = Bundle::parse($task);
-
- // Extract the task method from the task string. Methods are called
- // on tasks by separating the task and method with a single colon.
- // If no task is specified, "run" is used as the default.
- if (str_contains($task, ':'))
- {
- list($task, $method) = explode(':', $task);
- }
- else
- {
- $method = 'run';
- }
-
- return array($bundle, $task, $method);
- }
-
- /**
- * Resolve an instance of the given task name.
- *
- *
- * // Resolve an instance of a task
- * $task = Command::resolve('application', 'migrate');
- *
- * // Resolve an instance of a task wtihin a bundle
- * $task = Command::resolve('bundle', 'foo');
- *
- *
- * @param string $bundle
- * @param string $task
- * @return object
- */
- public static function resolve($bundle, $task)
- {
- $identifier = Bundle::identifier($bundle, $task);
-
- // First we'll check to see if the task has been registered in the
- // application IoC container. This allows all dependencies to be
- // injected into tasks for more flexible testability.
- if (IoC::registered("task: {$identifier}"))
- {
- return IoC::resolve("task: {$identifier}");
- }
-
- // If the task file exists, we'll format the bundle and task name
- // into a task class name and resolve an instance of the so that
- // the requested method may be executed.
- if (file_exists($path = Bundle::path($bundle).'tasks/'.$task.EXT))
- {
- require $path;
-
- $task = static::format($bundle, $task);
-
- return new $task;
- }
- }
-
- /**
- * Parse the command line arguments and return the results.
- *
- * @param array $argv
- * @return array
- */
- public static function options($argv)
- {
- $options = array();
-
- $arguments = array();
-
- for ($i = 0, $count = count($argv); $i < $count; $i++)
- {
- $argument = $argv[$i];
-
- // If the CLI argument starts with a double hyphen, it is an option,
- // so we will extract the value and add it to the array of options
- // to be returned by the method.
- if (starts_with($argument, '--'))
- {
- // By default, we will assume the value of the options is true,
- // but if the option contains an equals sign, we will take the
- // value to the right of the equals sign as the value and
- // remove the value from the option key.
- list($key, $value) = array(substr($argument, 2), true);
-
- if (($equals = strpos($argument, '=')) !== false)
- {
- $key = substr($argument, 2, $equals - 2);
-
- $value = substr($argument, $equals + 1);
- }
-
- $options[$key] = $value;
- }
- // If the CLI argument does not start with a double hyphen it's
- // simply an argument to be passed to the console task so we'll
- // add it to the array of "regular" arguments.
- else
- {
- $arguments[] = $argument;
- }
- }
-
- return array($arguments, $options);
- }
-
- /**
- * Format a bundle and task into a task class name.
- *
- * @param string $bundle
- * @param string $task
- * @return string
- */
- protected static function format($bundle, $task)
- {
- $prefix = Bundle::class_prefix($bundle);
-
- return '\\'.$prefix.Str::classify($task).'_Task';
- }
-
-}
diff --git a/laravel/cli/dependencies.php b/laravel/cli/dependencies.php
deleted file mode 100644
index 3c6acc49291..00000000000
--- a/laravel/cli/dependencies.php
+++ /dev/null
@@ -1,100 +0,0 @@
-repository = $repository;
- }
-
- /**
- * Install the given bundles into the application.
- *
- * @param array $bundles
- * @return void
- */
- public function install($bundles)
- {
- foreach ($this->get($bundles) as $bundle)
- {
- if (Bundle::exists($bundle['name']))
- {
- echo "Bundle {$bundle['name']} is already installed.";
-
- continue;
- }
-
- // Once we have the bundle information, we can resolve an instance
- // of a provider and install the bundle into the application and
- // all of its registered dependencies as well.
- //
- // Each bundle provider implements the Provider interface and
- // is repsonsible for retrieving the bundle source from its
- // hosting party and installing it into the application.
- $path = path('bundle').$this->path($bundle);
-
- echo "Fetching [{$bundle['name']}]...";
-
- $this->download($bundle, $path);
-
- echo "done! Bundle installed.".PHP_EOL;
- }
- }
-
- /**
- * Upgrade the given bundles for the application.
- *
- * @param array $bundles
- * @return void
- */
- public function upgrade($bundles)
- {
- if (count($bundles) == 0) $bundles = Bundle::names();
-
- foreach ($bundles as $name)
- {
- if ( ! Bundle::exists($name))
- {
- echo "Bundle [{$name}] is not installed!";
-
- continue;
- }
-
- // First we want to retrieve the information for the bundle, such as
- // where it is currently installed. This will allow us to upgrade
- // the bundle into it's current installation path.
- $location = Bundle::path($name);
-
- // If the bundle exists, we will grab the data about the bundle from
- // the API so we can make the right bundle provider for the bundle,
- // since we don't know the provider used to install.
- $response = $this->retrieve($name);
-
- if ($response['status'] == 'not-found')
- {
- continue;
- }
-
- // Once we have the bundle information from the API, we'll simply
- // recursively delete the bundle and then re-download it using
- // the correct provider assigned to the bundle.
- File::rmdir($location);
-
- $this->download($response['bundle'], $location);
-
- echo "Bundle [{$name}] has been upgraded!".PHP_EOL;
- }
- }
-
- /**
- * Gather all of the bundles from the bundle repository.
- *
- * @param array $bundles
- * @return array
- */
- protected function get($bundles)
- {
- $responses = array();
-
- foreach ($bundles as $bundle)
- {
- // First we'll call the bundle repository to gather the bundle data
- // array, which contains all of the information needed to install
- // the bundle into the Laravel application.
- $response = $this->retrieve($bundle);
-
- if ($response['status'] == 'not-found')
- {
- throw new \Exception("There is not a bundle named [$bundle].");
- }
-
- // If the bundle was retrieved successfully, we will add it to
- // our array of bundles, as well as merge all of the bundle's
- // dependencies into the array of responses.
- $bundle = $response['bundle'];
-
- $responses[] = $bundle;
-
- // We'll also get the bundle's declared dependenceis so they
- // can be installed along with the bundle, making it easy
- // to install a group of bundles.
- $dependencies = $this->get($bundle['dependencies']);
-
- $responses = array_merge($responses, $dependencies);
- }
-
- return $responses;
- }
-
- /**
- * Publish bundle assets to the public directory.
- *
- * @param array $bundles
- * @return void
- */
- public function publish($bundles)
- {
- if (count($bundles) == 0) $bundles = Bundle::names();
-
- array_walk($bundles, array(IoC::resolve('bundle.publisher'), 'publish'));
- }
-
- /**
- * Install a bundle using a provider.
- *
- * @param string $bundle
- * @param string $path
- * @return void
- */
- protected function download($bundle, $path)
- {
- $provider = "bundle.provider: {$bundle['provider']}";
-
- IoC::resolve($provider)->install($bundle, $path);
- }
-
- /**
- * Retrieve a bundle from the repository.
- *
- * @param string $bundle
- * @return array
- */
- protected function retrieve($bundle)
- {
- $response = $this->repository->get($bundle);
-
- if ( ! $response)
- {
- throw new \Exception("The bundle API is not responding.");
- }
-
- return $response;
- }
-
- /**
- * Return the path for a given bundle.
- *
- * @param array $bundle
- * @return string
- */
- protected function path($bundle)
- {
- return array_get($bundle, 'path', $bundle['name']);
- }
-
-}
diff --git a/laravel/cli/tasks/bundle/providers/github.php b/laravel/cli/tasks/bundle/providers/github.php
deleted file mode 100644
index 7aa34623693..00000000000
--- a/laravel/cli/tasks/bundle/providers/github.php
+++ /dev/null
@@ -1,19 +0,0 @@
-download($url));
-
- $zip = new \ZipArchive;
-
- $zip->open($target);
-
- // Once we have the Zip archive, we can open it and extract it
- // into the working directory. By convention, we expect the
- // archive to contain one root directory with the bundle.
- mkdir($work.'zip');
-
- $zip->extractTo($work.'zip');
-
- $latest = File::latest($work.'zip')->getRealPath();
-
- @chmod($latest, 0777);
-
- // Once we have the latest modified directory, we should be
- // able to move its contents over into the bundles folder
- // so the bundle will be usable by the develoepr.
- File::mvdir($latest, $path);
-
- File::rmdir($work.'zip');
-
- @unlink($target);
- }
-
- /**
- * Download a remote zip archive from a URL.
- *
- * @param string $url
- * @return string
- */
- protected function download($url)
- {
- $remote = file_get_contents($url);
-
- // If we were unable to download the zip archive correctly
- // we'll bomb out since we don't want to extract the last
- // zip that was put in the storage directory.
- if ($remote === false)
- {
- throw new \Exception("Error downloading bundle [{$bundle}].");
- }
-
- return $remote;
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/bundle/publisher.php b/laravel/cli/tasks/bundle/publisher.php
deleted file mode 100644
index 12527b08eb7..00000000000
--- a/laravel/cli/tasks/bundle/publisher.php
+++ /dev/null
@@ -1,65 +0,0 @@
-move($path.'public', path('public').'bundles'.DS.$bundle);
-
- echo "Assets published for bundle [$bundle].".PHP_EOL;
- }
-
- /**
- * Copy the contents of a bundle's assets to the public folder.
- *
- * @param string $source
- * @param string $destination
- * @return void
- */
- protected function move($source, $destination)
- {
- File::cpdir($source, $destination);
- }
-
- /**
- * Get the "to" location of the bundle's assets.
- *
- * @param string $bundle
- * @return string
- */
- protected function to($bundle)
- {
- return path('public').'bundles'.DS.$bundle.DS;
- }
-
- /**
- * Get the "from" location of the bundle's assets.
- *
- * @param string $bundle
- * @return string
- */
- protected function from($bundle)
- {
- return Bundle::path($bundle).'public';
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/bundle/repository.php b/laravel/cli/tasks/bundle/repository.php
deleted file mode 100644
index 2ee43d9c177..00000000000
--- a/laravel/cli/tasks/bundle/repository.php
+++ /dev/null
@@ -1,29 +0,0 @@
-api.$bundle);
-
- return json_decode($bundle, true);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/key.php b/laravel/cli/tasks/key.php
deleted file mode 100644
index 0c08a84f96c..00000000000
--- a/laravel/cli/tasks/key.php
+++ /dev/null
@@ -1,57 +0,0 @@
-path = path('app').'config/application'.EXT;
- }
-
- /**
- * Generate a random key for the application.
- *
- * @param array $arguments
- * @return void
- */
- public function generate($arguments = array())
- {
- // By default the Crypter class uses AES-256 encryption which uses
- // a 32 byte input vector, so that is the length of string we will
- // generate for the application token unless another length is
- // specified through the CLI.
- $key = Str::random(array_get($arguments, 0, 32));
-
- $config = File::get($this->path);
-
- $config = str_replace("'key' => '',", "'key' => '{$key}',", $config, $count);
-
- File::put($this->path, $config);
-
- if ($count > 0)
- {
- echo "Configuration updated with secure key!";
- }
- else
- {
- echo "An application key already exists!";
- }
-
- echo PHP_EOL;
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/migrate/database.php b/laravel/cli/tasks/migrate/database.php
deleted file mode 100644
index a6aae9d5e1a..00000000000
--- a/laravel/cli/tasks/migrate/database.php
+++ /dev/null
@@ -1,84 +0,0 @@
-table()->insert(compact('bundle', 'name', 'batch'));
- }
-
- /**
- * Delete a row from the migration table.
- *
- * @param string $bundle
- * @param string $name
- * @return void
- */
- public function delete($bundle, $name)
- {
- $this->table()->where_bundle_and_name($bundle, $name)->delete();
- }
-
- /**
- * Return an array of the last batch of migrations.
- *
- * @return array
- */
- public function last()
- {
- $table = $this->table();
-
- // First we need to grab the last batch ID from the migration table,
- // as this will allow us to grab the lastest batch of migrations
- // that need to be run for a rollback command.
- $id = $this->batch();
-
- // Once we have the batch ID, we will pull all of the rows for that
- // batch. Then we can feed the results into the resolve method to
- // get the migration instances for the command.
- return $table->where_batch($id)->order_by('name', 'desc')->get();
- }
-
- /**
- * Get all of the migrations that have run for a bundle.
- *
- * @param string $bundle
- * @return array
- */
- public function ran($bundle)
- {
- return $this->table()->where_bundle($bundle)->lists('name');
- }
-
- /**
- * Get the maximum batch ID from the migration table.
- *
- * @return int
- */
- public function batch()
- {
- return $this->table()->max('batch');
- }
-
- /**
- * Get a database query instance for the migration table.
- *
- * @return Laravel\Database\Query
- */
- protected function table()
- {
- return DB::connection(Request::server('cli.db'))->table('laravel_migrations');
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/migrate/migrator.php b/laravel/cli/tasks/migrate/migrator.php
deleted file mode 100644
index 5bf7617bf2f..00000000000
--- a/laravel/cli/tasks/migrate/migrator.php
+++ /dev/null
@@ -1,245 +0,0 @@
-resolver = $resolver;
- $this->database = $database;
- }
-
- /**
- * Run a database migration command.
- *
- * @param array $arguments
- * @return void
- */
- public function run($arguments = array())
- {
- // If no arguments were passed to the task, we will just migrate
- // to the latest version across all bundles. Otherwise, we will
- // parse the arguments to determine the bundle for which the
- // database migrations should be run.
- if (count($arguments) == 0)
- {
- $this->migrate();
- }
- else
- {
- $this->migrate(array_get($arguments, 0));
- }
- }
-
- /**
- * Run the outstanding migrations for a given bundle.
- *
- * @param string $bundle
- * @param int $version
- * @return void
- */
- public function migrate($bundle = null, $version = null)
- {
- $migrations = $this->resolver->outstanding($bundle);
-
- if (count($migrations) == 0)
- {
- echo "No outstanding migrations.";
-
- return;
- }
-
- // We need to grab the latest batch ID and increment it by one.
- // This allows us to group the migrations so we can easily
- // determine which migrations need to roll back.
- $batch = $this->database->batch() + 1;
-
- foreach ($migrations as $migration)
- {
- $migration['migration']->up();
-
- echo 'Migrated: '.$this->display($migration).PHP_EOL;
-
- // After running a migration, we log its execution in the migration
- // table so that we can easily determine which migrations we'll
- // reverse in the event of a migration rollback.
- $this->database->log($migration['bundle'], $migration['name'], $batch);
- }
- }
-
- /**
- * Rollback the latest migration command.
- *
- * @param array $arguments
- * @return bool
- */
- public function rollback($arguments = array())
- {
- $migrations = $this->resolver->last();
-
- if (count($migrations) == 0)
- {
- echo "Nothing to rollback.";
-
- return false;
- }
-
- // The "last" method on the resolver returns an array of migrations,
- // along with their bundles and names. We will iterate through each
- // migration and run the "down" method.
- foreach (array_reverse($migrations) as $migration)
- {
- $migration['migration']->down();
-
- echo 'Rolled back: '.$this->display($migration).PHP_EOL;
-
- // By only removing the migration after it has successfully rolled back,
- // we can re-run the rollback command in the event of any errors with
- // the migration and pick up where we left off.
- $this->database->delete($migration['bundle'], $migration['name']);
- }
-
- return true;
- }
-
- /**
- * Rollback all of the executed migrations.
- *
- * @param array $arguments
- * @return void
- */
- public function reset($arguments = array())
- {
- while ($this->rollback()) {};
- }
-
- /**
- * Install the database tables used by the migration system.
- *
- * @return void
- */
- public function install()
- {
- Schema::table('laravel_migrations', function($table)
- {
- $table->create();
-
- // Migrations can be run for a specific bundle, so we'll use
- // the bundle name and string migration name as an unique ID
- // for the migrations, allowing us to easily identify which
- // migrations have been run for each bundle.
- $table->string('bundle', 50);
-
- $table->string('name', 200);
-
- // When running a migration command, we will store a batch
- // ID with each of the rows on the table. This will allow
- // us to grab all of the migrations that were run for the
- // last command when performing rollbacks.
- $table->integer('batch');
-
- $table->primary(array('bundle', 'name'));
- });
-
- echo "Migration table created successfully.";
- }
-
- /**
- * Generate a new migration file.
- *
- * @param array $arguments
- * @return string
- */
- public function make($arguments = array())
- {
- if (count($arguments) == 0)
- {
- throw new \Exception("I need to know what to name the migration.");
- }
-
- list($bundle, $migration) = Bundle::parse($arguments[0]);
-
- // The migration path is prefixed with the date timestamp, which
- // is a better way of ordering migrations than a simple integer
- // incrementation, since developers may start working on the
- // next migration at the same time unknowingly.
- $prefix = date('Y_m_d_His');
-
- $path = Bundle::path($bundle).'migrations'.DS;
-
- // If the migration directory does not exist for the bundle,
- // we will create the directory so there aren't errors when
- // when we try to write the migration file.
- if ( ! is_dir($path)) mkdir($path);
-
- $file = $path.$prefix.'_'.$migration.EXT;
-
- File::put($file, $this->stub($bundle, $migration));
-
- echo "Great! New migration created!";
-
- // Once the migration has been created, we'll return the
- // migration file name so it can be used by the task
- // consumer if necessary for futher work.
- return $file;
- }
-
- /**
- * Get the stub migration with the proper class name.
- *
- * @param string $bundle
- * @param string $migration
- * @return string
- */
- protected function stub($bundle, $migration)
- {
- $stub = File::get(path('sys').'cli/tasks/migrate/stub'.EXT);
-
- $prefix = Bundle::class_prefix($bundle);
-
- // The class name is formatted simialrly to tasks and controllers,
- // where the bundle name is prefixed to the class if it is not in
- // the default "application" bundle.
- $class = $prefix.Str::classify($migration);
-
- return str_replace('{{class}}', $class, $stub);
- }
-
- /**
- * Get the migration bundle and name for display.
- *
- * @param array $migration
- * @return string
- */
- protected function display($migration)
- {
- return $migration['bundle'].'/'.$migration['name'];
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/migrate/resolver.php b/laravel/cli/tasks/migrate/resolver.php
deleted file mode 100644
index f139195ce2c..00000000000
--- a/laravel/cli/tasks/migrate/resolver.php
+++ /dev/null
@@ -1,175 +0,0 @@
-database = $database;
- }
-
- /**
- * Resolve all of the outstanding migrations for a bundle.
- *
- * @param string $bundle
- * @return array
- */
- public function outstanding($bundle = null)
- {
- $migrations = array();
-
- // If no bundle was given to the command, we'll grab every bundle for
- // the application, including the "application" bundle, which is not
- // returned by "all" method on the Bundle class.
- if (is_null($bundle))
- {
- $bundles = array_merge(Bundle::names(), array('application'));
- }
- else
- {
- $bundles = array($bundle);
- }
-
- foreach ($bundles as $bundle)
- {
- // First we need to grab all of the migrations that have already
- // run for this bundle, as well as all of the migration files
- // for the bundle. Once we have these, we can determine which
- // migrations are still outstanding.
- $ran = $this->database->ran($bundle);
-
- $files = $this->migrations($bundle);
-
- // To find outstanding migrations, we will simply iterate over
- // the migration files and add the files that do not exist in
- // the array of ran migrations to the outstanding array.
- foreach ($files as $key => $name)
- {
- if ( ! in_array($name, $ran))
- {
- $migrations[] = compact('bundle', 'name');
- }
- }
- }
-
- return $this->resolve($migrations);
- }
-
- /**
- * Resolve an array of the last batch of migrations.
- *
- * @return array
- */
- public function last()
- {
- return $this->resolve($this->database->last());
- }
-
- /**
- * Resolve an array of migration instances.
- *
- * @param array $migrations
- * @return array
- */
- protected function resolve($migrations)
- {
- $instances = array();
-
- foreach ($migrations as $migration)
- {
- $migration = (array) $migration;
-
- // The migration array contains the bundle name, so we will get the
- // path to the bundle's migrations and resolve an instance of the
- // migration using the name.
- $bundle = $migration['bundle'];
-
- $path = Bundle::path($bundle).'migrations/';
-
- // Migrations are not resolved through the auto-loader, so we will
- // manually instantiate the migration class instances for each of
- // the migration names we're given.
- $name = $migration['name'];
-
- require_once $path.$name.EXT;
-
- // Since the migration name will begin with the numeric ID, we'll
- // slice off the ID so we are left with the migration class name.
- // The IDs are for sorting when resolving outstanding migrations.
- //
- // Migrations that exist within bundles other than the default
- // will be prefixed with the bundle name to avoid any possible
- // naming collisions with other bundle's migrations.
- $prefix = Bundle::class_prefix($bundle);
-
- $class = $prefix.substr($name, 18);
-
- $migration = new $class;
-
- // When adding to the array of instances, we will actually
- // add the migration instance, the bundle, and the name.
- // This allows the migrator to log the bundle and name
- // when the migration is executed.
- $instances[] = compact('bundle', 'name', 'migration');
- }
-
- // At this point the migrations are only sorted within their
- // bundles so we need to resort them by name to ensure they
- // are in a consistent order.
- usort($instances, function($a, $b)
- {
- return strcmp($a['name'], $b['name']);
- });
-
- return $instances;
- }
-
- /**
- * Grab all of the migration filenames for a bundle.
- *
- * @param string $bundle
- * @return array
- */
- protected function migrations($bundle)
- {
- $files = glob(Bundle::path($bundle).'migrations/*_*'.EXT);
-
- // When open_basedir is enabled, glob will return false on an
- // empty directory, so we will return an empty array in this
- // case so the application doesn't bomb out.
- if ($files === false)
- {
- return array();
- }
-
- // Once we have the array of files in the migration directory,
- // we'll take the basename of the file and remove the PHP file
- // extension, which isn't needed.
- foreach ($files as &$file)
- {
- $file = str_replace(EXT, '', basename($file));
- }
-
- // We'll also sort the files so that the earlier migrations
- // will be at the front of the array and will be resolved
- // first by this class' resolve method.
- sort($files);
-
- return $files;
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/migrate/stub.php b/laravel/cli/tasks/migrate/stub.php
deleted file mode 100644
index 6ce685f40fb..00000000000
--- a/laravel/cli/tasks/migrate/stub.php
+++ /dev/null
@@ -1,25 +0,0 @@
-route();
-
- echo PHP_EOL;
- }
-
- /**
- * Dump the results of the currently established route.
- *
- * @return void
- */
- protected function route()
- {
- // We'll call the router using the method and URI specified by
- // the developer on the CLI. If a route is found, we will not
- // run the filters, but simply dump the result.
- $route = Router::route(Request::method(), URI::current());
-
- if ( ! is_null($route))
- {
- var_dump($route->response());
- }
- else
- {
- echo '404: Not Found';
- }
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/session/manager.php b/laravel/cli/tasks/session/manager.php
deleted file mode 100644
index ebf30a0c3ec..00000000000
--- a/laravel/cli/tasks/session/manager.php
+++ /dev/null
@@ -1,93 +0,0 @@
-generate();
-
- // To create the session table, we will actually create a database
- // migration and then run it. This allows the application to stay
- // portable through the framework's migrations system.
- $migration = $migrator->make(array('create_session_table'));
-
- $stub = path('sys').'cli/tasks/session/migration'.EXT;
-
- File::put($migration, File::get($stub));
-
- // By default no session driver is set within the configuration.
- // Since the developer is requesting that the session table be
- // created on the database, we'll set it.
- $this->driver('database');
-
- echo PHP_EOL;
-
- $migrator->run();
- }
-
- /**
- * Sweep the expired sessions from storage.
- *
- * @param array $arguments
- * @return void
- */
- public function sweep($arguments = array())
- {
- $driver = Session::factory(Config::get('session.driver'));
-
- // If the driver implements the "Sweeper" interface, we know that it
- // can sweep expired sessions from storage. Not all drivers need be
- // sweepers since they do their own.
- if ($driver instanceof Sweeper)
- {
- $lifetime = Config::get('session.lifetime');
-
- $driver->sweep(time() - ($lifetime * 60));
- }
-
- echo "The session table has been swept!";
- }
-
- /**
- * Set the session driver to a given value.
- *
- * @param string $driver
- * @return void
- */
- protected function driver($driver)
- {
- // By default no session driver is set within the configuration.
- // This method will replace the empty driver option with the
- // driver specified in the arguments.
- $config = File::get(path('app').'config/session'.EXT);
-
- $config = str_replace(
- "'driver' => '',",
- "'driver' => 'database',",
- $config
- );
-
- File::put(path('app').'config/session'.EXT, $config);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/session/migration.php b/laravel/cli/tasks/session/migration.php
deleted file mode 100644
index 8ef8632eeb2..00000000000
--- a/laravel/cli/tasks/session/migration.php
+++ /dev/null
@@ -1,40 +0,0 @@
-create();
-
- // The session table consists simply of an ID, a UNIX timestamp to
- // indicate the expiration time, and a blob field which will hold
- // the serialized form of the session payload.
- $table->string('id')->length(40)->primary('session_primary');
-
- $table->integer('last_activity');
-
- $table->text('data');
- });
- }
-
- /**
- * Revert the changes to the database.
- *
- * @return void
- */
- public function down()
- {
- Schema::table(Config::get('session.table'), function($table)
- {
- $table->drop();
- });
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/task.php b/laravel/cli/tasks/task.php
deleted file mode 100644
index 0ed4e2c1b51..00000000000
--- a/laravel/cli/tasks/task.php
+++ /dev/null
@@ -1,3 +0,0 @@
-
- * @link http://laravel.com
- */
-
-// --------------------------------------------------------------
-// Define the directory separator for the environment.
-// --------------------------------------------------------------
-define('DS', DIRECTORY_SEPARATOR);
-
-// --------------------------------------------------------------
-// Set the core Laravel path constants.
-// --------------------------------------------------------------
-require 'paths.php';
-
-// --------------------------------------------------------------
-// Override the application paths when testing the core.
-// --------------------------------------------------------------
-$config = file_get_contents('phpunit.xml');
-
-if (strpos($config, 'laravel-tests') !== false)
-{
- $path = path('bundle').'laravel-tests'.DS;
-
- set_path('app', $path.'application'.DS);
-
- set_path('bundle', $path.'bundles'.DS);
-
- set_path('storage', $path.'storage'.DS);
-}
-
-// --------------------------------------------------------------
-// Bootstrap the Laravel core.
-// --------------------------------------------------------------
-require path('sys').'core.php';
-
-// --------------------------------------------------------------
-// Start the default bundle.
-// --------------------------------------------------------------
-Laravel\Bundle::start(DEFAULT_BUNDLE);
\ No newline at end of file
diff --git a/laravel/cli/tasks/test/runner.php b/laravel/cli/tasks/test/runner.php
deleted file mode 100644
index 85787896e08..00000000000
--- a/laravel/cli/tasks/test/runner.php
+++ /dev/null
@@ -1,138 +0,0 @@
-bundle($bundles);
- }
-
- /**
- * Run the tests for the Laravel framework.
- *
- * @return void
- */
- public function core()
- {
- if ( ! is_dir(path('bundle').'laravel-tests'))
- {
- throw new \Exception("The bundle [laravel-tests] has not been installed!");
- }
-
- // When testing the Laravel core, we will just stub the path directly
- // so the test bundle is not required to be registered in the bundle
- // configuration, as it is kind of a unique bundle.
- $this->stub(path('bundle').'laravel-tests/cases');
-
- $path = path('bundle').'laravel-tests/';
-
- $this->test();
- }
-
- /**
- * Run the tests for a given bundle.
- *
- * @param array $bundles
- * @return void
- */
- public function bundle($bundles = array())
- {
- if (count($bundles) == 0)
- {
- $bundles = Bundle::names();
- }
-
- foreach ($bundles as $bundle)
- {
- // To run PHPUnit for the application, bundles, and the framework
- // from one task, we'll dynamically stub PHPUnit.xml files via
- // the task and point the test suite to the correct directory
- // based on what was requested.
- if (is_dir($path = Bundle::path($bundle).'tests'))
- {
- $this->stub($path);
-
- $this->test();
- }
- }
- }
-
- /**
- * Run PHPUnit with the temporary XML configuration.
- *
- * @return void
- */
- protected function test()
- {
- // We'll simply fire off PHPUnit with the configuration switch
- // pointing to our temporary configuration file. This allows
- // us to flexibly run tests for any setup.
- $path = path('base').'phpunit.xml';
-
- passthru('phpunit --configuration '.$path);
-
- @unlink($path);
- }
-
- /**
- * Write a stub phpunit.xml file to the base directory.
- *
- * @param string $directory
- * @return void
- */
- protected function stub($directory)
- {
- $path = path('sys').'cli/tasks/test/';
-
- $stub = File::get($path.'stub.xml');
-
- // The PHPUnit bootstrap file contains several items that are swapped
- // at test time. This allows us to point PHPUnit at a few different
- // locations depending on what the developer wants to test.
- foreach (array('bootstrap', 'directory') as $item)
- {
- $stub = $this->{"swap_{$item}"}($stub, $path, $directory);
- }
-
- File::put(path('base').'phpunit.xml', $stub);
- }
-
- /**
- * Swap the bootstrap file in the stub.
- *
- * @param string $stub
- * @param string $path
- * @param string $directory
- * @return string
- */
- protected function swap_bootstrap($stub, $path, $directory)
- {
- return str_replace('{{bootstrap}}', $path.'phpunit.php', $stub);
- }
-
- /**
- * Swap the directory in the stub.
- *
- * @param string $stub
- * @param string $path
- * @param string $directory
- * @return string
- */
- protected function swap_directory($stub, $path, $directory)
- {
- return str_replace('{{directory}}', $directory, $stub);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cli/tasks/test/stub.xml b/laravel/cli/tasks/test/stub.xml
deleted file mode 100644
index d8f569fed54..00000000000
--- a/laravel/cli/tasks/test/stub.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-
- * // Get the "session" configuration array
- * $session = Config::get('session');
- *
- * // Get a configuration item from a bundle's configuration file
- * $name = Config::get('admin::names.first');
- *
- * // Get the "timezone" option from the "application" configuration file
- * $timezone = Config::get('application.timezone');
- *
- *
- * @param string $key
- * @param mixed $default
- * @return array
- */
- public static function get($key, $default = null)
- {
- list($bundle, $file, $item) = static::parse($key);
-
- if ( ! static::load($bundle, $file)) return value($default);
-
- $items = static::$items[$bundle][$file];
-
- // If a specific configuration item was not requested, the key will be null,
- // meaning we'll to return the entire array of configuration item from the
- // requested configuration file. Otherwise we can return the item.
- if (is_null($item))
- {
- return $items;
- }
- else
- {
- return array_get($items, $item, $default);
- }
- }
-
- /**
- * Set a configuration item's value.
- *
- *
- * // Set the "session" configuration array
- * Config::set('session', $array);
- *
- * // Set a configuration option that belongs by a bundle
- * Config::set('admin::names.first', 'Taylor');
- *
- * // Set the "timezone" option in the "application" configuration file
- * Config::set('application.timezone', 'UTC');
- *
- *
- * @param string $key
- * @param mixed $value
- * @return void
- */
- public static function set($key, $value)
- {
- list($bundle, $file, $item) = static::parse($key);
-
- static::load($bundle, $file);
-
- // If the item is null, it means the developer wishes to set the entire
- // configuration array to a given value, so we will pass the entire
- // array for the bundle into the array_set method.
- if (is_null($item))
- {
- array_set(static::$items[$bundle], $file, $value);
- }
- else
- {
- array_set(static::$items[$bundle][$file], $item, $value);
- }
- }
-
- /**
- * Parse a key and return its bundle, file, and key segments.
- *
- * Configuration items are named using the {bundle}::{file}.{item} convention.
- *
- * @param string $key
- * @return array
- */
- protected static function parse($key)
- {
- // First, we'll check the keyed cache of configuration items, as this will
- // be the fastest method of retrieving the configuration option. After an
- // item is parsed, it is always stored in the cache by its key.
- if (array_key_exists($key, static::$cache))
- {
- return static::$cache[$key];
- }
-
- $bundle = Bundle::name($key);
-
- $segments = explode('.', Bundle::element($key));
-
- // If there are not at least two segments in the array, it means that the
- // developer is requesting the entire configuration array to be returned.
- // If that is the case, we'll make the item field "null".
- if (count($segments) >= 2)
- {
- $parsed = array($bundle, $segments[0], implode('.', array_slice($segments, 1)));
- }
- else
- {
- $parsed = array($bundle, $segments[0], null);
- }
-
- return static::$cache[$key] = $parsed;
- }
-
- /**
- * Load all of the configuration items from a configuration file.
- *
- * @param string $bundle
- * @param string $file
- * @return bool
- */
- public static function load($bundle, $file)
- {
- if (isset(static::$items[$bundle][$file])) return true;
-
- // We allow a "config.loader" event to be registered which is responsible for
- // returning an array representing the configuration for the bundle and file
- // requested. This allows many types of config "drivers".
- $config = Event::first(static::loader, func_get_args());
-
- // If configuration items were actually found for the bundle and file we
- // will add them to the configuration array and return true, otherwise
- // we will return false indicating the file was not found.
- if (count($config) > 0)
- {
- static::$items[$bundle][$file] = $config;
- }
-
- return isset(static::$items[$bundle][$file]);
- }
-
- /**
- * Load the configuration items from a configuration file.
- *
- * @param string $bundle
- * @param string $file
- * @return array
- */
- public static function file($bundle, $file)
- {
- $config = array();
-
- // Configuration files cascade. Typically, the bundle configuration array is
- // loaded first, followed by the environment array, providing the convenient
- // cascading of configuration options across environments.
- foreach (static::paths($bundle) as $directory)
- {
- if ($directory !== '' and file_exists($path = $directory.$file.EXT))
- {
- $config = array_merge($config, require $path);
- }
- }
-
- return $config;
- }
-
- /**
- * Get the array of configuration paths that should be searched for a bundle.
- *
- * @param string $bundle
- * @return array
- */
- protected static function paths($bundle)
- {
- $paths[] = Bundle::path($bundle).'config/';
-
- // Configuration files can be made specific for a given environment. If an
- // environment has been set, we will merge the environment configuration
- // in last, so that it overrides all other options.
- if (isset($_SERVER['LARAVEL_ENV']))
- {
- $paths[] = $paths[count($paths) - 1].$_SERVER['LARAVEL_ENV'].'/';
- }
-
- return $paths;
- }
-
-}
\ No newline at end of file
diff --git a/laravel/cookie.php b/laravel/cookie.php
deleted file mode 100644
index fc48212e884..00000000000
--- a/laravel/cookie.php
+++ /dev/null
@@ -1,193 +0,0 @@
- 4000)
- {
- throw new \Exception("Payload too large for cookie.");
- }
- else
- {
- setcookie($name, $value, $time, $path, $domain, $secure);
- }
- }
-
-
- /**
- * Get the value of a cookie.
- *
- *
- * // Get the value of the "favorite" cookie
- * $favorite = Cookie::get('favorite');
- *
- * // Get the value of a cookie or return a default value
- * $favorite = Cookie::get('framework', 'Laravel');
- *
- *
- * @param string $name
- * @param mixed $default
- * @return string
- */
- public static function get($name, $default = null)
- {
- if (isset(static::$jar[$name])) return static::$jar[$name]['value'];
-
- $value = array_get($_COOKIE, $name);
-
- if ( ! is_null($value) and isset($value[40]) and $value[40] == '~')
- {
- // The hash signature and the cookie value are separated by a tilde
- // character for convenience. To separate the hash and the payload
- // we can simply expode on that character.
- list($hash, $value) = explode('~', $value, 2);
-
- // By re-feeding the cookie value into the "hash" method we should
- // be able to generate a hash that matches the one taken from the
- // cookie. If they don't, we return null.
- if (static::hash($name, $value) === $hash)
- {
- return $value;
- }
- }
-
- return value($default);
- }
-
- /**
- * Set the value of a cookie.
- *
- *
- * // Set the value of the "favorite" cookie
- * Cookie::put('favorite', 'Laravel');
- *
- * // Set the value of the "favorite" cookie for twenty minutes
- * Cookie::put('favorite', 'Laravel', 20);
- *
- *
- * @param string $name
- * @param string $value
- * @param int $minutes
- * @param string $path
- * @param string $domain
- * @param bool $secure
- * @return void
- */
- public static function put($name, $value, $minutes = 0, $path = '/', $domain = null, $secure = false)
- {
- static::$jar[$name] = compact('name', 'value', 'minutes', 'path', 'domain', 'secure');
- }
-
- /**
- * Set a "permanent" cookie. The cookie will last for one year.
- *
- *
- * // Set a cookie that should last one year
- * Cookie::forever('favorite', 'Blue');
- *
- *
- * @param string $name
- * @param string $value
- * @param string $path
- * @param string $domain
- * @param bool $secure
- * @return bool
- */
- public static function forever($name, $value, $path = '/', $domain = null, $secure = false)
- {
- return static::put($name, $value, 525600, $path, $domain, $secure);
- }
-
- /**
- * Generate a cookie signature based on the contents.
- *
- * @param string $name
- * @param string $value
- * @return string
- */
- public static function sign($name, $value)
- {
- return static::hash($name, $value).'~'.$value;
- }
-
- /**
- * Generate a cookie hash based on the contents.
- *
- * @param string $name
- * @param string $value
- * @return string
- */
- protected static function hash($name, $value)
- {
- return sha1($name.$value.Config::get('application.key'));
- }
-
- /**
- * Delete a cookie.
- *
- * @param string $name
- * @param string $path
- * @param string $domain
- * @param bool $secure
- * @return bool
- */
- public static function forget($name, $path = '/', $domain = null, $secure = false)
- {
- return static::put($name, null, -2000, $path, $domain, $secure);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/core.php b/laravel/core.php
deleted file mode 100644
index 48ad7ecb3ef..00000000000
--- a/laravel/core.php
+++ /dev/null
@@ -1,145 +0,0 @@
- path('sys')));
-
-/*
-|--------------------------------------------------------------------------
-| Register Eloquent Mappings
-|--------------------------------------------------------------------------
-|
-| A few of the Eloquent ORM classes use a non PSR-0 naming standard so
-| we will just map them with hard-coded paths here since PSR-0 uses
-| underscores as directory hierarchy indicators.
-|
-*/
-
-Autoloader::map(array(
- 'Laravel\\Database\\Eloquent\\Relationships\\Belongs_To'
- => path('sys').'database/eloquent/relationships/belongs_to'.EXT,
- 'Laravel\\Database\\Eloquent\\Relationships\\Has_Many'
- => path('sys').'database/eloquent/relationships/has_many'.EXT,
- 'Laravel\\Database\\Eloquent\\Relationships\\Has_Many_And_Belongs_To'
- => path('sys').'database/eloquent/relationships/has_many_and_belongs_to'.EXT,
- 'Laravel\\Database\\Eloquent\\Relationships\\Has_One'
- => path('sys').'database/eloquent/relationships/has_one'.EXT,
- 'Laravel\\Database\\Eloquent\\Relationships\\Has_One_Or_Many'
- => path('sys').'database/eloquent/relationships/has_one_or_many'.EXT,
-));
-
-/*
-|--------------------------------------------------------------------------
-| Set The CLI Options Array
-|--------------------------------------------------------------------------
-|
-| If the current request is from the Artisan command-line interface, we
-| will parse the command line arguments and options and set them the
-| array of options in the $_SERVER global array for convenience.
-|
-*/
-
-if (defined('STDIN'))
-{
- $console = CLI\Command::options($_SERVER['argv']);
-
- list($arguments, $options) = $console;
-
- $options = array_change_key_case($options, CASE_UPPER);
-
- $_SERVER['CLI'] = $options;
-}
-
-/*
-|--------------------------------------------------------------------------
-| Set The CLI Laravel Environment
-|--------------------------------------------------------------------------
-|
-| Next we'll set the LARAVEL_ENV variable if the current request is from
-| the Artisan command-line interface. Since the environment is often
-| specified within an Apache .htaccess file, we need to set it here
-| when the request is not coming through Apache.
-|
-*/
-
-if (isset($_SERVER['CLI']['ENV']))
-{
- $_SERVER['LARAVEL_ENV'] = $_SERVER['CLI']['ENV'];
-}
-
-/*
-|--------------------------------------------------------------------------
-| Register The Laravel Bundles
-|--------------------------------------------------------------------------
-|
-| Finally we will register all of the bundles that have been defined for
-| the application. None of them will be started, yet but will be setup
-| so that they may be started by the develop at any time.
-|
-*/
-
-$bundles = require path('app').'bundles'.EXT;
-
-foreach ($bundles as $bundle => $config)
-{
- Bundle::register($bundle, $config);
-}
\ No newline at end of file
diff --git a/laravel/crypter.php b/laravel/crypter.php
deleted file mode 100644
index f5113f34005..00000000000
--- a/laravel/crypter.php
+++ /dev/null
@@ -1,166 +0,0 @@
-
- * // Get the default database connection for the application
- * $connection = DB::connection();
- *
- * // Get a specific connection by passing the connection name
- * $connection = DB::connection('mysql');
- *
- *
- * @param string $connection
- * @return Database\Connection
- */
- public static function connection($connection = null)
- {
- if (is_null($connection)) $connection = Config::get('database.default');
-
- if ( ! isset(static::$connections[$connection]))
- {
- $config = Config::get("database.connections.{$connection}");
-
- if (is_null($config))
- {
- throw new \Exception("Database connection is not defined for [$connection].");
- }
-
- static::$connections[$connection] = new Connection(static::connect($config), $config);
- }
-
- return static::$connections[$connection];
- }
-
- /**
- * Get a PDO database connection for a given database configuration.
- *
- * @param array $config
- * @return PDO
- */
- protected static function connect($config)
- {
- return static::connector($config['driver'])->connect($config);
- }
-
- /**
- * Create a new database connector instance.
- *
- * @param string $driver
- * @return Database\Connectors\Connector
- */
- protected static function connector($driver)
- {
- switch ($driver)
- {
- case 'sqlite':
- return new Database\Connectors\SQLite;
-
- case 'mysql':
- return new Database\Connectors\MySQL;
-
- case 'pgsql':
- return new Database\Connectors\Postgres;
-
- case 'sqlsrv':
- return new Database\Connectors\SQLServer;
-
- default:
- throw new \Exception("Database driver [$driver] is not supported.");
- }
- }
-
- /**
- * Begin a fluent query against a table.
- *
- * @param string $table
- * @param string $connection
- * @return Database\Query
- */
- public static function table($table, $connection = null)
- {
- return static::connection($connection)->table($table);
- }
-
- /**
- * Create a new database expression instance.
- *
- * Database expressions are used to inject raw SQL into a fluent query.
- *
- * @param string $value
- * @return Expression
- */
- public static function raw($value)
- {
- return new Expression($value);
- }
-
- /**
- * Get the profiling data for all queries.
- *
- * @return array
- */
- public static function profile()
- {
- return Database\Connection::$queries;
- }
-
- /**
- * Magic Method for calling methods on the default database connection.
- *
- *
- * // Get the driver name for the default database connection
- * $driver = DB::driver();
- *
- * // Execute a fluent query on the default database connection
- * $users = DB::table('users')->get();
- *
- */
- public static function __callStatic($method, $parameters)
- {
- return call_user_func_array(array(static::connection(), $method), $parameters);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/connection.php b/laravel/database/connection.php
deleted file mode 100644
index 5b2ec0e9928..00000000000
--- a/laravel/database/connection.php
+++ /dev/null
@@ -1,301 +0,0 @@
-pdo = $pdo;
- $this->config = $config;
- }
-
- /**
- * Begin a fluent query against a table.
- *
- *
- * // Start a fluent query against the "users" table
- * $query = DB::connection()->table('users');
- *
- * // Start a fluent query against the "users" table and get all the users
- * $users = DB::connection()->table('users')->get();
- *
- *
- * @param string $table
- * @return Query
- */
- public function table($table)
- {
- return new Query($this, $this->grammar(), $table);
- }
-
- /**
- * Create a new query grammar for the connection.
- *
- * @return Query\Grammars\Grammar
- */
- protected function grammar()
- {
- if (isset($this->grammar)) return $this->grammar;
-
- switch (isset($this->config['grammar']) ? $this->config['grammar'] : $this->driver())
- {
- case 'mysql':
- return $this->grammar = new Query\Grammars\MySQL($this);
-
- case 'sqlsrv':
- return $this->grammar = new Query\Grammars\SQLServer($this);
-
- default:
- return $this->grammar = new Query\Grammars\Grammar($this);
- }
- }
-
- /**
- * Execute a callback wrapped in a database transaction.
- *
- * @param Closure $callback
- * @return void
- */
- public function transaction($callback)
- {
- $this->pdo->beginTransaction();
-
- // After beginning the database transaction, we will call the Closure
- // so that it can do its database work. If an exception occurs we'll
- // rollback the transaction and re-throw back to the developer.
- try
- {
- call_user_func($callback);
- }
- catch (\Exception $e)
- {
- $this->pdo->rollBack();
-
- throw $e;
- }
-
- $this->pdo->commit();
- }
-
- /**
- * Execute a SQL query against the connection and return a single column result.
- *
- *
- * // Get the total number of rows on a table
- * $count = DB::connection()->only('select count(*) from users');
- *
- * // Get the sum of payment amounts from a table
- * $sum = DB::connection()->only('select sum(amount) from payments')
- *
- *
- * @param string $sql
- * @param array $bindings
- * @return mixed
- */
- public function only($sql, $bindings = array())
- {
- $results = (array) $this->first($sql, $bindings);
-
- return reset($results);
- }
-
- /**
- * Execute a SQL query against the connection and return the first result.
- *
- *
- * // Execute a query against the database connection
- * $user = DB::connection()->first('select * from users');
- *
- * // Execute a query with bound parameters
- * $user = DB::connection()->first('select * from users where id = ?', array($id));
- *
- *
- * @param string $sql
- * @param array $bindings
- * @return object
- */
- public function first($sql, $bindings = array())
- {
- if (count($results = $this->query($sql, $bindings)) > 0)
- {
- return $results[0];
- }
- }
-
- /**
- * Execute a SQL query and return an array of StdClass objects.
- *
- * @param string $sql
- * @param array $bindings
- * @return array
- */
- public function query($sql, $bindings = array())
- {
- list($statement, $result) = $this->execute($sql, $bindings);
-
- // The result we return depends on the type of query executed against the
- // database. On SELECT clauses, we will return the result set, for update
- // and deletes we will return the affected row count.
- if (stripos($sql, 'select') === 0)
- {
- return $this->fetch($statement, Config::get('database.fetch'));
- }
- elseif (stripos($sql, 'update') === 0 or stripos($sql, 'delete') === 0)
- {
- return $statement->rowCount();
- }
- else
- {
- return $result;
- }
- }
-
- /**
- * Execute a SQL query against the connection.
- *
- * The PDO statement and boolean result will be return in an array.
- *
- * @param string $sql
- * @param array $bindings
- * @return array
- */
- protected function execute($sql, $bindings = array())
- {
- $bindings = (array) $bindings;
-
- // Since expressions are injected into the query as strings, we need to
- // remove them from the array of bindings. After we have removed them,
- // we'll reset the array so there are not gaps within the keys.
- $bindings = array_filter($bindings, function($binding)
- {
- return ! $binding instanceof Expression;
- });
-
- $bindings = array_values($bindings);
-
- $sql = $this->grammar()->shortcut($sql, $bindings);
-
- // Each database operation is wrapped in a try / catch so we can wrap
- // any database exceptions in our custom exception class, which will
- // set the message to include the SQL and query bindings.
- try
- {
- $statement = $this->pdo->prepare($sql);
-
- $start = microtime(true);
-
- $result = $statement->execute($bindings);
- }
- // If an exception occurs, we'll pass it into our custom exception
- // and set the message to include the SQL and query bindings so
- // debugging is much easier on the developer.
- catch (\Exception $exception)
- {
- $exception = new Exception($sql, $bindings, $exception);
-
- throw $exception;
- }
-
- // Once we have execute the query, we log the SQL, bindings, and
- // execution time in a static array that is accessed by all of
- // the connections actively being used by the application.
- if (Config::get('database.profile'))
- {
- $this->log($sql, $bindings, $start);
- }
-
- return array($statement, $result);
- }
-
- /**
- * Fetch all of the rows for a given statement.
- *
- * @param PDOStatement $statement
- * @param int $style
- * @return array
- */
- protected function fetch($statement, $style)
- {
- // If the fetch style is "class", we'll hydrate an array of PHP
- // stdClass objects as generic containers for the query rows,
- // otherwise we'll just use the fetch styel value.
- if ($style === PDO::FETCH_CLASS)
- {
- return $statement->fetchAll(PDO::FETCH_CLASS, 'stdClass');
- }
- else
- {
- return $statement->fetchAll($style);
- }
- }
-
- /**
- * Log the query and fire the core query event.
- *
- * @param string $sql
- * @param array $bindings
- * @param int $start
- * @return void
- */
- protected function log($sql, $bindings, $start)
- {
- $time = number_format((microtime(true) - $start) * 1000, 2);
-
- Event::fire('laravel.query', array($sql, $bindings, $time));
-
- static::$queries[] = compact('sql', 'bindings', 'time');
- }
-
- /**
- * Get the driver name for the database connection.
- *
- * @return string
- */
- public function driver()
- {
- return $this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME);
- }
-
- /**
- * Magic Method for dynamically beginning queries on database tables.
- */
- public function __call($method, $parameters)
- {
- return $this->table($method);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/connectors/connector.php b/laravel/database/connectors/connector.php
deleted file mode 100644
index 01065583258..00000000000
--- a/laravel/database/connectors/connector.php
+++ /dev/null
@@ -1,41 +0,0 @@
- PDO::CASE_LOWER,
- PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
- PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
- PDO::ATTR_STRINGIFY_FETCHES => false,
- PDO::ATTR_EMULATE_PREPARES => false,
- );
-
- /**
- * Establish a PDO database connection.
- *
- * @param array $config
- * @return PDO
- */
- abstract public function connect($config);
-
- /**
- * Get the PDO connection options for the configuration.
- *
- * Developer specified options will override the default connection options.
- *
- * @param array $config
- * @return array
- */
- protected function options($config)
- {
- $options = (isset($config['options'])) ? $config['options'] : array();
-
- return $this->options + $options;
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/connectors/mysql.php b/laravel/database/connectors/mysql.php
deleted file mode 100644
index 0ea5eba2578..00000000000
--- a/laravel/database/connectors/mysql.php
+++ /dev/null
@@ -1,46 +0,0 @@
-options($config));
-
- // If a character set has been specified, we'll execute a query against
- // the database to set the correct character set. By default, this is
- // set to UTF-8 which should be fine for most scenarios.
- if (isset($config['charset']))
- {
- $connection->prepare("SET NAMES '{$config['charset']}'")->execute();
- }
-
- return $connection;
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/connectors/postgres.php b/laravel/database/connectors/postgres.php
deleted file mode 100644
index 233914fd12c..00000000000
--- a/laravel/database/connectors/postgres.php
+++ /dev/null
@@ -1,38 +0,0 @@
-options($config));
-
- // If a character set has been specified, we'll execute a query against
- // the database to set the correct character set. By default, this is
- // set to UTF-8 which should be fine for most scenarios.
- if (isset($config['charset']))
- {
- $connection->prepare("SET NAMES '{$config['charset']}'")->execute();
- }
-
- return $connection;
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/connectors/sqlite.php b/laravel/database/connectors/sqlite.php
deleted file mode 100644
index 1e2fc7e5534..00000000000
--- a/laravel/database/connectors/sqlite.php
+++ /dev/null
@@ -1,28 +0,0 @@
-options($config);
-
- // SQLite provides supported for "in-memory" databases, which exist only for
- // lifetime of the request. Any given in-memory database may only have one
- // PDO connection open to it at a time. These are mainly for tests.
- if ($config['database'] == ':memory:')
- {
- return new PDO('sqlite::memory:', null, null, $options);
- }
-
- $path = path('storage').'database'.DS.$config['database'].'.sqlite';
-
- return new PDO('sqlite:'.$path, null, null, $options);
- }
-
-}
diff --git a/laravel/database/connectors/sqlserver.php b/laravel/database/connectors/sqlserver.php
deleted file mode 100644
index 29c6929ba1f..00000000000
--- a/laravel/database/connectors/sqlserver.php
+++ /dev/null
@@ -1,37 +0,0 @@
- PDO::CASE_LOWER,
- PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
- PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
- PDO::ATTR_STRINGIFY_FETCHES => false,
- );
-
- /**
- * Establish a PDO database connection.
- *
- * @param array $config
- * @return PDO
- */
- public function connect($config)
- {
- extract($config);
-
- // Format the SQL Server connection string. This connection string format can
- // also be used to connect to Azure SQL Server databases. The port is defined
- // directly after the server name, so we'll create that first.
- $port = (isset($port)) ? ','.$port : '';
-
- $dsn = "sqlsrv:Server={$host}{$port};Database={$database}";
-
- return new PDO($dsn, $username, $password, $this->options($config));
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/eloquent/model.php b/laravel/database/eloquent/model.php
deleted file mode 100644
index 763cd46fc21..00000000000
--- a/laravel/database/eloquent/model.php
+++ /dev/null
@@ -1,664 +0,0 @@
-exists = $exists;
-
- $this->fill($attributes);
- }
-
- /**
- * Hydrate the model with an array of attributes.
- *
- * @param array $attributes
- * @return Model
- */
- public function fill($attributes)
- {
- $attributes = (array) $attributes;
-
- foreach ($attributes as $key => $value)
- {
- // If the "accessible" property is an array, the developer is limiting the
- // attributes that may be mass assigned, and we need to verify that the
- // current attribute is included in that list of allowed attributes.
- if (is_array(static::$accessible))
- {
- if (in_array($key, static::$accessible))
- {
- $this->$key = $value;
- }
- }
-
- // If the "accessible" property is not an array, no attributes have been
- // white-listed and we are free to set the value of the attribute to
- // the value that has been passed into the method without a check.
- else
- {
- $this->$key = $value;
- }
- }
-
- // If the original attribute values have not been set, we will set
- // them to the values passed to this method allowing us to easily
- // check if the model has changed since hydration.
- if (count($this->original) === 0)
- {
- $this->original = $this->attributes;
- }
-
- return $this;
- }
-
- /**
- * Set the accessible attributes for the given model.
- *
- * @param array $attributes
- * @return void
- */
- public static function accessible($attributes)
- {
- static::$accessible = $attributes;
- }
-
- /**
- * Create a new model and store it in the database.
- *
- * If save is successful, the model will be returned, otherwise false.
- *
- * @param array $attributes
- * @return Model|false
- */
- public static function create($attributes)
- {
- $model = new static($attributes);
-
- $success = $model->save();
-
- return ($success) ? $model : false;
- }
-
- /**
- * Update a model instance in the database.
- *
- * @param mixed $id
- * @param array $attributes
- * @return int
- */
- public static function update($id, $attributes)
- {
- $model = new static(array(), true);
-
- if (static::$timestamps) $attributes['updated_at'] = $model->get_timestamp();
-
- return $model->query()->where($model->key(), '=', $id)->update($attributes);
- }
-
- /**
- * Find a model by its primary key.
- *
- * @param string $id
- * @param array $columns
- * @return Model
- */
- public static function find($id, $columns = array('*'))
- {
- $model = new static;
-
- return $model->query()->where(static::$key, '=', $id)->first($columns);
- }
-
- /**
- * Get all of the models in the database.
- *
- * @return array
- */
- public static function all()
- {
- return with(new static)->query()->get();
- }
-
- /**
- * The relationships that should be eagerly loaded by the query.
- *
- * @param array $includes
- * @return Model
- */
- public function _with($includes)
- {
- $this->includes = (array) $includes;
-
- return $this;
- }
-
- /**
- * Get the query for a one-to-one association.
- *
- * @param string $model
- * @param string $foreign
- * @return Relationship
- */
- public function has_one($model, $foreign = null)
- {
- return $this->has_one_or_many(__FUNCTION__, $model, $foreign);
- }
-
- /**
- * Get the query for a one-to-many association.
- *
- * @param string $model
- * @param string $foreign
- * @return Relationship
- */
- public function has_many($model, $foreign = null)
- {
- return $this->has_one_or_many(__FUNCTION__, $model, $foreign);
- }
-
- /**
- * Get the query for a one-to-one / many association.
- *
- * @param string $type
- * @param string $model
- * @param string $foreign
- * @return Relationship
- */
- protected function has_one_or_many($type, $model, $foreign)
- {
- if ($type == 'has_one')
- {
- return new Relationships\Has_One($this, $model, $foreign);
- }
- else
- {
- return new Relationships\Has_Many($this, $model, $foreign);
- }
- }
-
- /**
- * Get the query for a one-to-one (inverse) relationship.
- *
- * @param string $model
- * @param string $foreign
- * @return Relationship
- */
- public function belongs_to($model, $foreign = null)
- {
- // If no foreign key is specified for the relationship, we will assume that the
- // name of the calling function matches the foreign key. For example, if the
- // calling function is "manager", we'll assume the key is "manager_id".
- if (is_null($foreign))
- {
- list(, $caller) = debug_backtrace(false);
-
- $foreign = "{$caller['function']}_id";
- }
-
- return new Relationships\Belongs_To($this, $model, $foreign);
- }
-
- /**
- * Get the query for a many-to-many relationship.
- *
- * @param string $model
- * @param string $table
- * @param string $foreign
- * @param string $other
- * @return Relationship
- */
- public function has_many_and_belongs_to($model, $table = null, $foreign = null, $other = null)
- {
- return new Has_Many_And_Belongs_To($this, $model, $table, $foreign, $other);
- }
-
- /**
- * Save the model and all of its relations to the database.
- *
- * @return bool
- */
- public function push()
- {
- $this->save();
-
- // To sync all of the relationships to the database, we will simply spin through
- // the relationships, calling the "push" method on each of the models in that
- // given relationship, this should ensure that each model is saved.
- foreach ($this->relationships as $name => $models)
- {
- if ( ! is_array($models))
- {
- $models = array($models);
- }
-
- foreach ($models as $model)
- {
- $model->push();
- }
- }
- }
-
- /**
- * Save the model instance to the database.
- *
- * @return bool
- */
- public function save()
- {
- if ( ! $this->dirty()) return true;
-
- if (static::$timestamps)
- {
- $this->timestamp();
- }
-
- // If the model exists, we only need to update it in the database, and the update
- // will be considered successful if there is one affected row returned from the
- // fluent query instance. We'll set the where condition automatically.
- if ($this->exists)
- {
- $query = $this->query()->where(static::$key, '=', $this->get_key());
-
- $result = $query->update($this->get_dirty()) === 1;
- }
-
- // If the model does not exist, we will insert the record and retrieve the last
- // insert ID that is associated with the model. If the ID returned is numeric
- // then we can consider the insert successful.
- else
- {
- $id = $this->query()->insert_get_id($this->attributes, $this->sequence());
-
- $this->set_key($id);
-
- $this->exists = $result = is_numeric($this->get_key());
- }
-
- // After the model has been "saved", we will set the original attributes to
- // match the current attributes so the model will not be viewed as being
- // dirty and subsequent calls won't hit the database.
- $this->original = $this->attributes;
-
- return $result;
- }
-
- /**
- * Set the update and creation timestamps on the model.
- *
- * @return void
- */
- protected function timestamp()
- {
- $this->updated_at = $this->get_timestamp();
-
- if ( ! $this->exists) $this->created_at = $this->updated_at;
- }
-
- /**
- * Get the current timestamp in its storable form.
- *
- * @return mixed
- */
- public function get_timestamp()
- {
- return date('Y-m-d H:i:s');
- }
-
- /**
- * Get a new fluent query builder instance for the model.
- *
- * @return Query
- */
- protected function query()
- {
- return new Query($this);
- }
-
- /**
- * Sync the original attributes with the current attributes.
- *
- * @return bool
- */
- final public function sync()
- {
- $this->original = $this->attributes;
-
- return true;
- }
-
- /**
- * Determine if a given attribute has changed from its original state.
- *
- * @param string $attribute
- * @return bool
- */
- public function changed($attribute)
- {
- return array_get($this->attributes, $attribute) !== array_get($this->original, $attribute);
- }
-
- /**
- * Determine if the model has been changed from its original state.
- *
- * Models that haven't been persisted to storage are always considered dirty.
- *
- * @return bool
- */
- public function dirty()
- {
- return ! $this->exists or count($this->get_dirty()) > 0;
- }
-
- /**
- * Get the name of the table associated with the model.
- *
- * @return string
- */
- public function table()
- {
- return static::$table ?: strtolower(Str::plural(basename(get_class($this))));
- }
-
- /**
- * Get the dirty attributes for the model.
- *
- * @return array
- */
- public function get_dirty()
- {
- return array_diff_assoc($this->attributes, $this->original);
- }
-
- /**
- * Get the value of the primary key for the model.
- *
- * @return int
- */
- public function get_key()
- {
- return $this->get_attribute(static::$key);
- }
-
- /**
- * Set the value of the primary key for the model.
- *
- * @param int $value
- * @return void
- */
- public function set_key($value)
- {
- return $this->set_attribute(static::$key, $value);
- }
-
- /**
- * Get a given attribute from the model.
- *
- * @param string $key
- */
- public function get_attribute($key)
- {
- return array_get($this->attributes, $key);
- }
-
- /**
- * Set an attribute's value on the model.
- *
- * @param string $key
- * @param mixed $value
- * @return void
- */
- public function set_attribute($key, $value)
- {
- $this->attributes[$key] = $value;
- }
-
- /**
- * Remove an attribute from the model.
- *
- * @param string $key
- */
- final public function purge($key)
- {
- unset($this->original[$key]);
-
- unset($this->attributes[$key]);
- }
-
- /**
- * Handle the dynamic retrieval of attributes and associations.
- *
- * @param string $key
- * @return mixed
- */
- public function __get($key)
- {
- // First we will check to see if the requested key is an already loaded
- // relationship and return it if it is. All relationships are stored
- // in the special relationships array so they are not persisted.
- if (array_key_exists($key, $this->relationships))
- {
- return $this->relationships[$key];
- }
-
- // Next we'll check if the requested key is in the array of attributes
- // for the model. These are simply regular properties that typically
- // correspond to a single column on the database for the model.
- elseif (array_key_exists($key, $this->attributes))
- {
- return $this->{"get_{$key}"}();
- }
-
- // If the item is not a loaded relationship, it may be a relationship
- // that hasn't been loaded yet. If it is, we will lazy load it and
- // set the value of the relationship in the relationship array.
- elseif (method_exists($this, $key))
- {
- return $this->relationships[$key] = $this->$key()->results();
- }
-
- // Finally we will just assume the requested key is just a regular
- // attribute and attempt to call the getter method for it, which
- // will fall into the __call method if one doesn't exist.
- else
- {
- return $this->{"get_{$key}"}();
- }
- }
-
- /**
- * Handle the dynamic setting of attributes.
- *
- * @param string $key
- * @param mixed $value
- * @return void
- */
- public function __set($key, $value)
- {
- $this->{"set_{$key}"}($value);
- }
-
- /**
- * Determine if an attribute exists on the model.
- *
- * @param string $key
- * @return bool
- */
- public function __isset($key)
- {
- foreach (array('attributes', 'relationships') as $source)
- {
- if (array_key_exists($key, $this->$source)) return true;
- }
- }
-
- /**
- * Remove an attribute from the model.
- *
- * @param string $key
- * @return void
- */
- public function __unset($key)
- {
- foreach (array('attributes', 'relationships') as $source)
- {
- unset($this->$source[$key]);
- }
- }
-
- /**
- * Handle dynamic method calls on the model.
- *
- * @param string $method
- * @param array $parameters
- * @return mixed
- */
- public function __call($method, $parameters)
- {
- // If the method is actually the name of a static property on the model we'll
- // return the value of the static property. This makes it convenient for
- // relationships to access these values off of the instances.
- if (in_array($method, array('key', 'table', 'connection', 'sequence', 'per_page')))
- {
- return static::$$method;
- }
-
- // Some methods need to be accessed both staticly and non-staticly so we'll
- // keep underscored methods of those methods and intercept calls to them
- // here so they can be called either way on the model instance.
- if (in_array($method, array('with')))
- {
- return call_user_func_array(array($this, '_'.$method), $parameters);
- }
-
- // First we want to see if the method is a getter / setter for an attribute.
- // If it is, we'll call the basic getter and setter method for the model
- // to perform the appropriate action based on the method.
- if (starts_with($method, 'get_'))
- {
- return $this->attributes[substr($method, 4)];
- }
- elseif (starts_with($method, 'set_'))
- {
- $this->attributes[substr($method, 4)] = $parameters[0];
- }
-
- // Finally we will assume that the method is actually the beginning of a
- // query, such as "where", and will create a new query instance and
- // call the method on the query instance, returning it after.
- else
- {
- return call_user_func_array(array($this->query(), $method), $parameters);
- }
- }
-
- /**
- * Dynamically handle static method calls on the model.
- *
- * @param string $method
- * @param array $parameters
- * @return mixed
- */
- public static function __callStatic($method, $parameters)
- {
- $model = get_called_class();
-
- return call_user_func_array(array(new $model, $method), $parameters);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/eloquent/pivot.php b/laravel/database/eloquent/pivot.php
deleted file mode 100644
index b98fc226473..00000000000
--- a/laravel/database/eloquent/pivot.php
+++ /dev/null
@@ -1,42 +0,0 @@
-pivot_table = $table;
-
- parent::__construct(array(), true);
- }
-
- /**
- * Get the name of the pivot table.
- *
- * @return string
- */
- public function table()
- {
- return $this->pivot_table;
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/eloquent/query.php b/laravel/database/eloquent/query.php
deleted file mode 100644
index e438f56d79d..00000000000
--- a/laravel/database/eloquent/query.php
+++ /dev/null
@@ -1,285 +0,0 @@
-model = ($model instanceof Model) ? $model : new $model;
-
- $this->table = $this->query();
- }
-
- /**
- * Get the first model result for the query.
- *
- * @param array $columns
- * @return mixed
- */
- public function first($columns = array('*'))
- {
- $results = $this->hydrate($this->model, $this->table->take(1)->get($columns, false));
-
- return (count($results) > 0) ? head($results) : null;
- }
-
- /**
- * Get all of the model results for the query.
- *
- * @param array $columns
- * @param bool $include
- * @return array
- */
- public function get($columns = array('*'), $include = true)
- {
- return $this->hydrate($this->model, $this->table->get($columns), $include);
- }
-
- /**
- * Get an array of paginated model results.
- *
- * @param int $per_page
- * @param array $columns
- * @return Paginator
- */
- public function paginate($per_page = null, $columns = array('*'))
- {
- $per_page = $per_page ?: $this->model->per_page();
-
- // First we'll grab the Paginator instance and get the results. Then we can
- // feed those raw database results into the hydrate method to get models
- // for the results, which we'll set on the paginator and return it.
- $paginator = $this->table->paginate($per_page, $columns);
-
- $paginator->results = $this->hydrate($this->model, $paginator->results);
-
- return $paginator;
- }
-
- /**
- * Hydrate an array of models from the given results.
- *
- * @param Model $model
- * @param array $results
- * @return array
- */
- public function hydrate($model, $results, $include = true)
- {
- $class = get_class($model);
-
- $models = array();
-
- // We'll spin through the array of database results and hydrate a model
- // for each one of the records. We will also set the "exists" flag to
- // "true" so that the model will be updated when it is saved.
- foreach ((array) $results as $result)
- {
- $result = (array) $result;
-
- $new = new $class(array(), true);
-
- // We need to set the attributes manually in case the accessible property is
- // set on the array which will prevent the mass assignemnt of attributes if
- // we were to pass them in using the constructor or fill methods.
- foreach ($result as $key => $value)
- {
- $new->$key = $value;
- }
-
- $new->original = $new->attributes;
-
- $models[$result[$this->model->key()]] = $new;
- }
-
- if ($include and count($results) > 0)
- {
- foreach ($this->model_includes() as $relationship => $constraints)
- {
- // If the relationship is nested, we will skip laoding it here and let
- // the load method parse and set the nested eager loads on the right
- // relationship when it is getting ready to eager laod.
- if (str_contains($relationship, '.'))
- {
- continue;
- }
-
- $this->load($models, $relationship, $constraints);
- }
- }
-
- // The many to many relationships may have pivot table column on them
- // so we will call the "clean" method on the relationship to remove
- // any pivot columns that are on the model.
- if ($this instanceof Relationships\Has_Many_And_Belongs_To)
- {
- $this->hydrate_pivot($models);
- }
-
- return $models;
- }
-
- /**
- * Hydrate an eagerly loaded relationship on the model results.
- *
- * @param array $results
- * @param string $relationship
- * @param array|null $constraints
- * @return void
- */
- protected function load(&$results, $relationship, $constraints)
- {
- $query = $this->model->$relationship();
-
- $query->model->includes = $this->nested_includes($relationship);
-
- // We'll remove any of the where clauses from the relationship to give
- // the relationship the opportunity to set the constraints for an
- // eager relationship using a separate, specific method.
- $query->table->reset_where();
-
- $query->eagerly_constrain($results);
-
- // Constraints may be specified in-line for the eager load by passing
- // a Closure as the value portion of the eager load. We can use the
- // query builder's nested query support to add the constraints.
- if ( ! is_null($constraints))
- {
- $query->table->where_nested($constraints);
- }
-
- // Before matching the models, we will initialize the relationship
- // to either null for single-value relationships or an array for
- // the multi-value relationships as their baseline value.
- $query->initialize($results, $relationship);
-
- $query->match($relationship, $results, $query->get());
- }
-
- /**
- * Gather the nested includes for a given relationship.
- *
- * @param string $relationship
- * @return array
- */
- protected function nested_includes($relationship)
- {
- $nested = array();
-
- foreach ($this->model_includes() as $include => $constraints)
- {
- // To get the nested includes, we want to find any includes that begin
- // the relationship and a dot, then we will strip off the leading
- // nesting indicator and set the include in the array.
- if (starts_with($include, $relationship.'.'))
- {
- $nested[substr($include, strlen($relationship.'.'))] = $constraints;
- }
- }
-
- return $nested;
- }
-
- /**
- * Get the eagerly loaded relationships for the model.
- *
- * @return array
- */
- protected function model_includes()
- {
- $includes = array();
-
- foreach ($this->model->includes as $relationship => $constraints)
- {
- // When eager loading relationships, constraints may be set on the eager
- // load definition; however, is none are set, we need to swap the key
- // and the value of the array since there are no constraints.
- if (is_numeric($relationship))
- {
- list($relationship, $constraints) = array($constraints, null);
- }
-
- $includes[$relationship] = $constraints;
- }
-
- return $includes;
- }
-
- /**
- * Get a fluent query builder for the model.
- *
- * @return Query
- */
- protected function query()
- {
- return $this->connection()->table($this->model->table());
- }
-
- /**
- * Get the database connection for the model.
- *
- * @return Connection
- */
- public function connection()
- {
- return Database::connection($this->model->connection());
- }
-
- /**
- * Handle dynamic method calls to the query.
- *
- * @param string $method
- * @param array $parameters
- * @return mixed
- */
- public function __call($method, $parameters)
- {
- $result = call_user_func_array(array($this->table, $method), $parameters);
-
- // Some methods may get their results straight from the fluent query
- // builder, such as the aggregate methods. If the called method is
- // one of these, we will return the result straight away.
- if (in_array($method, $this->passthru))
- {
- return $result;
- }
-
- return $this;
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/eloquent/relationships/belongs_to.php b/laravel/database/eloquent/relationships/belongs_to.php
deleted file mode 100644
index b73c57bf3f4..00000000000
--- a/laravel/database/eloquent/relationships/belongs_to.php
+++ /dev/null
@@ -1,104 +0,0 @@
-get_dirty() : $attributes;
-
- return $this->model->update($this->foreign_value(), $attributes);
- }
-
- /**
- * Set the proper constraints on the relationship table.
- *
- * @return void
- */
- protected function constrain()
- {
- $this->table->where($this->base->key(), '=', $this->foreign_value());
- }
-
- /**
- * Initialize a relationship on an array of parent models.
- *
- * @param array $parents
- * @param string $relationship
- * @return void
- */
- public function initialize(&$parents, $relationship)
- {
- foreach ($parents as &$parent)
- {
- $parent->relationships[$relationship] = null;
- }
- }
-
- /**
- * Set the proper constraints on the relationship table for an eager load.
- *
- * @param array $results
- * @return void
- */
- public function eagerly_constrain($results)
- {
- $keys = array();
-
- // Inverse one-to-many relationships require us to gather the keys from the
- // parent models and use those keys when setting the constraint since we
- // are looking for the parent of a child model in this relationship.
- foreach ($results as $result)
- {
- $keys[] = $result->{$this->foreign_key()};
- }
-
- $this->table->where_in($this->model->key(), array_unique($keys));
- }
-
- /**
- * Match eagerly loaded child models to their parent models.
- *
- * @param array $children
- * @param array $parents
- * @return void
- */
- public function match($relationship, &$children, $parents)
- {
- $foreign = $this->foreign_key();
-
- foreach ($children as &$child)
- {
- if (array_key_exists($child->$foreign, $parents))
- {
- $child->relationships[$relationship] = $parents[$child->$foreign];
- }
- }
- }
-
- /**
- * Get the value of the foreign key from the base model.
- *
- * @return mixed
- */
- public function foreign_value()
- {
- return $this->base->get_attribute($this->foreign);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/eloquent/relationships/has_many.php b/laravel/database/eloquent/relationships/has_many.php
deleted file mode 100644
index b80d3844c6f..00000000000
--- a/laravel/database/eloquent/relationships/has_many.php
+++ /dev/null
@@ -1,47 +0,0 @@
-relationships[$relationship] = array();
- }
- }
-
- /**
- * Match eagerly loaded child models to their parent models.
- *
- * @param array $parents
- * @param array $children
- * @return void
- */
- public function match($relationship, &$parents, $children)
- {
- $foreign = $this->foreign_key();
-
- foreach ($children as $key => $child)
- {
- $parents[$child->$foreign]->relationships[$relationship][$child->get_key()] = $child;
- }
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/eloquent/relationships/has_many_and_belongs_to.php b/laravel/database/eloquent/relationships/has_many_and_belongs_to.php
deleted file mode 100644
index 225f7eb8786..00000000000
--- a/laravel/database/eloquent/relationships/has_many_and_belongs_to.php
+++ /dev/null
@@ -1,369 +0,0 @@
-other = $other;
-
- $this->joining = $table ?: $this->joining($model, $associated);
-
- parent::__construct($model, $associated, $foreign);
- }
-
- /**
- * Determine the joining table name for the relationship.
- *
- * By default, the name is the models sorted and joined with underscores.
- *
- * @return string
- */
- protected function joining($model, $associated)
- {
- $models = array(class_basename($model), class_basename($associated));
-
- sort($models);
-
- return strtolower($models[0].'_'.$models[1]);
- }
-
- /**
- * Get the properly hydrated results for the relationship.
- *
- * @return array
- */
- public function results()
- {
- return parent::get();
- }
-
- /**
- * Insert a new record into the joining table of the association.
- *
- * @param int $id
- * @param array $joining
- * @return bool
- */
- public function attach($id, $attributes = array())
- {
- $joining = array_merge($this->join_record($id), $attributes);
-
- return $this->insert_joining($joining);
- }
-
- /**
- * Insert a new record for the association.
- *
- * @param Model|array $attributes
- * @param array $joining
- * @return bool
- */
- public function insert($attributes, $joining = array())
- {
- // If the attributes are actually an instance of a model, we'll just grab the
- // array of attributes off of the model for saving, allowing the developer
- // to easily validate the joining models before inserting them.
- if ($attributes instanceof Model)
- {
- $attributes = $attributes->attributes;
- }
-
- $model = $this->model->create($attributes);
-
- // If the insert was successful, we'll insert a record into the joining table
- // using the new ID that was just inserted into the related table, allowing
- // the developer to not worry about maintaining the join table.
- if ($model instanceof Model)
- {
- $joining = array_merge($this->join_record($model->get_key()), $joining);
-
- $result = $this->insert_joining($joining);
- }
-
- return $model instanceof Model and $result;
- }
-
- /**
- * Delete all of the records from the joining table for the model.
- *
- * @return int
- */
- public function delete()
- {
- $id = $this->base->get_key();
-
- return $this->joining_table()->where($this->foreign_key(), '=', $id)->delete();
- }
-
- /**
- * Create an array representing a new joining record for the association.
- *
- * @param int $id
- * @return array
- */
- protected function join_record($id)
- {
- return array($this->foreign_key() => $this->base->get_key(), $this->other_key() => $id);
- }
-
- /**
- * Insert a new record into the joining table of the association.
- *
- * @param array $attributes
- * @return void
- */
- protected function insert_joining($attributes)
- {
- $attributes['created_at'] = $this->model->get_timestamp();
-
- $attributes['updated_at'] = $attributes['created_at'];
-
- return $this->joining_table()->insert($attributes);
- }
-
- /**
- * Get a fluent query for the joining table of the relationship.
- *
- * @return Query
- */
- protected function joining_table()
- {
- return $this->connection()->table($this->joining);
- }
-
- /**
- * Set the proper constraints on the relationship table.
- *
- * @return void
- */
- protected function constrain()
- {
- $other = $this->other_key();
-
- $foreign = $this->foreign_key();
-
- $this->set_select($foreign, $other)->set_join($other)->set_where($foreign);
- }
-
- /**
- * Set the SELECT clause on the query builder for the relationship.
- *
- * @param string $foreign
- * @param string $other
- * @return void
- */
- protected function set_select($foreign, $other)
- {
- $columns = array($this->model->table().'.*');
-
- $this->with = array_merge($this->with, array($foreign, $other));
-
- // Since pivot tables may have extra information on them that the developer
- // needs, we allow an extra array of columns to be specified that will be
- // fetched from the pivot table and hydrate into the pivot model.
- foreach ($this->with as $column)
- {
- $columns[] = $this->joining.'.'.$column.' as pivot_'.$column;
- }
-
- $this->table->select($columns);
-
- return $this;
- }
-
- /**
- * Set the JOIN clause on the query builder for the relationship.
- *
- * @param string $other
- * @return void
- */
- protected function set_join($other)
- {
- $this->table->join($this->joining, $this->associated_key(), '=', $this->joining.'.'.$other);
-
- return $this;
- }
-
- /**
- * Set the WHERE clause on the query builder for the relationship.
- *
- * @param string $foreign
- * @return void
- */
- protected function set_where($foreign)
- {
- $this->table->where($this->joining.'.'.$foreign, '=', $this->base->get_key());
-
- return $this;
- }
-
- /**
- * Initialize a relationship on an array of parent models.
- *
- * @param array $parents
- * @param string $relationship
- * @return void
- */
- public function initialize(&$parents, $relationship)
- {
- foreach ($parents as &$parent)
- {
- $parent->relationships[$relationship] = array();
- }
- }
-
- /**
- * Set the proper constraints on the relationship table for an eager load.
- *
- * @param array $results
- * @return void
- */
- public function eagerly_constrain($results)
- {
- $this->table->where_in($this->joining.'.'.$this->foreign_key(), array_keys($results));
- }
-
- /**
- * Match eagerly loaded child models to their parent models.
- *
- * @param array $parents
- * @param array $children
- * @return void
- */
- public function match($relationship, &$parents, $children)
- {
- $foreign = $this->foreign_key();
-
- foreach ($children as $key => $child)
- {
- $parents[$child->pivot->$foreign]->relationships[$relationship][$child->{$child->key()}] = $child;
- }
- }
-
- /**
- * Hydrate the Pivot model on an array of results.
- *
- * @param array $results
- * @return void
- */
- protected function hydrate_pivot(&$results)
- {
- foreach ($results as &$result)
- {
- // Every model result for a many-to-many relationship needs a Pivot instance
- // to represent the pivot table's columns. Sometimes extra columns are on
- // the pivot table that may need to be accessed by the developer.
- $pivot = new Pivot($this->joining);
-
- // If the attribute key starts with "pivot_", we know this is a column on
- // the pivot table, so we will move it to the Pivot model and purge it
- // from the model since it actually belongs to the pivot.
- foreach ($result->attributes as $key => $value)
- {
- if (starts_with($key, 'pivot_'))
- {
- $pivot->{substr($key, 6)} = $value;
-
- $result->purge($key);
- }
- }
-
- // Once we have completed hydrating the pivot model instance, we'll set
- // it on the result model's relationships array so the developer can
- // quickly and easily access any pivot table information.
- $result->relationships['pivot'] = $pivot;
-
- $pivot->sync() and $result->sync();
- }
- }
-
- /**
- * Set the columns on the joining table that should be fetched.
- *
- * @param array $column
- * @return Relationship
- */
- public function with($columns)
- {
- $columns = (is_array($columns)) ? $columns : func_get_args();
-
- // The "with" array contains a couple of columns by default, so we will
- // just merge in the developer specified columns here, and we'll make
- // sure the values of the array are unique.
- $this->with = array_unique(array_merge($this->with, $columns));
-
- $this->set_select($this->foreign_key(), $this->other_key());
-
- return $this;
- }
-
- /**
- * Get a model instance of the pivot table for the relationship.
- *
- * @return Pivot
- */
- public function pivot()
- {
- $key = $this->base->get_key();
-
- $foreign = $this->foreign_key();
-
- return with(new Pivot($this->joining))->where($foreign, '=', $key);
- }
-
- /**
- * Get the other or associated key for the relationship.
- *
- * @return string
- */
- protected function other_key()
- {
- return Relationship::foreign($this->model, $this->other);
- }
-
- /**
- * Get the fully qualified associated table's primary key.
- *
- * @return string
- */
- protected function associated_key()
- {
- return $this->model->table().'.'.$this->model->key();
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/eloquent/relationships/has_one.php b/laravel/database/eloquent/relationships/has_one.php
deleted file mode 100644
index 077c3ada1f3..00000000000
--- a/laravel/database/eloquent/relationships/has_one.php
+++ /dev/null
@@ -1,47 +0,0 @@
-relationships[$relationship] = null;
- }
- }
-
- /**
- * Match eagerly loaded child models to their parent models.
- *
- * @param array $parents
- * @param array $children
- * @return void
- */
- public function match($relationship, &$parents, $children)
- {
- $foreign = $this->foreign_key();
-
- foreach ($children as $key => $child)
- {
- $parents[$child->$foreign]->relationships[$relationship] = $child;
- }
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/eloquent/relationships/has_one_or_many.php b/laravel/database/eloquent/relationships/has_one_or_many.php
deleted file mode 100644
index 2cdac83ec8f..00000000000
--- a/laravel/database/eloquent/relationships/has_one_or_many.php
+++ /dev/null
@@ -1,43 +0,0 @@
-attributes : $attributes;
-
- $attributes[$this->foreign_key()] = $this->base->get_key();
-
- return $this->model->create($attributes);
- }
-
- /**
- * Set the proper constraints on the relationship table.
- *
- * @return void
- */
- protected function constrain()
- {
- $this->table->where($this->foreign_key(), '=', $this->base->get_key());
- }
-
- /**
- * Set the proper constraints on the relationship table for an eager load.
- *
- * @param array $results
- * @return void
- */
- public function eagerly_constrain($results)
- {
- $this->table->where_in($this->foreign_key(), array_keys($results));
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/eloquent/relationships/relationship.php b/laravel/database/eloquent/relationships/relationship.php
deleted file mode 100644
index 84d023621ed..00000000000
--- a/laravel/database/eloquent/relationships/relationship.php
+++ /dev/null
@@ -1,104 +0,0 @@
-foreign = $foreign;
-
- // We will go ahead and set the model and associated instances on the
- // relationship to match the relationship targets passed in from the
- // model. These will allow us to gather the relationship info.
- if ($associated instanceof Model)
- {
- $this->model = $associated;
- }
- else
- {
- $this->model = new $associated;
- }
-
- // For relationships, we'll set the base model to be the model being
- // associated from. This model contains the value of the foreign
- // key needed to connect to the associated model.
- if ($model instanceof Model)
- {
- $this->base = $model;
- }
- else
- {
- $this->base = new $model;
- }
-
- // Next we'll set the fluent query builder for the relationship and
- // constrain the query such that it only returns the models that
- // are appropriate for the relationship.
- $this->table = $this->query();
-
- $this->constrain();
- }
-
- /**
- * Get the foreign key name for the given model.
- *
- * @param string $model
- * @param string $foreign
- * @return string
- */
- public static function foreign($model, $foreign = null)
- {
- if ( ! is_null($foreign)) return $foreign;
-
- // If the model is an object we'll simply get the class of the object and
- // then take the basename, which is simply the object name minus the
- // namespace, and we'll append "_id" to the name.
- if (is_object($model))
- {
- $model = class_basename($model);
- }
-
- return strtolower(basename($model).'_id');
- }
-
- /**
- * Get a freshly instantiated instance of the related model class.
- *
- * @param array $attributes
- * @return Model
- */
- protected function fresh_model($attributes = array())
- {
- $class = get_class($this->model);
-
- return new $class($attributes);
- }
-
- /**
- * Get the foreign key for the relationship.
- *
- * @return string
- */
- public function foreign_key()
- {
- return static::foreign($this->base, $this->foreign);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/exception.php b/laravel/database/exception.php
deleted file mode 100644
index a116ad70c81..00000000000
--- a/laravel/database/exception.php
+++ /dev/null
@@ -1,41 +0,0 @@
-inner = $inner;
-
- $this->setMessage($sql, $bindings);
- }
-
- /**
- * Set the exception message to include the SQL and bindings.
- *
- * @param string $sql
- * @param array $bindings
- * @return void
- */
- protected function setMessage($sql, $bindings)
- {
- $this->message = $this->inner->getMessage();
-
- $this->message .= "\n\nSQL: ".$sql."\n\nBindings: ".var_export($bindings, true);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/expression.php b/laravel/database/expression.php
deleted file mode 100644
index f92eed6a83b..00000000000
--- a/laravel/database/expression.php
+++ /dev/null
@@ -1,43 +0,0 @@
-value = $value;
- }
-
- /**
- * Get the string value of the database expression.
- *
- * @return string
- */
- public function get()
- {
- return $this->value;
- }
-
- /**
- * Get the string value of the database expression.
- *
- * @return string
- */
- public function __toString()
- {
- return $this->get();
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/grammar.php b/laravel/database/grammar.php
deleted file mode 100644
index 13d92d8ea10..00000000000
--- a/laravel/database/grammar.php
+++ /dev/null
@@ -1,174 +0,0 @@
-connection = $connection;
- }
-
- /**
- * Wrap a table in keyword identifiers.
- *
- * @param string $table
- * @return string
- */
- public function wrap_table($table)
- {
- // Expressions should be injected into the query as raw strings so
- // so we do not want to wrap them in any way. We will just return
- // the string value from the expression to be included.
- if ($table instanceof Expression)
- {
- return $this->wrap($table);
- }
-
- $prefix = '';
-
- // Tables may be prefixed with a string. This allows developers to
- // prefix tables by application on the same database which may be
- // required in some brown-field situations.
- if (isset($this->connection->config['prefix']))
- {
- $prefix = $this->connection->config['prefix'];
- }
-
- return $this->wrap($prefix.$table);
- }
-
- /**
- * Wrap a value in keyword identifiers.
- *
- * @param string $value
- * @return string
- */
- public function wrap($value)
- {
- // Expressions should be injected into the query as raw strings so
- // so we do not want to wrap them in any way. We will just return
- // the string value from the expression to be included.
- if ($value instanceof Expression)
- {
- return $value->get();
- }
-
- // If the value being wrapped contains a column alias, we need to
- // wrap it a little differently as each segment must be wrapped
- // and not the entire string.
- if (strpos(strtolower($value), ' as ') !== false)
- {
- $segments = explode(' ', $value);
-
- return sprintf(
- '%s AS %s',
- $this->wrap($segments[0]),
- $this->wrap($segments[2])
- );
- }
-
- // Since columns may be prefixed with their corresponding table
- // name so as to not make them ambiguous, we will need to wrap
- // the table and the column in keyword identifiers.
- $segments = explode('.', $value);
-
- foreach ($segments as $key => $value)
- {
- if ($key == 0 and count($segments) > 1)
- {
- $wrapped[] = $this->wrap_table($value);
- }
- else
- {
- $wrapped[] = $this->wrap_value($value);
- }
- }
-
- return implode('.', $wrapped);
- }
-
- /**
- * Wrap a single string value in keyword identifiers.
- *
- * @param string $value
- * @return string
- */
- protected function wrap_value($value)
- {
- return ($value !== '*') ? sprintf($this->wrapper, $value) : $value;
- }
-
- /**
- * Create query parameters from an array of values.
- *
- *
- * Returns "?, ?, ?", which may be used as PDO place-holders
- * $parameters = $grammar->parameterize(array(1, 2, 3));
- *
- * // Returns "?, "Taylor"" since an expression is used
- * $parameters = $grammar->parameterize(array(1, DB::raw('Taylor')));
- *
- *
- * @param array $values
- * @return string
- */
- final public function parameterize($values)
- {
- return implode(', ', array_map(array($this, 'parameter'), $values));
- }
-
- /**
- * Get the appropriate query parameter string for a value.
- *
- *
- * // Returns a "?" PDO place-holder
- * $value = $grammar->parameter('Taylor Otwell');
- *
- * // Returns "Taylor Otwell" as the raw value of the expression
- * $value = $grammar->parameter(DB::raw('Taylor Otwell'));
- *
- *
- * @param mixed $value
- * @return string
- */
- final public function parameter($value)
- {
- return ($value instanceof Expression) ? $value->get() : '?';
- }
-
- /**
- * Create a comma-delimited list of wrapped column names.
- *
- *
- * // Returns ""Taylor", "Otwell"" when the identifier is quotes
- * $columns = $grammar->columnize(array('Taylor', 'Otwell'));
- *
- *
- * @param array $columns
- * @return string
- */
- final public function columnize($columns)
- {
- return implode(', ', array_map(array($this, 'wrap'), $columns));
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/query.php b/laravel/database/query.php
deleted file mode 100644
index 9d221176ca2..00000000000
--- a/laravel/database/query.php
+++ /dev/null
@@ -1,853 +0,0 @@
-from = $table;
- $this->grammar = $grammar;
- $this->connection = $connection;
- }
-
- /**
- * Force the query to return distinct results.
- *
- * @return Query
- */
- public function distinct()
- {
- $this->distinct = true;
- return $this;
- }
-
- /**
- * Add an array of columns to the SELECT clause.
- *
- * @param array $columns
- * @return Query
- */
- public function select($columns = array('*'))
- {
- $this->selects = (array) $columns;
- return $this;
- }
-
- /**
- * Add a join clause to the query.
- *
- * @param string $table
- * @param string $column1
- * @param string $operator
- * @param string $column2
- * @param string $type
- * @return Query
- */
- public function join($table, $column1, $operator = null, $column2 = null, $type = 'INNER')
- {
- // If the "column" is really an instance of a Closure, the developer is
- // trying to create a join with a complex "ON" clause. So, we will add
- // the join, and then call the Closure with the join/
- if ($column1 instanceof Closure)
- {
- $this->joins[] = new Query\Join($type, $table);
-
- call_user_func($column1, end($this->joins));
- }
-
- // If the column is just a string, we can assume that the join just
- // has a simple on clause, and we'll create the join instance and
- // add the clause automatically for the develoepr.
- else
- {
- $join = new Query\Join($type, $table);
-
- $join->on($column1, $operator, $column2);
-
- $this->joins[] = $join;
- }
-
- return $this;
- }
-
- /**
- * Add a left join to the query.
- *
- * @param string $table
- * @param string $column1
- * @param string $operator
- * @param string $column2
- * @return Query
- */
- public function left_join($table, $column1, $operator = null, $column2 = null)
- {
- return $this->join($table, $column1, $operator, $column2, 'LEFT');
- }
-
- /**
- * Reset the where clause to its initial state.
- *
- * @return void
- */
- public function reset_where()
- {
- list($this->wheres, $this->bindings) = array(array(), array());
- }
-
- /**
- * Add a raw where condition to the query.
- *
- * @param string $where
- * @param array $bindings
- * @param string $connector
- * @return Query
- */
- public function raw_where($where, $bindings = array(), $connector = 'AND')
- {
- $this->wheres[] = array('type' => 'where_raw', 'connector' => $connector, 'sql' => $where);
-
- $this->bindings = array_merge($this->bindings, $bindings);
-
- return $this;
- }
-
- /**
- * Add a raw or where condition to the query.
- *
- * @param string $where
- * @param array $bindings
- * @return Query
- */
- public function raw_or_where($where, $bindings = array())
- {
- return $this->raw_where($where, $bindings, 'OR');
- }
-
- /**
- * Add a where condition to the query.
- *
- * @param string $column
- * @param string $operator
- * @param mixed $value
- * @param string $connector
- * @return Query
- */
- public function where($column, $operator = null, $value = null, $connector = 'AND')
- {
- // If a Closure is passed into the method, it means a nested where
- // clause is being initiated, so we will take a different course
- // of action than when the statement is just a simple where.
- if ($column instanceof Closure)
- {
- return $this->where_nested($column, $connector);
- }
-
- $type = 'where';
-
- $this->wheres[] = compact('type', 'column', 'operator', 'value', 'connector');
-
- $this->bindings[] = $value;
-
- return $this;
- }
-
- /**
- * Add an or where condition to the query.
- *
- * @param string $column
- * @param string $operator
- * @param mixed $value
- * @return Query
- */
- public function or_where($column, $operator = null, $value = null)
- {
- return $this->where($column, $operator, $value, 'OR');
- }
-
- /**
- * Add an or where condition for the primary key to the query.
- *
- * @param mixed $value
- * @return Query
- */
- public function or_where_id($value)
- {
- return $this->or_where('id', '=', $value);
- }
-
- /**
- * Add a where in condition to the query.
- *
- * @param string $column
- * @param array $values
- * @param string $connector
- * @param bool $not
- * @return Query
- */
- public function where_in($column, $values, $connector = 'AND', $not = false)
- {
- $type = ($not) ? 'where_not_in' : 'where_in';
-
- $this->wheres[] = compact('type', 'column', 'values', 'connector');
-
- $this->bindings = array_merge($this->bindings, $values);
-
- return $this;
- }
-
- /**
- * Add an or where in condition to the query.
- *
- * @param string $column
- * @param array $values
- * @return Query
- */
- public function or_where_in($column, $values)
- {
- return $this->where_in($column, $values, 'OR');
- }
-
- /**
- * Add a where not in condition to the query.
- *
- * @param string $column
- * @param array $values
- * @param string $connector
- * @return Query
- */
- public function where_not_in($column, $values, $connector = 'AND')
- {
- return $this->where_in($column, $values, $connector, true);
- }
-
- /**
- * Add an or where not in condition to the query.
- *
- * @param string $column
- * @param array $values
- * @return Query
- */
- public function or_where_not_in($column, $values)
- {
- return $this->where_not_in($column, $values, 'OR');
- }
-
- /**
- * Add a where null condition to the query.
- *
- * @param string $column
- * @param string $connector
- * @param bool $not
- * @return Query
- */
- public function where_null($column, $connector = 'AND', $not = false)
- {
- $type = ($not) ? 'where_not_null' : 'where_null';
-
- $this->wheres[] = compact('type', 'column', 'connector');
-
- return $this;
- }
-
- /**
- * Add an or where null condition to the query.
- *
- * @param string $column
- * @return Query
- */
- public function or_where_null($column)
- {
- return $this->where_null($column, 'OR');
- }
-
- /**
- * Add a where not null condition to the query.
- *
- * @param string $column
- * @param string $connector
- * @return Query
- */
- public function where_not_null($column, $connector = 'AND')
- {
- return $this->where_null($column, $connector, true);
- }
-
- /**
- * Add an or where not null condition to the query.
- *
- * @param string $column
- * @return Query
- */
- public function or_where_not_null($column)
- {
- return $this->where_not_null($column, 'OR');
- }
-
- /**
- * Add a nested where condition to the query.
- *
- * @param Closure $callback
- * @param string $connector
- * @return Query
- */
- public function where_nested($callback, $connector = 'AND')
- {
- $type = 'where_nested';
-
- // To handle a nested where statement, we will actually instantiate a new
- // Query instance and run the callback over that instance, which will
- // allow the developer to have a fresh query instance
- $query = new Query($this->connection, $this->grammar, $this->from);
-
- call_user_func($callback, $query);
-
- // Once the callback has been run on the query, we will store the nested
- // query instance on the where clause array so that it's passed to the
- // query's query grammar instance when building.
- $this->wheres[] = compact('type', 'query', 'connector');
-
- $this->bindings = array_merge($this->bindings, $query->bindings);
-
- return $this;
- }
-
- /**
- * Add dynamic where conditions to the query.
- *
- * @param string $method
- * @param array $parameters
- * @return Query
- */
- private function dynamic_where($method, $parameters)
- {
- $finder = substr($method, 6);
-
- $flags = PREG_SPLIT_DELIM_CAPTURE;
-
- $segments = preg_split('/(_and_|_or_)/i', $finder, -1, $flags);
-
- // The connector variable will determine which connector will be used
- // for the condition. We'll change it as we come across new boolean
- // connectors in the dynamic method string.
- //
- // The index variable helps us get the correct parameter value for
- // the where condition. We increment it each time we add another
- // condition to the query's where clause.
- $connector = 'AND';
-
- $index = 0;
-
- foreach ($segments as $segment)
- {
- // If the segment is not a boolean connector, we can assume it it is
- // a column name, and we'll add it to the query as a new constraint
- // of the query's where clause and keep iterating the segments.
- if ($segment != '_and_' and $segment != '_or_')
- {
- $this->where($segment, '=', $parameters[$index], $connector);
-
- $index++;
- }
- // Otherwise, we will store the connector so we know how the next
- // where clause we find in the query should be connected to the
- // previous one and will add it when we find the next one.
- else
- {
- $connector = trim(strtoupper($segment), '_');
- }
- }
-
- return $this;
- }
-
- /**
- * Add a grouping to the query.
- *
- * @param string $column
- * @return Query
- */
- public function group_by($column)
- {
- $this->groupings[] = $column;
- return $this;
- }
-
- /**
- * Add an ordering to the query.
- *
- * @param string $column
- * @param string $direction
- * @return Query
- */
- public function order_by($column, $direction = 'asc')
- {
- $this->orderings[] = compact('column', 'direction');
- return $this;
- }
-
- /**
- * Set the query offset.
- *
- * @param int $value
- * @return Query
- */
- public function skip($value)
- {
- $this->offset = $value;
- return $this;
- }
-
- /**
- * Set the query limit.
- *
- * @param int $value
- * @return Query
- */
- public function take($value)
- {
- $this->limit = $value;
- return $this;
- }
-
- /**
- * Set the query limit and offset for a given page.
- *
- * @param int $page
- * @param int $per_page
- * @return Query
- */
- public function for_page($page, $per_page)
- {
- return $this->skip(($page - 1) * $per_page)->take($per_page);
- }
-
- /**
- * Find a record by the primary key.
- *
- * @param int $id
- * @param array $columns
- * @return object
- */
- public function find($id, $columns = array('*'))
- {
- return $this->where('id', '=', $id)->first($columns);
- }
-
- /**
- * Execute the query as a SELECT statement and return a single column.
- *
- * @param string $column
- * @return mixed
- */
- public function only($column)
- {
- $sql = $this->grammar->select($this->select(array($column)));
-
- return $this->connection->only($sql, $this->bindings);
- }
-
- /**
- * Execute the query as a SELECT statement and return the first result.
- *
- * @param array $columns
- * @return mixed
- */
- public function first($columns = array('*'))
- {
- $columns = (array) $columns;
-
- // Since we only need the first result, we'll go ahead and set the
- // limit clause to 1, since this will be much faster than getting
- // all of the rows and then only returning the first.
- $results = $this->take(1)->get($columns);
-
- return (count($results) > 0) ? $results[0] : null;
- }
-
- /**
- * Get an array with the values of a given column.
- *
- * @param string $column
- * @param string $key
- * @return array
- */
- public function lists($column, $key = null)
- {
- $columns = (is_null($key)) ? array($column) : array($column, $key);
-
- $results = $this->get($columns);
-
- // First we will get the array of values for the requested column.
- // Of course, this array will simply have numeric keys. After we
- // have this array we will determine if we need to key the array
- // by another column from the result set.
- $values = array_map(function($row) use ($column)
- {
- return $row->$column;
-
- }, $results);
-
- // If a key was provided, we will extract an array of keys and
- // set the keys on the array of values using the array_combine
- // function provided by PHP, which should give us the proper
- // array form to return from the method.
- if ( ! is_null($key))
- {
- return array_combine(array_map(function($row) use ($key)
- {
- return $row->$key;
-
- }, $results), $values);
- }
-
- return $values;
- }
-
- /**
- * Execute the query as a SELECT statement.
- *
- * @param array $columns
- * @return array
- */
- public function get($columns = array('*'))
- {
- if (is_null($this->selects)) $this->select($columns);
-
- $sql = $this->grammar->select($this);
-
- $results = $this->connection->query($sql, $this->bindings);
-
- // If the query has an offset and we are using the SQL Server grammar,
- // we need to spin through the results and remove the "rownum" from
- // each of the objects since there is no "offset".
- if ($this->offset > 0 and $this->grammar instanceof SQLServer)
- {
- array_walk($results, function($result)
- {
- unset($result->rownum);
- });
- }
-
- // Reset the SELECT clause so more queries can be performed using
- // the same instance. This is helpful for getting aggregates and
- // then getting actual results from the query.
- $this->selects = null;
-
- return $results;
- }
-
- /**
- * Get an aggregate value.
- *
- * @param string $aggregator
- * @param array $columns
- * @return mixed
- */
- public function aggregate($aggregator, $columns)
- {
- // We'll set the aggregate value so the grammar does not try to compile
- // a SELECT clause on the query. If an aggregator is present, it's own
- // grammar function will be used to build the SQL syntax.
- $this->aggregate = compact('aggregator', 'columns');
-
- $sql = $this->grammar->select($this);
-
- $result = $this->connection->only($sql, $this->bindings);
-
- // Reset the aggregate so more queries can be performed using the same
- // instance. This is helpful for getting aggregates and then getting
- // actual results from the query such as during paging.
- $this->aggregate = null;
-
- return $result;
- }
-
- /**
- * Get the paginated query results as a Paginator instance.
- *
- * @param int $per_page
- * @param array $columns
- * @return Paginator
- */
- public function paginate($per_page = 20, $columns = array('*'))
- {
- // Because some database engines may throw errors if we leave orderings
- // on the query when retrieving the total number of records, we'll drop
- // all of the ordreings and put them back on the query.
- list($orderings, $this->orderings) = array($this->orderings, null);
-
- $total = $this->count(reset($columns));
-
- $page = Paginator::page($total, $per_page);
-
- $this->orderings = $orderings;
-
- // Now we're ready to get the actual pagination results from the table
- // using the for_page and get methods. The "for_page" method provides
- // a convenient way to set the paging limit and offset.
- $results = $this->for_page($page, $per_page)->get($columns);
-
- return Paginator::make($results, $total, $per_page);
- }
-
- /**
- * Insert an array of values into the database table.
- *
- * @param array $values
- * @return bool
- */
- public function insert($values)
- {
- // Force every insert to be treated like a batch insert to make creating
- // the binding array simpler since we can just spin through the inserted
- // rows as if there/ was more than one every time.
- if ( ! is_array(reset($values))) $values = array($values);
-
- $bindings = array();
-
- // We need to merge the the insert values into the array of the query
- // bindings so that they will be bound to the PDO statement when it
- // is executed by the database connection.
- foreach ($values as $value)
- {
- $bindings = array_merge($bindings, array_values($value));
- }
-
- $sql = $this->grammar->insert($this, $values);
-
- return $this->connection->query($sql, $bindings);
- }
-
- /**
- * Insert an array of values into the database table and return the ID.
- *
- * @param array $values
- * @param string $sequence
- * @return int
- */
- public function insert_get_id($values, $sequence = null)
- {
- $sql = $this->grammar->insert($this, $values);
-
- $this->connection->query($sql, array_values($values));
-
- // Some database systems (Postgres) require a sequence name to be
- // given when retrieving the auto-incrementing ID, so we'll pass
- // the given sequence into the method just in case.
- return (int) $this->connection->pdo->lastInsertId($sequence);
- }
-
- /**
- * Increment the value of a column by a given amount.
- *
- * @param string $column
- * @param int $amount
- * @return int
- */
- public function increment($column, $amount = 1)
- {
- return $this->adjust($column, $amount, ' + ');
- }
-
- /**
- * Decrement the value of a column by a given amount.
- *
- * @param string $column
- * @param int $amount
- * @return int
- */
- public function decrement($column, $amount = 1)
- {
- return $this->adjust($column, $amount, ' - ');
- }
-
- /**
- * Adjust the value of a column up or down by a given amount.
- *
- * @param string $column
- * @param int $amount
- * @param string $operator
- * @return int
- */
- protected function adjust($column, $amount, $operator)
- {
- $wrapped = $this->grammar->wrap($column);
-
- // To make the adjustment to the column, we'll wrap the expression in an
- // Expression instance, which forces the adjustment to be injected into
- // the query as a string instead of bound.
- $value = Database::raw($wrapped.$operator.$amount);
-
- return $this->update(array($column => $value));
- }
-
- /**
- * Update an array of values in the database table.
- *
- * @param array $values
- * @return int
- */
- public function update($values)
- {
- // For update statements, we need to merge the bindings such that the update
- // values occur before the where bindings in the array since the sets will
- // precede any of the where clauses in the SQL syntax that is generated.
- $bindings = array_merge(array_values($values), $this->bindings);
-
- $sql = $this->grammar->update($this, $values);
-
- return $this->connection->query($sql, $bindings);
- }
-
- /**
- * Execute the query as a DELETE statement.
- *
- * Optionally, an ID may be passed to the method do delete a specific row.
- *
- * @param int $id
- * @return int
- */
- public function delete($id = null)
- {
- // If an ID is given to the method, we'll set the where clause to
- // match on the value of the ID. This allows the developer to
- // quickly delete a row by its primary key value.
- if ( ! is_null($id))
- {
- $this->where('id', '=', $id);
- }
-
- $sql = $this->grammar->delete($this);
-
- return $this->connection->query($sql, $this->bindings);
- }
-
- /**
- * Magic Method for handling dynamic functions.
- *
- * This method handles calls to aggregates as well as dynamic where clauses.
- */
- public function __call($method, $parameters)
- {
- if (strpos($method, 'where_') === 0)
- {
- return $this->dynamic_where($method, $parameters, $this);
- }
-
- // All of the aggregate methods are handled by a single method, so we'll
- // catch them all here and then pass them off to the agregate method
- // instead of creating methods for each one of them.
- if (in_array($method, array('count', 'min', 'max', 'avg', 'sum')))
- {
- if (count($parameters) == 0) $parameters[0] = '*';
-
- return $this->aggregate(strtoupper($method), (array) $parameters[0]);
- }
-
- throw new \Exception("Method [$method] is not defined on the Query class.");
- }
-
-}
diff --git a/laravel/database/query/grammars/grammar.php b/laravel/database/query/grammars/grammar.php
deleted file mode 100644
index b0c06824e85..00000000000
--- a/laravel/database/query/grammars/grammar.php
+++ /dev/null
@@ -1,424 +0,0 @@
-concatenate($this->components($query));
- }
-
- /**
- * Generate the SQL for every component of the query.
- *
- * @param Query $query
- * @return array
- */
- final protected function components($query)
- {
- // Each portion of the statement is compiled by a function corresponding
- // to an item in the components array. This lets us to keep the creation
- // of the query very granular and very flexible.
- foreach ($this->components as $component)
- {
- if ( ! is_null($query->$component))
- {
- $sql[$component] = call_user_func(array($this, $component), $query);
- }
- }
-
- return (array) $sql;
- }
-
- /**
- * Concatenate an array of SQL segments, removing those that are empty.
- *
- * @param array $components
- * @return string
- */
- final protected function concatenate($components)
- {
- return implode(' ', array_filter($components, function($value)
- {
- return (string) $value !== '';
- }));
- }
-
- /**
- * Compile the SELECT clause for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function selects(Query $query)
- {
- if ( ! is_null($query->aggregate)) return;
-
- $select = ($query->distinct) ? 'SELECT DISTINCT ' : 'SELECT ';
-
- return $select.$this->columnize($query->selects);
- }
-
- /**
- * Compile an aggregating SELECT clause for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function aggregate(Query $query)
- {
- $column = $this->columnize($query->aggregate['columns']);
-
- // If the "distinct" flag is set and we're not aggregating everything
- // we'll set the distinct clause on the query, since this is used
- // to count all of the distinct values in a column, etc.
- if ($query->distinct and $column !== '*')
- {
- $column = 'DISTINCT '.$column;
- }
-
- return 'SELECT '.$query->aggregate['aggregator'].'('.$column.') AS '.$this->wrap('aggregate');
- }
-
- /**
- * Compile the FROM clause for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function from(Query $query)
- {
- return 'FROM '.$this->wrap_table($query->from);
- }
-
- /**
- * Compile the JOIN clauses for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function joins(Query $query)
- {
- // We need to iterate through each JOIN clause that is attached to the
- // query an translate it into SQL. The table and the columns will be
- // wrapped in identifiers to avoid naming collisions.
- foreach ($query->joins as $join)
- {
- $table = $this->wrap_table($join->table);
-
- $clauses = array();
-
- // Each JOIN statement may have multiple clauses, so we will iterate
- // through each clause creating the conditions then we'll join all
- // of the together at the end to build the clause.
- foreach ($join->clauses as $clause)
- {
- extract($clause);
-
- $column1 = $this->wrap($column1);
-
- $column2 = $this->wrap($column2);
-
- $clauses[] = "{$connector} {$column1} {$operator} {$column2}";
- }
-
- // The first clause will have a connector on the front, but it is
- // not needed on the first condition, so we will strip it off of
- // the condition before adding it to the arrya of joins.
- $search = array('AND ', 'OR ');
-
- $clauses[0] = str_replace($search, '', $clauses[0]);
-
- $clauses = implode(' ', $clauses);
-
- $sql[] = "{$join->type} JOIN {$table} ON {$clauses}";
- }
-
- // Finally, we should have an array of JOIN clauses that we can
- // implode together and return as the complete SQL for the
- // join clause of the query under construction.
- return implode(' ', $sql);
- }
-
- /**
- * Compile the WHERE clause for a query.
- *
- * @param Query $query
- * @return string
- */
- final protected function wheres(Query $query)
- {
- if (is_null($query->wheres)) return '';
-
- // Each WHERE clause array has a "type" that is assigned by the query
- // builder, and each type has its own compiler function. We will call
- // the appropriate compiler for each where clause.
- foreach ($query->wheres as $where)
- {
- $sql[] = $where['connector'].' '.$this->{$where['type']}($where);
- }
-
- if (isset($sql))
- {
- // We attach the boolean connector to every where segment just
- // for convenience. Once we have built the entire clause we'll
- // remove the first instance of a connector.
- return 'WHERE '.preg_replace('/AND |OR /', '', implode(' ', $sql), 1);
- }
- }
-
- /**
- * Compile a nested WHERE clause.
- *
- * @param array $where
- * @return string
- */
- protected function where_nested($where)
- {
- return '('.substr($this->wheres($where['query']), 6).')';
- }
-
- /**
- * Compile a simple WHERE clause.
- *
- * @param array $where
- * @return string
- */
- protected function where($where)
- {
- $parameter = $this->parameter($where['value']);
-
- return $this->wrap($where['column']).' '.$where['operator'].' '.$parameter;
- }
-
- /**
- * Compile a WHERE IN clause.
- *
- * @param array $where
- * @return string
- */
- protected function where_in($where)
- {
- $parameters = $this->parameterize($where['values']);
-
- return $this->wrap($where['column']).' IN ('.$parameters.')';
- }
-
- /**
- * Compile a WHERE NOT IN clause.
- *
- * @param array $where
- * @return string
- */
- protected function where_not_in($where)
- {
- $parameters = $this->parameterize($where['values']);
-
- return $this->wrap($where['column']).' NOT IN ('.$parameters.')';
- }
-
- /**
- * Compile a WHERE NULL clause.
- *
- * @param array $where
- * @return string
- */
- protected function where_null($where)
- {
- return $this->wrap($where['column']).' IS NULL';
- }
-
- /**
- * Compile a WHERE NULL clause.
- *
- * @param array $where
- * @return string
- */
- protected function where_not_null($where)
- {
- return $this->wrap($where['column']).' IS NOT NULL';
- }
-
- /**
- * Compile a raw WHERE clause.
- *
- * @param array $where
- * @return string
- */
- final protected function where_raw($where)
- {
- return $where['sql'];
- }
-
- /**
- * Compile the GROUP BY clause for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function groupings(Query $query)
- {
- return 'GROUP BY '.$this->columnize($query->groupings);
- }
-
- /**
- * Compile the ORDER BY clause for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function orderings(Query $query)
- {
- foreach ($query->orderings as $ordering)
- {
- $sql[] = $this->wrap($ordering['column']).' '.strtoupper($ordering['direction']);
- }
-
- return 'ORDER BY '.implode(', ', $sql);
- }
-
- /**
- * Compile the LIMIT clause for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function limit(Query $query)
- {
- return 'LIMIT '.$query->limit;
- }
-
- /**
- * Compile the OFFSET clause for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function offset(Query $query)
- {
- return 'OFFSET '.$query->offset;
- }
-
- /**
- * Compile a SQL INSERT statment from a Query instance.
- *
- * This method handles the compilation of single row inserts and batch inserts.
- *
- * @param Query $query
- * @param array $values
- * @return string
- */
- public function insert(Query $query, $values)
- {
- $table = $this->wrap_table($query->from);
-
- // Force every insert to be treated like a batch insert. This simply makes
- // creating the SQL syntax a little easier on us since we can always treat
- // the values as if it contains multiple inserts.
- if ( ! is_array(reset($values))) $values = array($values);
-
- // Since we only care about the column names, we can pass any of the insert
- // arrays into the "columnize" method. The columns should be the same for
- // every record inserted into the table.
- $columns = $this->columnize(array_keys(reset($values)));
-
- // Build the list of parameter place-holders of values bound to the query.
- // Each insert should have the same number of bound paramters, so we can
- // just use the first array of values.
- $parameters = $this->parameterize(reset($values));
-
- $parameters = implode(', ', array_fill(0, count($values), "($parameters)"));
-
- return "INSERT INTO {$table} ({$columns}) VALUES {$parameters}";
- }
-
- /**
- * Compile a SQL UPDATE statment from a Query instance.
- *
- * @param Query $query
- * @param array $values
- * @return string
- */
- public function update(Query $query, $values)
- {
- $table = $this->wrap_table($query->from);
-
- // Each column in the UPDATE statement needs to be wrapped in the keyword
- // identifiers, and a place-holder needs to be created for each value in
- // the array of bindings, so we'll build the sets first.
- foreach ($values as $column => $value)
- {
- $columns[] = $this->wrap($column).' = '.$this->parameter($value);
- }
-
- $columns = implode(', ', $columns);
-
- // UPDATE statements may be constrained by a WHERE clause, so we'll run
- // the entire where compilation process for those contraints. This is
- // easily achieved by passing it to the "wheres" method.
- return trim("UPDATE {$table} SET {$columns} ".$this->wheres($query));
- }
-
- /**
- * Compile a SQL DELETE statment from a Query instance.
- *
- * @param Query $query
- * @return string
- */
- public function delete(Query $query)
- {
- $table = $this->wrap_table($query->from);
-
- return trim("DELETE FROM {$table} ".$this->wheres($query));
- }
-
- /**
- * Transform an SQL short-cuts into real SQL for PDO.
- *
- * @param string $sql
- * @param array $bindings
- * @return string
- */
- public function shortcut($sql, $bindings)
- {
- // Laravel provides an easy short-cut notation for writing raw WHERE IN
- // statements. If (...) is in the query, it will be replaced with the
- // correct number of parameters based on the bindings.
- if (strpos($sql, '(...)') !== false)
- {
- for ($i = 0; $i < count($bindings); $i++)
- {
- // If the binding is an array, we can just assume it's used to
- // fill a "where in" condition, so we will just replace the
- // next place-holder in the query with the constraint.
- if (is_array($bindings[$i]))
- {
- $parameters = $this->parameterize($bindings[$i]);
-
- $sql = preg_replace('~\(\.\.\.\)~', "({$parameters})", $sql, 1);
- }
- }
- }
-
- return trim($sql);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/query/grammars/mysql.php b/laravel/database/query/grammars/mysql.php
deleted file mode 100644
index 37692e0a477..00000000000
--- a/laravel/database/query/grammars/mysql.php
+++ /dev/null
@@ -1,12 +0,0 @@
-offset > 0)
- {
- return $this->ansi_offset($query, $sql);
- }
-
- // Once all of the clauses have been compiled, we can join them all as
- // one statement. Any segments that are null or an empty string will
- // be removed from the array before imploding.
- return $this->concatenate($sql);
- }
-
- /**
- * Compile the SELECT clause for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function selects(Query $query)
- {
- if ( ! is_null($query->aggregate)) return;
-
- $select = ($query->distinct) ? 'SELECT DISTINCT ' : 'SELECT ';
-
- // Instead of using a "LIMIT" keyword, SQL Server uses the TOP keyword
- // within the SELECT statement. So, if we have a limit, we will add
- // it to the query here if there is not an OFFSET present.
- if ($query->limit > 0 and $query->offset <= 0)
- {
- $select .= 'TOP '.$query->limit.' ';
- }
-
- return $select.$this->columnize($query->selects);
- }
-
- /**
- * Generate the ANSI standard SQL for an offset clause.
- *
- * @param Query $query
- * @param array $components
- * @return array
- */
- protected function ansi_offset(Query $query, $components)
- {
- // An ORDER BY clause is required to make this offset query work, so if
- // one doesn't exist, we'll just create a dummy clause to trick the
- // database and pacify it so it doesn't complain about the query.
- if ( ! isset($components['orderings']))
- {
- $components['orderings'] = 'ORDER BY (SELECT 0)';
- }
-
- // We need to add the row number to the query so we can compare it to
- // the offset and limit values given for the statement. So we'll add
- // an expression to the select for the row number.
- $orderings = $components['orderings'];
-
- $components['selects'] .= ", ROW_NUMBER() OVER ({$orderings}) AS RowNum";
-
- unset($components['orderings']);
-
- $start = $query->offset + 1;
-
- // Next we need to calculate the constraint that should be placed on
- // the row number to get the correct offset and limit on the query.
- // If there is not limit, we'll just handle the offset.
- if ($query->limit > 0)
- {
- $finish = $query->offset + $query->limit;
-
- $constraint = "BETWEEN {$start} AND {$finish}";
- }
- else
- {
- $constraint = ">= {$start}";
- }
-
- // We're finally ready to build the final SQL query so we'll create
- // a common table expression with the query and select all of the
- // results with row numbers between the limit and offset.
- $sql = $this->concatenate($components);
-
- return "SELECT * FROM ($sql) AS TempTable WHERE RowNum {$constraint}";
- }
-
- /**
- * Compile the LIMIT clause for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function limit(Query $query)
- {
- return '';
- }
-
- /**
- * Compile the OFFSET clause for a query.
- *
- * @param Query $query
- * @return string
- */
- protected function offset(Query $query)
- {
- return '';
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/query/join.php b/laravel/database/query/join.php
deleted file mode 100644
index ff3c0141f06..00000000000
--- a/laravel/database/query/join.php
+++ /dev/null
@@ -1,68 +0,0 @@
-type = $type;
- $this->table = $table;
- }
-
- /**
- * Add an ON clause to the join.
- *
- * @param string $column1
- * @param string $operator
- * @param string $column2
- * @param string $connector
- * @return Join
- */
- public function on($column1, $operator, $column2, $connector = 'AND')
- {
- $this->clauses[] = compact('column1', 'operator', 'column2', 'connector');
-
- return $this;
- }
-
- /**
- * Add an OR ON clause to the join.
- *
- * @param string $column1
- * @param string $operator
- * @param string $column2
- * @return Join
- */
- public function or_on($column1, $operator, $column2)
- {
- return $this->on($column1, $operator, $column2, 'OR');
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/schema.php b/laravel/database/schema.php
deleted file mode 100644
index 3787e33bc32..00000000000
--- a/laravel/database/schema.php
+++ /dev/null
@@ -1,166 +0,0 @@
-create();
-
- call_user_func($callback, $table);
-
- return static::execute($table);
- }
-
- /**
- * Drop a database table from the schema.
- *
- * @param string $table
- * @return void
- */
- public static function drop($table)
- {
- $table = new Schema\Table($table);
-
- // To indicate that the table needs to be dropped, we will run the
- // "drop" command on the table instance and pass the instance to
- // the execute method as calling a Closure isn't needed.
- $table->drop();
-
- return static::execute($table);
- }
-
- /**
- * Execute the given schema operation against the database.
- *
- * @param Schema\Table $table
- * @return void
- */
- public static function execute($table)
- {
- // The implications method is responsible for finding any fluently
- // defined indexes on the schema table and adding the explicit
- // commands that are needed to tbe schema instance.
- static::implications($table);
-
- foreach ($table->commands as $command)
- {
- $connection = DB::connection($table->connection);
-
- $grammar = static::grammar($connection);
-
- // Each grammar has a function that corresponds to the command type and
- // is for building that command's SQL. This lets the SQL syntax builds
- // stay granular across various database systems.
- if (method_exists($grammar, $method = $command->type))
- {
- $statements = $grammar->$method($table, $command);
-
- // Once we have the statements, we will cast them to an array even
- // though not all of the commands return an array just in case it
- // needs multiple queries to complete.
- foreach ((array) $statements as $statement)
- {
- $connection->query($statement);
- }
- }
- }
- }
-
- /**
- * Add any implicit commands to the schema table operation.
- *
- * @param Schema\Table $table
- * @return void
- */
- protected static function implications($table)
- {
- // If the developer has specified columns for the table and the table is
- // not being created, we'll assume they simply want to add the columns
- // to the table and generate the add command.
- if (count($table->columns) > 0 and ! $table->creating())
- {
- $command = new Fluent(array('type' => 'add'));
-
- array_unshift($table->commands, $command);
- }
-
- // For some extra syntax sugar, we'll check for any implicit indexes
- // on the table since the developer may specify the index type on
- // the fluent column declaration for convenience.
- foreach ($table->columns as $column)
- {
- foreach (array('primary', 'unique', 'fulltext', 'index') as $key)
- {
- if (isset($column->$key))
- {
- if ($column->$key === true)
- {
- $table->$key($column->name);
- }
- else
- {
- $table->$key($column->name, $column->$key);
- }
- }
- }
- }
- }
-
- /**
- * Create the appropriate schema grammar for the driver.
- *
- * @param Connection $connection
- * @return Grammar
- */
- public static function grammar(Connection $connection)
- {
- $driver = $connection->driver();
-
- switch ($driver)
- {
- case 'mysql':
- return new Schema\Grammars\MySQL($connection);
-
- case 'pgsql':
- return new Schema\Grammars\Postgres($connection);
-
- case 'sqlsrv':
- return new Schema\Grammars\SQLServer($connection);
-
- case 'sqlite':
- return new Schema\Grammars\SQLite($connection);
- }
-
- throw new \Exception("Schema operations not supported for [$driver].");
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/schema/grammars/grammar.php b/laravel/database/schema/grammars/grammar.php
deleted file mode 100644
index 1d3390a1c6e..00000000000
--- a/laravel/database/schema/grammars/grammar.php
+++ /dev/null
@@ -1,99 +0,0 @@
-name;
-
- // We need to wrap both of the table names in quoted identifiers to protect
- // against any possible keyword collisions, both the table on which the
- // command is being executed and the referenced table are wrapped.
- $table = $this->wrap($table);
-
- $on = $this->wrap($command->on);
-
- // Next we need to columnize both the command table's columns as well as
- // the columns referenced by the foreign key. We'll cast the referenced
- // columns to an array since they aren't by the fluent command.
- $foreign = $this->columnize($command->columns);
-
- $referenced = $this->columnize((array) $command->references);
-
- $sql = "ALTER TABLE $table ADD CONSTRAINT $name ";
-
- $sql .= "FOREIGN KEY ($foreign) REFERENCES $on ($referenced)";
-
- // Finally we will check for any "on delete" or "on update" options for
- // the foreign key. These control the behavior of the constraint when
- // an update or delete statement is run against the record.
- if ( ! is_null($command->on_delete))
- {
- $sql .= " ON DELETE {$command->on_delete}";
- }
-
- if ( ! is_null($command->on_update))
- {
- $sql .= " ON UPDATE {$command->on_update}";
- }
-
- return $sql;
- }
-
- /**
- * Drop a constraint from the table.
- *
- * @param Table $table
- * @param Fluent $fluent
- * @return string
- */
- protected function drop_constraint(Table $table, Fluent $command)
- {
- return "ALTER TABLE ".$this->wrap($table)." DROP CONSTRAINT ".$command->name;
- }
-
- /**
- * Wrap a value in keyword identifiers.
- *
- * @param Table|string $value
- * @return string
- */
- public function wrap($value)
- {
- // This method is primarily for convenience so we can just pass a
- // column or table instance into the wrap method without sending
- // in the name each time we need to wrap one of these objects.
- if ($value instanceof Table)
- {
- return $this->wrap_table($value->name);
- }
- elseif ($value instanceof Fluent)
- {
- $value = $value->name;
- }
-
- return parent::wrap($value);
- }
-
- /**
- * Get the appropriate data type definition for the column.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type(Fluent $column)
- {
- return $this->{'type_'.$column->type}($column);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/schema/grammars/mysql.php b/laravel/database/schema/grammars/mysql.php
deleted file mode 100644
index c2ae7455e6d..00000000000
--- a/laravel/database/schema/grammars/mysql.php
+++ /dev/null
@@ -1,421 +0,0 @@
-columns($table));
-
- // First we will generate the base table creation statement. Other than auto
- // incrementing keys, no indexes will be created during the first creation
- // of the table as they're added in separate commands.
- $sql = 'CREATE TABLE '.$this->wrap($table).' ('.$columns.')';
-
- if ( ! is_null($table->engine))
- {
- $sql .= ' ENGINE = '.$table->engine;
- }
-
- return $sql;
- }
-
- /**
- * Geenrate the SQL statements for a table modification command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return array
- */
- public function add(Table $table, Fluent $command)
- {
- $columns = $this->columns($table);
-
- // Once we the array of column definitions, we need to add "add" to the
- // front of each definition, then we'll concatenate the definitions
- // using commas like normal and generate the SQL.
- $columns = implode(', ', array_map(function($column)
- {
- return 'ADD '.$column;
-
- }, $columns));
-
- return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
- }
-
- /**
- * Create the individual column definitions for the table.
- *
- * @param Table $table
- * @return array
- */
- protected function columns(Table $table)
- {
- $columns = array();
-
- foreach ($table->columns as $column)
- {
- // Each of the data type's have their own definition creation method,
- // which is responsible for creating the SQL for the type. This lets
- // us to keep the syntax easy and fluent, while translating the
- // types to the correct types.
- $sql = $this->wrap($column).' '.$this->type($column);
-
- $elements = array('unsigned', 'nullable', 'defaults', 'incrementer');
-
- foreach ($elements as $element)
- {
- $sql .= $this->$element($table, $column);
- }
-
- $columns[] = $sql;
- }
-
- return $columns;
- }
-
- /**
- * Get the SQL syntax for indicating if a column is unsigned.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function unsigned(Table $table, Fluent $column)
- {
- if ($column->type == 'integer' && $column->unsigned)
- {
- return ' UNSIGNED';
- }
- }
-
- /**
- * Get the SQL syntax for indicating if a column is nullable.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function nullable(Table $table, Fluent $column)
- {
- return ($column->nullable) ? ' NULL' : ' NOT NULL';
- }
-
- /**
- * Get the SQL syntax for specifying a default value on a column.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function defaults(Table $table, Fluent $column)
- {
- if ( ! is_null($column->default))
- {
- return " DEFAULT '".$column->default."'";
- }
- }
-
- /**
- * Get the SQL syntax for defining an auto-incrementing column.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function incrementer(Table $table, Fluent $column)
- {
- if ($column->type == 'integer' and $column->increment)
- {
- return ' AUTO_INCREMENT PRIMARY KEY';
- }
- }
-
- /**
- * Generate the SQL statement for creating a primary key.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function primary(Table $table, Fluent $command)
- {
- return $this->key($table, $command->name(null), 'PRIMARY KEY');
- }
-
- /**
- * Generate the SQL statement for creating a unique index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function unique(Table $table, Fluent $command)
- {
- return $this->key($table, $command, 'UNIQUE');
- }
-
- /**
- * Generate the SQL statement for creating a full-text index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function fulltext(Table $table, Fluent $command)
- {
- return $this->key($table, $command, 'FULLTEXT');
- }
-
- /**
- * Generate the SQL statement for creating a regular index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function index(Table $table, Fluent $command)
- {
- return $this->key($table, $command, 'INDEX');
- }
-
- /**
- * Generate the SQL statement for creating a new index.
- *
- * @param Table $table
- * @param Fluent $command
- * @param string $type
- * @return string
- */
- protected function key(Table $table, Fluent $command, $type)
- {
- $keys = $this->columnize($command->columns);
-
- $name = $command->name;
-
- return 'ALTER TABLE '.$this->wrap($table)." ADD {$type} {$name}({$keys})";
- }
-
- /**
- * Generate the SQL statement for a drop table command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop(Table $table, Fluent $command)
- {
- return 'DROP TABLE '.$this->wrap($table);
- }
-
- /**
- * Generate the SQL statement for a drop column command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_column(Table $table, Fluent $command)
- {
- $columns = array_map(array($this, 'wrap'), $command->columns);
-
- // Once we the array of column names, we need to add "drop" to the front
- // of each column, then we'll concatenate the columns using commas and
- // generate the alter statement SQL.
- $columns = implode(', ', array_map(function($column)
- {
- return 'DROP '.$column;
-
- }, $columns));
-
- return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
- }
-
- /**
- * Generate the SQL statement for a drop primary key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_primary(Table $table, Fluent $command)
- {
- return 'ALTER TABLE '.$this->wrap($table).' DROP PRIMARY KEY';
- }
-
- /**
- * Generate the SQL statement for a drop unqique key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_unique(Table $table, Fluent $command)
- {
- return $this->drop_key($table, $command);
- }
-
- /**
- * Generate the SQL statement for a drop full-text key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_fulltext(Table $table, Fluent $command)
- {
- return $this->drop_key($table, $command);
- }
-
- /**
- * Generate the SQL statement for a drop unqique key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_index(Table $table, Fluent $command)
- {
- return $this->drop_key($table, $command);
- }
-
- /**
- * Generate the SQL statement for a drop key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- protected function drop_key(Table $table, Fluent $command)
- {
- return 'ALTER TABLE '.$this->wrap($table)." DROP INDEX {$command->name}";
- }
-
- /**
- * Drop a foreign key constraint from the table.
- *
- * @param Table $table
- * @param Fluent $fluent
- * @return string
- */
- public function drop_foreign(Table $table, Fluent $command)
- {
- return "ALTER TABLE ".$this->wrap($table)." DROP FOREIGN KEY ".$command->name;
- }
-
- /**
- * Generate the data-type definition for a string.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_string(Fluent $column)
- {
- return 'VARCHAR('.$column->length.')';
- }
-
- /**
- * Generate the data-type definition for an integer.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_integer(Fluent $column)
- {
- return 'INT';
- }
-
- /**
- * Generate the data-type definition for an integer.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_float(Fluent $column)
- {
- return 'FLOAT';
- }
-
- /**
- * Generate the data-type definintion for a decimal.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_decimal(Fluent $column)
- {
- return "DECIMAL({$column->precision}, {$column->scale})";
- }
-
- /**
- * Generate the data-type definition for a boolean.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_boolean(Fluent $column)
- {
- return 'TINYINT';
- }
-
- /**
- * Generate the data-type definition for a date.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_date(Fluent $column)
- {
- return 'DATETIME';
- }
-
- /**
- * Generate the data-type definition for a timestamp.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_timestamp(Fluent $column)
- {
- return 'TIMESTAMP';
- }
-
- /**
- * Generate the data-type definition for a text column.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_text(Fluent $column)
- {
- return 'TEXT';
- }
-
- /**
- * Generate the data-type definition for a blob.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_blob(Fluent $column)
- {
- return 'BLOB';
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/schema/grammars/postgres.php b/laravel/database/schema/grammars/postgres.php
deleted file mode 100644
index 760af1a8a3f..00000000000
--- a/laravel/database/schema/grammars/postgres.php
+++ /dev/null
@@ -1,407 +0,0 @@
-columns($table));
-
- // First we will generate the base table creation statement. Other than auto
- // incrementing keys, no indexes will be created during the first creation
- // of the table as they're added in separate commands.
- $sql = 'CREATE TABLE '.$this->wrap($table).' ('.$columns.')';
-
- return $sql;
- }
-
- /**
- * Geenrate the SQL statements for a table modification command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return array
- */
- public function add(Table $table, Fluent $command)
- {
- $columns = $this->columns($table);
-
- // Once we the array of column definitions, we need to add "add" to the
- // front of each definition, then we'll concatenate the definitions
- // using commas like normal and generate the SQL.
- $columns = implode(', ', array_map(function($column)
- {
- return 'ADD COLUMN '.$column;
-
- }, $columns));
-
- return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
- }
-
- /**
- * Create the individual column definitions for the table.
- *
- * @param Table $table
- * @return array
- */
- protected function columns(Table $table)
- {
- $columns = array();
-
- foreach ($table->columns as $column)
- {
- // Each of the data type's have their own definition creation method,
- // which is responsible for creating the SQL for the type. This lets
- // us to keep the syntax easy and fluent, while translating the
- // types to the types used by the database.
- $sql = $this->wrap($column).' '.$this->type($column);
-
- $elements = array('incrementer', 'nullable', 'defaults');
-
- foreach ($elements as $element)
- {
- $sql .= $this->$element($table, $column);
- }
-
- $columns[] = $sql;
- }
-
- return $columns;
- }
-
- /**
- * Get the SQL syntax for indicating if a column is nullable.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function nullable(Table $table, Fluent $column)
- {
- return ($column->nullable) ? ' NULL' : ' NOT NULL';
- }
-
- /**
- * Get the SQL syntax for specifying a default value on a column.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function defaults(Table $table, Fluent $column)
- {
- if ( ! is_null($column->default))
- {
- return " DEFAULT '".$column->default."'";
- }
- }
-
- /**
- * Get the SQL syntax for defining an auto-incrementing column.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function incrementer(Table $table, Fluent $column)
- {
- // We don't actually need to specify an "auto_increment" keyword since we
- // handle the auto-increment definition in the type definition for
- // integers by changing the type to "serial".
- if ($column->type == 'integer' and $column->increment)
- {
- return ' PRIMARY KEY';
- }
- }
-
- /**
- * Generate the SQL statement for creating a primary key.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function primary(Table $table, Fluent $command)
- {
- $columns = $this->columnize($command->columns);
-
- return 'ALTER TABLE '.$this->wrap($table)." ADD PRIMARY KEY ({$columns})";
- }
-
- /**
- * Generate the SQL statement for creating a unique index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function unique(Table $table, Fluent $command)
- {
- $table = $this->wrap($table);
-
- $columns = $this->columnize($command->columns);
-
- return "ALTER TABLE $table ADD CONSTRAINT ".$command->name." UNIQUE ($columns)";
- }
-
- /**
- * Generate the SQL statement for creating a full-text index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function fulltext(Table $table, Fluent $command)
- {
- $name = $command->name;
-
- $columns = $this->columnize($command->columns);
-
- return "CREATE INDEX {$name} ON ".$this->wrap($table)." USING gin({$columns})";
- }
-
- /**
- * Generate the SQL statement for creating a regular index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function index(Table $table, Fluent $command)
- {
- return $this->key($table, $command);
- }
-
- /**
- * Generate the SQL statement for creating a new index.
- *
- * @param Table $table
- * @param Fluent $command
- * @param bool $unique
- * @return string
- */
- protected function key(Table $table, Fluent $command, $unique = false)
- {
- $columns = $this->columnize($command->columns);
-
- $create = ($unique) ? 'CREATE UNIQUE' : 'CREATE';
-
- return $create." INDEX {$command->name} ON ".$this->wrap($table)." ({$columns})";
- }
-
- /**
- * Generate the SQL statement for a drop table command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop(Table $table, Fluent $command)
- {
- return 'DROP TABLE '.$this->wrap($table);
- }
-
- /**
- * Generate the SQL statement for a drop column command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_column(Table $table, Fluent $command)
- {
- $columns = array_map(array($this, 'wrap'), $command->columns);
-
- // Once we the array of column names, we need to add "drop" to the front
- // of each column, then we'll concatenate the columns using commas and
- // generate the alter statement SQL.
- $columns = implode(', ', array_map(function($column)
- {
- return 'DROP COLUMN '.$column;
-
- }, $columns));
-
- return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
- }
-
- /**
- * Generate the SQL statement for a drop primary key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_primary(Table $table, Fluent $command)
- {
- return 'ALTER TABLE '.$this->wrap($table).' DROP CONSTRAINT '.$table->name.'_pkey';
- }
-
- /**
- * Generate the SQL statement for a drop unqique key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_unique(Table $table, Fluent $command)
- {
- return $this->drop_constraint($table, $command);
- }
-
- /**
- * Generate the SQL statement for a drop full-text key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_fulltext(Table $table, Fluent $command)
- {
- return $this->drop_key($table, $command);
- }
-
- /**
- * Generate the SQL statement for a drop index command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_index(Table $table, Fluent $command)
- {
- return $this->drop_key($table, $command);
- }
-
- /**
- * Generate the SQL statement for a drop key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- protected function drop_key(Table $table, Fluent $command)
- {
- return 'DROP INDEX '.$command->name;
- }
-
- /**
- * Drop a foreign key constraint from the table.
- *
- * @param Table $table
- * @param Fluent $fluent
- * @return string
- */
- public function drop_foreign(Table $table, Fluent $command)
- {
- return $this->drop_constraint($table, $command);
- }
-
- /**
- * Generate the data-type definition for a string.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_string(Fluent $column)
- {
- return 'VARCHAR('.$column->length.')';
- }
-
- /**
- * Generate the data-type definition for an integer.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_integer(Fluent $column)
- {
- return ($column->increment) ? 'SERIAL' : 'INTEGER';
- }
-
- /**
- * Generate the data-type definition for an integer.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_float(Fluent $column)
- {
- return 'REAL';
- }
-
- /**
- * Generate the data-type definintion for a decimal.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_decimal(Fluent $column)
- {
- return "DECIMAL({$column->precision}, {$column->scale})";
- }
-
- /**
- * Generate the data-type definition for a boolean.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_boolean(Fluent $column)
- {
- return 'SMALLINT';
- }
-
- /**
- * Generate the data-type definition for a date.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_date(Fluent $column)
- {
- return 'TIMESTAMP';
- }
-
- /**
- * Generate the data-type definition for a timestamp.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_timestamp(Fluent $column)
- {
- return 'TIMESTAMP';
- }
-
- /**
- * Generate the data-type definition for a text column.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_text(Fluent $column)
- {
- return 'TEXT';
- }
-
- /**
- * Generate the data-type definition for a blob.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_blob(Fluent $column)
- {
- return 'BYTEA';
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/schema/grammars/sqlite.php b/laravel/database/schema/grammars/sqlite.php
deleted file mode 100644
index 09102f52ca2..00000000000
--- a/laravel/database/schema/grammars/sqlite.php
+++ /dev/null
@@ -1,351 +0,0 @@
-columns($table));
-
- // First we will generate the base table creation statement. Other than incrementing
- // keys, no indexes will be created during the first creation of the table since
- // they will be added in separate commands.
- $sql = 'CREATE TABLE '.$this->wrap($table).' ('.$columns;
-
- // SQLite does not allow adding a primary key as a command apart from the creation
- // of the table, so we'll need to sniff out any primary keys here and add them to
- // the table now during this command.
- $primary = array_first($table->commands, function($key, $value)
- {
- return $value->type == 'primary';
- });
-
- // If we found primary key in the array of commands, we'll create the SQL for
- // the key addition and append it to the SQL table creation statement for
- // the schema table so the index is properly generated.
- if ( ! is_null($primary))
- {
- $columns = $this->columnize($primary->columns);
-
- $sql .= ", PRIMARY KEY ({$columns})";
- }
-
- return $sql .= ')';
- }
-
- /**
- * Geenrate the SQL statements for a table modification command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return array
- */
- public function add(Table $table, Fluent $command)
- {
- $columns = $this->columns($table);
-
- // Once we the array of column definitions, we need to add "add" to the
- // front of each definition, then we'll concatenate the definitions
- // using commas like normal and generate the SQL.
- $columns = array_map(function($column)
- {
- return 'ADD COLUMN '.$column;
-
- }, $columns);
-
- // SQLite only allows one column to be added in an ALTER statement,
- // so we will create an array of statements and return them all to
- // the schema manager for separate execution.
- foreach ($columns as $column)
- {
- $sql[] = 'ALTER TABLE '.$this->wrap($table).' '.$column;
- }
-
- return (array) $sql;
- }
-
- /**
- * Create the individual column definitions for the table.
- *
- * @param Table $table
- * @return array
- */
- protected function columns(Table $table)
- {
- $columns = array();
-
- foreach ($table->columns as $column)
- {
- // Each of the data type's have their own definition creation method
- // which is responsible for creating the SQL for the type. This lets
- // us to keep the syntax easy and fluent, while translating the
- // types to the types used by the database.
- $sql = $this->wrap($column).' '.$this->type($column);
-
- $elements = array('nullable', 'defaults', 'incrementer');
-
- foreach ($elements as $element)
- {
- $sql .= $this->$element($table, $column);
- }
-
- $columns[] = $sql;
- }
-
- return $columns;
- }
-
- /**
- * Get the SQL syntax for indicating if a column is nullable.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function nullable(Table $table, Fluent $column)
- {
- return ' NULL';
- }
-
- /**
- * Get the SQL syntax for specifying a default value on a column.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function defaults(Table $table, Fluent $column)
- {
- if ( ! is_null($column->default))
- {
- return ' DEFAULT '.$this->wrap($column->default);
- }
- }
-
- /**
- * Get the SQL syntax for defining an auto-incrementing column.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function incrementer(Table $table, Fluent $column)
- {
- if ($column->type == 'integer' and $column->increment)
- {
- return ' PRIMARY KEY AUTOINCREMENT';
- }
- }
-
- /**
- * Generate the SQL statement for creating a unique index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function unique(Table $table, Fluent $command)
- {
- return $this->key($table, $command, true);
- }
-
- /**
- * Generate the SQL statement for creating a full-text index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function fulltext(Table $table, Fluent $command)
- {
- $columns = $this->columnize($command->columns);
-
- return 'CREATE VIRTUAL TABLE '.$this->wrap($table)." USING fts4({$columns})";
- }
-
- /**
- * Generate the SQL statement for creating a regular index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function index(Table $table, Fluent $command)
- {
- return $this->key($table, $command);
- }
-
- /**
- * Generate the SQL statement for creating a new index.
- *
- * @param Table $table
- * @param Fluent $command
- * @param bool $unique
- * @return string
- */
- protected function key(Table $table, Fluent $command, $unique = false)
- {
- $columns = $this->columnize($command->columns);
-
- $create = ($unique) ? 'CREATE UNIQUE' : 'CREATE';
-
- return $create." INDEX {$command->name} ON ".$this->wrap($table)." ({$columns})";
- }
-
- /**
- * Generate the SQL statement for a drop table command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop(Table $table, Fluent $command)
- {
- return 'DROP TABLE '.$this->wrap($table);
- }
-
- /**
- * Generate the SQL statement for a drop unqique key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_unique(Table $table, Fluent $command)
- {
- return $this->drop_key($table, $command);
- }
-
- /**
- * Generate the SQL statement for a drop unqique key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_index(Table $table, Fluent $command)
- {
- return $this->drop_key($table, $command);
- }
-
- /**
- * Generate the SQL statement for a drop key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- protected function drop_key(Table $table, Fluent $command)
- {
- return 'DROP INDEX '.$this->wrap($command->name);
- }
-
- /**
- * Generate the data-type definition for a string.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_string(Fluent $column)
- {
- return 'VARCHAR';
- }
-
- /**
- * Generate the data-type definition for an integer.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_integer(Fluent $column)
- {
- return 'INTEGER';
- }
-
- /**
- * Generate the data-type definition for an integer.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_float(Fluent $column)
- {
- return 'FLOAT';
- }
-
- /**
- * Generate the data-type definintion for a decimal.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_decimal(Fluent $column)
- {
- return 'FLOAT';
- }
-
- /**
- * Generate the data-type definition for a boolean.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_boolean(Fluent $column)
- {
- return 'INTEGER';
- }
-
- /**
- * Generate the data-type definition for a date.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_date(Fluent $column)
- {
- return 'DATETIME';
- }
-
- /**
- * Generate the data-type definition for a timestamp.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_timestamp(Fluent $column)
- {
- return 'DATETIME';
- }
-
- /**
- * Generate the data-type definition for a text column.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_text(Fluent $column)
- {
- return 'TEXT';
- }
-
- /**
- * Generate the data-type definition for a blob.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_blob(Fluent $column)
- {
- return 'BLOB';
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/schema/grammars/sqlserver.php b/laravel/database/schema/grammars/sqlserver.php
deleted file mode 100644
index 0fb80f6a471..00000000000
--- a/laravel/database/schema/grammars/sqlserver.php
+++ /dev/null
@@ -1,425 +0,0 @@
-columns($table));
-
- // First we will generate the base table creation statement. Other than auto
- // incrementing keys, no indexes will be created during the first creation
- // of the table as they're added in separate commands.
- $sql = 'CREATE TABLE '.$this->wrap($table).' ('.$columns.')';
-
- return $sql;
- }
-
- /**
- * Geenrate the SQL statements for a table modification command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return array
- */
- public function add(Table $table, Fluent $command)
- {
- $columns = $this->columns($table);
-
- // Once we the array of column definitions, we need to add "add" to the
- // front of each definition, then we'll concatenate the definitions
- // using commas like normal and generate the SQL.
- $columns = implode(', ', array_map(function($column)
- {
- return 'ADD '.$column;
-
- }, $columns));
-
- return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
- }
-
- /**
- * Create the individual column definitions for the table.
- *
- * @param Table $table
- * @return array
- */
- protected function columns(Table $table)
- {
- $columns = array();
-
- foreach ($table->columns as $column)
- {
- // Each of the data type's have their own definition creation method,
- // which is responsible for creating the SQL for the type. This lets
- // us to keep the syntax easy and fluent, while translating the
- // types to the types used by the database.
- $sql = $this->wrap($column).' '.$this->type($column);
-
- $elements = array('incrementer', 'nullable', 'defaults');
-
- foreach ($elements as $element)
- {
- $sql .= $this->$element($table, $column);
- }
-
- $columns[] = $sql;
- }
-
- return $columns;
- }
-
- /**
- * Get the SQL syntax for indicating if a column is nullable.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function nullable(Table $table, Fluent $column)
- {
- return ($column->nullable) ? ' NULL' : ' NOT NULL';
- }
-
- /**
- * Get the SQL syntax for specifying a default value on a column.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function defaults(Table $table, Fluent $column)
- {
- if ( ! is_null($column->default))
- {
- return " DEFAULT '".$column->default."'";
- }
- }
-
- /**
- * Get the SQL syntax for defining an auto-incrementing column.
- *
- * @param Table $table
- * @param Fluent $column
- * @return string
- */
- protected function incrementer(Table $table, Fluent $column)
- {
- if ($column->type == 'integer' and $column->increment)
- {
- return ' IDENTITY PRIMARY KEY';
- }
- }
-
- /**
- * Generate the SQL statement for creating a primary key.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function primary(Table $table, Fluent $command)
- {
- $name = $command->name;
-
- $columns = $this->columnize($columns);
-
- return 'ALTER TABLE '.$this->wrap($table)." ADD CONSTRAINT {$name} PRIMARY KEY ({$columns})";
- }
-
- /**
- * Generate the SQL statement for creating a unique index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function unique(Table $table, Fluent $command)
- {
- return $this->key($table, $command, true);
- }
-
- /**
- * Generate the SQL statement for creating a full-text index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function fulltext(Table $table, Fluent $command)
- {
- $columns = $this->columnize($command->columns);
-
- $table = $this->wrap($table);
-
- // SQL Server requires the creation of a full-text "catalog" before creating
- // a full-text index, so we'll first create the catalog then add another
- // separate statement for the index.
- $sql[] = "CREATE FULLTEXT CATALOG {$command->catalog}";
-
- $create = "CREATE FULLTEXT INDEX ON ".$table." ({$columns}) ";
-
- // Full-text indexes must specify a unique, non-null column as the index
- // "key" and this should have been created manually by the developer in
- // a separate column addition command.
- $sql[] = $create .= "KEY INDEX {$command->key} ON {$command->catalog}";
-
- return $sql;
- }
-
- /**
- * Generate the SQL statement for creating a regular index.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function index(Table $table, Fluent $command)
- {
- return $this->key($table, $command);
- }
-
- /**
- * Generate the SQL statement for creating a new index.
- *
- * @param Table $table
- * @param Fluent $command
- * @param bool $unique
- * @return string
- */
- protected function key(Table $table, Fluent $command, $unique = false)
- {
- $columns = $this->columnize($command->columns);
-
- $create = ($unique) ? 'CREATE UNIQUE' : 'CREATE';
-
- return $create." INDEX {$command->name} ON ".$this->wrap($table)." ({$columns})";
- }
-
- /**
- * Generate the SQL statement for a drop table command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop(Table $table, Fluent $command)
- {
- return 'DROP TABLE '.$this->wrap($table);
- }
-
- /**
- * Generate the SQL statement for a drop column command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_column(Table $table, Fluent $command)
- {
- $columns = array_map(array($this, 'wrap'), $command->columns);
-
- // Once we the array of column names, we need to add "drop" to the front
- // of each column, then we'll concatenate the columns using commas and
- // generate the alter statement SQL.
- $columns = implode(', ', array_map(function($column)
- {
- return 'DROP '.$column;
-
- }, $columns));
-
- return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
- }
-
- /**
- * Generate the SQL statement for a drop primary key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_primary(Table $table, Fluent $command)
- {
- return 'ALTER TABLE '.$this->wrap($table).' DROP CONSTRAINT '.$command->name;
- }
-
- /**
- * Generate the SQL statement for a drop unqiue key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_unique(Table $table, Fluent $command)
- {
- return $this->drop_key($table, $command);
- }
-
- /**
- * Generate the SQL statement for a drop full-text key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_fulltext(Table $table, Fluent $command)
- {
- $sql[] = "DROP FULLTEXT INDEX ".$command->name;
-
- $sql[] = "DROP FULLTEXT CATALOG ".$command->catalog;
-
- return $sql;
- }
-
- /**
- * Generate the SQL statement for a drop index command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- public function drop_index(Table $table, Fluent $command)
- {
- return $this->drop_key($table, $command);
- }
-
- /**
- * Generate the SQL statement for a drop key command.
- *
- * @param Table $table
- * @param Fluent $command
- * @return string
- */
- protected function drop_key(Table $table, Fluent $command)
- {
- return "DROP INDEX {$command->name} ON ".$this->wrap($table);
- }
-
- /**
- * Drop a foreign key constraint from the table.
- *
- * @param Table $table
- * @param Fluent $fluent
- * @return string
- */
- public function drop_foreign(Table $table, Fluent $command)
- {
- return $this->drop_constraint($table, $command);
- }
-
- /**
- * Generate the data-type definition for a string.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_string(Fluent $column)
- {
- return 'NVARCHAR('.$column->length.')';
- }
-
- /**
- * Generate the data-type definition for an integer.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_integer(Fluent $column)
- {
- return 'INT';
- }
-
- /**
- * Generate the data-type definition for an integer.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_float(Fluent $column)
- {
- return 'FLOAT';
- }
-
- /**
- * Generate the data-type definintion for a decimal.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_decimal(Fluent $column)
- {
- return "DECIMAL({$column->precision}, {$column->scale})";
- }
-
- /**
- * Generate the data-type definition for a boolean.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_boolean(Fluent $column)
- {
- return 'TINYINT';
- }
-
- /**
- * Generate the data-type definition for a date.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_date(Fluent $column)
- {
- return 'DATETIME';
- }
-
- /**
- * Generate the data-type definition for a timestamp.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_timestamp(Fluent $column)
- {
- return 'TIMESTAMP';
- }
-
- /**
- * Generate the data-type definition for a text column.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_text(Fluent $column)
- {
- return 'NVARCHAR(MAX)';
- }
-
- /**
- * Generate the data-type definition for a blob.
- *
- * @param Fluent $column
- * @return string
- */
- protected function type_blob(Fluent $column)
- {
- return 'VARBINARY(MAX)';
- }
-
-}
\ No newline at end of file
diff --git a/laravel/database/schema/table.php b/laravel/database/schema/table.php
deleted file mode 100644
index 9518d6e7790..00000000000
--- a/laravel/database/schema/table.php
+++ /dev/null
@@ -1,415 +0,0 @@
-name = $name;
- }
-
- /**
- * Indicate that the table should be created.
- *
- * @return Fluent
- */
- public function create()
- {
- return $this->command(__FUNCTION__);
- }
-
- /**
- * Create a new primary key on the table.
- *
- * @param string|array $columns
- * @param string $name
- * @return Fluent
- */
- public function primary($columns, $name = null)
- {
- return $this->key(__FUNCTION__, $columns, $name);
- }
-
- /**
- * Create a new unique index on the table.
- *
- * @param string|array $columns
- * @param string $name
- * @return Fluent
- */
- public function unique($columns, $name = null)
- {
- return $this->key(__FUNCTION__, $columns, $name);
- }
-
- /**
- * Create a new full-text index on the table.
- *
- * @param string|array $columns
- * @param string $name
- * @return Fluent
- */
- public function fulltext($columns, $name = null)
- {
- return $this->key(__FUNCTION__, $columns, $name);
- }
-
- /**
- * Create a new index on the table.
- *
- * @param string|array $columns
- * @param string $name
- * @return Fluent
- */
- public function index($columns, $name = null)
- {
- return $this->key(__FUNCTION__, $columns, $name);
- }
-
- /**
- * Add a foreign key constraint to the table.
- *
- * @param string|array $columns
- * @param string $name
- */
- public function foreign($columns, $name = null)
- {
- return $this->key(__FUNCTION__, $columns, $name);
- }
-
- /**
- * Create a command for creating any index.
- *
- * @param string $type
- * @param string|array $columns
- * @param string $name
- * @return Fluent
- */
- public function key($type, $columns, $name)
- {
- $columns = (array) $columns;
-
- // If no index name was specified, we will concatenate the columns and
- // append the index type to the name to generate a unique name for
- // the index that can be used when dropping indexes.
- if (is_null($name))
- {
- $name = $this->name.'_'.implode('_', $columns).'_'.$type;
- }
-
- return $this->command($type, compact('name', 'columns'));
- }
-
- /**
- * Drop the database table.
- *
- * @return Fluent
- */
- public function drop()
- {
- return $this->command(__FUNCTION__);
- }
-
- /**
- * Drop a column from the table.
- *
- * @param string|array $columns
- * @return void
- */
- public function drop_column($columns)
- {
- return $this->command(__FUNCTION__, array('columns' => (array) $columns));
- }
-
- /**
- * Drop a primary key from the table.
- *
- * @param string $name
- * @return void
- */
- public function drop_primary($name = null)
- {
- return $this->drop_key(__FUNCTION__, $name);
- }
-
- /**
- * Drop a unique index from the table.
- *
- * @param string $name
- * @return void
- */
- public function drop_unique($name)
- {
- return $this->drop_key(__FUNCTION__, $name);
- }
-
- /**
- * Drop a full-text index from the table.
- *
- * @param string $name
- * @return void
- */
- public function drop_fulltext($name)
- {
- return $this->drop_key(__FUNCTION__, $name);
- }
-
- /**
- * Drop an index from the table.
- *
- * @param string $name
- * @return void
- */
- public function drop_index($name)
- {
- return $this->drop_key(__FUNCTION__, $name);
- }
-
- /**
- * Drop a foreign key constraint from the table.
- *
- * @param string $name
- * @return void
- */
- public function drop_foreign($name)
- {
- return $this->drop_key(__FUNCTION__, $name);
- }
-
- /**
- * Create a command to drop any type of index.
- *
- * @param string $type
- * @param string $name
- * @return Fluent
- */
- protected function drop_key($type, $name)
- {
- return $this->command($type, compact('name'));
- }
-
- /**
- * Add an auto-incrementing integer to the table.
- *
- * @param string $name
- * @return Fluent
- */
- public function increments($name)
- {
- return $this->integer($name, true);
- }
-
- /**
- * Add a string column to the table.
- *
- * @param string $name
- * @param int $length
- * @return Fluent
- */
- public function string($name, $length = 200)
- {
- return $this->column(__FUNCTION__, compact('name', 'length'));
- }
-
- /**
- * Add an integer column to the table.
- *
- * @param string $name
- * @param bool $increment
- * @return Fluent
- */
- public function integer($name, $increment = false)
- {
- return $this->column(__FUNCTION__, compact('name', 'increment'));
- }
-
- /**
- * Add a float column to the table.
- *
- * @param string $name
- * @return Fluent
- */
- public function float($name)
- {
- return $this->column(__FUNCTION__, compact('name'));
- }
-
- /**
- * Add a decimal column to the table.
- *
- * @param string $name
- * @param int $precision
- * @param int $scale
- * @return Fluent
- */
- public function decimal($name, $precision, $scale)
- {
- return $this->column(__FUNCTION__, compact('name', 'precision', 'scale'));
- }
-
- /**
- * Add a boolean column to the table.
- *
- * @param string $name
- * @return Fluent
- */
- public function boolean($name)
- {
- return $this->column(__FUNCTION__, compact('name'));
- }
-
- /**
- * Create date-time columns for creation and update timestamps.
- *
- * @return void
- */
- public function timestamps()
- {
- $this->date('created_at');
-
- $this->date('updated_at');
- }
-
- /**
- * Add a date-time column to the table.
- *
- * @param string $name
- * @return Fluent
- */
- public function date($name)
- {
- return $this->column(__FUNCTION__, compact('name'));
- }
-
- /**
- * Add a timestamp column to the table.
- *
- * @param string $name
- * @return Fluent
- */
- public function timestamp($name)
- {
- return $this->column(__FUNCTION__, compact('name'));
- }
-
- /**
- * Add a text column to the table.
- *
- * @param string $name
- * @return Fluent
- */
- public function text($name)
- {
- return $this->column(__FUNCTION__, compact('name'));
- }
-
- /**
- * Add a blob column to the table.
- *
- * @param string $name
- * @return Fluent
- */
- public function blob($name)
- {
- return $this->column(__FUNCTION__, compact('name'));
- }
-
- /**
- * Set the database connection for the table operation.
- *
- * @param string $connection
- * @return void
- */
- public function on($connection)
- {
- $this->connection = $connection;
- }
-
- /**
- * Determine if the schema table has a creation command.
- *
- * @return bool
- */
- public function creating()
- {
- return ! is_null(array_first($this->commands, function($key, $value)
- {
- return $value->type == 'create';
- }));
- }
-
- /**
- * Create a new fluent command instance.
- *
- * @param string $type
- * @param array $parameters
- * @return Fluent
- */
- protected function command($type, $parameters = array())
- {
- $parameters = array_merge(compact('type'), $parameters);
-
- $this->commands[] = new Fluent($parameters);
-
- return end($this->commands);
- }
-
- /**
- * Create a new fluent column instance.
- *
- * @param string $type
- * @param array $parameters
- * @return Fluent
- */
- protected function column($type, $parameters = array())
- {
- $parameters = array_merge(compact('type'), $parameters);
-
- $this->columns[] = new Fluent($parameters);
-
- return end($this->columns);
- }
-
-}
\ No newline at end of file
diff --git a/laravel/error.php b/laravel/error.php
deleted file mode 100644
index bf668d8a414..00000000000
--- a/laravel/error.php
+++ /dev/null
@@ -1,106 +0,0 @@
-".$exception->getMessage()."-
".$exception->getFile()." on line ".$exception->getLine()."-
".$exception->getTraceAsString()."