malhuda/laravel
1
0
Fork 0
mirror of https://github.com/laravel/laravel.git synced 2025-02-20 11:53:14 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

removing tests and vendor.

Browse Source
This commit is contained in:
Taylor Otwell 2012-03-27 15:50:33 -05:00
parent 9eabd73b64
commit 70f586281f
122 changed files with 0 additions and 13182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
phpunit.php
View File

@ -1,32 +0,0 @@
<?php
// --------------------------------------------------------------
// 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.
// --------------------------------------------------------------
$path = path('base').'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);

9
phpunit.xml
View File

@ -1,9 +0,0 @@
<phpunit colors="true"
bootstrap="phpunit.php"
backupGlobals="false">
<testsuites>
<testsuite name="Test Suite">
<directory suffix=".test.php">tests/cases</directory>
</testsuite>
</testsuites>
</phpunit>

97
release
View File

@ -1,97 +0,0 @@
<?php
require 'paths.php';
require 'laravel/core.php';
require 'vendor/Symfony/Component/ClassLoader/UniversalClassLoader.php';
use Symfony\Component\ClassLoader\UniversalClassLoader;
$loader = new UniversalClassLoader;
$loader->register();
$loader->registerNamespace('Symfony', __DIR__.'/vendor');
use Laravel\File;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
$console = new Application;
class TestingReleaser extends Command {
/**
* Configure the console command.
*
* @return void
*/
protected function configure()
{
$this->setName('testing:release')->setDescription('Release to testing');
}
/**
* Merge the develop branch into testing.
*
* return void
*/
public function execute(InputInterface $input, OutputInterface $output)
{
passthru('git checkout testing');
passthru('git merge develop');
File::rmdir(__DIR__.'/tests');
@unlink(__DIR__.'/phpunit.php');
@unlink(__DIR__.'/phpunit.xml');
passthru('git commit -am "<auto> removed unit tests from repository."');
}
}
class DevelopHotfixer extends Command {
/**
* Configure the console command.
*
* @return void
*/
public function configure()
{
$this->setName('develop:hotfix')->setDescription('Bring hotfixes into develop');
}
/**
* Merge the testing and master branch hotfixes into the develop branch.
*
* @return void
*/
public function execute(InputInterface $input, OutputInterface $output)
{
passthru('git checkout develop');
File::cpdir(__DIR__.'/tests', __DIR__.'/tests_bkp');
File::copy(__DIR__.'/phpunit.php', __DIR__.'/phpunit_bkp.php');
File::copy(__DIR__.'/phpunit.xml', __DIR__.'/phpunit_bkp.xml');
passthru('git merge testing');
File::rmdir(__DIR__.'/tests');
@unlink(__DIR__.'/phpunit.php');
@unlink(__DIR__.'/phpunit.xml');
File::cpdir(__DIR__.'/tests_bkp', __DIR__.'/tests');
File::copy(__DIR__.'/phpunit_bkp.php', __DIR__.'/phpunit.php');
File::copy(__DIR__.'/phpunit_bkp.xml', __DIR__.'/phpunit.xml');
File::rmdir(__DIR__.'/tests_bkp');
@unlink(__DIR__.'/phpunit_bkp.php');
@unlink(__DIR__.'/phpunit_bkp.xml');
passthru('git add .');
passthru('git commit -am "<auto> merging hotfixes. re-added tests into repository."');
}
}
$console->add(new TestingReleaser);
$console->add(new DevelopHotfixer);
$console->run();

36
tests/application/bundles.php
View File

@ -1,36 +0,0 @@
<?php
/*
|--------------------------------------------------------------------------
| Bundle Configuration
|--------------------------------------------------------------------------
|
| Bundles allow you to conveniently extend and organize your application.
| Think of bundles as self-contained applications. They can have routes,
| controllers, models, views, configuration, etc. You can even create
| your own bundles to share with the Laravel community.
|
| This is a list of the bundles installed for your application and tells
| Laravel the location of the bundle's root directory, as well as the
| root URI the bundle responds to.
|
| For example, if you have an "admin" bundle located in "bundles/admin"
| that you want to handle requests with URIs that begin with "admin",
| simply add it to the array like this:
|
| 'admin' => array(
| 'location' => 'admin',
| 'handles' => 'admin',
| ),
|
| Note that the "location" is relative to the "bundles" directory.
| Now the bundle will be recognized by Laravel and will be able
| to respond to requests beginning with "admin"!
|
| Have a bundle that lives in the root of the bundle directory
| and doesn't respond to any requests? Just add the bundle
| name to the array and we'll take care of the rest.
|
*/
return array('dashboard' => array('handles' => 'dashboard'), 'dummy');

158
tests/application/config/application.php
View File

@ -1,158 +0,0 @@
<?php
return array(
/*
|--------------------------------------------------------------------------
| Application URL
|--------------------------------------------------------------------------
|
| The URL used to access your application without a trailing slash. The URL
| does nto have to be set. If it isn't we'll try our best to guess the URL
| of your application.
|
*/
'url' => '',
/*
|--------------------------------------------------------------------------
| Application Index
|--------------------------------------------------------------------------
|
| If you are including the "index.php" in your URLs, you can ignore this.
|
| However, if you are using mod_rewrite to get cleaner URLs, just set
| this option to an empty string and we'll take care of the rest.
|
*/
'index' => 'index.php',
/*
|--------------------------------------------------------------------------
| Application Key
|--------------------------------------------------------------------------
|
| This key is used by the encryption and cookie classes to generate secure
| encrypted strings and hashes. It is extremely important that this key
| remain secret and should not be shared with anyone. Make it about 32
| characters of random gibberish.
|
*/
'key' => '',
/*
|--------------------------------------------------------------------------
| Application Character Encoding
|--------------------------------------------------------------------------
|
| The default character encoding used by your application. This encoding
| will be used by the Str, Text, Form, and any other classes that need
| to know what type of encoding to use for your awesome application.
|
*/
'encoding' => 'UTF-8',
/*
|--------------------------------------------------------------------------
| Application Language
|--------------------------------------------------------------------------
|
| The default language of your application. This language will be used by
| Lang library as the default language when doing string localization.
|
*/
'language' => 'en',
/*
|--------------------------------------------------------------------------
| SSL Link Generation
|--------------------------------------------------------------------------
|
| Many sites use SSL to protect their users data. However, you may not
| always be able to use SSL on your development machine, meaning all HTTPS
| will be broken during development.
|
| For this reason, you may wish to disable the generation of HTTPS links
| throughout your application. This option does just that. All attempts to
| generate HTTPS links will generate regular HTTP links instead.
|
*/
'ssl' => true,
/*
|--------------------------------------------------------------------------
| Application Timezone
|--------------------------------------------------------------------------
|
| The default timezone of your application. This timezone will be used when
| Laravel needs a date, such as when writing to a log file or travelling
| to a distant star at warp speed.
|
*/
'timezone' => 'UTC',
/*
|--------------------------------------------------------------------------
| Class Aliases
|--------------------------------------------------------------------------
|
| Here, you can specify any class aliases that you would like registered
| when Laravel loads. Aliases are lazy-loaded, so add as many as you want.
|
| Aliases make it more convenient to use namespaced classes. Instead of
| referring to the class using its full namespace, you may simply use
| the alias defined here.
|
| We have already aliased common Laravel classes to make your life easier.
|
*/
'aliases' => array(
'Auth' => 'Laravel\\Auth',
'Asset' => 'Laravel\\Asset',
'Autoloader' => 'Laravel\\Autoloader',
'Blade' => 'Laravel\\Blade',
'Bundle' => 'Laravel\\Bundle',
'Cache' => 'Laravel\\Cache',
'Config' => 'Laravel\\Config',
'Controller' => 'Laravel\\Routing\\Controller',
'Cookie' => 'Laravel\\Cookie',
'Crypter' => 'Laravel\\Crypter',
'DB' => 'Laravel\\Database',
'Event' => 'Laravel\\Event',
'File' => 'Laravel\\File',
'Filter' => 'Laravel\\Routing\\Filter',
'Form' => 'Laravel\\Form',
'Hash' => 'Laravel\\Hash',
'HTML' => 'Laravel\\HTML',
'Input' => 'Laravel\\Input',
'IoC' => 'Laravel\\IoC',
'Lang' => 'Laravel\\Lang',
'Log' => 'Laravel\\Log',
'Memcached' => 'Laravel\\Memcached',
'Paginator' => 'Laravel\\Paginator',
'URL' => 'Laravel\\URL',
'Redirect' => 'Laravel\\Redirect',
'Redis' => 'Laravel\\Redis',
'Request' => 'Laravel\\Request',
'Response' => 'Laravel\\Response',
'Route' => 'Laravel\\Routing\\Route',
'Router' => 'Laravel\\Routing\\Router',
'Schema' => 'Laravel\\Database\\Schema',
'Section' => 'Laravel\\Section',
'Session' => 'Laravel\\Session',
'Str' => 'Laravel\\Str',
'Task' => 'Laravel\\CLI\\Tasks\\Task',
'URI' => 'Laravel\\URI',
'Validator' => 'Laravel\\Validator',
'View' => 'Laravel\\View',
),
);

81
tests/application/config/auth.php
View File

@ -1,81 +0,0 @@
<?php
return array(
/*
|--------------------------------------------------------------------------
| Retrieve The Current User
|--------------------------------------------------------------------------
|
| This closure is called by the Auth class' "user" method when trying to
| retrieve a user by the ID that is stored in their session. If you find
| the user, just return the user object, but make sure it has an "id"
| property. If you can't find the user, just return null.
|
| Of course, a simple and elegant authentication solution has already
| been provided for you using the query builder and hashing engine.
| We love making your life as easy as possible.
|
*/
'user' => function($id)
{
if (filter_var($id, FILTER_VALIDATE_INT) !== false)
{
return DB::table('users')->find($id);
}
},
/*
|--------------------------------------------------------------------------
| Authenticate User Credentials
|--------------------------------------------------------------------------
|
| This closure is called by the Auth::attempt() method when attempting to
| authenticate a user that is logging into your application. It's like a
| super buff bouncer to your application.
|
| If the provided credentials are correct, simply return an object that
| represents the user being authenticated. As long as it has a property
| for the "id", any object will work. If the credentials are not valid,
| you don't meed to return anything.
|
*/
'attempt' => function($username, $password)
{
$user = DB::table('users')->where_username($username)->first();
if ( ! is_null($user) and Hash::check($password, $user->password))
{
return $user;
}
},
/*
|--------------------------------------------------------------------------
| Logout The Current User
|--------------------------------------------------------------------------
|
| Here you may do anything that needs to be done when a user logs out of
| your application, such as call the logout method on a third-party API
| you are using for authentication or anything else you desire.
|
*/
'logout' => function($user) {},
/*
|--------------------------------------------------------------------------
| "Remember Me" Cookie Name
|--------------------------------------------------------------------------
|
| Here you may specify the cookie name that will be used for the cookie
| that serves as the "remember me" token. Of course, a sensible default
| has been set for you, so you probably don't need to change it.
|
*/
'cookie' => 'laravel_remember',
);

71
tests/application/config/cache.php
View File

@ -1,71 +0,0 @@
<?php
return array(
/*
|--------------------------------------------------------------------------
| Cache Driver
|--------------------------------------------------------------------------
|
| The name of the default cache driver for your application. Caching can
| be used to increase the performance of your application by storing any
| commonly accessed data in memory, a file, or some other storage.
|
| A variety of awesome drivers are available for you to use with Laravel.
| Some, like APC, are extremely fast. However, if that isn't an option
| in your environment, try file or database caching.
|
| Drivers: 'file', 'memcached', 'apc', 'redis', 'database'.
|
*/
'driver' => 'file',
/*
|--------------------------------------------------------------------------
| Cache Key
|--------------------------------------------------------------------------
|
| This key will be prepended to item keys stored using Memcached and APC
| to prevent collisions with other applications on the server. Since the
| memory based stores could be shared by other applications, we need to
| be polite and use a prefix to uniquely identifier our items.
|
*/
'key' => 'laravel',
/*
|--------------------------------------------------------------------------
| Cache Database
|--------------------------------------------------------------------------
|
| When using the database cache driver, this database table will be used
| to store the cached item. You may also add a "connection" option to
| the array to specify which database connection should be used.
|
*/
'database' => array('table' => 'laravel_cache'),
/*
|--------------------------------------------------------------------------
| Memcached Servers
|--------------------------------------------------------------------------
|
| The Memcached servers used by your application. Memcached is a free and
| open source, high-performance, distributed memory caching system. It is
| generic in nature but intended for use in speeding up web applications
| by alleviating database load.
|
| For more information, check out: http://memcached.org
|
*/
'memcached' => array(
array('host' => '127.0.0.1', 'port' => 11211, 'weight' => 100),
),
);

108
tests/application/config/database.php
View File

@ -1,108 +0,0 @@
<?php
return array(
/*
|--------------------------------------------------------------------------
| Default Database Connection
|--------------------------------------------------------------------------
|
| The name of your default database connection. This connection will used
| as the default for all database operations unless a different name is
| given when performing said operation. This connection name should be
| listed in the array of connections below.
|
*/
'default' => 'sqlite',
/*
|--------------------------------------------------------------------------
| PDO Fetch Style
|--------------------------------------------------------------------------
|
| By default, database results will be returned as instances of the PHP
| stdClass object; however, you may wish to retrieve records as arrays
| instead of objects. Here you can control the PDO fetch style of the
| database queries run by your application.
|
*/
'fetch' => PDO::FETCH_CLASS,
/*
|--------------------------------------------------------------------------
| Database Connections
|--------------------------------------------------------------------------
|
| All of the database connections used by your application. Many of your
| applications will no doubt only use one connection; however, you have
| the freedom to specify as many connections as you can handle.
|
| All database work in Laravel is done through the PHP's PDO facilities,
| so make sure you have the PDO drivers for your particlar database of
| choice installed on your machine.
|
| Drivers: 'mysql', 'pgsql', 'sqlsrv', 'sqlite'.
|
*/
'connections' => array(
'sqlite' => array(
'driver' => 'sqlite',
'database' => 'application',
'prefix' => '',
),
'mysql' => array(
'driver' => 'mysql',
'host' => 'localhost',
'database' => 'database',
'username' => 'root',
'password' => 'password',
'charset' => 'utf8',
'prefix' => '',
),
'pgsql' => array(
'driver' => 'pgsql',
'host' => 'localhost',
'database' => 'database',
'username' => 'root',
'password' => 'password',
'charset' => 'utf8',
'prefix' => '',
),
'sqlsrv' => array(
'driver' => 'sqlsrv',
'host' => 'localhost',
'database' => 'database',
'username' => 'root',
'password' => 'password',
'prefix' => '',
),
),
/*
|--------------------------------------------------------------------------
| Redis Databases
|--------------------------------------------------------------------------
|
| Redis is an open source, fast, and advanced key-value store. However, it
| provides a richer set of commands than a typical key-value store such as
| APC or memcached. All the cool kids are using it.
|
| To get the scoop on Redis, check out: http://redis.io
|
*/
'redis' => array(
'default' => array('host' => '127.0.0.1', 'port' => 6379),
),
);

69
tests/application/config/error.php
View File

@ -1,69 +0,0 @@
<?php
return array(
/*
|--------------------------------------------------------------------------
| Ignored Error Levels
|--------------------------------------------------------------------------
|
| Here you simply specify the error levels that should be ignored by the
| Laravel error handler. These levels will still be logged; however, no
| information about about them will be displayed.
|
*/
'ignore' => array(E_NOTICE, E_USER_NOTICE, E_DEPRECATED, E_USER_DEPRECATED),
/*
|--------------------------------------------------------------------------
| Error Detail
|--------------------------------------------------------------------------
|
| Detailed error messages contain information about the file in which an
| error occurs, as well as a PHP stack trace containing the call stack.
| You'll want them when you're trying to debug your application.
|
| If your application is in production, you'll want to turn off the error
| details for enhanced security and user experience since the exception
| stack trace could contain sensitive information.
|
*/
'detail' => true,
/*
|--------------------------------------------------------------------------
| Error Logging
|--------------------------------------------------------------------------
|
| When error logging is enabled, the "logger" Closure defined below will
| be called for every error in your application. You are free to log the
| errors however you want. Enjoy the flexibility.
|
*/
'log' => false,
/*
|--------------------------------------------------------------------------
| Error Logger
|--------------------------------------------------------------------------
|
| Because of the various ways of managing error logging, you get complete
| flexibility to manage error logging as you see fit. This function will
| be called anytime an error occurs within your application and error
| logging is enabled.
|
| You may log the error message however you like; however, a simple log
| solution has been setup for you which will log all error messages to
| text files within the application storage directory.
|
*/
'logger' => function($exception)
{
Log::exception($exception);
},
);

7
tests/application/config/local/database.php
View File

@ -1,7 +0,0 @@
<?php
return array(
'default' => 'sqlite',
);

97
tests/application/config/mimes.php
View File

@ -1,97 +0,0 @@
<?php
return array(
'hqx' => 'application/mac-binhex40',
'cpt' => 'application/mac-compactpro',
'csv' => array('text/x-comma-separated-values', 'text/comma-separated-values', 'application/octet-stream'),
'bin' => 'application/macbinary',
'dms' => 'application/octet-stream',
'lha' => 'application/octet-stream',
'lzh' => 'application/octet-stream',
'exe' => array('application/octet-stream', 'application/x-msdownload'),
'class' => 'application/octet-stream',
'psd' => 'application/x-photoshop',
'so' => 'application/octet-stream',
'sea' => 'application/octet-stream',
'dll' => 'application/octet-stream',
'oda' => 'application/oda',
'pdf' => array('application/pdf', 'application/x-download'),
'ai' => 'application/postscript',
'eps' => 'application/postscript',
'ps' => 'application/postscript',
'smi' => 'application/smil',
'smil' => 'application/smil',
'mif' => 'application/vnd.mif',
'xls' => array('application/excel', 'application/vnd.ms-excel', 'application/msexcel'),
'ppt' => array('application/powerpoint', 'application/vnd.ms-powerpoint'),
'wbxml' => 'application/wbxml',
'wmlc' => 'application/wmlc',
'dcr' => 'application/x-director',
'dir' => 'application/x-director',
'dxr' => 'application/x-director',
'dvi' => 'application/x-dvi',
'gtar' => 'application/x-gtar',
'gz' => 'application/x-gzip',
'php' => array('application/x-httpd-php', 'text/x-php'),
'php4' => 'application/x-httpd-php',
'php3' => 'application/x-httpd-php',
'phtml' => 'application/x-httpd-php',
'phps' => 'application/x-httpd-php-source',
'js' => 'application/x-javascript',
'swf' => 'application/x-shockwave-flash',
'sit' => 'application/x-stuffit',
'tar' => 'application/x-tar',
'tgz' => array('application/x-tar', 'application/x-gzip-compressed'),
'xhtml' => 'application/xhtml+xml',
'xht' => 'application/xhtml+xml',
'zip' => array('application/x-zip', 'application/zip', 'application/x-zip-compressed'),
'mid' => 'audio/midi',
'midi' => 'audio/midi',
'mpga' => 'audio/mpeg',
'mp2' => 'audio/mpeg',
'mp3' => array('audio/mpeg', 'audio/mpg', 'audio/mpeg3', 'audio/mp3'),
'aif' => 'audio/x-aiff',
'aiff' => 'audio/x-aiff',
'aifc' => 'audio/x-aiff',
'ram' => 'audio/x-pn-realaudio',
'rm' => 'audio/x-pn-realaudio',
'rpm' => 'audio/x-pn-realaudio-plugin',
'ra' => 'audio/x-realaudio',
'rv' => 'video/vnd.rn-realvideo',
'wav' => 'audio/x-wav',
'bmp' => 'image/bmp',
'gif' => 'image/gif',
'jpeg' => array('image/jpeg', 'image/pjpeg'),
'jpg' => array('image/jpeg', 'image/pjpeg'),
'jpe' => array('image/jpeg', 'image/pjpeg'),
'png' => 'image/png',
'tiff' => 'image/tiff',
'tif' => 'image/tiff',
'css' => 'text/css',
'html' => 'text/html',
'htm' => 'text/html',
'shtml' => 'text/html',
'txt' => 'text/plain',
'text' => 'text/plain',
'log' => array('text/plain', 'text/x-log'),
'rtx' => 'text/richtext',
'rtf' => 'text/rtf',
'xml' => 'text/xml',
'xsl' => 'text/xml',
'mpeg' => 'video/mpeg',
'mpg' => 'video/mpeg',
'mpe' => 'video/mpeg',
'qt' => 'video/quicktime',
'mov' => 'video/quicktime',
'avi' => 'video/x-msvideo',
'movie' => 'video/x-sgi-movie',
'doc' => 'application/msword',
'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
'word' => array('application/msword', 'application/octet-stream'),
'xl' => 'application/excel',
'eml' => 'message/rfc822',
'json' => array('application/json', 'text/json'),
);

117
tests/application/config/session.php
View File

@ -1,117 +0,0 @@
<?php
return array(
/*
|--------------------------------------------------------------------------
| Session Driver
|--------------------------------------------------------------------------
|
| The name of the session driver used by your application. Since HTTP is
| stateless, sessions are used to simulate "state" across requests made
| by the same user of your application. In other words, it's how an
| application knows who the heck you are.
|
| Drivers: 'cookie', 'file', 'database', 'memcached', 'apc', 'redis'.
|
*/
'driver' => '',
/*
|--------------------------------------------------------------------------
| Session Database
|--------------------------------------------------------------------------
|
| The database table on which the session should be stored. It probably
| goes without saying that this option only matters if you are using
| the super slick database session driver.
|
*/
'table' => 'sessions',
/*
|--------------------------------------------------------------------------
| Session Garbage Collection Probability
|--------------------------------------------------------------------------
|
| Some session drivers require the manual clean-up of expired sessions.
| This option specifies the probability of session garbage collection
| occuring for any given request.
|
| For example, the default value states that garbage collection has a
| 2% chance of occuring for any given request to the application.
| Feel free to tune this to your application's size and speed.
|
*/
'sweepage' => array(2, 100),
/*
|--------------------------------------------------------------------------
| Session Lifetime
|--------------------------------------------------------------------------
|
| The number of minutes a session can be idle before expiring.
|
*/
'lifetime' => 60,
/*
|--------------------------------------------------------------------------
| Session Expiration On Close
|--------------------------------------------------------------------------
|
| Determines if the session should expire when the user's web browser closes.
|
*/
'expire_on_close' => false,
/*
|--------------------------------------------------------------------------
| Session Cookie Name
|--------------------------------------------------------------------------
|
| The name that should be given to the session cookie.
|
*/
'cookie' => 'laravel_session',
/*
|--------------------------------------------------------------------------
| Session Cookie Path
|--------------------------------------------------------------------------
|
| The path for which the session cookie is available.
|
*/
'path' => '/',
/*
|--------------------------------------------------------------------------
| Session Cookie Domain
|--------------------------------------------------------------------------
|
| The domain for which the session cookie is available.
|
*/
'domain' => null,
/*
|--------------------------------------------------------------------------
| HTTPS Only Session Cookie
|--------------------------------------------------------------------------
|
| Determines if the cookie should only be sent over HTTPS.
|
*/
'secure' => false,
);

187
tests/application/config/strings.php
View File

@ -1,187 +0,0 @@
<?php
return array(
/*
|--------------------------------------------------------------------------
| String Inflection
|--------------------------------------------------------------------------
|
| This array contains the singular and plural forms of words. It's used by
| the "singular" and "plural" methods on the Str class to convert a given
| word from singular to plural and vice versa.
|
| Note that the regular expressions are only for inflecting English words.
| To inflect a non-English string, simply add its singular and plural
| form to the array of "irregular" word forms.
|
*/
'plural' => array(
'/(quiz)$/i' => "$1zes",
'/^(ox)$/i' => "$1en",
'/([m|l])ouse$/i' => "$1ice",
'/(matr|vert|ind)ix|ex$/i' => "$1ices",
'/(x|ch|ss|sh)$/i' => "$1es",
'/([^aeiouy]|qu)y$/i' => "$1ies",
'/(hive)$/i' => "$1s",
'/(?:([^f])fe|([lr])f)$/i' => "$1$2ves",
'/(shea|lea|loa|thie)f$/i' => "$1ves",
'/sis$/i' => "ses",
'/([ti])um$/i' => "$1a",
'/(tomat|potat|ech|her|vet)o$/i' => "$1oes",
'/(bu)s$/i' => "$1ses",
'/(alias)$/i' => "$1es",
'/(octop)us$/i' => "$1i",
'/(ax|test)is$/i' => "$1es",
'/(us)$/i' => "$1es",
'/s$/i' => "s",
'/$/' => "s"
),
'singular' => array(
'/(quiz)zes$/i' => "$1",
'/(matr)ices$/i' => "$1ix",
'/(vert|ind)ices$/i' => "$1ex",
'/^(ox)en$/i' => "$1",
'/(alias)es$/i' => "$1",
'/(octop|vir)i$/i' => "$1us",
'/(cris|ax|test)es$/i' => "$1is",
'/(shoe)s$/i' => "$1",
'/(o)es$/i' => "$1",
'/(bus)es$/i' => "$1",
'/([m|l])ice$/i' => "$1ouse",
'/(x|ch|ss|sh)es$/i' => "$1",
'/(m)ovies$/i' => "$1ovie",
'/(s)eries$/i' => "$1eries",
'/([^aeiouy]|qu)ies$/i' => "$1y",
'/([lr])ves$/i' => "$1f",
'/(tive)s$/i' => "$1",
'/(hive)s$/i' => "$1",
'/(li|wi|kni)ves$/i' => "$1fe",
'/(shea|loa|lea|thie)ves$/i' => "$1f",
'/(^analy)ses$/i' => "$1sis",
'/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i' => "$1$2sis",
'/([ti])a$/i' => "$1um",
'/(n)ews$/i' => "$1ews",
'/(h|bl)ouses$/i' => "$1ouse",
'/(corpse)s$/i' => "$1",
'/(us)es$/i' => "$1",
'/(us|ss)$/i' => "$1",
'/s$/i' => "",
),
'irregular' => array(
'child' => 'children',
'foot' => 'feet',
'goose' => 'geese',
'man' => 'men',
'move' => 'moves',
'person' => 'people',
'sex' => 'sexes',
'tooth' => 'teeth',
),
'uncountable' => array(
'audio',
'equipment',
'deer',
'fish',
'gold',
'information',
'money',
'rice',
'police',
'series',
'sheep',
'species',
),
/*
|--------------------------------------------------------------------------
| ASCII Characters
|--------------------------------------------------------------------------
|
| This array contains foreign characters and their 7-bit ASCII equivalents.
| The array is used by the "ascii" method on the Str class to get strings
| ready for inclusion in a URL slug.
|
| Of course, the "ascii" method may also be used by you for whatever your
| application requires. Feel free to add any characters we missed, and be
| sure to let us know about them!
|
*/
'ascii' => array(
'/æ|ǽ/' => 'ae',
'/œ/' => 'oe',
'/À|Á|Â|Ã|Ä|Å|Ǻ|Ā|Ă|Ą|Ǎ|А/' => 'A',
'/à|á|â|ã|ä|å|ǻ|ā|ă|ą|ǎ|ª|а/' => 'a',
'/Б/' => 'B',
'/б/' => 'b',
'/Ç|Ć|Ĉ|Ċ|Č|Ц/' => 'C',
'/ç|ć|ĉ|ċ|č|ц/' => 'c',
'/Ð|Ď|Đ|Д/' => 'Dj',
'/ð|ď|đ|д/' => 'dj',
'/È|É|Ê|Ë|Ē|Ĕ|Ė|Ę|Ě|Е|Ё|Э/' => 'E',
'/è|é|ê|ë|ē|ĕ|ė|ę|ě|е|ё|э/' => 'e',
'/Ф/' => 'F',
'/ƒ|ф/' => 'f',
'/Ĝ|Ğ|Ġ|Ģ|Г/' => 'G',
'/ĝ|ğ|ġ|ģ|г/' => 'g',
'/Ĥ|Ħ|Х/' => 'H',
'/ĥ|ħ|х/' => 'h',
'/Ì|Í|Î|Ï|Ĩ|Ī|Ĭ|Ǐ|Į|İ|И/' => 'I',
'/ì|í|î|ï|ĩ|ī|ĭ|ǐ|į|ı|и/' => 'i',
'/Ĵ|Й/' => 'J',
'/ĵ|й/' => 'j',
'/Ķ|К/' => 'K',
'/ķ|к/' => 'k',
'/Ĺ|Ļ|Ľ|Ŀ|Ł|Л/' => 'L',
'/ĺ|ļ|ľ|ŀ|ł|л/' => 'l',
'/М/' => 'M',
'/м/' => 'm',
'/Ñ|Ń|Ņ|Ň|Н/' => 'N',
'/ñ|ń|ņ|ň|ʼn|н/' => 'n',
'/Ö|Ò|Ó|Ô|Õ|Ō|Ŏ|Ǒ|Ő|Ơ|Ø|Ǿ|О/' => 'O',
'/ö|ò|ó|ô|õ|ō|ŏ|ǒ|ő|ơ|ø|ǿ|º|о/' => 'o',
'/П/' => 'P',
'/п/' => 'p',
'/Ŕ|Ŗ|Ř|Р/' => 'R',
'/ŕ|ŗ|ř|р/' => 'r',
'/Ś|Ŝ|Ş|Ș|Š|С/' => 'S',
'/ś|ŝ|ş|ș|š|ſ|с/' => 's',
'/Ţ|Ț|Ť|Ŧ|Т/' => 'T',
'/ţ|ț|ť|ŧ|т/' => 't',
'/Ù|Ú|Û|Ũ|Ū|Ŭ|Ů|Ü|Ű|Ų|Ư|Ǔ|Ǖ|Ǘ|Ǚ|Ǜ|У/' => 'U',
'/ù|ú|û|ũ|ū|ŭ|ů|ü|ű|ų|ư|ǔ|ǖ|ǘ|ǚ|ǜ|у/' => 'u',
'/В/' => 'V',
'/в/' => 'v',
'/Ý|Ÿ|Ŷ|Ы/' => 'Y',
'/ý|ÿ|ŷ|ы/' => 'y',
'/Ŵ/' => 'W',
'/ŵ/' => 'w',
'/Ź|Ż|Ž|З/' => 'Z',
'/ź|ż|ž|з/' => 'z',
'/Æ|Ǽ/' => 'AE',
'/ß/'=> 'ss',
'/IJ/' => 'IJ',
'/ij/' => 'ij',
'/Œ/' => 'OE',
'/Ч/' => 'Ch',
'/ч/' => 'ch',
'/Ю/' => 'Ju',
'/ю/' => 'ju',
'/Я/' => 'Ja',
'/я/' => 'ja',
'/Ш/' => 'Sh',
'/ш/' => 'sh',
'/Щ/' => 'Shch',
'/щ/' => 'shch',
'/Ж/' => 'Zh',
'/ж/' => 'zh',
),
);

10
tests/application/controllers/admin/panel.php
View File

@ -1,10 +0,0 @@
<?php
class Admin_Panel_Controller extends Controller {
public function action_index()
{
return 'Admin_Panel_Index';
}
}

20
tests/application/controllers/auth.php
View File

@ -1,20 +0,0 @@
<?php
class Auth_Controller extends Controller {
public function action_index()
{
return __FUNCTION__;
}
public function action_login()
{
return __FUNCTION__;
}
public function action_profile($name)
{
return $name;
}
}

65
tests/application/controllers/filter.php
View File

@ -1,65 +0,0 @@
<?php
class Filter_Controller extends Controller {
public function __construct()
{
Filter::register('test-all-before', function() { $_SERVER['test-all-before'] = true; });
Filter::register('test-all-after', function() { $_SERVER['test-all-after'] = true; });
Filter::register('test-profile-before', function() { $_SERVER['test-profile-before'] = true; });
Filter::register('test-except', function() { $_SERVER['test-except'] = true; });
Filter::register('test-on-post', function() { $_SERVER['test-on-post'] = true; });
Filter::register('test-on-get-put', function() { $_SERVER['test-on-get-put'] = true; });
Filter::register('test-before-filter', function() { return 'Filtered!'; });
Filter::register('test-param', function($var1, $var2) { return $var1.$var2; });
Filter::register('test-multi-1', function() { $_SERVER['test-multi-1'] = true; });
Filter::register('test-multi-2', function() { $_SERVER['test-multi-2'] = true; });
$this->filter('before', 'test-all-before');
$this->filter('after', 'test-all-after');
$this->filter('before', 'test-profile-before')->only(array('profile'));
$this->filter('before', 'test-except')->except(array('index', 'profile'));
$this->filter('before', 'test-on-post')->on(array('post'));
$this->filter('before', 'test-on-get-put')->on(array('get', 'put'));
$this->filter('before', 'test-before-filter')->only('login');
$this->filter('after', 'test-before-filter')->only('logout');
$this->filter('before', 'test-param:1,2')->only('edit');
$this->filter('before', 'test-multi-1|test-multi-2')->only('save');
}
public function action_index()
{
return __FUNCTION__;
}
public function action_profile()
{
return __FUNCTION__;
}
public function action_show()
{
return __FUNCTION__;
}
public function action_edit()
{
return __FUNCTION__;
}
public function action_save()
{
return __FUNCTION__;
}
public function action_login()
{
return __FUNCTION__;
}
public function action_logout()
{
return __FUNCTION__;
}
}

42
tests/application/controllers/home.php
View File

@ -1,42 +0,0 @@
<?php
class Home_Controller extends Controller {
/*
|--------------------------------------------------------------------------
| The Default Controller
|--------------------------------------------------------------------------
|
| Instead of using RESTful routes and anonymous functions, you might wish
| to use controllers to organize your application API. You'll love them.
|
| To start using this controller simply remove the default route from the
| application "routes.php" file. Laravel is smart enough to locate this
| controller and call the default method, which is "action_index".
|
| This controller responds to URIs beginning with "home", and it also
| serves as the default controller for the application, meaning it
| handles requests to the root of the application.
|
| You can respond to GET requests to "/home/profile" like so:
|
| public function action_profile()
| {
| return "This is your profile!";
| }
|
| Any extra segments are passed to the method as parameters:
|
| public function action_profile($id)
| {
| return "This is the profile for user {$id}.";
| }
|
*/
public function action_index()
{
return View::make('home.index');
}
}

17
tests/application/controllers/restful.php
View File

@ -1,17 +0,0 @@
<?php
class Restful_Controller extends Controller {
public $restful = true;
public function get_index()
{
return __FUNCTION__;
}
public function post_index()
{
return __FUNCTION__;
}
}

12
tests/application/controllers/template/basic.php
View File

@ -1,12 +0,0 @@
<?php
class Template_Basic_Controller extends Controller {
public $layout = 'home.index';
public function action_index()
{
//
}
}

12
tests/application/controllers/template/named.php
View File

@ -1,12 +0,0 @@
<?php
class Template_Named_Controller extends Controller {
public $layout = 'name: home';
public function action_index()
{
//
}
}

26
tests/application/controllers/template/override.php
View File

@ -1,26 +0,0 @@
<?php
class TemplateStub {
public function __toString()
{
return 'TemplateStub';
}
}
class Template_Override_Controller extends Controller {
public $layout = 'home.index';
public function action_index()
{
//
}
public function layout()
{
return 'Layout';
}
}

7
tests/application/dashboard/repository.php
View File

@ -1,7 +0,0 @@
<?php namespace Dashboard;
/**
* This class is used for testing the auto-loading of classes
* that are mapped by namesapce.
*/
class Repository {}

19
tests/application/language/en/pagination.php
View File

@ -1,19 +0,0 @@
<?php
return array(
/*
|--------------------------------------------------------------------------
| Pagination Language Lines
|--------------------------------------------------------------------------
|
| The following language lines are used by the paginator library to build
| the pagination links. You're free to change them to anything you want.
| If you come up with something more exciting, let us know.
|
*/
'previous' => '&laquo; Previous',
'next' => 'Next &raquo;',
);

96
tests/application/language/en/validation.php
View File

@ -1,96 +0,0 @@
<?php
return array(
/*
|--------------------------------------------------------------------------
| Validation Language Lines
|--------------------------------------------------------------------------
|
| The following language lines contain the default error messages used
| by the validator class. Some of the rules contain multiple versions,
| such as the size (max, min, between) rules. These versions are used
| for different input types such as strings and files.
|
| These language lines may be easily changed to provide custom error
| messages in your application. Error messages for custom validation
| rules may also be added to this file.
|
*/
"accepted" => "The :attribute must be accepted.",
"active_url" => "The :attribute is not a valid URL.",
"alpha" => "The :attribute may only contain letters.",
"alpha_dash" => "The :attribute may only contain letters, numbers, and dashes.",
"alpha_num" => "The :attribute may only contain letters and numbers.",
"between" => array(
"numeric" => "The :attribute must be between :min - :max.",
"file" => "The :attribute must be between :min - :max kilobytes.",
"string" => "The :attribute must be between :min - :max characters.",
),
"confirmed" => "The :attribute confirmation does not match.",
"different" => "The :attribute and :other must be different.",
"email" => "The :attribute format is invalid.",
"exists" => "The selected :attribute is invalid.",
"image" => "The :attribute must be an image.",
"in" => "The selected :attribute is invalid.",
"integer" => "The :attribute must be an integer.",
"ip" => "The :attribute must be a valid IP address.",
"max" => array(
"numeric" => "The :attribute must be less than :max.",
"file" => "The :attribute must be less than :max kilobytes.",
"string" => "The :attribute must be less than :max characters.",
),
"mimes" => "The :attribute must be a file of type: :values.",
"min" => array(
"numeric" => "The :attribute must be at least :min.",
"file" => "The :attribute must be at least :min kilobytes.",
"string" => "The :attribute must be at least :min characters.",
),
"not_in" => "The selected :attribute is invalid.",
"numeric" => "The :attribute must be a number.",
"required" => "The :attribute field is required.",
"same" => "The :attribute and :other must match.",
"size" => array(
"numeric" => "The :attribute must be :size.",
"file" => "The :attribute must be :size kilobyte.",
"string" => "The :attribute must be :size characters.",
),
"unique" => "The :attribute has already been taken.",
"url" => "The :attribute format is invalid.",
/*
|--------------------------------------------------------------------------
| Custom Validation Language Lines
|--------------------------------------------------------------------------
|
| Here you may specify custom validation messages for attributes using the
| convention "attribute_rule" to name the lines. This helps keep your
| custom validation clean and tidy.
|
| So, say you want to use a custom validation message when validating that
| the "email" attribute is unique. Just add "email_unique" to this array
| with your custom message. The Validator will handle the rest!
|
*/
'custom' => array('custom_required' => 'This field is required!'),
/*
|--------------------------------------------------------------------------
| Validation Attributes
|--------------------------------------------------------------------------
|
| The following language lines are used to swap attribute place-holders
| with something more reader friendly such as "E-Mail Address" instead
| of "email". Your users will thank you.
|
| The Validator class will automatically search this array of lines it
| is attempting to replace the :attribute place-holder in messages.
| It's pretty slick. We think you'll like it.
|
*/
'attributes' => array('test_attribute' => 'attribute'),
);

7
tests/application/language/sp/validation.php
View File

@ -1,7 +0,0 @@
<?php
return array(
'required' => 'El campo de atributo es necesario.',
);

0
tests/application/libraries/.gitignore vendored
View File

0
tests/application/migrations/.gitignore vendored
View File

0
tests/application/models/.gitignore vendored
View File

3
tests/application/models/autoloader.php
View File

@ -1,3 +0,0 @@
<?php
class Autoloader_HardCoded {}

3
tests/application/models/repositories/user.php
View File

@ -1,3 +0,0 @@
<?php namespace Repositories;
class User {}

3
tests/application/models/user.php
View File

@ -1,3 +0,0 @@
<?php
class User {}

93
tests/application/routes.php
View File

@ -1,93 +0,0 @@
<?php
/*
|--------------------------------------------------------------------------
| Application Routes
|--------------------------------------------------------------------------
|
| Simply tell Laravel the HTTP verbs and URIs it should respond to. It is a
| breeze to setup your applications using Laravel's RESTful routing, and it
| is perfectly suited for building both large applications and simple APIs.
| Enjoy the fresh air and simplicity of the framework.
|
| Let's respond to a simple GET request to http://example.com/hello:
|
| Router::register('GET /hello', function()
| {
| return 'Hello World!';
| });
|
| You can even respond to more than one URI:
|
| Router::register('GET /hello, GET /world', function()
| {
| return 'Hello World!';
| });
|
| It's easy to allow URI wildcards using (:num) or (:any):
|
| Router::register('GET /hello/(:any)', function($name)
| {
| return "Welcome, $name.";
| });
|
*/
Route::get('/, home', array('as' => 'home', function()
{
return View::make('home.index');
}));
Route::controller(array(
'auth', 'filter', 'home', 'restful',
'template.basic', 'template.name', 'template.override',
'admin.panel',
));
/*
|--------------------------------------------------------------------------
| Route Filters
|--------------------------------------------------------------------------
|
| Filters provide a convenient method for attaching functionality to your
| routes. The built-in "before" and "after" filters are called before and
| after every request to your application, and you may even create other
| filters that can be attached to individual routes.
|
| Let's walk through an example...
|
| First, define a filter:
|
| Filter::register('filter', function()
| {
| return 'Filtered!';
| });
|
| Next, attach the filter to a route:
|
| Router::register('GET /', array('before' => 'filter', function()
| {
| return 'Hello World!';
| }));
|
*/
Filter::register('before', function()
{
$_SERVER['before'] = true;
});
Filter::register('after', function()
{
$_SERVER['after'] = true;
});
Filter::register('csrf', function()
{
if (Request::forged()) return Response::error('500');
});
Filter::register('auth', function()
{
if (Auth::guest()) return Redirect::to('login');
});

157
tests/application/start.php
View File

@ -1,157 +0,0 @@
<?php
/*
|--------------------------------------------------------------------------
| PHP Display Errors Configuration
|--------------------------------------------------------------------------
|
| Since Laravel intercepts and displays all errors with a detailed stack
| trace, we can turn off the display_errors ini directive. However, you
| may want to enable this option if you ever run into a dreaded white
| screen of death, as it can provide some clues.
|
*/
ini_set('display_errors', 'On');
/*
|--------------------------------------------------------------------------
| Laravel Configuration Loader
|--------------------------------------------------------------------------
|
| The Laravel configuration loader is responsible for returning an array
| of configuration options for a given bundle and file. By default, we
| use the files provided with Laravel; however, you are free to use
| your own storage mechanism for configuration arrays.
|
*/
Laravel\Event::listen(Laravel\Config::loader, function($bundle, $file)
{
return Laravel\Config::file($bundle, $file);
});
/*
|--------------------------------------------------------------------------
| Register Class Aliases
|--------------------------------------------------------------------------
|
| Aliases allow you to use classes without always specifying their fully
| namespaced path. This is convenient for working with any library that
| makes a heavy use of namespace for class organization. Here we will
| simply register the configured class aliases.
|
*/
$aliases = Laravel\Config::get('application.aliases');
Laravel\Autoloader::$aliases = $aliases;
/*
|--------------------------------------------------------------------------
| Auto-Loader Mappings
|--------------------------------------------------------------------------
|
| Registering a mapping couldn't be easier. Just pass an array of class
| to path maps into the "map" function of Autoloader. Then, when you
| want to use that class, just use it. It's simple!
|
*/
Autoloader::map(array(
'Base_Controller' => path('app').'controllers/base.php',
));
/*
|--------------------------------------------------------------------------
| Auto-Loader Directories
|--------------------------------------------------------------------------
|
| The Laravel auto-loader can search directories for files using the PSR-0
| naming convention. This convention basically organizes classes by using
| the class namespace to indicate the directory structure.
|
*/
Autoloader::directories(array(
path('app').'models',
path('app').'libraries',
));
/*
|--------------------------------------------------------------------------
| Laravel View Loader
|--------------------------------------------------------------------------
|
| The Laravel view loader is responsible for returning the full file path
| for the given bundle and view. Of course, a default implementation is
| provided to load views according to typical Laravel conventions but
| you may change this to customize how your views are organized.
|
*/
Event::listen(View::loader, function($bundle, $view)
{
return View::file($bundle, $view, Bundle::path($bundle).'views');
});
/*
|--------------------------------------------------------------------------
| Laravel Language Loader
|--------------------------------------------------------------------------
|
| The Laravel language loader is responsible for returning the array of
| language lines for a given bundle, language, and "file". A default
| implementation has been provided which uses the default language
| directories included with Laravel.
|
*/
Event::listen(Lang::loader, function($bundle, $language, $file)
{
return Lang::file($bundle, $language, $file);
});
/*
|--------------------------------------------------------------------------
| Enable The Blade View Engine
|--------------------------------------------------------------------------
|
| The Blade view engine provides a clean, beautiful templating language
| for your application, including syntax for echoing data and all of
| the typical PHP control structures. We'll simply enable it here.
|
*/
Blade::sharpen();
/*
|--------------------------------------------------------------------------
| Set The Default Timezone
|--------------------------------------------------------------------------
|
| We need to set the default timezone for the application. This controls
| the timezone that will be used by any of the date methods and classes
| utilized by Laravel or your application. The timezone may be set in
| your application configuration file.
|
*/
date_default_timezone_set(Config::get('application.timezone'));
/*
|--------------------------------------------------------------------------
| Start / Load The User Session
|--------------------------------------------------------------------------
|
| Sessions allow the web, which is stateless, to simulate state. In other
| words, sessions allow you to store information about the current user
| and state of your application. Here we'll just fire up the session
| if a session driver has been configured.
|
*/
if ( ! Request::cli() and Config::get('session.driver') !== '')
{
Session::load();
}

0
tests/application/tasks/.gitignore vendored
View File

103
tests/application/views/error/404.php
View File

@ -1,103 +0,0 @@
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>Error 404 - Not Found</title>
<style>
@import url(http://fonts.googleapis.com/css?family=Ubuntu);
body {
background: #eee;
color: #6d6d6d;
font: normal normal normal 14px/1.253 Ubuntu, sans-serif;
margin: 0 0 25px 0;
min-width: 800px;
padding: 0;
}
#main {
background-clip: padding-box;
background-color: #fff;
border:1px solid #ccc;
border-radius: 5px;
box-shadow: 0 0 10px #cdcdcd;
margin: 25px auto 0;
padding: 30px;
width: 700px;
position: relative;
}
#main h1 {
font-family: 'Ubuntu';
font-size: 38px;
letter-spacing: 2px;
margin: 0 0 10px 0;
padding: 0;
}
#main h2 {
color: #999;
font-size: 18px;
letter-spacing: 3px;
margin: 0 0 25px 0;
padding: 0 0 0 0;
}
#main h3 {
color: #999;
margin-top: 24px;
padding: 0 0 0 0;
}
#main h3 {
font-size: 18px;
}
#main p {
line-height: 25px;
margin: 10px 0;
}
#main pre {
background-color: #333;
border-left: 1px solid #d8d8d8;
border-top: 1px solid #d8d8d8;
border-radius: 5px;
color: #eee;
padding: 10px;
}
#main ul {
margin: 10px 0;
padding: 0 30px;
}
#main li {
margin: 5px 0;
}
</style>
</head>
<body>
<div id="main">
<?php $messages = array('We need a map.', 'I think we\'re lost.', 'We took a wrong turn.'); ?>
<h1><?php echo $messages[mt_rand(0, 2)]; ?></h1>
<h2>Server Error: 404 (Not Found)</h2>
<h3>What does this mean?</h3>
<p>
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.
</p>
<p>
Perhaps you would like to go to our <?php echo HTML::link('/', 'home page'); ?>?
</p>
</div>
</body>
</html>

103
tests/application/views/error/500.php
View File

@ -1,103 +0,0 @@
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>Error 500 - Internal Server Error</title>
<style>
@import url(http://fonts.googleapis.com/css?family=Ubuntu);
body {
background: #eee;
color: #6d6d6d;
font: normal normal normal 14px/1.253 Ubuntu, sans-serif;
margin: 0 0 25px 0;
min-width: 800px;
padding: 0;
}
#main {
background-clip: padding-box;
background-color: #fff;
border:1px solid #ccc;
border-radius: 5px;
box-shadow: 0 0 10px #cdcdcd;
margin: 25px auto 0;
padding: 30px;
width: 700px;
position: relative;
}
#main h1 {
font-family: 'Ubuntu';
font-size: 38px;
letter-spacing: 2px;
margin: 0 0 10px 0;
padding: 0;
}
#main h2 {
color: #999;
font-size: 18px;
letter-spacing: 3px;
margin: 0 0 25px 0;
padding: 0 0 0 0;
}
#main h3 {
color: #999;
margin-top: 24px;
padding: 0 0 0 0;
}
#main h3 {
font-size: 18px;
}
#main p {
line-height: 25px;
margin: 10px 0;
}
#main pre {
background-color: #333;
border-left: 1px solid #d8d8d8;
border-top: 1px solid #d8d8d8;
border-radius: 5px;
color: #eee;
padding: 10px;
}
#main ul {
margin: 10px 0;
padding: 0 30px;
}
#main li {
margin: 5px 0;
}
</style>
</head>
<body>
<div id="main">
<?php $messages = array('Ouch.', 'Oh no!', 'Whoops!'); ?>
<h1><?php echo $messages[mt_rand(0, 2)]; ?></h1>
<h2>Server Error: 500 (Internal Server Error)</h2>
<h3>What does this mean?</h3>
<p>
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.
</p>
<p>
Perhaps you would like to go to our <?php echo HTML::link('/', 'home page'); ?>?
</p>
</div>
</body>
</html>

122
tests/application/views/home/index.php
View File

@ -1,122 +0,0 @@
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>Laravel - A Framework For Web Artisans</title>
<style>
@import url(http://fonts.googleapis.com/css?family=Ubuntu);
body {
background: #eee;
color: #6d6d6d;
font: normal normal normal 14px/1.253 Ubuntu, sans-serif;
margin: 0 0 25px 0;
min-width: 800px;
padding: 0;
}
#main {
background-clip: padding-box;
background-color: #fff;
border:1px solid #ccc;
border-radius: 5px;
box-shadow: 0 0 10px #cdcdcd;
margin: 25px auto 0;
padding: 30px;
width: 700px;
position: relative;
}
#main h1 {
font-family: 'Ubuntu';
font-size: 38px;
letter-spacing: 2px;
margin: 0 0 10px 0;
padding: 0;
}
#main h2 {
color: #999;
font-size: 18px;
letter-spacing: 3px;
margin: 0 0 25px 0;
padding: 0 0 0 0;
}
#main h3 {
color: #999;
margin-top: 24px;
padding: 0 0 0 0;
}
#main h3 {
font-size: 18px;
}
#main p {
line-height: 25px;
margin: 10px 0;
}
#main pre {
background-color: #333;
border-left: 1px solid #d8d8d8;
border-top: 1px solid #d8d8d8;
border-radius: 5px;
color: #eee;
padding: 10px;
}
#main ul {
margin: 10px 0;
padding: 0 30px;
}
#main li {
margin: 5px 0;
}
</style>
</head>
<body>
<div id="main">
<h1>Welcome To Laravel</h1>
<h2>A Framework For Web Artisans</h2>
<p>
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.
</p>
<h3>Learn the terrain.</h3>
<p>
You've landed yourself on our default home page. The route that
is generating this page lives at:
</p>
<pre><code>APP_PATH/routes.php</code></pre>
<p>And the view sitting before you can be found at:</p>
<pre><code>APP_PATH/views/home/index.php</code></pre>
<h3>Create something beautiful.</h3>
<p>
Now that you're up and running, it's time to start creating!
Here are some links to help you get started:
</p>
<ul>
<li><a href="http://laravel.com">Official Website</a></li>
<li><a href="http://forums.laravel.com">Laravel Forums</a></li>
<li><a href="http://github.com/laravel/laravel">GitHub Repository</a></li>
</ul>
</div>
</body>
</html>

1
tests/application/views/tests/basic.php
View File

@ -1 +0,0 @@
<?php echo $name; ?> is <?php echo $age; ?>

1
tests/application/views/tests/nested.php
View File

@ -1 +0,0 @@
Taylor

0
tests/bundles/.gitignore vendored
View File

7
tests/bundles/dashboard/config/meta.php
View File

@ -1,7 +0,0 @@
<?php
return array(
'bundle' => 'dashboard',
);

10
tests/bundles/dashboard/controllers/panel.php
View File

@ -1,10 +0,0 @@
<?php
class Dashboard_Panel_Controller extends Controller {
public function action_index()
{
return 'Dashboard_Panel_Index';
}
}

7
tests/bundles/dashboard/models/repository.php
View File

@ -1,7 +0,0 @@
<?php namespace Dashboard;
/**
* This class is used for testing the auto-loading of classes
* that are mapped by namesapce.
*/
class Repository {}

8
tests/bundles/dashboard/routes.php
View File

@ -1,8 +0,0 @@
<?php
Route::get('dashboard', array('as' => 'dashboard', function()
{
//
}));
Route::controller('dashboard::panel');

6
tests/bundles/dummy/routes.php
View File

@ -1,6 +0,0 @@
<?php
if (isset($_SERVER['bundle.dummy.routes']))
{
$_SERVER['bundle.dummy.routes']++;
}

3
tests/bundles/dummy/start.php
View File

@ -1,3 +0,0 @@
<?php
$_SERVER['bundle.dummy.start']++;

262
tests/cases/asset.test.php
View File

@ -1,262 +0,0 @@
<?php
class AssetTest extends PHPUnit_Framework_TestCase {
/**
* Initialize the test environment.
*/
public function setUp()
{
Config::$items = array();
Config::$cache = array();
Asset::$containers = array();
}
/**
* Test the Asset::container method.
*
* @group laravel
*/
public function testContainersCanBeCreated()
{
$container = Asset::container('foo');
$this->assertTrue($container === Asset::container('foo'));
$this->assertInstanceOf('\\Laravel\\Asset_Container', $container);
}
/**
* Test the Asset::container method for default container creation.
*
* @group laravel
*/
public function testDefaultContainerCreatedByDefault()
{
$this->assertEquals('default', Asset::container()->name);
}
/**
* Test the Asset::__callStatic method.
*
* @group laravel
*/
public function testContainerMethodsCanBeDynamicallyCalled()
{
Asset::style('common', 'common.css');
$this->assertEquals('common.css', Asset::container()->assets['style']['common']['source']);
}
/**
* Test the Asset_Container constructor.
*
* @group laravel
*/
public function testNameIsSetOnAssetContainerConstruction()
{
$container = $this->getContainer();
$this->assertEquals('foo', $container->name);
}
/**
* Test the Asset_Container::add method.
*
* @group laravel
*/
public function testAddMethodProperlySniffsAssetType()
{
$container = $this->getContainer();
$container->add('jquery', 'jquery.js');
$container->add('common', 'common.css');
$this->assertEquals('jquery.js', $container->assets['script']['jquery']['source']);
$this->assertEquals('common.css', $container->assets['style']['common']['source']);
}
/**
* Test the Asset_Container::style method.
*
* @group laravel
*/
public function testStyleMethodProperlyRegistersAnAsset()
{
$container = $this->getContainer();
$container->style('common', 'common.css');
$this->assertEquals('common.css', $container->assets['style']['common']['source']);
}
/**
* Test the Asset_Container::style method sets media attribute.
*
* @group laravel
*/
public function testStyleMethodProperlySetsMediaAttributeIfNotSet()
{
$container = $this->getContainer();
$container->style('common', 'common.css');
$this->assertEquals('all', $container->assets['style']['common']['attributes']['media']);
}
/**
* Test the Asset_Container::style method sets media attribute.
*
* @group laravel
*/
public function testStyleMethodProperlyIgnoresMediaAttributeIfSet()
{
$container = $this->getContainer();
$container->style('common', 'common.css', array(), array('media' => 'print'));
$this->assertEquals('print', $container->assets['style']['common']['attributes']['media']);
}
/**
* Test the Asset_Container::script method.
*
* @group laravel
*/
public function testScriptMethodProperlyRegistersAnAsset()
{
$container = $this->getContainer();
$container->script('jquery', 'jquery.js');
$this->assertEquals('jquery.js', $container->assets['script']['jquery']['source']);
}
/**
* Test the Asset_Container::add method properly sets dependencies.
*
* @group laravel
*/
public function testAddMethodProperlySetsDependencies()
{
$container = $this->getContainer();
$container->add('common', 'common.css', 'jquery');
$container->add('jquery', 'jquery.js', array('jquery-ui'));
$this->assertEquals(array('jquery'), $container->assets['style']['common']['dependencies']);
$this->assertEquals(array('jquery-ui'), $container->assets['script']['jquery']['dependencies']);
}
/**
* Test the Asset_Container::add method properly sets attributes.
*
* @group laravel
*/
public function testAddMethodProperlySetsAttributes()
{
$container = $this->getContainer();
$container->add('common', 'common.css', array(), array('media' => 'print'));
$container->add('jquery', 'jquery.js', array(), array('defer'));
$this->assertEquals(array('media' => 'print'), $container->assets['style']['common']['attributes']);
$this->assertEquals(array('defer'), $container->assets['script']['jquery']['attributes']);
}
/**
* Test the Asset_Container::bundle method.
*
* @group laravel
*/
public function testBundleMethodCorrectlySetsTheAssetBundle()
{
$container = $this->getContainer();
$container->bundle('eloquent');
$this->assertEquals('eloquent', $container->bundle);
}
/**
* Test the Asset_Container::path method.
*
* @group laravel
*/
public function testPathMethodReturnsCorrectPathForABundleAsset()
{
Config::set('application.url', 'http://localhost');
$container = $this->getContainer();
$container->bundle('eloquent');
$this->assertEquals('http://localhost/bundles/eloquent/foo.jpg', $container->path('foo.jpg'));
}
/**
* Test the Asset_Container::path method.
*
* @group laravel
*/
public function testPathMethodReturnsCorrectPathForAnApplicationAsset()
{
Config::set('application.url', 'http://localhost');
$container = $this->getContainer();
$this->assertEquals('http://localhost/foo.jpg', $container->path('foo.jpg'));
}
/**
* Test the Asset_Container::scripts method.
*
* @group laravel
*/
public function testScriptsCanBeRetrieved()
{
$container = $this->getContainer();
$container->script('dojo', 'dojo.js', array('jquery-ui'));
$container->script('jquery', 'jquery.js', array('jquery-ui', 'dojo'));
$container->script('jquery-ui', 'jquery-ui.js');
$scripts = $container->scripts();
$this->assertTrue(strpos($scripts, 'jquery.js') > 0);
$this->assertTrue(strpos($scripts, 'jquery.js') > strpos($scripts, 'jquery-ui.js'));
$this->assertTrue(strpos($scripts, 'dojo.js') > strpos($scripts, 'jquery-ui.js'));
}
/**
* Test the Asset_Container::styles method.
*
* @group laravel
*/
public function testStylesCanBeRetrieved()
{
$container = $this->getContainer();
$container->style('dojo', 'dojo.css', array('jquery-ui'), array('media' => 'print'));
$container->style('jquery', 'jquery.css', array('jquery-ui', 'dojo'));
$container->style('jquery-ui', 'jquery-ui.css');
$styles = $container->styles();
$this->assertTrue(strpos($styles, 'jquery.css') > 0);
$this->assertTrue(strpos($styles, 'media="print"') > 0);
$this->assertTrue(strpos($styles, 'jquery.css') > strpos($styles, 'jquery-ui.css'));
$this->assertTrue(strpos($styles, 'dojo.css') > strpos($styles, 'jquery-ui.css'));
}
/**
* Get an asset container instance.
*
* @param string $name
* @return Asset_Container
*/
private function getContainer($name = 'foo')
{
return new Laravel\Asset_Container($name);
}
}

259
tests/cases/auth.test.php
View File

@ -1,259 +0,0 @@
<?php
use Laravel\Str;
use Laravel\Auth;
use Laravel\Cookie;
use Laravel\Session;
use Laravel\Crypter;
use Laravel\Session\Payload;
class AuthTest extends PHPUnit_Framework_TestCase {
/**
* Setup teh test environment.
*/
public function setUp()
{
$_SERVER['auth.login.stub'] = null;
Cookie::$jar = array();
Config::$items = array();
Auth::$user = null;
Session::$instance = null;
Config::set('database.default', 'sqlite');
}
/**
* Tear down the test environment.
*/
public function tearDown()
{
$_SERVER['auth.login.stub'] = null;
Cookie::$jar = array();
Config::$items = array();
Auth::$user = null;
Session::$instance = null;
Config::set('database.default', 'mysql');
}
/**
* Test the Auth::user method.
*
* @group laravel
*/
public function testUserMethodReturnsCurrentUser()
{
Auth::$user = 'Taylor';
$this->assertEquals('Taylor', Auth::user());
}
/**
* Test the Auth::check method.
*
* @group laravel
*/
public function testCheckMethodReturnsTrueWhenUserIsSet()
{
$this->assertTrue(AuthUserReturnsDummy::check());
}
/**
* Test the Auth::check method.
*
* @group laravel
*/
public function testCheckMethodReturnsFalseWhenNoUserIsSet()
{
$this->assertFalse(AuthUserReturnsNull::check());
}
/**
* Test the Auth::guest method.
*
* @group laravel
*/
public function testGuestReturnsTrueWhenNoUserIsSet()
{
$this->assertTrue(AuthUserReturnsNull::guest());
}
/**
* Test the Auth::guest method.
*
* @group laravel
*/
public function testGuestReturnsFalseWhenUserIsSet()
{
$this->assertFalse(AuthUserReturnsDummy::guest());
}
/**
* Test the Auth::user method.
*
* @group laravel
*/
public function testUserMethodReturnsNullWhenNoUserExistsAndNoRecallerExists()
{
Session::$instance = new Payload($this->getMock('Laravel\\Session\\Drivers\\Driver'));
$this->assertNull(Auth::user());
}
/**
* Test the Auth::user method.
*
* @group laravel
*/
public function testUserReturnsUserByID()
{
Session::$instance = new Payload($this->getMock('Laravel\\Session\\Drivers\\Driver'));
Session::$instance->session['data'][Auth::user_key] = 1;
$this->assertEquals('Taylor Otwell', Auth::user()->name);
}
/**
* Test the Auth::user method.
*
* @group laravel
*/
public function testNullReturnedWhenUserIDNotValidInteger()
{
Session::$instance = new Payload($this->getMock('Laravel\\Session\\Drivers\\Driver'));
Session::$instance->session['data'][Auth::user_key] = 'asdlkasd';
$this->assertNull(Auth::user());
}
/**
* Test the Auth::recall method.
*
* @group laravel
*/
public function testUserCanBeRecalledViaCookie()
{
Session::$instance = new Payload($this->getMock('Laravel\\Session\\Drivers\\Driver'));
$cookie = Crypter::encrypt('1|'.Str::random(40));
Cookie::forever(Config::get('auth.cookie'), $cookie);
$this->assertEquals('Taylor Otwell', AuthLoginStub::user()->name);
$this->assertTrue(AuthLoginStub::user() === $_SERVER['auth.login.stub']['user']);
}
/**
* Test the Auth::attempt method.
*
* @group laravel
*/
public function testAttemptMethodReturnsFalseWhenCredentialsAreInvalid()
{
$this->assertFalse(Auth::attempt('foo', 'foo'));
$this->assertFalse(Auth::attempt('foo', null));
$this->assertFalse(Auth::attempt(null, null));
$this->assertFalse(Auth::attempt('taylor', 'password'));
$this->assertFalse(Auth::attempt('taylor', 232));
}
/**
* Test the Auth::attempt method.
*
* @group laravel
*/
public function testAttemptReturnsTrueWhenCredentialsAreCorrect()
{
$this->assertTrue(AuthLoginStub::attempt('taylor', 'password1'));
$this->assertEquals('Taylor Otwell', $_SERVER['auth.login.stub']['user']->name);
$this->assertFalse($_SERVER['auth.login.stub']['remember']);
$this->assertTrue(AuthLoginStub::attempt('taylor', 'password1', true));
$this->assertEquals('Taylor Otwell', $_SERVER['auth.login.stub']['user']->name);
$this->assertTrue($_SERVER['auth.login.stub']['remember']);
}
/**
* Test Auth::login method.
*
* @group laravel
*/
public function testLoginMethodStoresUserKeyInSession()
{
Session::$instance = new Payload($this->getMock('Laravel\\Session\\Drivers\\Driver'));
$user = new StdClass;
$user->id = 10;
Auth::login($user);
$this->assertEquals(10, Session::$instance->session['data'][Auth::user_key]);
Auth::login(5);
$this->assertEquals(5, Session::$instance->session['data'][Auth::user_key]);
}
/**
* Test the Auth::login method.
*
* @group laravel
*/
public function testLoginStoresRememberCookieWhenNeeded()
{
Session::$instance = new Payload($this->getMock('Laravel\\Session\\Drivers\\Driver'));
// Set the session vars to make sure remember cookie uses them
Config::set('session.path', 'foo');
Config::set('session.domain', 'bar');
Config::set('session.secure', true);
Auth::login(10, true);
$this->assertTrue(isset(Cookie::$jar[Config::get('auth.cookie')]));
$cookie = Cookie::$jar[Config::get('auth.cookie')]['value'];
$cookie = explode('|', Crypter::decrypt($cookie));
$this->assertEquals(10, $cookie[0]);
$this->assertEquals('foo', Cookie::$jar[Config::get('auth.cookie')]['path']);
$this->assertEquals('bar', Cookie::$jar[Config::get('auth.cookie')]['domain']);
$this->assertTrue(Cookie::$jar[Config::get('auth.cookie')]['secure']);
}
/**
* Test the Auth::logout method.
*
* @group laravel
*/
public function testLogoutMethodLogsOutUser()
{
Session::$instance = new Payload($this->getMock('Laravel\\Session\\Drivers\\Driver'));
Session::$instance->session['data'][Auth::user_key] = 10;
Config::set('auth.logout', function($user) { $_SERVER['auth.logout.stub'] = $user; });
Auth::$user = 'Taylor';
Auth::logout();
$this->assertEquals('Taylor', $_SERVER['auth.logout.stub']);
$this->assertNull(Auth::$user);
$this->assertFalse(isset(Session::$instance->session['data'][Auth::user_key]));
$this->assertTrue(Cookie::$jar[Config::get('auth.cookie')]['minutes'] < 0);
}
}
class AuthUserReturnsNull extends Laravel\Auth {
public static function user() {}
}
class AuthUserReturnsDummy extends Laravel\Auth {
public static function user() { return 'Taylor'; }
}
class AuthLoginStub extends Laravel\Auth {
public static function login($user, $remember = false)
{
$_SERVER['auth.login.stub'] = compact('user', 'remember');
}
}

102
tests/cases/autoloader.test.php
View File

@ -1,102 +0,0 @@
<?php
class AutoloaderTest extends PHPUnit_Framework_TestCase {
/**
* Test the Autoloader::map method.
*
* @group laravel
*/
public function testMapsCanBeRegistered()
{
Autoloader::map(array(
'Foo' => path('app').'models/foo.php',
));
$this->assertEquals(path('app').'models/foo.php', Autoloader::$mappings['Foo']);
}
/**
* Test the Autoloader::alias method.
*
* @group laravel
*/
public function testAliasesCanBeRegistered()
{
Autoloader::alias('Foo\\Bar', 'Foo');
$this->assertEquals('Foo\\Bar', Autoloader::$aliases['Foo']);
}
/**
* Test the Autoloader::directories method.
*
* @group laravel
*/
public function testPsrDirectoriesCanBeRegistered()
{
Autoloader::directories(array(
path('app').'foo'.DS.'bar',
path('app').'foo'.DS.'baz'.DS.DS,
));
$this->assertTrue(in_array(path('app').'foo'.DS.'bar'.DS, Autoloader::$directories));
$this->assertTrue(in_array(path('app').'foo'.DS.'baz'.DS, Autoloader::$directories));
}
/**
* Test the Autoloader::namespaces method.
*
* @group laravel
*/
public function testNamespacesCanBeRegistered()
{
Autoloader::namespaces(array(
'Autoloader_1' => path('bundle').'autoload'.DS.'models',
'Autoloader_2' => path('bundle').'autoload'.DS.'libraries'.DS.DS,
));
$this->assertEquals(path('bundle').'autoload'.DS.'models'.DS, Autoloader::$namespaces['Autoloader_1\\']);
$this->assertEquals(path('bundle').'autoload'.DS.'libraries'.DS, Autoloader::$namespaces['Autoloader_2\\']);
}
/**
* Test the loading of PSR-0 models and libraries.
*
* @group laravel
*/
public function testPsrLibrariesAndModelsCanBeLoaded()
{
$this->assertInstanceOf('User', new User);
$this->assertInstanceOf('Repositories\\User', new Repositories\User);
}
/**
* Test the loading of hard-coded classes.
*
* @group laravel
*/
public function testHardcodedClassesCanBeLoaded()
{
Autoloader::map(array(
'Autoloader_HardCoded' => path('app').'models'.DS.'autoloader.php',
));
$this->assertInstanceOf('Autoloader_HardCoded', new Autoloader_HardCoded);
}
/**
* Test the loading of classes mapped by namespaces.
*
* @group laravel
*/
public function testClassesMappedByNamespaceCanBeLoaded()
{
Autoloader::namespaces(array(
'Dashboard' => path('bundle').'dashboard'.DS.'models',
));
$this->assertInstanceOf('Dashboard\\Repository', new Dashboard\Repository);
}
}

63
tests/cases/blade.test.php
View File

@ -1,63 +0,0 @@
<?php
use Laravel\Blade;
class BladeTest extends PHPUnit_Framework_TestCase {
/**
* Test the compilation of echo statements.
*
* @group laravel
*/
public function testEchosAreConvertedProperly()
{
$blade1 = '{{$a}}';
$blade2 = '{{e($a)}}';
$this->assertEquals('<?php echo $a; ?>', Blade::compile_string($blade1));
$this->assertEquals('<?php echo e($a); ?>', Blade::compile_string($blade2));
}
/**
* Test the compilation of control structures.
*
* @group laravel
*/
public function testControlStructuresAreCreatedCorrectly()
{
$blade1 = "@if (true)\nfoo\n@endif";
$blade2 = "@if (count(".'$something'.") > 0)\nfoo\n@endif";
$blade3 = "@if (true)\nfoo\n@elseif (false)\nbar\n@endif";
$blade4 = "@if (true)\nfoo\n@else\nbar\n@endif";
$this->assertEquals("<?php if (true): ?>\nfoo\n<?php endif; ?>", Blade::compile_string($blade1));
$this->assertEquals("<?php if (count(".'$something'.") > 0): ?>\nfoo\n<?php endif; ?>", Blade::compile_string($blade2));
$this->assertEquals("<?php if (true): ?>\nfoo\n<?php elseif (false): ?>\nbar\n<?php endif; ?>", Blade::compile_string($blade3));
$this->assertEquals("<?php if (true): ?>\nfoo\n<?php else: ?>\nbar\n<?php endif; ?>", Blade::compile_string($blade4));
}
/**
* Test the compilation of yield statements.
*
* @group laravel
*/
public function testYieldsAreCompiledCorrectly()
{
$blade = "@yield('something')";
$this->assertEquals("<?php echo \\Laravel\\Section::yield('something'); ?>", Blade::compile_string($blade));
}
/**
* Test the compilation of section statements.
*
* @group laravel
*/
public function testSectionsAreCompiledCorrectly()
{
$blade = "@section('something')\nfoo\n@endsection";
$this->assertEquals("<?php \\Laravel\\Section::start('something'); ?>\nfoo\n<?php \\Laravel\\Section::stop(); ?>", Blade::compile_string($blade));
}
}

253
tests/cases/bundle.test.php
View File

@ -1,253 +0,0 @@
<?php
class BundleTest extends PHPUnit_Framework_TestCase {
/**
* Setup the test environment.
*/
public function setUp()
{
Bundle::$started = array();
Bundle::$elements = array();
unset(Bundle::$bundles['foo']);
}
/**
* Tear down the test environment.
*/
public function tearDown()
{
Bundle::$started = array();
Bundle::$elements = array();
unset(Bundle::$bundles['foo']);
}
/**
* Test Bundle::register method.
*
* @group laravel
*/
public function testRegisterMethodCorrectlyRegistersBundle()
{
Bundle::register('foo-baz', array('handles' => 'foo-baz'));
$this->assertEquals('foo-baz', Bundle::$bundles['foo-baz']['handles']);
$this->assertFalse(Bundle::$bundles['foo-baz']['auto']);
Bundle::register('foo-bar', array());
$this->assertFalse(Bundle::$bundles['foo-baz']['auto']);
$this->assertNull(Bundle::$bundles['foo-bar']['handles']);
unset(Bundle::$bundles['foo-baz']);
unset(Bundle::$bundles['foo-bar']);
}
/**
* Test the Bundle::start method.
*
* @group laravel
*/
public function testStartMethodStartsBundle()
{
$_SERVER['bundle.dummy.start'] = 0;
$_SERVER['bundle.dummy.routes'] = 0;
$_SERVER['started.dummy'] = false;
Event::listen('laravel.started: dummy', function()
{
$_SERVER['started.dummy'] = true;
});
Bundle::register('dummy');
Bundle::start('dummy');
$this->assertTrue($_SERVER['started.dummy']);
$this->assertEquals(1, $_SERVER['bundle.dummy.start']);
$this->assertEquals(1, $_SERVER['bundle.dummy.routes']);
Bundle::start('dummy');
$this->assertEquals(1, $_SERVER['bundle.dummy.start']);
$this->assertEquals(1, $_SERVER['bundle.dummy.routes']);
}
/**
* Test Bundle::handles method.
*
* @group laravel
*/
public function testHandlesMethodReturnsBundleThatHandlesURI()
{
Bundle::register('foo', array('handles' => 'foo-bar'));
$this->assertEquals('foo', Bundle::handles('foo-bar/admin'));
unset(Bundle::$bundles['foo']);
}
/**
* Test the Bundle::exist method.
*
* @group laravel
*/
public function testExistMethodIndicatesIfBundleExist()
{
$this->assertTrue(Bundle::exists('dashboard'));
$this->assertFalse(Bundle::exists('foo'));
}
/**
* Test the Bundle::started method.
*
* @group laravel
*/
public function testStartedMethodIndicatesIfBundleIsStarted()
{
Bundle::register('dummy');
Bundle::start('dummy');
$this->assertTrue(Bundle::started('dummy'));
}
/**
* Test the Bundle::prefix method.
*
* @group laravel
*/
public function testPrefixMethodReturnsCorrectPrefix()
{
$this->assertEquals('dummy::', Bundle::prefix('dummy'));
$this->assertEquals('', Bundle::prefix(DEFAULT_BUNDLE));
}
/**
* Test the Bundle::class_prefix method.
*
* @group laravel
*/
public function testClassPrefixMethodReturnsProperClassPrefixForBundle()
{
$this->assertEquals('Dummy_', Bundle::class_prefix('dummy'));
$this->assertEquals('', Bundle::class_prefix(DEFAULT_BUNDLE));
}
/**
* Test the Bundle::path method.
*
* @group laravel
*/
public function testPathMethodReturnsCorrectPath()
{
$this->assertEquals(path('app'), Bundle::path(null));
$this->assertEquals(path('app'), Bundle::path(DEFAULT_BUNDLE));
$this->assertEquals(path('bundle').'dashboard'.DS, Bundle::path('dashboard'));
}
/**
* Test the Bundle::asset method.
*
* @group laravel
*/
public function testAssetPathReturnsPathToBundlesAssets()
{
Config::set('application.url', 'http://localhost');
$this->assertEquals('http://localhost/bundles/dashboard/', Bundle::assets('dashboard'));
$this->assertEquals('http://localhost/', Bundle::assets(DEFAULT_BUNDLE));
Config::set('application.url', '');
}
/**
* Test the Bundle::name method.
*
* @group laravel
*/
public function testBundleNameCanBeRetrievedFromIdentifier()
{
$this->assertEquals(DEFAULT_BUNDLE, Bundle::name('something'));
$this->assertEquals(DEFAULT_BUNDLE, Bundle::name('something.else'));
$this->assertEquals('bundle', Bundle::name('bundle::something.else'));
}
/**
* Test the Bundle::element method.
*
* @group laravel
*/
public function testElementCanBeRetrievedFromIdentifier()
{
$this->assertEquals('something', Bundle::element('something'));
$this->assertEquals('something.else', Bundle::element('something.else'));
$this->assertEquals('something.else', Bundle::element('bundle::something.else'));
}
/**
* Test the Bundle::identifier method.
*
* @group laravel
*/
public function testIdentifierCanBeConstructed()
{
$this->assertEquals('something.else', Bundle::identifier(DEFAULT_BUNDLE, 'something.else'));
$this->assertEquals('dashboard::something', Bundle::identifier('dashboard', 'something'));
$this->assertEquals('dashboard::something.else', Bundle::identifier('dashboard', 'something.else'));
}
/**
* Test the Bundle::resolve method.
*
* @group laravel
*/
public function testBundleNamesCanBeResolved()
{
$this->assertEquals(DEFAULT_BUNDLE, Bundle::resolve('foo'));
$this->assertEquals('dashboard', Bundle::resolve('dashboard'));
}
/**
* Test the Bundle::parse method.
*
* @group laravel
*/
public function testParseMethodReturnsElementAndIdentifier()
{
$this->assertEquals(array('application', 'something'), Bundle::parse('something'));
$this->assertEquals(array('application', 'something.else'), Bundle::parse('something.else'));
$this->assertEquals(array('dashboard', 'something'), Bundle::parse('dashboard::something'));
$this->assertEquals(array('dashboard', 'something.else'), Bundle::parse('dashboard::something.else'));
}
/**
* Test the Bundle::get method.
*
* @group laravel
*/
public function testOptionMethodReturnsBundleOption()
{
$this->assertFalse(Bundle::option('dashboard', 'auto'));
$this->assertEquals('dashboard', Bundle::option('dashboard', 'location'));
}
/**
* Test the Bundle::all method.
*
* @group laravel
*/
public function testAllMethodReturnsBundleArray()
{
Bundle::register('foo');
$this->assertEquals(Bundle::$bundles, Bundle::all());
unset(Bundle::$bundles['foo']);
}
/**
* Test the Bundle::names method.
*
* @group laravel
*/
public function testNamesMethodReturnsBundleNames()
{
Bundle::register('foo');
$this->assertEquals(array('dashboard', 'dummy', 'foo'), Bundle::names());
unset(Bundle::$bundles['foo']);
}
}

79
tests/cases/config.test.php
View File

@ -1,79 +0,0 @@
<?php
class ConfigTest extends PHPUnit_Framework_TestCase {
/**
* Tear down the testing environment.
*/
public function tearDown()
{
Config::$items = array();
Config::$cache = array();
}
/**
* Test the Config::get method.
*
* @group laravel
*/
public function testItemsCanBeRetrievedFromConfigFiles()
{
$this->assertEquals('UTF-8', Config::get('application.encoding'));
$this->assertEquals('mysql', Config::get('database.connections.mysql.driver'));
$this->assertEquals('dashboard', Config::get('dashboard::meta.bundle'));
}
/**
* Test the Config::has method.
*
* @group laravel
*/
public function testHasMethodIndicatesIfConfigItemExists()
{
$this->assertFalse(Config::has('application.foo'));
$this->assertTrue(Config::has('application.encoding'));
}
/**
* Test the Config::set method.
*
* @group laravel
*/
public function testConfigItemsCanBeSet()
{
Config::set('application.encoding', 'foo');
Config::set('dashboard::meta.bundle', 'bar');
$this->assertEquals('foo', Config::get('application.encoding'));
$this->assertEquals('bar', Config::get('dashboard::meta.bundle'));
}
/**
* Test that environment configurations are loaded correctly.
*
* @group laravel
*/
public function testEnvironmentConfigsOverrideNormalConfigurations()
{
$_SERVER['LARAVEL_ENV'] = 'local';
$this->assertEquals('sqlite', Config::get('database.default'));
unset($_SERVER['LARAVEL_ENV']);
}
/**
* Test that items can be set after the entire file has already been loaded.
*
* @group laravel
*/
public function testItemsCanBeSetAfterEntireFileIsLoaded()
{
Config::get('application');
Config::set('application.key', 'taylor');
$application = Config::get('application');
$this->assertEquals('taylor', $application['key']);
}
}

264
tests/cases/controller.test.php
View File

@ -1,264 +0,0 @@
<?php
class ControllerTest extends PHPUnit_Framework_TestCase {
/**
* Setup the testing environment.
*/
public function setUp()
{
$_SERVER['REQUEST_METHOD'] = 'GET';
}
/**
* Tear down the testing environment.
*/
public function tearDown()
{
unset(Filter::$filters['test-all-before']);
unset(Filter::$filters['test-all-after']);
unset(Filter::$filters['test-profile-before']);
unset($_SERVER['REQUEST_METHOD']);
}
/**
* Test the Controller::call method.
*
* @group laravel
*/
public function testBasicControllerActionCanBeCalled()
{
$this->assertEquals('action_index', Controller::call('auth@index')->content);
$this->assertEquals('Admin_Panel_Index', Controller::call('admin.panel@index')->content);
$this->assertEquals('Taylor', Controller::call('auth@profile', array('Taylor'))->content);
$this->assertEquals('Dashboard_Panel_Index', Controller::call('dashboard::panel@index')->content);
}
/**
* Test basic controller filters are called.
*
* @group laravel
*/
public function testAssignedBeforeFiltersAreRun()
{
$_SERVER['test-all-after'] = false;
$_SERVER['test-all-before'] = false;
Controller::call('filter@index');
$this->assertTrue($_SERVER['test-all-after']);
$this->assertTrue($_SERVER['test-all-before']);
}
/**
* Test that "only" filters only apply to their assigned methods.
*
* @group laravel
*/
public function testOnlyFiltersOnlyApplyToTheirAssignedMethods()
{
$_SERVER['test-profile-before'] = false;
Controller::call('filter@index');
$this->assertFalse($_SERVER['test-profile-before']);
Controller::call('filter@profile');
$this->assertTrue($_SERVER['test-profile-before']);
}
/**
* Test that "except" filters only apply to the excluded methods.
*
* @group laravel
*/
public function testExceptFiltersOnlyApplyToTheExlucdedMethods()
{
$_SERVER['test-except'] = false;
Controller::call('filter@index');
Controller::call('filter@profile');
$this->assertFalse($_SERVER['test-except']);
Controller::call('filter@show');
$this->assertTrue($_SERVER['test-except']);
}
/**
* Test that filters can be constrained by the request method.
*
* @group laravel
*/
public function testFiltersCanBeConstrainedByRequestMethod()
{
$_SERVER['test-on-post'] = false;
$_SERVER['REQUEST_METHOD'] = 'GET';
Controller::call('filter@index');
$this->assertFalse($_SERVER['test-on-post']);
$_SERVER['REQUEST_METHOD'] = 'POST';
Controller::call('filter@index');
$this->assertTrue($_SERVER['test-on-post']);
$_SERVER['test-on-get-put'] = false;
$_SERVER['REQUEST_METHOD'] = 'POST';
Controller::call('filter@index');
$this->assertFalse($_SERVER['test-on-get-put']);
$_SERVER['REQUEST_METHOD'] = 'PUT';
Controller::call('filter@index');
$this->assertTrue($_SERVER['test-on-get-put']);
}
public function testGlobalBeforeFilterIsNotCalledByController()
{
$_SERVER['before'] = false;
$_SERVER['after'] = false;
Controller::call('auth@index');
$this->assertFalse($_SERVER['before']);
$this->assertFalse($_SERVER['after']);
}
/**
* Test that before filters can override the controller response.
*
* @group laravel
*/
public function testBeforeFiltersCanOverrideResponses()
{
$this->assertEquals('Filtered!', Controller::call('filter@login')->content);
}
/**
* Test that after filters do not affect the response.
*
* @group laravel
*/
public function testAfterFiltersDoNotAffectControllerResponse()
{
$this->assertEquals('action_logout', Controller::call('filter@logout')->content);
}
/**
* Test that filter parameters are passed to the filter.
*
* @group laravel
*/
public function testFilterParametersArePassedToTheFilter()
{
$this->assertEquals('12', Controller::call('filter@edit')->content);
}
/**
* Test that multiple filters can be assigned to a single method.
*
* @group laravel
*/
public function testMultipleFiltersCanBeAssignedToAnAction()
{
$_SERVER['test-multi-1'] = false;
$_SERVER['test-multi-2'] = false;
Controller::call('filter@save');
$this->assertTrue($_SERVER['test-multi-1']);
$this->assertTrue($_SERVER['test-multi-2']);
}
/**
* Test Restful controllers respond by request method.
*
* @group laravel
*/
public function testRestfulControllersRespondWithRestfulMethods()
{
$_SERVER['REQUEST_METHOD'] = 'GET';
$this->assertEquals('get_index', Controller::call('restful@index')->content);
$_SERVER['REQUEST_METHOD'] = 'PUT';
$this->assertEquals(404, Controller::call('restful@index')->status);
$_SERVER['REQUEST_METHOD'] = 'POST';
$this->assertEquals('post_index', Controller::call('restful@index')->content);
}
/**
* Test that the template is returned by template controllers.
*
* @group laravel
*/
public function testTemplateControllersReturnTheTemplate()
{
$response = Controller::call('template.basic@index');
$home = file_get_contents(path('app').'views/home/index.php');
$this->assertEquals($home, $response->content);
}
/**
* Test that controller templates can be named views.
*
* @group laravel
*/
public function testControllerTemplatesCanBeNamedViews()
{
View::name('home.index', 'home');
$response = Controller::call('template.named@index');
$home = file_get_contents(path('app').'views/home/index.php');
$this->assertEquals($home, $response->content);
View::$names = array();
}
/**
* Test that the "layout" method is called on the controller.
*
* @group laravel
*/
public function testTheTemplateCanBeOverriden()
{
$this->assertEquals('Layout', Controller::call('template.override@index')->content);
}
/**
* Test the Controller::resolve method.
*
* @group laravel
*/
public function testResolveMethodChecksTheIoCContainer()
{
IoC::controller('home', function()
{
require_once path('app').'controllers/home.php';
$controller = new Home_Controller;
$controller->foo = 'bar';
return $controller;
});
$controller = Controller::resolve(DEFAULT_BUNDLE, 'home');
$this->assertEquals('bar', $controller->foo);
}
}

140
tests/cases/cookie.test.php
View File

@ -1,140 +0,0 @@
<?php namespace Laravel;
/**
* Stub the global setcookie method into the Laravel namespace.
*/
function setcookie($name, $value, $time, $path, $domain, $secure)
{
$_SERVER['cookie.stub'][$name] = compact('name', 'value', 'time', 'path', 'domain', 'secure');
}
function headers_sent()
{
return $_SERVER['function.headers_sent'];
}
class CookieTest extends \PHPUnit_Framework_TestCase {
/**
* Setup the test environment.
*/
public function setUp()
{
Cookie::$jar = array();
}
/**
* Tear down the test environment.
*/
public function tearDown()
{
Cookie::$jar = array();
}
/**
* Test Cookie::has method.
*
* @group laravel
*/
public function testHasMethodIndicatesIfCookieInSet()
{
Cookie::$jar['foo'] = array('value' => 'bar');
$this->assertTrue(Cookie::has('foo'));
$this->assertFalse(Cookie::has('bar'));
Cookie::put('baz', 'foo');
$this->assertTrue(Cookie::has('baz'));
}
/**
* Test the Cookie::get method.
*
* @group laravel
*/
public function testGetMethodCanReturnValueOfCookies()
{
Cookie::$jar['foo'] = array('value' => 'bar');
$this->assertEquals('bar', Cookie::get('foo'));
Cookie::put('bar', 'baz');
$this->assertEquals('baz', Cookie::get('bar'));
}
/**
* Test the Cookie::get method respects signatures.
*
* @group laravel
*/
public function testTamperedCookiesAreReturnedAsNull()
{
$_COOKIE['foo'] = Cookie::sign('foo', 'bar');
$this->assertEquals('bar', Cookie::get('foo'));
$_COOKIE['foo'] .= '-baz';
$this->assertNull(Cookie::get('foo'));
$_COOKIE['foo'] = Cookie::sign('foo', 'bar');
$_COOKIE['foo'] = 'aslk'.$_COOKIE['foo'];
$this->assertNull(Cookie::get('foo'));
}
/**
* Test Cookie::forever method.
*
* @group laravel
*/
public function testForeverShouldUseATonOfMinutes()
{
Cookie::forever('foo', 'bar');
$this->assertEquals('bar', Cookie::$jar['foo']['value']);
$this->assertEquals(525600, Cookie::$jar['foo']['minutes']);
Cookie::forever('bar', 'baz', 'path', 'domain', true);
$this->assertEquals('path', Cookie::$jar['bar']['path']);
$this->assertEquals('domain', Cookie::$jar['bar']['domain']);
$this->assertTrue(Cookie::$jar['bar']['secure']);
}
/**
* Test the Cookie::forget method.
*
* @group laravel
*/
public function testForgetSetsCookieWithExpiration()
{
Cookie::forget('bar', 'path', 'domain', true);
$this->assertEquals(-2000, Cookie::$jar['bar']['minutes']);
$this->assertEquals('path', Cookie::$jar['bar']['path']);
$this->assertEquals('domain', Cookie::$jar['bar']['domain']);
$this->assertTrue(Cookie::$jar['bar']['secure']);
}
/**
* Test the Cookie::send method.
*
* @group laravel
*/
public function testSendMethodSetsProperValuesOnCookie()
{
$_SERVER['cookie.stub'] = array();
$_SERVER['function.headers_sent'] = false;
Cookie::send();
$this->assertTrue(count($_SERVER['cookie.stub']) == 0);
Cookie::put('foo', 'bar', 20, 'path', 'domain', true);
Cookie::send();
$this->assertTrue(count($_SERVER['cookie.stub']) == 1);
$this->assertEquals('foo', $_SERVER['cookie.stub']['foo']['name']);
$this->assertEquals(Cookie::sign('foo', 'bar'), $_SERVER['cookie.stub']['foo']['value']);
$this->assertEquals('path', $_SERVER['cookie.stub']['foo']['path']);
$this->assertEquals('domain', $_SERVER['cookie.stub']['foo']['domain']);
$this->assertEquals((time() + (20 * 60)), $_SERVER['cookie.stub']['foo']['time']);
$this->assertTrue($_SERVER['cookie.stub']['foo']['secure']);
Cookie::put('bar', 'baz', 0);
Cookie::send();
$this->assertEquals(0, $_SERVER['cookie.stub']['bar']['time']);
}
}

74
tests/cases/database.test.php
View File

@ -1,74 +0,0 @@
<?php
class DatabaseTest extends PHPUnit_Framework_TestCase {
/**
* Set up the test environment.
*/
public function setUp()
{
DB::$connections = array();
}
/**
* Tear down the test environment.
*/
public function tearDown()
{
DB::$connections = array();
}
/**
* Test the DB::connection method.
*
* @group laravel
*/
public function testConnectionMethodReturnsConnection()
{
$connection = DatabaseConnectStub::connection();
$this->assertTrue(isset(DB::$connections[Config::get('database.default')]));
$connection = DatabaseConnectStub::connection('mysql');
$this->assertTrue(isset(DB::$connections['mysql']));
$this->assertEquals(DB::$connections['mysql']->pdo->laravel_config, Config::get('database.connections.mysql'));
}
/**
* Test the DB::profile method.
*
* @group laravel
*/
public function testProfileMethodReturnsQueries()
{
Laravel\Database\Connection::$queries = array('Taylor');
$this->assertEquals(array('Taylor'), DB::profile());
Laravel\Database\Connection::$queries = array();
}
/**
* Test the __callStatic method.
*
* @group laravel
*/
public function testConnectionMethodsCanBeCalledStaticly()
{
$this->assertEquals('sqlite', DB::driver());
}
}
class DatabaseConnectStub extends Laravel\Database {
protected static function connect($config) { return new PDOStub($config); }
}
class PDOStub extends PDO {
public $laravel_config;
public function __construct($config) { $this->laravel_config = $config; }
public function foo() { return 'foo'; }
}

43
tests/cases/event.test.php
View File

@ -1,43 +0,0 @@
<?php
class EventTest extends PHPUnit_Framework_TestCase {
/**
* Tear down the testing environment.
*/
public function tearDown()
{
unset(Event::$events['test.event']);
}
/**
* Test basic event firing.
*
* @group laravel
*/
public function testListenersAreFiredForEvents()
{
Event::listen('test.event', function() { return 1; });
Event::listen('test.event', function() { return 2; });
$responses = Event::fire('test.event');
$this->assertEquals(1, $responses[0]);
$this->assertEquals(2, $responses[1]);
}
/**
* Test parameters can be passed to event listeners.
*
* @group laravel
*/
public function testParametersCanBePassedToEvents()
{
Event::listen('test.event', function($var) { return $var; });
$responses = Event::fire('test.event', array('Taylor'));
$this->assertEquals('Taylor', $responses[0]);
}
}

50
tests/cases/fluent.test.php
View File

@ -1,50 +0,0 @@
<?php
use Laravel\Fluent;
class FluentTest extends PHPUnit_Framework_TestCase {
/**
* Test the Fluent constructor.
*
* @group laravel
*/
public function testAttributesAreSetByConstructor()
{
$array = array('name' => 'Taylor', 'age' => 25);
$fluent = new FLuent($array);
$this->assertEquals($array, $fluent->attributes);
}
/**
* Test the Fluent::get method.
*
* @group laravel
*/
public function testGetMethodReturnsAttribute()
{
$fluent = new Fluent(array('name' => 'Taylor'));
$this->assertEquals('Taylor', $fluent->get('name'));
$this->assertEquals('Default', $fluent->get('foo', 'Default'));
$this->assertEquals('Taylor', $fluent->name);
$this->assertNull($fluent->foo);
}
public function testMagicMethodsCanBeUsedToSetAttributes()
{
$fluent = new FLuent;
$fluent->name = 'Taylor';
$fluent->developer();
$fluent->age(25);
$this->assertEquals('Taylor', $fluent->name);
$this->assertTrue($fluent->developer);
$this->assertEquals(25, $fluent->age);
$this->assertInstanceOf('Laravel\\Fluent', $fluent->programmer());
}
}

37
tests/cases/hash.test.php
View File

@ -1,37 +0,0 @@
<?php
class HashTest extends PHPUnit_Framework_TestCase {
/**
* Test the Hash::make method.
*
* @group laravel
*/
public function testHashProducesValidBcryptHash()
{
$this->assertTrue(strlen(Hash::make('taylor')) == 60);
}
/**
* Test the Hash::check method.
*
* @group laravel
*/
public function testHashCheckFailsWhenNotMatching()
{
$hash = Hash::make('taylor');
$this->assertFalse(Hash::check('foo', $hash));
}
/**
* Test the Hash::check method.
*
* @group laravel
*/
public function testHashCheckPassesWhenMatches()
{
$this->assertTrue(Hash::check('taylor', Hash::make('taylor')));
}
}

172
tests/cases/input.test.php
View File

@ -1,172 +0,0 @@
<?php
class InputTest extends PHPUnit_Framework_TestCase {
/**
* Setup the testing environment.
*/
public function setUp()
{
Config::set('application.key', 'foo');
}
/**
* Tear down the testing environemnt.
*/
public function tearDown()
{
Input::$input = array();
Config::set('application.key', '');
Session::$instance = null;
}
/**
* Test the Input::all method.
*
* @group laravel
*/
public function testAllMethodReturnsInputAndFiles()
{
Input::$input = array('name' => 'Taylor');
$_FILES = array('age' => 25);
$this->assertEquals(Input::all(), array('name' => 'Taylor', 'age' => 25));
}
/**
* Test the Input::has method.
*
* @group laravel
*/
public function testHasMethodIndicatesTheExistenceOfInput()
{
$this->assertFalse(Input::has('foo'));
Input::$input = array('name' => 'Taylor');
$this->assertTrue(Input::has('name'));
}
/**
* Test the Input::get method.
*
* @group laravel
*/
public function testGetMethodReturnsInputValue()
{
Input::$input = array('name' => 'Taylor');
$this->assertEquals('Taylor', Input::get('name'));
$this->assertEquals('Default', Input::get('foo', 'Default'));
}
/**
* Test the Input::only method.
*
* @group laravel
*/
public function testOnlyMethodReturnsSubsetOfInput()
{
Input::$input = array('name' => 'Taylor', 'age' => 25);
$this->assertEquals(array('name' => 'Taylor'), Input::only(array('name')));
}
/**
* Test the Input::except method.
*
* @group laravel
*/
public function testExceptMethodReturnsSubsetOfInput()
{
Input::$input = array('name' => 'Taylor', 'age' => 25);
$this->assertEquals(array('age' => 25), Input::except(array('name')));
}
/**
* Test the Input::old method.
*
* @group laravel
*/
public function testOldInputCanBeRetrievedFromSession()
{
$this->setSession();
Session::$instance->session['data']['laravel_old_input'] = array('name' => 'Taylor');
$this->assertNull(Input::old('foo'));
$this->assertTrue(Input::had('name'));
$this->assertFalse(Input::had('foo'));
$this->assertEquals('Taylor', Input::old('name'));
}
/**
* Test the Input::file method.
*
* @group laravel
*/
public function testFileMethodReturnsFromFileArray()
{
$_FILES['foo'] = array('name' => 'Taylor', 'size' => 100);
$this->assertEquals('Taylor', Input::file('foo.name'));
$this->assertEquals(array('name' => 'Taylor', 'size' => 100), Input::file('foo'));
}
/**
* Test the Input::flash method.
*
* @group laravel
*/
public function testFlashMethodFlashesInputToSession()
{
$this->setSession();
Input::$input = $input = array('name' => 'Taylor', 'age' => 25);
Input::flash();
$this->assertEquals($input, Session::$instance->session['data'][':new:']['laravel_old_input']);
Input::flash('only', array('name'));
$this->assertEquals(array('name' => 'Taylor'), Session::$instance->session['data'][':new:']['laravel_old_input']);
Input::flash('except', array('name'));
$this->assertEquals(array('age' => 25), Session::$instance->session['data'][':new:']['laravel_old_input']);
}
/**
* Test the Input::flush method.
*
* @group laravel
*/
public function testFlushMethodClearsFlashedInput()
{
$this->setSession();
Input::$input = $input = array('name' => 'Taylor');
Input::flash();
$this->assertEquals($input, Session::$instance->session['data'][':new:']['laravel_old_input']);
Input::flush();
$this->assertEquals(array(), Session::$instance->session['data'][':new:']['laravel_old_input']);
}
/**
* Set the session payload instance.
*/
protected function setSession()
{
$driver = $this->getMock('Laravel\\Session\\Drivers\\Driver');
Session::$instance = new Laravel\Session\Payload($driver);
}
}

86
tests/cases/ioc.test.php
View File

@ -1,86 +0,0 @@
<?php
class IoCTest extends PHPUnit_Framework_TestCase {
/**
* Test IoC::register and IoC::resolve.
*
* @group laravel
*/
public function testRegisteredClassCanBeResolved()
{
IoC::register('foo', function()
{
return 'Taylor';
});
$this->assertEquals('Taylor', IoC::resolve('foo'));
}
/**
* Test that singletons are created once.
*
* @group laravel
*/
public function testSingletonsAreCreatedOnce()
{
IoC::singleton('foo', function()
{
return new StdClass;
});
$object = IoC::resolve('foo');
$this->assertTrue($object === IoC::resolve('foo'));
}
/**
* Test the IoC::instance method.
*
* @group laravel
*/
public function testInstancesAreReturnedBySingleton()
{
$object = new StdClass;
IoC::instance('bar', $object);
$this->assertTrue($object === IoC::resolve('bar'));
}
/**
* Test the IoC::registered method.
*/
public function testRegisteredMethodIndicatesIfRegistered()
{
IoC::register('foo', function() {});
$this->assertTrue(IoC::registered('foo'));
$this->assertFalse(IoC::registered('baz'));
}
/**
* Test the IoC::controller method.
*
* @group laravel
*/
public function testControllerMethodRegistersAController()
{
IoC::controller('ioc.test', function() {});
$this->assertTrue(IoC::registered('controller: ioc.test'));
}
/**
* Test the IoC::core method.
*
* @group laravel
*/
public function testCoreMethodReturnsFromLaravel()
{
IoC::register('laravel.ioc.test', function() { return 'Taylor'; });
$this->assertEquals('Taylor', IoC::core('ioc.test'));
}
}

68
tests/cases/lang.test.php
View File

@ -1,68 +0,0 @@
<?php
class LangTest extends PHPUnit_Framework_TestCase {
/**
* Test the Lang::line method.
*
* @group laravel
*/
public function testGetMethodCanGetFromDefaultLanguage()
{
$validation = require path('app').'language/en/validation.php';
$this->assertEquals($validation['required'], Lang::line('validation.required')->get());
$this->assertEquals('Taylor', Lang::line('validation.foo')->get(null, 'Taylor'));
}
/**
* Test the Lang::line method.
*
* @group laravel
*/
public function testGetMethodCanGetLinesForAGivenLanguage()
{
$validation = require path('app').'language/sp/validation.php';
$this->assertEquals($validation['required'], Lang::line('validation.required')->get('sp'));
}
/**
* Test the __toString method.
*
* @group laravel
*/
public function testLineCanBeCastAsString()
{
$validation = require path('app').'language/en/validation.php';
$this->assertEquals($validation['required'], (string) Lang::line('validation.required'));
}
/**
* Test that string replacements are made on lines.
*
* @group laravel
*/
public function testReplacementsAreMadeOnLines()
{
$validation = require path('app').'language/en/validation.php';
$line = str_replace(':attribute', 'e-mail', $validation['required']);
$this->assertEquals($line, Lang::line('validation.required', array('attribute' => 'e-mail'))->get());
}
/**
* Test the Lang::has method.
*
* @group laravel
*/
public function testHasMethodIndicatesIfLangaugeLineExists()
{
$this->assertTrue(Lang::has('validation'));
$this->assertTrue(Lang::has('validation.required'));
$this->assertFalse(Lang::has('validation.foo'));
}
}

115
tests/cases/messages.test.php
View File

@ -1,115 +0,0 @@
<?php
class MessagesTest extends PHPUnit_Framework_TestCase {
/**
* The Messages instance.
*
* @var Messages
*/
public $messages;
/**
* Setup the test environment.
*/
public function setUp()
{
$this->messages = new Laravel\Messages;
}
/**
* Test the Messages::add method.
*
* @group laravel
*/
public function testAddingMessagesDoesNotCreateDuplicateMessages()
{
$this->messages->add('email', 'test');
$this->messages->add('email', 'test');
$this->assertCount(1, $this->messages->messages);
}
/**
* Test the Messages::add method.
*
* @group laravel
*/
public function testAddMethodPutsMessageInMessagesArray()
{
$this->messages->add('email', 'test');
$this->assertArrayHasKey('email', $this->messages->messages);
$this->assertEquals('test', $this->messages->messages['email'][0]);
}
/**
* Test the Messages::has method.
*
* @group laravel
*/
public function testHasMethodReturnsTrue()
{
$this->messages->add('email', 'test');
$this->assertTrue($this->messages->has('email'));
}
/**
* Test the Messages::has method.
*
* @group laravel
*/
public function testHasMethodReturnsFalse()
{
$this->assertFalse($this->messages->has('something'));
}
/**
* Test the Messages::first method.
*
* @group laravel
*/
public function testFirstMethodReturnsSingleString()
{
$this->messages->add('email', 'test');
$this->assertEquals('test', $this->messages->first('email'));
$this->assertEquals('', $this->messages->first('something'));
}
/**
* Test the Messages::get method.
*
* @group laravel
*/
public function testGetMethodReturnsAllMessagesForAttribute()
{
$messages = array('email' => array('something', 'else'));
$this->messages->messages = $messages;
$this->assertEquals(array('something', 'else'), $this->messages->get('email'));
}
/**
* Test the Messages::all method.
*
* @group laravel
*/
public function testAllMethodReturnsAllErrorMessages()
{
$messages = array('email' => array('something', 'else'), 'name' => array('foo'));
$this->messages->messages = $messages;
$this->assertEquals(array('something', 'else', 'foo'), $this->messages->all());
}
/**
* Test the Messages::get method.
*
* @group laravel
*/
public function testMessagesRespectFormat()
{
$this->messages->add('email', 'test');
$this->assertEquals('<p>test</p>', $this->messages->first('email', '<p>:message</p>'));
$this->assertEquals(array('<p>test</p>'), $this->messages->get('email', '<p>:message</p>'));
$this->assertEquals(array('<p>test</p>'), $this->messages->all('<p>:message</p>'));
}
}

48
tests/cases/query.test.php
View File

@ -1,48 +0,0 @@
<?php
class QueryTest extends PHPUnit_Framework_TestCase {
/**
* Test the "find" method.
*
* @group laravel
*/
public function testFindMethodCanReturnByID()
{
$this->assertEquals('taylor@example.com', $this->query()->find(1)->email);
}
/**
* Test the select method.
*
* @group laravel
*/
public function testSelectMethodLimitsColumns()
{
$result = $this->query()->select(array('email'))->first();
$this->assertTrue(isset($result->email));
$this->assertFalse(isset($result->name));
}
/**
* Test the raw_where method.
*
* @group laravel
*/
public function testRawWhereCanBeUsed()
{
}
/**
* Get the query instance for the test case.
*
* @return Query
*/
protected function query()
{
return DB::table('query_test');
}
}

142
tests/cases/redirect.test.php
View File

@ -1,142 +0,0 @@
<?php
use Laravel\Routing\Router;
class RedirectTest extends PHPUnit_Framework_TestCase {
/**
* Setup the test environment.
*/
public function setUp()
{
Config::set('session.driver', 'foo');
Router::$routes = array();
Router::$names = array();
Config::set('application.url', 'http://localhost');
Config::set('application.index', '');
}
/**
* Destroy the test environment.
*/
public function tearDown()
{
Input::$input = array();
Config::set('session.driver', '');
Router::$routes = array();
Router::$names = array();
Config::set('application.url', '');
Config::set('application.index', 'index.php');
Session::$instance = null;
}
/**
* Test the Redirect::to method.
*
* @group laravel
*/
public function testSimpleRedirectSetsCorrectHeaders()
{
$redirect = Redirect::to('user/profile');
$this->assertEquals(302, $redirect->status);
$this->assertEquals('http://localhost/user/profile', $redirect->headers['location']);
$redirect = Redirect::to('user/profile', 301, true);
$this->assertEquals(301, $redirect->status);
$this->assertEquals('https://localhost/user/profile', $redirect->headers['location']);
$redirect = Redirect::to_secure('user/profile', 301);
$this->assertEquals(301, $redirect->status);
$this->assertEquals('https://localhost/user/profile', $redirect->headers['location']);
}
/**
* Test the Redirect::to_route method.
*
* @group laravel
*/
public function testRedirectsCanBeGeneratedForNamedRoutes()
{
Route::get('redirect', array('as' => 'redirect'));
Route::get('redirect/(:any)/(:any)', array('as' => 'redirect-2'));
Route::get('secure/redirect', array('https' => true, 'as' => 'redirect-3'));
$this->assertEquals(301, Redirect::to_route('redirect', array(), 301, true)->status);
$this->assertEquals('http://localhost/redirect', Redirect::to_route('redirect')->headers['location']);
$this->assertEquals('https://localhost/secure/redirect', Redirect::to_route('redirect-3', array(), 302)->headers['location']);
$this->assertEquals('http://localhost/redirect/1/2', Redirect::to_route('redirect-2', array('1', '2'))->headers['location']);
}
/**
* Test the Redirect::with method.
*
* @group laravel
*/
public function testWithMethodFlashesItemToSession()
{
$this->setSession();
$redirect = Redirect::to('')->with('name', 'Taylor');
$this->assertEquals('Taylor', Session::$instance->session['data'][':new:']['name']);
}
/**
* Test the Redirect::with_input function.
*
* @group laravel
*/
public function testWithInputMethodFlashesInputToTheSession()
{
$this->setSession();
Input::$input = $input = array('name' => 'Taylor', 'age' => 25);
$redirect = Redirect::to('')->with_input();
$this->assertEquals($input, Session::$instance->session['data'][':new:']['laravel_old_input']);
$redirect = Redirect::to('')->with_input('only', array('name'));
$this->assertEquals(array('name' => 'Taylor'), Session::$instance->session['data'][':new:']['laravel_old_input']);
$redirect = Redirect::to('')->with_input('except', array('name'));
$this->assertEquals(array('age' => 25), Session::$instance->session['data'][':new:']['laravel_old_input']);
}
/**
* Test the Redirect::with_errors method.
*
* @group laravel
*/
public function testWithErrorsFlashesErrorsToTheSession()
{
$this->setSession();
Redirect::to('')->with_errors(array('name' => 'Taylor'));
$this->assertEquals(array('name' => 'Taylor'), Session::$instance->session['data'][':new:']['errors']);
$validator = Validator::make(array(), array());
$validator->errors = array('name' => 'Taylor');
Redirect::to('')->with_errors($validator);
$this->assertEquals(array('name' => 'Taylor'), Session::$instance->session['data'][':new:']['errors']);
}
/**
* Set the session payload instance.
*/
protected function setSession()
{
$driver = $this->getMock('Laravel\\Session\\Drivers\\Driver');
Session::$instance = new Laravel\Session\Payload($driver);
}
}

145
tests/cases/request.test.php
View File

@ -1,145 +0,0 @@
<?php
class SessionPayloadTokenStub {
public function token() { return 'Taylor'; }
}
class RequestTest extends PHPUnit_Framework_TestCase {
/**
* Tear down the test environment.
*/
public function tearDown()
{
$_POST = array();
$_SERVER = array();
Request::$route = null;
Session::$instance = null;
}
/**
* Test the Request::method method.
*
* @group laravel
*/
public function testMethodReturnsTheHTTPRequestMethod()
{
$_SERVER['REQUEST_METHOD'] = 'POST';
$this->assertEquals('POST', Request::method());
$_POST[Request::spoofer] = 'PUT';
$this->assertEquals('PUT', Request::method());
}
/**
* Test the Request::server method.
*
* @group laravel
*/
public function testServerMethodReturnsFromServerArray()
{
$_SERVER = array('TEST' => 'something', 'USER' => array('NAME' => 'taylor'));
$this->assertEquals('something', Request::server('test'));
$this->assertEquals('taylor', Request::server('user.name'));
}
/**
* Test the Request::ip method.
*
* @group laravel
*/
public function testIPMethodReturnsClientIPAddress()
{
$_SERVER['REMOTE_ADDR'] = 'something';
$this->assertEquals('something', Request::ip());
$_SERVER['HTTP_CLIENT_IP'] = 'something';
$this->assertEquals('something', Request::ip());
$_SERVER['HTTP_X_FORWARDED_FOR'] = 'something';
$this->assertEquals('something', Request::ip());
$_SERVER = array();
$this->assertEquals('0.0.0.0', Request::ip());
}
/**
* Test the Request::protocol method.
*
* @group laravel
*/
public function testProtocolMethodReturnsProtocol()
{
$_SERVER['SERVER_PROTOCOL'] = 'taylor';
$this->assertEquals('taylor', Request::protocol());
unset($_SERVER['SERVER_PROTOCOL']);
$this->assertEquals('HTTP/1.1', Request::protocol());
}
/**
* Test the Request::secure method.
*
* @group laravel
*/
public function testSecureMethodsIndicatesIfHTTPS()
{
$_SERVER['HTTPS'] = 'on';
$this->assertTrue(Request::secure());
$_SERVER['HTTPS'] = 'off';
$this->assertFalse(Request::secure());
}
/**
* Test the Request::ajax method.
*
* @group laravel
*/
public function testAjaxMethodIndicatesWhenAjax()
{
$this->assertFalse(Request::ajax());
$_SERVER['HTTP_X_REQUESTED_WITH'] = 'xmlhttprequest';
$this->assertTrue(Request::ajax());
}
/**
* Test the Request::forged method.
*
* @group laravel
*/
public function testForgedMethodIndicatesIfRequestWasForged()
{
Session::$instance = new SessionPayloadTokenStub;
Input::$input = array(Session::csrf_token => 'Foo');
$this->assertTrue(Request::forged());
Input::$input = array(Session::csrf_token => 'Taylor');
$this->assertFalse(Request::forged());
}
/**
* Test the Request::route method.
*
* @group laravel
*/
public function testRouteMethodReturnsStaticRoute()
{
Request::$route = 'Taylor';
$this->assertEquals('Taylor', Request::route());
}
}

98
tests/cases/response.test.php
View File

@ -1,98 +0,0 @@
<?php
class ResponseTest extends PHPUnit_Framework_TestCase {
/**
* Test the Response::make method.
*
* @group laravel
*/
public function testMakeMethodProperlySetsContent()
{
$response = Response::make('foo', 201, array('bar' => 'baz'));
$this->assertEquals('foo', $response->content);
$this->assertEquals(201, $response->status);
$this->assertEquals(array('bar' => 'baz'), $response->headers);
}
/**
* Test the Response::view method.
*
* @group laravel
*/
public function testViewMethodSetsContentToView()
{
$response = Response::view('home.index', array('name' => 'Taylor'));
$this->assertEquals('home.index', $response->content->view);
$this->assertEquals('Taylor', $response->content->data['name']);
}
/**
* Test the Response::error method.
*
* @group laravel
*/
public function testErrorMethodSetsContentToErrorView()
{
$response = Response::error('404', array('name' => 'Taylor'));
$this->assertEquals(404, $response->status);
$this->assertEquals('error.404', $response->content->view);
$this->assertEquals('Taylor', $response->content->data['name']);
}
/**
* Test the Response::prepare method.
*
* @group laravel
*/
public function testPrepareMethodCreatesAResponseInstanceFromGivenValue()
{
$response = Response::prepare('Taylor');
$this->assertInstanceOf('Laravel\\Response', $response);
$this->assertEquals('Taylor', $response->content);
$response = Response::prepare(new Response('Taylor'));
$this->assertInstanceOf('Laravel\\Response', $response);
$this->assertEquals('Taylor', $response->content);
}
/**
* Test the Response::message method.
*
* @group laravel
*/
public function testMessageReturnsStatusCodeMessage()
{
$this->assertEquals('OK', Response::make('')->message());
}
/**
* Test the Response::header method.
*
* @group laravel
*/
public function testHeaderMethodSetsValueInHeaderArray()
{
$response = Response::make('')->header('foo', 'bar');
$this->assertEquals('bar', $response->headers['foo']);
}
/**
* Test the Response::status method.
*
* @group laravel
*/
public function testStatusMethodSetsStatusCode()
{
$response = Response::make('')->status(404);
$this->assertEquals(404, $response->status);
}
}

179
tests/cases/route.test.php
View File

@ -1,179 +0,0 @@
<?php
use Laravel\Routing\Route;
class RouteTest extends PHPUnit_Framework_TestCase {
/**
* Tear down the testing environment.
*/
public static function tearDownAfterClass()
{
unset($_SERVER['REQUEST_METHOD']);
unset(Filter::$filters['test-after']);
unset(Filter::$filters['test-before']);
unset(Filter::$filters['test-params']);
unset(Filter::$filters['test-multi-1']);
unset(Filter::$filters['test-multi-2']);
}
/**
* Destroy the testing environment.
*/
public function tearDown()
{
Request::$route = null;
}
/**
* Tests the Route::is method.
*
* @group laravel
*/
public function testIsMethodIndicatesIfTheRouteHasAGivenName()
{
$route = new Route('GET', '/', array('as' => 'profile'));
$this->assertTrue($route->is('profile'));
$this->assertFalse($route->is('something'));
}
/**
* Test the basic execution of a route.
*
* @group laravel
*/
public function testBasicRoutesCanBeExecutedProperly()
{
$route = new Route('GET', '', array(function() { return 'Route!'; }));
$this->assertEquals('Route!', $route->call()->content);
$this->assertInstanceOf('Laravel\\Response', $route->call());
}
/**
* Test that route parameters are passed into the handlers.
*
* @group laravel
*/
public function testRouteParametersArePassedIntoTheHandler()
{
$route = new Route('GET', '', array(function($var) { return $var; }), array('Taylor'));
$this->assertEquals('Taylor', $route->call()->content);
$this->assertInstanceOf('Laravel\\Response', $route->call());
}
/**
* Test that calling a route calls the global before and after filters.
*
* @group laravel
*/
public function testCallingARouteCallsTheBeforeAndAfterFilters()
{
$route = new Route('GET', '', array(function() { return 'Hi!'; }));
$_SERVER['before'] = false;
$_SERVER['after'] = false;
$route->call();
$this->assertTrue($_SERVER['before']);
$this->assertTrue($_SERVER['after']);
}
/**
* Test that before filters override the route response.
*
* @group laravel
*/
public function testBeforeFiltersOverrideTheRouteResponse()
{
Filter::register('test-before', function()
{
return 'Filtered!';
});
$route = new Route('GET', '', array('before' => 'test-before', function() {
return 'Route!';
}));
$this->assertEquals('Filtered!', $route->call()->content);
}
/**
* Test that after filters do not affect the route response.
*
* @group laravel
*/
public function testAfterFilterDoesNotAffectTheResponse()
{
$_SERVER['test-after'] = false;
Filter::register('test-after', function()
{
$_SERVER['test-after'] = true;
return 'Filtered!';
});
$route = new Route('GET', '', array('after' => 'test-after', function()
{
return 'Route!';
}));
$this->assertEquals('Route!', $route->call()->content);
$this->assertTrue($_SERVER['test-after']);
}
/**
* Test that the route calls the appropriate controller method when delegating.
*
* @group laravel
*/
public function testControllerActionCalledWhenDelegating()
{
$_SERVER['REQUEST_METHOD'] = 'GET';
$route = new Route('GET', '', array('uses' => 'auth@index'));
$this->assertEquals('action_index', $route->call()->content);
}
/**
* Test that filter parameters are passed to the filter.
*
* @group laravel
*/
public function testFilterParametersArePassedToFilter()
{
Filter::register('test-params', function($var1, $var2)
{
return $var1.$var2;
});
$route = new Route('GET', '', array('before' => 'test-params:1,2'));
$this->assertEquals('12', $route->call()->content);
}
/**
* Test that multiple filters can be assigned to a route.
*
* @group laravel
*/
public function testMultipleFiltersCanBeAssignedToARoute()
{
$_SERVER['test-multi-1'] = false;
$_SERVER['test-multi-2'] = false;
Filter::register('test-multi-1', function() { $_SERVER['test-multi-1'] = true; });
Filter::register('test-multi-2', function() { $_SERVER['test-multi-2'] = true; });
$route = new Route('GET', '', array('before' => 'test-multi-1|test-multi-2'));
$route->call();
$this->assertTrue($_SERVER['test-multi-1']);
$this->assertTrue($_SERVER['test-multi-2']);
}
}

160
tests/cases/routing.test.php
View File

@ -1,160 +0,0 @@
<?php
use Laravel\Routing\Router;
class RoutingTest extends PHPUnit_Framework_TestCase {
/**
* Destroy the testing environment.
*/
public function setUp()
{
Bundle::$started = array();
Bundle::$routed = array();
Router::$names = array();
Router::$routes = array();
}
/**
* Destroy the testing environment.
*/
public function tearDown()
{
Bundle::$started = array();
Bundle::$routed = array();
Router::$names = array();
Router::$routes = array();
}
/**
* Test the Router::find method.
*
* @group laravel
*/
public function testNamedRoutesCanBeLocatedByTheRouter()
{
Route::get('/', array('as' => 'home'));
Route::get('dashboard', array('as' => 'dashboard'));
$home = Router::find('home');
$dashboard = Router::find('dashboard');
$this->assertTrue(isset($home['/']));
$this->assertTrue(isset($dashboard['dashboard']));
}
/**
* Test the basic routing mechanism.
*
* @group laravel
*/
public function testBasicRouteCanBeRouted()
{
Route::get('/', function() {});
Route::get('home, main', function() {});
$this->assertEquals('/', Router::route('GET', '/')->uri);
$this->assertEquals('home', Router::route('GET', 'home')->uri);
$this->assertEquals('main', Router::route('GET', 'main')->uri);
}
/**
* Test that the router can handle basic wildcards.
*
* @group laravel
*/
public function testWildcardRoutesCanBeRouted()
{
Route::get('user/(:num)', function() {});
Route::get('profile/(:any)/(:num)', function() {});
$this->assertNull(Router::route('GET', 'user/1.5'));
$this->assertNull(Router::route('GET', 'user/taylor'));
$this->assertEquals(array(25), Router::route('GET', 'user/25')->parameters);
$this->assertEquals('user/(:num)', Router::route('GET', 'user/1')->uri);
$this->assertNull(Router::route('GET', 'profile/1/otwell'));
$this->assertNull(Router::route('POST', 'profile/taylor/1'));
$this->assertNull(Router::route('GET', 'profile/taylor/otwell'));
$this->assertNull(Router::route('GET', 'profile/taylor/1/otwell'));
$this->assertEquals(array('taylor', 25), Router::route('GET', 'profile/taylor/25')->parameters);
$this->assertEquals('profile/(:any)/(:num)', Router::route('GET', 'profile/taylor/1')->uri);
}
/**
* Test that optional wildcards can be routed.
*
* @group laravel
*/
public function testOptionalWildcardsCanBeRouted()
{
Route::get('user/(:num?)', function() {});
Route::get('profile/(:any)/(:any?)', function() {});
$this->assertNull(Router::route('GET', 'user/taylor'));
$this->assertEquals('user/(:num?)', Router::route('GET', 'user')->uri);
$this->assertEquals(array(25), Router::route('GET', 'user/25')->parameters);
$this->assertEquals('user/(:num?)', Router::route('GET', 'user/1')->uri);
$this->assertNull(Router::route('GET', 'profile/taylor/otwell/test'));
$this->assertEquals('profile/(:any)/(:any?)', Router::route('GET', 'profile/taylor')->uri);
$this->assertEquals('profile/(:any)/(:any?)', Router::route('GET', 'profile/taylor/25')->uri);
$this->assertEquals('profile/(:any)/(:any?)', Router::route('GET', 'profile/taylor/otwell')->uri);
$this->assertEquals(array('taylor', 'otwell'), Router::route('GET', 'profile/taylor/otwell')->parameters);
}
/**
* Test that basic controller routing is working.
*
* @group laravel
*/
public function testBasicRouteToControllerIsRouted()
{
$this->assertEquals('auth@(:1)', Router::route('GET', 'auth')->action['uses']);
$this->assertEquals('home@(:1)', Router::route('GET', 'home/index')->action['uses']);
$this->assertEquals('home@(:1)', Router::route('GET', 'home/profile')->action['uses']);
$this->assertEquals('admin.panel@(:1)', Router::route('GET', 'admin/panel')->action['uses']);
$this->assertEquals('admin.panel@(:1)', Router::route('GET', 'admin/panel/show')->action['uses']);
}
/**
* Test basic bundle route resolution.
*
* @group laravel
*/
public function testRoutesToBundlesCanBeResolved()
{
$this->assertNull(Router::route('GET', 'dashboard/foo'));
$this->assertEquals('dashboard', Router::route('GET', 'dashboard')->uri);
}
/**
* Test bundle controller route resolution.
*
* @group laravel
*/
public function testBundleControllersCanBeResolved()
{
$this->assertEquals('dashboard::panel@(:1)', Router::route('GET', 'dashboard/panel')->action['uses']);
$this->assertEquals('dashboard::panel@(:1)', Router::route('GET', 'dashboard/panel/show')->action['uses']);
}
/**
* Test foreign characters can be used in routes.
*
* @group laravel
*/
public function testForeignCharsInRoutes()
{
Route::get(urlencode('مدرس_رياضيات').'/(:any)', function() {});
Route::get(urlencode('مدرس_رياضيات'), function() {});
Route::get(urlencode('ÇœŪ'), function() {});
Route::get(urlencode('私は料理が大好き'), function() {});
$this->assertEquals(array(urlencode('مدرس_رياضيات')), Router::route('GET', urlencode('مدرس_رياضيات').'/'.urlencode('مدرس_رياضيات'))->parameters);
$this->assertEquals(urlencode('مدرس_رياضيات'), Router::route('GET', urlencode('مدرس_رياضيات'))->uri);
$this->assertEquals(urlencode('ÇœŪ'), Router::route('GET', urlencode('ÇœŪ'))->uri);
$this->assertEquals(urlencode('私は料理が大好き'), Router::route('GET', urlencode('私は料理が大好き'))->uri);
}
}

441
tests/cases/session.test.php
View File

@ -1,441 +0,0 @@
<?php
use Laravel\Session;
use Laravel\Session\Payload;
class DummyPayload {
public function test() { return 'Foo'; }
}
class SessionTest extends PHPUnit_Framework_TestCase {
/**
* Setup the testing environment.
*/
public function setUp()
{
Config::set('application.key', 'foo');
Session::$instance = null;
}
/**
* Tear down the testing environment.
*/
public function tearDown()
{
Config::set('application.key', '');
Session::$instance = null;
}
/**
* Test the __callStatic method.
*
* @group laravel
*/
public function testPayloadCanBeCalledStaticly()
{
Session::$instance = new DummyPayload;
$this->assertEquals('Foo', Session::test());
}
/**
* Test the Session::started method.
*
* @group laravel
*/
public function testStartedMethodIndicatesIfSessionIsStarted()
{
$this->assertFalse(Session::started());
Session::$instance = 'foo';
$this->assertTrue(Session::started());
}
/**
* Test the Payload::load method.
*
* @group laravel
*/
public function testLoadMethodCreatesNewSessionWithNullIDGiven()
{
$payload = $this->getPayload();
$payload->load(null);
$this->verifyNewSession($payload);
}
/**
* Test the Payload::load method.
*
* @group laravel
*/
public function testLoadMethodCreatesNewSessionWhenSessionIsExpired()
{
$payload = $this->getPayload();
$session = $this->getSession();
$session['last_activity'] = time() - 10000;
$payload->driver->expects($this->any())
->method('load')
->will($this->returnValue($session));
$payload->load('foo');
$this->verifyNewSession($payload);
$this->assertTrue($payload->session['id'] !== $session['id']);
}
/**
* Assert that a session is new.
*
* @param Payload $payload
* @return void
*/
protected function verifyNewSession($payload)
{
$this->assertFalse($payload->exists);
$this->assertTrue(isset($payload->session['id']));
$this->assertEquals(array(), $payload->session['data'][':new:']);
$this->assertEquals(array(), $payload->session['data'][':old:']);
$this->assertTrue(isset($payload->session['data'][Session::csrf_token]));
}
/**
* Test the Payload::load method.
*
* @group laravel
*/
public function testLoadMethodSetsValidSession()
{
$payload = $this->getPayload();
$session = $this->getSession();
$payload->driver->expects($this->any())
->method('load')
->will($this->returnValue($session));
$payload->load('foo');
$this->assertEquals($session, $payload->session);
}
/**
* Test the Payload::load method.
*
* @group laravel
*/
public function testLoadMethodSetsCSRFTokenIfDoesntExist()
{
$payload = $this->getPayload();
$session = $this->getSession();
unset($session['data']['csrf_token']);
$payload->driver->expects($this->any())
->method('load')
->will($this->returnValue($session));
$payload->load('foo');
$this->assertEquals('foo', $payload->session['id']);
$this->assertTrue(isset($payload->session['data']['csrf_token']));
}
/**
* Test the various data retrieval methods.
*
* @group laravel
*/
public function testSessionDataCanBeRetrievedProperly()
{
$payload = $this->getPayload();
$payload->session = $this->getSession();
$this->assertTrue($payload->has('name'));
$this->assertEquals('Taylor', $payload->get('name'));
$this->assertFalse($payload->has('foo'));
$this->assertEquals('Default', $payload->get('foo', 'Default'));
$this->assertTrue($payload->has('votes'));
$this->assertEquals(10, $payload->get('votes'));
$this->assertTrue($payload->has('state'));
$this->assertEquals('AR', $payload->get('state'));
}
/**
* Test the various data manipulation methods.
*
* @group laravel
*/
public function testDataCanBeSetProperly()
{
$payload = $this->getPayload();
$payload->session = $this->getSession();
// Test the "put" and "flash" methods.
$payload->put('name', 'Weldon');
$this->assertEquals('Weldon', $payload->session['data']['name']);
$payload->flash('language', 'php');
$this->assertEquals('php', $payload->session['data'][':new:']['language']);
// Test the "reflash" method.
$payload->session['data'][':new:'] = array('name' => 'Taylor');
$payload->session['data'][':old:'] = array('age' => 25);
$payload->reflash();
$this->assertEquals(array('name' => 'Taylor', 'age' => 25), $payload->session['data'][':new:']);
// Test the "keep" method.
$payload->session['data'][':new:'] = array();
$payload->keep(array('age'));
$this->assertEquals(25, $payload->session['data'][':new:']['age']);
}
/**
* Test the Payload::forget method.
*
* @group laravel
*/
public function testSessionDataCanBeForgotten()
{
$payload = $this->getPayload();
$payload->session = $this->getSession();
$this->assertTrue(isset($payload->session['data']['name']));
$payload->forget('name');
$this->assertFalse(isset($payload->session['data']['name']));
}
/**
* Test the Payload::flush method.
*
* @group laravel
*/
public function testFlushMaintainsTokenButDeletesEverythingElse()
{
$payload = $this->getPayload();
$payload->session = $this->getSession();
$this->assertTrue(isset($payload->session['data']['name']));
$payload->flush();
$this->assertFalse(isset($payload->session['data']['name']));
$this->assertEquals('bar', $payload->session['data']['csrf_token']);
$this->assertEquals(array(), $payload->session['data'][':new:']);
$this->assertEquals(array(), $payload->session['data'][':old:']);
}
/**
* Test the Payload::regenerate method.
*
* @group laravel
*/
public function testRegenerateMethodSetsNewIDAndTurnsOffExistenceIndicator()
{
$payload = $this->getPayload();
$payload->sesion = $this->getSession();
$payload->exists = true;
$payload->regenerate();
$this->assertFalse($payload->exists);
$this->assertTrue(strlen($payload->session['id']) == 40);
}
/**
* Test the Payload::token method.
*
* @group laravel
*/
public function testTokenMethodReturnsCSRFToken()
{
$payload = $this->getPayload();
$payload->session = $this->getSession();
$this->assertEquals('bar', $payload->token());
}
/**
* Test the Payload::save method.
*
* @group laravel
*/
public function testSaveMethodCorrectlyCallsDriver()
{
$payload = $this->getPayload();
$session = $this->getSession();
$payload->session = $session;
$payload->exists = true;
$config = Laravel\Config::get('session');
$expect = $session;
$expect['data'][':old:'] = $session['data'][':new:'];
$expect['data'][':new:'] = array();
$payload->driver->expects($this->once())
->method('save')
->with($this->equalTo($expect), $this->equalTo($config), $this->equalTo(true));
$payload->save();
$this->assertEquals($session['data'][':new:'], $payload->session['data'][':old:']);
}
/**
* Test the Payload::save method.
*
* @group laravel
*/
public function testSaveMethodSweepsIfSweeperAndOddsHitWithTimeGreaterThanThreshold()
{
Config::set('session.sweepage', array(100, 100));
$payload = $this->getPayload();
$payload->driver = $this->getMock('Laravel\\Session\\Drivers\\File', array('save', 'sweep'), array(null));
$payload->session = $this->getSession();
$expiration = time() - (Config::get('session.lifetime') * 60);
// Here we set the time to the expected expiration minus 5 seconds, just to
// allow plenty of room for PHP execution. In the next test, we'll do the
// same thing except add 5 seconds to check that the time is between a
// given window.
$payload->driver->expects($this->once())
->method('sweep')
->with($this->greaterThan($expiration - 5));
$payload->save();
Config::set('session.sweepage', array(2, 100));
}
/**
* Test the Payload::save method.
*
* @group laravel
*/
public function testSaveMethodSweepsIfSweeperAndOddsHitWithTimeLessThanThreshold()
{
Config::set('session.sweepage', array(100, 100));
$payload = $this->getPayload();
$payload->driver = $this->getMock('Laravel\\Session\\Drivers\\File', array('save', 'sweep'), array(null));
$payload->session = $this->getSession();
$expiration = time() - (Config::get('session.lifetime') * 60);
$payload->driver->expects($this->once())
->method('sweep')
->with($this->lessThan($expiration + 5));
$payload->save();
Config::set('session.sweepage', array(2, 100));
}
/**
* Test that the session sweeper is never called if not a sweeper.
*
* @group laravel
*/
public function testSweeperShouldntBeCalledIfDriverIsntSweeper()
{
Config::set('session.sweepage', array(100, 100));
$payload = $this->getPayload();
$payload->driver = $this->getMock('Laravel\\Session\\Drivers\\APC', array('save', 'sweep'), array(), '', false);
$payload->session = $this->getSession();
$payload->driver->expects($this->never())->method('sweep');
$payload->save();
Config::set('session.sweepage', array(2, 100));
}
/**
* Test the Payload::save method.
*
* @group laravel
*/
public function testSaveMethodSetsCookieWithCorrectValues()
{
$payload = $this->getPayload();
$payload->session = $this->getSession();
$payload->save();
$this->assertTrue(isset(Cookie::$jar[Config::get('session.cookie')]));
$cookie = Cookie::$jar[Config::get('session.cookie')];
$this->assertEquals('foo', $cookie['value']);
$this->assertEquals(Config::get('session.lifetime'), $cookie['minutes']);
$this->assertEquals(Config::get('session.domain'), $cookie['domain']);
$this->assertEquals(Config::get('session.path'), $cookie['path']);
$this->assertEquals(Config::get('session.secure'), $cookie['secure']);
}
/**
* Test the Session::activity method.
*
* @group laravel
*/
public function testActivityMethodReturnsLastActivity()
{
$payload = $this->getPayload();
$payload->session['last_activity'] = 10;
$this->assertEquals(10, $payload->activity());
}
/**
* Get a session payload instance.
*
* @return Payload
*/
protected function getPayload()
{
return new Payload($this->getMockDriver());
}
/**
* Get a mock driver instance.
*
* @return Driver
*/
protected function getMockDriver()
{
$mock = $this->getMock('Laravel\\Session\\Drivers\\Driver', array('id', 'load', 'save', 'delete'));
$mock->expects($this->any())->method('id')->will($this->returnValue(Str::random(40)));
return $mock;
}
/**
* Get a dummy session.
*
* @return array
*/
protected function getSession()
{
return array(
'id' => 'foo',
'last_activity' => time(),
'data' => array(
'name' => 'Taylor',
'age' => 25,
'csrf_token' => 'bar',
':new:' => array(
'votes' => 10,
),
':old:' => array(
'state' => 'AR',
),
));
}
}

133
tests/cases/str.test.php
View File

@ -1,133 +0,0 @@
<?php
class StrTest extends PHPUnit_Framework_TestCase {
/**
* Test the Str::encoding method.
*
* @group laravel
*/
public function testEncodingShouldReturnApplicationEncoding()
{
$this->assertEquals('UTF-8', Config::get('application.encoding'));
Config::set('application.encoding', 'foo');
$this->assertEquals('foo', Config::get('application.encoding'));
Config::set('application.encoding', 'UTF-8');
}
/**
* Test the Str::length method.
*
* @group laravel
*/
public function testStringLengthIsCorrect()
{
$this->assertEquals(6, Str::length('Taylor'));
$this->assertEquals(5, Str::length('ラドクリフ'));
}
/**
* Test the Str::lower method.
*
* @group laravel
*/
public function testStringCanBeConvertedToLowercase()
{
$this->assertEquals('taylor', Str::lower('TAYLOR'));
$this->assertEquals('άχιστη', Str::lower('ΆΧΙΣΤΗ'));
}
/**
* Test the Str::upper method.
*
* @group laravel
*/
public function testStringCanBeConvertedToUppercase()
{
$this->assertEquals('TAYLOR', Str::upper('taylor'));
$this->assertEquals('ΆΧΙΣΤΗ', Str::upper('άχιστη'));
}
/**
* Test the Str::title method.
*
* @group laravel
*/
public function testStringCanBeConvertedToTitleCase()
{
$this->assertEquals('Taylor', Str::title('taylor'));
$this->assertEquals('Άχιστη', Str::title('άχιστη'));
}
/**
* Test the Str::limit method.
*
* @group laravel
*/
public function testStringCanBeLimitedByCharacters()
{
$this->assertEquals('Tay...', Str::limit('Taylor', 3));
$this->assertEquals('Taylor', Str::limit('Taylor', 6));
$this->assertEquals('Tay___', Str::limit('Taylor', 3, '___'));
}
/**
* Test the Str::words method.
*
* @group laravel
*/
public function testStringCanBeLimitedByWords()
{
$this->assertEquals('Taylor...', Str::words('Taylor Otwell', 1));
$this->assertEquals('Taylor___', Str::words('Taylor Otwell', 1, '___'));
$this->assertEquals('Taylor Otwell', Str::words('Taylor Otwell', 3));
}
/**
* Test the Str::plural and Str::singular methods.
*
* @group laravel
*/
public function testStringsCanBeSingularOrPlural()
{
$this->assertEquals('user', Str::singular('users'));
$this->assertEquals('users', Str::plural('user'));
$this->assertEquals('User', Str::singular('Users'));
$this->assertEquals('Users', Str::plural('User'));
$this->assertEquals('user', Str::plural('user', 1));
$this->assertEquals('users', Str::plural('user', 2));
}
/**
* Test the Str::slug method.
*
* @group laravel
*/
public function testStringsCanBeSlugged()
{
$this->assertEquals('my-new-post', Str::slug('My nEw post!!!'));
$this->assertEquals('my_new_post', Str::slug('My nEw post!!!', '_'));
}
/**
* Test the Str::classify method.
*
* @group laravel
*/
public function testStringsCanBeClassified()
{
$this->assertEquals('Something_Else', Str::classify('something.else'));
$this->assertEquals('Something_Else', Str::classify('something_else'));
}
/**
* Test the Str::random method.
*
* @group laravel
*/
public function testRandomStringsCanBeGenerated()
{
$this->assertEquals(40, strlen(Str::random(40)));
}
}

59
tests/cases/uri.test.php
View File

@ -1,59 +0,0 @@
<?php
class URITest extends PHPUnit_Framework_TestCase {
/**
* Destroy the test environment.
*/
public function tearDown()
{
$_SERVER = array();
URI::$uri = null;
URI::$segments = array();
}
/**
* Test the URI::current method.
*
* @group laravel
* @dataProvider requestUriProvider
*/
public function testCorrectURIIsReturnedByCurrentMethod($uri, $expectation)
{
$_SERVER['REQUEST_URI'] = $uri;
$this->assertEquals($expectation, URI::current());
}
/**
* Test the URI::segment method.
*
* @group laravel
*/
public function testSegmentMethodReturnsAURISegment()
{
$_SERVER['REQUEST_URI'] = 'http://localhost/index.php/user/profile';
$this->assertEquals('user', URI::segment(1));
$this->assertEquals('profile', URI::segment(2));
}
/**
* Data provider for the URI::current test.
*/
public function requestUriProvider()
{
return array(
array('/index.php', '/'),
array('/index.php/', '/'),
array('http://localhost/user', 'user'),
array('http://localhost/user/', 'user'),
array('http://localhost/index.php', '/'),
array('http://localhost/index.php/', '/'),
array('http://localhost/index.php//', '/'),
array('http://localhost/index.php/user', 'user'),
array('http://localhost/index.php/user/', 'user'),
array('http://localhost/index.php/user/profile', 'user/profile'),
);
}
}

105
tests/cases/url.test.php
View File

@ -1,105 +0,0 @@
<?php
use Laravel\Routing\Router;
class URLTest extends PHPUnit_Framework_TestCase {
/**
* Setup the test enviornment.
*/
public function setUp()
{
Router::$routes = array();
Router::$names = array();
Router::$uses = array();
Router::$fallback = array();
Config::set('application.url', 'http://localhost');
}
/**
* Destroy the test enviornment.
*/
public function tearDown()
{
$_SERVER = array();
Router::$routes = array();
Router::$names = array();
Router::$uses = array();
Router::$fallback = array();
Config::set('application.ssl', true);
Config::set('application.url', '');
Config::set('application.index', 'index.php');
}
/**
* Test the URL::to method.
*
* @group laravel
*/
public function testToMethodGeneratesURL()
{
$this->assertEquals('http://localhost/index.php/user/profile', URL::to('user/profile'));
$this->assertEquals('https://localhost/index.php/user/profile', URL::to('user/profile', true));
Config::set('application.index', '');
$this->assertEquals('http://localhost/user/profile', URL::to('user/profile'));
$this->assertEquals('https://localhost/user/profile', URL::to('user/profile', true));
Config::set('application.ssl', false);
$this->assertEquals('http://localhost/user/profile', URL::to('user/profile', true));
}
/**
* Test the URL::to_action method.
*
* @group laravel
*/
public function testToActionMethodGeneratesURLToControllerAction()
{
Route::get('foo/bar/(:any?)', 'foo@baz');
$this->assertEquals('http://localhost/index.php/x/y', URL::to_action('x@y'));
$this->assertEquals('http://localhost/index.php/x/y/Taylor', URL::to_action('x@y', array('Taylor')));
$this->assertEquals('http://localhost/index.php/foo/bar', URL::to_action('foo@baz'));
$this->assertEquals('http://localhost/index.php/foo/bar/Taylor', URL::to_action('foo@baz', array('Taylor')));
}
/**
* Test the URL::to_asset method.
*
* @group laravel
*/
public function testToAssetGeneratesURLWithoutFrontControllerInURL()
{
$this->assertEquals('http://localhost/image.jpg', URL::to_asset('image.jpg'));
$this->assertEquals('https://localhost/image.jpg', URL::to_asset('image.jpg', true));
Config::set('application.index', '');
$this->assertEquals('http://localhost/image.jpg', URL::to_asset('image.jpg'));
$this->assertEquals('https://localhost/image.jpg', URL::to_asset('image.jpg', true));
$_SERVER['HTTPS'] = 'on';
$this->assertEquals('https://localhost/image.jpg', URL::to_asset('image.jpg'));
}
/**
* Test the URL::to_route method.
*
* @group laravel
*/
public function testToRouteMethodGeneratesURLsToRoutes()
{
Route::get('url/test', array('as' => 'url-test'));
Route::get('url/test/(:any)/(:any?)', array('as' => 'url-test-2'));
Route::get('url/secure/(:any)/(:any?)', array('as' => 'url-test-3', 'https' => true));
$this->assertEquals('http://localhost/index.php/url/test', URL::to_route('url-test'));
$this->assertEquals('http://localhost/index.php/url/test/taylor', URL::to_route('url-test-2', array('taylor')));
$this->assertEquals('https://localhost/index.php/url/secure/taylor', URL::to_route('url-test-3', array('taylor')));
$this->assertEquals('http://localhost/index.php/url/test/taylor/otwell', URL::to_route('url-test-2', array('taylor', 'otwell')));
}
}

669
tests/cases/validator.test.php
View File

@ -1,669 +0,0 @@
<?php
class ValidatorTest extends PHPUnit_Framework_TestCase {
/**
* Setup the test environment.
*/
public function setUp()
{
Config::set('database.default', 'sqlite');
}
/**
* Tear down the test environment.
*/
public function tearDown()
{
Config::set('database.default', 'mysql');
$_FILES = array();
}
/**
* Test the required validation rule.
*
* @group laravel
*/
public function testRequiredRule()
{
$input = array('name' => 'Taylor Otwell');
$rules = array('name' => 'required');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['name'] = '';
$this->assertFalse(Validator::make($input, $rules)->valid());
unset($input['name']);
$this->assertFalse(Validator::make($input, $rules)->valid());
$_FILES['name']['tmp_name'] = 'foo';
$this->assertTrue(Validator::make($_FILES, $rules)->valid());
$_FILES['name']['tmp_name'] = '';
$this->assertFalse(Validator::make($_FILES, $rules)->valid());
}
/**
* Test the confirmed validation rule.
*
* @group laravel
*/
public function testTheConfirmedRule()
{
$input = array('password' => 'foo', 'password_confirmation' => 'foo');
$rules = array('password' => 'confirmed');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['password_confirmation'] = 'foo_bar';
$this->assertFalse(Validator::make($input, $rules)->valid());
unset($input['password_confirmation']);
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the different validation rule.
*
* @group laravel
*/
public function testTheDifferentRule()
{
$input = array('password' => 'foo', 'password_confirmation' => 'bar');
$rules = array('password' => 'different:password_confirmation');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['password_confirmation'] = 'foo';
$this->assertFalse(Validator::make($input, $rules)->valid());
unset($input['password_confirmation']);
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the accepted validation rule.
*
* @group laravel
*/
public function testTheAcceptedRule()
{
$input = array('terms' => '1');
$rules = array('terms' => 'accepted');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['terms'] = 'yes';
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['terms'] = '2';
$this->assertFalse(Validator::make($input, $rules)->valid());
// The accepted rule implies required, so should fail if field not present.
unset($input['terms']);
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the numeric validation rule.
*
* @group laravel
*/
public function testTheNumericRule()
{
$input = array('amount' => '1.21');
$rules = array('amount' => 'numeric');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['amount'] = '1';
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['amount'] = 1.2;
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['amount'] = '1.2a';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the integer validation rule.
*
* @group laravel
*/
public function testTheIntegerRule()
{
$input = array('amount' => '1');
$rules = array('amount' => 'integer');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['amount'] = '0';
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['amount'] = 1.2;
$this->assertFalse(Validator::make($input, $rules)->valid());
$input['amount'] = '1.2a';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the size validation rule.
*
* @group laravel
*/
public function testTheSizeRule()
{
$input = array('amount' => '1.21');
$rules = array('amount' => 'numeric|size:1.21');
$this->assertTrue(Validator::make($input, $rules)->valid());
$rules = array('amount' => 'numeric|size:1');
$this->assertFalse(Validator::make($input, $rules)->valid());
// If no numeric rule is on the field, it is treated as a string
$input = array('amount' => '111');
$rules = array('amount' => 'size:3');
$this->assertTrue(Validator::make($input, $rules)->valid());
$rules = array('amount' => 'size:4');
$this->assertFalse(Validator::make($input, $rules)->valid());
// The size rules checks kilobytes on files
$_FILES['photo']['tmp_name'] = 'foo';
$_FILES['photo']['size'] = 10240;
$rules = array('photo' => 'size:10');
$this->assertTrue(Validator::make($_FILES, $rules)->valid());
$_FILES['photo']['size'] = 14000;
$this->assertFalse(Validator::make($_FILES, $rules)->valid());
}
/**
* Test the between validation rule.
*
* @group laravel
*/
public function testTheBetweenRule()
{
$input = array('amount' => '1.21');
$rules = array('amount' => 'numeric|between:1,2');
$this->assertTrue(Validator::make($input, $rules)->valid());
$rules = array('amount' => 'numeric|between:2,3');
$this->assertFalse(Validator::make($input, $rules)->valid());
// If no numeric rule is on the field, it is treated as a string
$input = array('amount' => '111');
$rules = array('amount' => 'between:1,3');
$this->assertTrue(Validator::make($input, $rules)->valid());
$rules = array('amount' => 'between:100,111');
$this->assertFalse(Validator::make($input, $rules)->valid());
// The size rules checks kilobytes on files
$_FILES['photo']['tmp_name'] = 'foo';
$_FILES['photo']['size'] = 10240;
$rules = array('photo' => 'between:9,11');
$this->assertTrue(Validator::make($_FILES, $rules)->valid());
$_FILES['photo']['size'] = 14000;
$this->assertFalse(Validator::make($_FILES, $rules)->valid());
}
/**
* Test the between validation rule.
*
* @group laravel
*/
public function testTheMinRule()
{
$input = array('amount' => '1.21');
$rules = array('amount' => 'numeric|min:1');
$this->assertTrue(Validator::make($input, $rules)->valid());
$rules = array('amount' => 'numeric|min:2');
$this->assertFalse(Validator::make($input, $rules)->valid());
// If no numeric rule is on the field, it is treated as a string
$input = array('amount' => '01');
$rules = array('amount' => 'min:2');
$this->assertTrue(Validator::make($input, $rules)->valid());
$rules = array('amount' => 'min:3');
$this->assertFalse(Validator::make($input, $rules)->valid());
// The size rules checks kilobytes on files
$_FILES['photo']['tmp_name'] = 'foo';
$_FILES['photo']['size'] = 10240;
$rules = array('photo' => 'min:9');
$this->assertTrue(Validator::make($_FILES, $rules)->valid());
$_FILES['photo']['size'] = 8000;
$this->assertFalse(Validator::make($_FILES, $rules)->valid());
}
/**
* Test the between validation rule.
*
* @group laravel
*/
public function testTheMaxRule()
{
$input = array('amount' => '1.21');
$rules = array('amount' => 'numeric|max:2');
$this->assertTrue(Validator::make($input, $rules)->valid());
$rules = array('amount' => 'numeric|max:1');
$this->assertFalse(Validator::make($input, $rules)->valid());
// If no numeric rule is on the field, it is treated as a string
$input = array('amount' => '01');
$rules = array('amount' => 'max:3');
$this->assertTrue(Validator::make($input, $rules)->valid());
$rules = array('amount' => 'max:1');
$this->assertFalse(Validator::make($input, $rules)->valid());
// The size rules checks kilobytes on files
$_FILES['photo']['tmp_name'] = 'foo';
$_FILES['photo']['size'] = 10240;
$rules = array('photo' => 'max:11');
$this->assertTrue(Validator::make($_FILES, $rules)->valid());
$_FILES['photo']['size'] = 140000;
$this->assertFalse(Validator::make($_FILES, $rules)->valid());
}
/**
* Test the in validation rule.
*
* @group laravel
*/
public function testTheInRule()
{
$input = array('size' => 'L');
$rules = array('size' => 'in:S,M,L');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['size'] = 'XL';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the not-in validation rule.
*
* @group laravel
*/
public function testTheNotInRule()
{
$input = array('size' => 'L');
$rules = array('size' => 'not_in:S,M,L');
$this->assertFalse(Validator::make($input, $rules)->valid());
$input['size'] = 'XL';
$this->assertTrue(Validator::make($input, $rules)->valid());
}
/**
* Test the IP validation rule.
*
* @group laravel
*/
public function testTheIPRule()
{
$input = array('ip' => '192.168.1.1');
$rules = array('ip' => 'ip');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['ip'] = '192.111';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the e-mail validation rule.
*
* @group laravel
*/
public function testTheEmailRule()
{
$input = array('email' => 'example@gmail.com');
$rules = array('email' => 'email');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['email'] = 'blas-asok';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the URL validation rule.
*
* @group laravel
*/
public function testTheUrlRule()
{
$input = array('url' => 'http://www.google.com');
$rules = array('url' => 'url');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['url'] = 'blas-asok';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the active URL validation rule.
*
* @group laravel
*/
public function testTheActiveUrlRule()
{
$input = array('url' => 'http://google.com');
$rules = array('url' => 'active_url');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['url'] = 'http://asdlk-aselkaiwels.com';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the image validation rule.
*
* @group laravel
*/
public function testTheImageRule()
{
$_FILES['photo']['tmp_name'] = path('storage').'files/desert.jpg';
$rules = array('photo' => 'image');
$this->assertTrue(Validator::make($_FILES, $rules)->valid());
$_FILES['photo']['tmp_name'] = path('app').'routes.php';
$this->assertFalse(Validator::make($_FILES, $rules)->valid());
}
/**
* Test the alpha validation rule.
*
* @group laravel
*/
public function testTheAlphaRule()
{
$input = array('name' => 'TaylorOtwell');
$rules = array('name' => 'alpha');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['name'] = 'Taylor Otwell';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the alpha_num validation rule.
*
* @group laravel
*/
public function testTheAlphaNumRule()
{
$input = array('name' => 'TaylorOtwell1');
$rules = array('name' => 'alpha_num');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['name'] = 'Taylor Otwell';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the alpha_num validation rule.
*
* @group laravel
*/
public function testTheAlphaDashRule()
{
$input = array('name' => 'Taylor-Otwell_1');
$rules = array('name' => 'alpha_dash');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['name'] = 'Taylor Otwell';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test the mimes validation rule.
*
* @group laravel
*/
public function testTheMimesRule()
{
$_FILES['file']['tmp_name'] = path('app').'routes.php';
$rules = array('file' => 'mimes:php,txt');
$this->assertTrue(Validator::make($_FILES, $rules)->valid());
$rules = array('file' => 'mimes:jpg,bmp');
$this->assertFalse(Validator::make($_FILES, $rules)->valid());
$_FILES['file']['tmp_name'] = path('storage').'files/desert.jpg';
$rules['file'] = 'mimes:jpg,bmp';
$this->assertTrue(Validator::make($_FILES, $rules)->valid());
$rules['file'] = 'mimes:txt,bmp';
$this->assertFalse(Validator::make($_FILES, $rules)->valid());
}
/**
* Test the unique validation rule.
*
* @group laravel
*/
public function testUniqueRule()
{
$input = array('code' => 'ZZ');
$rules = array('code' => 'unique:validation_unique');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input = array('code' => 'AR');
$this->assertFalse(Validator::make($input, $rules)->valid());
$rules = array('code' => 'unique:validation_unique,code,AR,code');
$this->assertTrue(Validator::make($input, $rules)->valid());
}
/**
* Tests the exists validation rule.
*
* @group laravel
*/
public function testExistsRule()
{
$input = array('code' => 'TX');
$rules = array('code' => 'exists:validation_unique');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['code'] = array('TX', 'NY');
$rules = array('code' => 'exists:validation_unique,code');
$this->assertTrue(Validator::make($input, $rules)->valid());
$input['code'] = array('TX', 'XX');
$this->assertFalse(Validator::make($input, $rules)->valid());
$input['code'] = 'XX';
$this->assertFalse(Validator::make($input, $rules)->valid());
}
/**
* Test that the validator sets the correct messages.
*
* @group laravel
*/
public function testCorrectMessagesAreSet()
{
$lang = require path('app').'language/en/validation.php';
$input = array('email' => 'example-foo');
$rules = array('name' => 'required', 'email' => 'required|email');
$v = Validator::make($input, $rules);
$v->valid();
$messages = $v->errors;
$this->assertInstanceOf('Laravel\\Messages', $messages);
$this->assertEquals(str_replace(':attribute', 'name', $lang['required']), $messages->first('name'));
$this->assertEquals(str_replace(':attribute', 'email', $lang['email']), $messages->first('email'));
}
/**
* Test that custom messages are recognized.
*
* @group laravel
*/
public function testCustomMessagesAreRecognize()
{
$messages = array('required' => 'Required!');
$rules = array('name' => 'required');
$v = Validator::make(array(), $rules, $messages);
$v->valid();
$this->assertEquals('Required!', $v->errors->first('name'));
$messages['email_required'] = 'Email Required!';
$rules = array('name' => 'required', 'email' => 'required');
$v = Validator::make(array(), $rules, $messages);
$v->valid();
$this->assertEquals('Required!', $v->errors->first('name'));
$this->assertEquals('Email Required!', $v->errors->first('email'));
$rules = array('custom' => 'required');
$v = Validator::make(array(), $rules);
$v->valid();
$this->assertEquals('This field is required!', $v->errors->first('custom'));
}
/**
* Test that size replacements are made on messages.
*
* @group laravel
*/
public function testNumericSizeReplacementsAreMade()
{
$lang = require path('app').'language/en/validation.php';
$input = array('amount' => 100);
$rules = array('amount' => 'numeric|size:80');
$v = Validator::make($input, $rules);
$v->valid();
$this->assertEquals(str_replace(array(':attribute', ':size'), array('amount', '80'), $lang['size']['numeric']), $v->errors->first('amount'));
$rules = array('amount' => 'numeric|between:70,80');
$v = Validator::make($input, $rules);
$v->valid();
$expect = str_replace(array(':attribute', ':min', ':max'), array('amount', '70', '80'), $lang['between']['numeric']);
$this->assertEquals($expect, $v->errors->first('amount'));
$rules = array('amount' => 'numeric|min:120');
$v = Validator::make($input, $rules);
$v->valid();
$expect = str_replace(array(':attribute', ':min'), array('amount', '120'), $lang['min']['numeric']);
$this->assertEquals($expect, $v->errors->first('amount'));
$rules = array('amount' => 'numeric|max:20');
$v = Validator::make($input, $rules);
$v->valid();
$expect = str_replace(array(':attribute', ':max'), array('amount', '20'), $lang['max']['numeric']);
$this->assertEquals($expect, $v->errors->first('amount'));
}
/**
* Test that string size replacements are made on messages.
*
* @group laravel
*/
public function testStringSizeReplacementsAreMade()
{
$lang = require path('app').'language/en/validation.php';
$input = array('amount' => '100');
$rules = array('amount' => 'size:80');
$v = Validator::make($input, $rules);
$v->valid();
$this->assertEquals(str_replace(array(':attribute', ':size'), array('amount', '80'), $lang['size']['string']), $v->errors->first('amount'));
$rules = array('amount' => 'between:70,80');
$v = Validator::make($input, $rules);
$v->valid();
$expect = str_replace(array(':attribute', ':min', ':max'), array('amount', '70', '80'), $lang['between']['string']);
$this->assertEquals($expect, $v->errors->first('amount'));
$rules = array('amount' => 'min:120');
$v = Validator::make($input, $rules);
$v->valid();
$expect = str_replace(array(':attribute', ':min'), array('amount', '120'), $lang['min']['string']);
$this->assertEquals($expect, $v->errors->first('amount'));
$rules = array('amount' => 'max:2');
$v = Validator::make($input, $rules);
$v->valid();
$expect = str_replace(array(':attribute', ':max'), array('amount', '2'), $lang['max']['string']);
$this->assertEquals($expect, $v->errors->first('amount'));
}
/**
* Test that string size replacements are made on messages.
*
* @group laravel
*/
public function testFileSizeReplacementsAreMade()
{
$lang = require path('app').'language/en/validation.php';
$_FILES['amount']['tmp_name'] = 'foo';
$_FILES['amount']['size'] = 10000;
$rules = array('amount' => 'size:80');
$v = Validator::make($_FILES, $rules);
$v->valid();
$this->assertEquals(str_replace(array(':attribute', ':size'), array('amount', '80'), $lang['size']['file']), $v->errors->first('amount'));
$rules = array('amount' => 'between:70,80');
$v = Validator::make($_FILES, $rules);
$v->valid();
$expect = str_replace(array(':attribute', ':min', ':max'), array('amount', '70', '80'), $lang['between']['file']);
$this->assertEquals($expect, $v->errors->first('amount'));
$rules = array('amount' => 'min:120');
$v = Validator::make($_FILES, $rules);
$v->valid();
$expect = str_replace(array(':attribute', ':min'), array('amount', '120'), $lang['min']['file']);
$this->assertEquals($expect, $v->errors->first('amount'));
$rules = array('amount' => 'max:2');
$v = Validator::make($_FILES, $rules);
$v->valid();
$expect = str_replace(array(':attribute', ':max'), array('amount', '2'), $lang['max']['file']);
$this->assertEquals($expect, $v->errors->first('amount'));
}
/**
* Test that values get replaced in messages.
*
* @group laravel
*/
public function testValuesGetReplaced()
{
$lang = require path('app').'language/en/validation.php';
$_FILES['file']['tmp_name'] = path('storage').'files/desert.jpg';
$rules = array('file' => 'mimes:php,txt');
$v = Validator::make($_FILES, $rules);
$v->valid();
$expect = str_replace(array(':attribute', ':values'), array('file', 'php, txt'), $lang['mimes']);
$this->assertEquals($expect, $v->errors->first('file'));
}
/**
* Test custom attribute names are replaced.
*
* @group laravel
*/
public function testCustomAttributesAreReplaced()
{
$lang = require path('app').'language/en/validation.php';
$rules = array('test_attribute' => 'required');
$v = Validator::make(array(), $rules);
$v->valid();
$expect = str_replace(':attribute', 'attribute', $lang['required']);
$this->assertEquals($expect, $v->errors->first('test_attribute'));
}
}

237
tests/cases/view.test.php
View File

@ -1,237 +0,0 @@
<?php
class ViewTest extends PHPUnit_Framework_TestCase {
/**
* Tear down the testing environment.
*/
public function tearDown()
{
View::$shared = array();
unset(Event::$events['composing: test.basic']);
}
/**
* Test the View::make method.
*
* @group laravel
*/
public function testMakeMethodReturnsAViewInstance()
{
$this->assertInstanceOf('Laravel\\View', View::make('home.index'));
}
/**
* Test the View class constructor.
*
* @group laravel
*/
public function testViewNameIsSetByConstrutor()
{
$view = new View('home.index');
$this->assertEquals('home.index', $view->view);
}
/**
* Test the View class constructor.
*
* @group laravel
*/
public function testViewIsCreatedWithCorrectPath()
{
$view = new View('home.index');
$this->assertEquals(path('app').'views/home/index.php', $view->path);
}
/**
* Test the View class constructor.
*
* @group laravel
*/
public function testDataIsSetOnViewByConstructor()
{
$view = new View('home.index', array('name' => 'Taylor'));
$this->assertEquals('Taylor', $view->data['name']);
}
/**
* Test the View::name method.
*
* @group laravel
*/
public function testNameMethodRegistersAViewName()
{
View::name('home.index', 'home');
$this->assertEquals('home.index', View::$names['home']);
}
/**
* Test the View::shared method.
*
* @group laravel
*/
public function testSharedMethodAddsDataToSharedArray()
{
View::share('comment', 'Taylor');
$this->assertEquals('Taylor', View::$shared['comment']);
}
/**
* Test the View::with method.
*
* @group laravel
*/
public function testViewDataCanBeSetUsingWithMethod()
{
$view = View::make('home.index')->with('comment', 'Taylor');
$this->assertEquals('Taylor', $view->data['comment']);
}
/**
* Test the View class constructor.
*
* @group laravel
*/
public function testEmptyMessageContainerSetOnViewWhenNoErrorsInSession()
{
$view = new View('home.index');
$this->assertInstanceOf('Laravel\\Messages', $view->data['errors']);
}
/**
* Test the View __set method.
*
* @group laravel
*/
public function testDataCanBeSetOnViewsThroughMagicMethods()
{
$view = new View('home.index');
$view->comment = 'Taylor';
$this->assertEquals('Taylor', $view->data['comment']);
}
/**
* Test the View __get method.
*
* @group laravel
*/
public function testDataCanBeRetrievedFromViewsThroughMagicMethods()
{
$view = new View('home.index');
$view->comment = 'Taylor';
$this->assertEquals('Taylor', $view->comment);
}
/**
* Test the View's ArrayAccess implementation.
*
* @group laravel
*/
public function testDataCanBeSetOnTheViewThroughArrayAccess()
{
$view = new View('home.index');
$view['comment'] = 'Taylor';
$this->assertEquals('Taylor', $view->data['comment']);
}
/**
* Test the View's ArrayAccess implementation.
*
* @group laravel
*/
public function testDataCanBeRetrievedThroughArrayAccess()
{
$view = new View('home.index');
$view['comment'] = 'Taylor';
$this->assertEquals('Taylor', $view['comment']);
}
/**
* Test the View::nest method.
*
* @group laravel
*/
public function testNestMethodSetsViewInstanceInData()
{
$view = View::make('home.index')->nest('partial', 'tests.basic');
$this->assertEquals('tests.basic', $view->data['partial']->view);
$this->assertInstanceOf('Laravel\\View', $view->data['partial']);
}
/**
* Test that the registered data is passed to the view correctly.
*
* @group laravel
*/
public function testDataIsPassedToViewCorrectly()
{
View::share('name', 'Taylor');
$view = View::make('tests.basic')->with('age', 25)->render();
$this->assertEquals('Taylor is 25', $view);
}
/**
* Test that the View class renders nested views.
*
* @group laravel
*/
public function testNestedViewsAreRendered()
{
$view = View::make('tests.basic')
->with('age', 25)
->nest('name', 'tests.nested');
$this->assertEquals('Taylor is 25', $view->render());
}
/**
* Test that the View class renders nested responses.
*
* @group laravel
*/
public function testNestedResponsesAreRendered()
{
$view = View::make('tests.basic')
->with('age', 25)
->with('name', Response::view('tests.nested'));
$this->assertEquals('Taylor is 25', $view->render());
}
/**
* Test the View class raises a composer event.
*
* @group laravel
*/
public function testComposerEventIsCalledWhenViewIsRendering()
{
View::composer('tests.basic', function($view)
{
$view->data = array('name' => 'Taylor', 'age' => 25);
});
$view = View::make('tests.basic')->render();
$this->assertEquals('Taylor is 25', $view);
}
}

0
tests/storage/cache/.gitignore vendored
View File

BIN
tests/storage/database/application.sqlite
View File

Binary file not shown.

BIN
tests/storage/files/desert.jpg
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 826 KiB

0
tests/storage/logs/.gitignore vendored
View File

0
tests/storage/sessions/.gitignore vendored
View File

0
tests/storage/views/.gitignore vendored
View File

96
vendor/Symfony/Component/ClassLoader/ApcUniversalClassLoader.php vendored
View File

@ -1,96 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\ClassLoader;
/**
* ApcUniversalClassLoader implements a "universal" autoloader cached in APC for PHP 5.3.
*
* It is able to load classes that use either:
*
* * The technical interoperability standards for PHP 5.3 namespaces and
* class names (https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md);
*
* * The PEAR naming convention for classes (http://pear.php.net/).
*
* Classes from a sub-namespace or a sub-hierarchy of PEAR classes can be
* looked for in a list of locations to ease the vendoring of a sub-set of
* classes for large projects.
*
* Example usage:
*
* require 'vendor/symfony/src/Symfony/Component/ClassLoader/UniversalClassLoader.php';
* require 'vendor/symfony/src/Symfony/Component/ClassLoader/ApcUniversalClassLoader.php';
*
* use Symfony\Component\ClassLoader\ApcUniversalClassLoader;
*
* $loader = new ApcUniversalClassLoader('apc.prefix.');
*
* // register classes with namespaces
* $loader->registerNamespaces(array(
* 'Symfony\Component' => __DIR__.'/component',
* 'Symfony' => __DIR__.'/framework',
* 'Sensio' => array(__DIR__.'/src', __DIR__.'/vendor'),
* ));
*
* // register a library using the PEAR naming convention
* $loader->registerPrefixes(array(
* 'Swift_' => __DIR__.'/Swift',
* ));
*
* // activate the autoloader
* $loader->register();
*
* In this example, if you try to use a class in the Symfony\Component
* namespace or one of its children (Symfony\Component\Console for instance),
* the autoloader will first look for the class under the component/
* directory, and it will then fallback to the framework/ directory if not
* found before giving up.
*
* @author Fabien Potencier <fabien@symfony.com>
* @author Kris Wallsmith <kris@symfony.com>
*
* @api
*/
class ApcUniversalClassLoader extends UniversalClassLoader
{
private $prefix;
/**
* Constructor.
*
* @param string $prefix A prefix to create a namespace in APC
*
* @api
*/
public function __construct($prefix)
{
if (!extension_loaded('apc')) {
throw new \RuntimeException('Unable to use ApcUniversalClassLoader as APC is not enabled.');
}
$this->prefix = $prefix;
}
/**
* Finds a file by class name while caching lookups to APC.
*
* @param string $class A class name to resolve to file
*/
public function findFile($class)
{
if (false === $file = apc_fetch($this->prefix.$class)) {
apc_store($this->prefix.$class, $file = parent::findFile($class));
}
return $file;
}
}

222
vendor/Symfony/Component/ClassLoader/ClassCollectionLoader.php vendored
View File

@ -1,222 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\ClassLoader;
/**
* ClassCollectionLoader.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
class ClassCollectionLoader
{
static private $loaded;
/**
* Loads a list of classes and caches them in one big file.
*
* @param array $classes An array of classes to load
* @param string $cacheDir A cache directory
* @param string $name The cache name prefix
* @param Boolean $autoReload Whether to flush the cache when the cache is stale or not
* @param Boolean $adaptive Whether to remove already declared classes or not
* @param string $extension File extension of the resulting file
*
* @throws \InvalidArgumentException When class can't be loaded
*/
static public function load($classes, $cacheDir, $name, $autoReload, $adaptive = false, $extension = '.php')
{
// each $name can only be loaded once per PHP process
if (isset(self::$loaded[$name])) {
return;
}
self::$loaded[$name] = true;
if ($adaptive) {
// don't include already declared classes
$classes = array_diff($classes, get_declared_classes(), get_declared_interfaces());
// the cache is different depending on which classes are already declared
$name = $name.'-'.substr(md5(implode('|', $classes)), 0, 5);
}
$cache = $cacheDir.'/'.$name.$extension;
// auto-reload
$reload = false;
if ($autoReload) {
$metadata = $cacheDir.'/'.$name.$extension.'.meta';
if (!is_file($metadata) || !is_file($cache)) {
$reload = true;
} else {
$time = filemtime($cache);
$meta = unserialize(file_get_contents($metadata));
if ($meta[1] != $classes) {
$reload = true;
} else {
foreach ($meta[0] as $resource) {
if (!is_file($resource) || filemtime($resource) > $time) {
$reload = true;
break;
}
}
}
}
}
if (!$reload && is_file($cache)) {
require_once $cache;
return;
}
$files = array();
$content = '';
foreach ($classes as $class) {
if (!class_exists($class) && !interface_exists($class) && (!function_exists('trait_exists') || !trait_exists($class))) {
throw new \InvalidArgumentException(sprintf('Unable to load class "%s"', $class));
}
$r = new \ReflectionClass($class);
$files[] = $r->getFileName();
$c = preg_replace(array('/^\s*<\?php/', '/\?>\s*$/'), '', file_get_contents($r->getFileName()));
// add namespace declaration for global code
if (!$r->inNamespace()) {
$c = "\nnamespace\n{\n".self::stripComments($c)."\n}\n";
} else {
$c = self::fixNamespaceDeclarations('<?php '.$c);
$c = preg_replace('/^\s*<\?php/', '', $c);
}
$content .= $c;
}
// cache the core classes
if (!is_dir(dirname($cache))) {
mkdir(dirname($cache), 0777, true);
}
self::writeCacheFile($cache, '<?php '.$content);
if ($autoReload) {
// save the resources
self::writeCacheFile($metadata, serialize(array($files, $classes)));
}
}
/**
* Adds brackets around each namespace if it's not already the case.
*
* @param string $source Namespace string
*
* @return string Namespaces with brackets
*/
static public function fixNamespaceDeclarations($source)
{
if (!function_exists('token_get_all')) {
return $source;
}
$output = '';
$inNamespace = false;
$tokens = token_get_all($source);
for ($i = 0, $max = count($tokens); $i < $max; $i++) {
$token = $tokens[$i];
if (is_string($token)) {
$output .= $token;
} elseif (in_array($token[0], array(T_COMMENT, T_DOC_COMMENT))) {
// strip comments
continue;
} elseif (T_NAMESPACE === $token[0]) {
if ($inNamespace) {
$output .= "}\n";
}
$output .= $token[1];
// namespace name and whitespaces
while (($t = $tokens[++$i]) && is_array($t) && in_array($t[0], array(T_WHITESPACE, T_NS_SEPARATOR, T_STRING))) {
$output .= $t[1];
}
if (is_string($t) && '{' === $t) {
$inNamespace = false;
--$i;
} else {
$output .= "\n{";
$inNamespace = true;
}
} else {
$output .= $token[1];
}
}
if ($inNamespace) {
$output .= "}\n";
}
return $output;
}
/**
* Writes a cache file.
*
* @param string $file Filename
* @param string $content Temporary file content
*
* @throws \RuntimeException when a cache file cannot be written
*/
static private function writeCacheFile($file, $content)
{
$tmpFile = tempnam(dirname($file), basename($file));
if (false !== @file_put_contents($tmpFile, $content) && @rename($tmpFile, $file)) {
chmod($file, 0644);
return;
}
throw new \RuntimeException(sprintf('Failed to write cache file "%s".', $file));
}
/**
* Removes comments from a PHP source string.
*
* We don't use the PHP php_strip_whitespace() function
* as we want the content to be readable and well-formatted.
*
* @param string $source A PHP string
*
* @return string The PHP string with the comments removed
*/
static private function stripComments($source)
{
if (!function_exists('token_get_all')) {
return $source;
}
$output = '';
foreach (token_get_all($source) as $token) {
if (is_string($token)) {
$output .= $token;
} elseif (!in_array($token[0], array(T_COMMENT, T_DOC_COMMENT))) {
$output .= $token[1];
}
}
// replace multiple new lines with a single newline
$output = preg_replace(array('/\s+$/Sm', '/\n+/S'), "\n", $output);
return $output;
}
}

133
vendor/Symfony/Component/ClassLoader/ClassMapGenerator.php vendored
View File

@ -1,133 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\ClassLoader;
/**
* ClassMapGenerator
*
* @author Gyula Sallai <salla016@gmail.com>
*/
class ClassMapGenerator
{
/**
* Generate a class map file
*
* @param array|string $dirs Directories or a single path to search in
* @param string $file The name of the class map file
*/
static public function dump($dirs, $file)
{
$dirs = (array) $dirs;
$maps = array();
foreach ($dirs as $dir) {
$maps = array_merge($maps, static::createMap($dir));
}
file_put_contents($file, sprintf('<?php return %s;', var_export($maps, true)));
}
/**
* Iterate over all files in the given directory searching for classes
*
* @param Iterator|string $dir The directory to search in or an iterator
*
* @return array A class map array
*/
static public function createMap($dir)
{
if (is_string($dir)) {
$dir = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($dir));
}
$map = array();
foreach ($dir as $file) {
if (!$file->isFile()) {
continue;
}
$path = $file->getRealPath();
if (pathinfo($path, PATHINFO_EXTENSION) !== 'php') {
continue;
}
$classes = self::findClasses($path);
foreach ($classes as $class) {
$map[$class] = $path;
}
}
return $map;
}
/**
* Extract the classes in the given file
*
* @param string $path The file to check
*
* @return array The found classes
*/
static private function findClasses($path)
{
$contents = file_get_contents($path);
$tokens = token_get_all($contents);
$T_TRAIT = version_compare(PHP_VERSION, '5.4', '<') ? -1 : T_TRAIT;
$classes = array();
$namespace = '';
for ($i = 0, $max = count($tokens); $i < $max; $i++) {
$token = $tokens[$i];
if (is_string($token)) {
continue;
}
$class = '';
switch ($token[0]) {
case T_NAMESPACE:
$namespace = '';
// If there is a namespace, extract it
while (($t = $tokens[++$i]) && is_array($t)) {
if (in_array($t[0], array(T_STRING, T_NS_SEPARATOR))) {
$namespace .= $t[1];
}
}
$namespace .= '\\';
break;
case T_CLASS:
case T_INTERFACE:
case $T_TRAIT:
// Find the classname
while (($t = $tokens[++$i]) && is_array($t)) {
if (T_STRING === $t[0]) {
$class .= $t[1];
} elseif ($class !== '' && T_WHITESPACE == $t[0]) {
break;
}
}
$classes[] = ltrim($namespace . $class, '\\');
break;
default:
break;
}
}
return $classes;
}
}

63
vendor/Symfony/Component/ClassLoader/DebugUniversalClassLoader.php vendored
View File

@ -1,63 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\ClassLoader;
/**
* Checks that the class is actually declared in the included file.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
class DebugUniversalClassLoader extends UniversalClassLoader
{
/**
* Replaces all regular UniversalClassLoader instances by a DebugUniversalClassLoader ones.
*/
static public function enable()
{
if (!is_array($functions = spl_autoload_functions())) {
return;
}
foreach ($functions as $function) {
spl_autoload_unregister($function);
}
foreach ($functions as $function) {
if (is_array($function) && $function[0] instanceof UniversalClassLoader) {
$loader = new static();
$loader->registerNamespaceFallbacks($function[0]->getNamespaceFallbacks());
$loader->registerPrefixFallbacks($function[0]->getPrefixFallbacks());
$loader->registerNamespaces($function[0]->getNamespaces());
$loader->registerPrefixes($function[0]->getPrefixes());
$loader->useIncludePath($function[0]->getUseIncludePath());
$function[0] = $loader;
}
spl_autoload_register($function);
}
}
/**
* {@inheritDoc}
*/
public function loadClass($class)
{
if ($file = $this->findFile($class)) {
require $file;
if (!class_exists($class, false) && !interface_exists($class, false) && (!function_exists('trait_exists') || !trait_exists($class, false))) {
throw new \RuntimeException(sprintf('The autoloader expected class "%s" to be defined in file "%s". The file was found but the class was not in it, the class name or namespace probably has a typo.', $class, $file));
}
}
}
}

19
vendor/Symfony/Component/ClassLoader/LICENSE vendored
View File

@ -1,19 +0,0 @@
Copyright (c) 2004-2012 Fabien Potencier
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

76
vendor/Symfony/Component/ClassLoader/MapClassLoader.php vendored
View File

@ -1,76 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\ClassLoader;
/**
* A class loader that uses a mapping file to look up paths.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
class MapClassLoader
{
private $map = array();
/**
* Constructor.
*
* @param array $map A map where keys are classes and values the absolute file path
*/
public function __construct(array $map)
{
$this->map = $map;
}
/**
* Registers this instance as an autoloader.
*
* @param Boolean $prepend Whether to prepend the autoloader or not
*/
public function register($prepend = false)
{
spl_autoload_register(array($this, 'loadClass'), true, $prepend);
}
/**
* Loads the given class or interface.
*
* @param string $class The name of the class
*/
public function loadClass($class)
{
if ('\\' === $class[0]) {
$class = substr($class, 1);
}
if (isset($this->map[$class])) {
require $this->map[$class];
}
}
/**
* Finds the path to the file where the class is defined.
*
* @param string $class The name of the class
*
* @return string|null The path, if found
*/
public function findFile($class)
{
if ('\\' === $class[0]) {
$class = substr($class, 1);
}
if (isset($this->map[$class])) {
return $this->map[$class];
}
}
}

60
vendor/Symfony/Component/ClassLoader/README.md vendored
View File

@ -1,60 +0,0 @@
ClassLoader Component
=====================
ClassLoader loads your project classes automatically if they follow some
standard PHP conventions.
The Universal ClassLoader is able to autoload classes that implement the PSR-0
standard or the PEAR naming convention.
First, register the autoloader:
require_once __DIR__.'/src/Symfony/Component/ClassLoader/UniversalClassLoader.php';
use Symfony\Component\ClassLoader\UniversalClassLoader;
$loader = new UniversalClassLoader();
$loader->register();
Then, register some namespaces with the `registerNamespace()` method:
$loader->registerNamespace('Symfony', __DIR__.'/src');
$loader->registerNamespace('Monolog', __DIR__.'/vendor/monolog/src');
The `registerNamespace()` method takes a namespace prefix and a path where to
look for the classes as arguments.
You can also register a sub-namespaces:
$loader->registerNamespace('Doctrine\\Common', __DIR__.'/vendor/doctrine-common/lib');
The order of registration is significant and the first registered namespace
takes precedence over later registered one.
You can also register more than one path for a given namespace:
$loader->registerNamespace('Symfony', array(__DIR__.'/src', __DIR__.'/symfony/src'));
Alternatively, you can use the `registerNamespaces()` method to register more
than one namespace at once:
$loader->registerNamespaces(array(
'Symfony' => array(__DIR__.'/src', __DIR__.'/symfony/src'),
'Doctrine\\Common' => __DIR__.'/vendor/doctrine-common/lib',
'Doctrine' => __DIR__.'/vendor/doctrine/lib',
'Monolog' => __DIR__.'/vendor/monolog/src',
));
For better performance, you can use the APC based version of the universal
class loader:
require_once __DIR__.'/src/Symfony/Component/ClassLoader/UniversalClassLoader.php';
require_once __DIR__.'/src/Symfony/Component/ClassLoader/ApcUniversalClassLoader.php';
use Symfony\Component\ClassLoader\ApcUniversalClassLoader;
$loader = new ApcUniversalClassLoader('apc.prefix.');
Furthermore, the component provides tools to aggregate classes into a single
file, which is especially useful to improve performance on servers that do not
provide byte caches.

319
vendor/Symfony/Component/ClassLoader/UniversalClassLoader.php vendored
View File

@ -1,319 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\ClassLoader;
/**
* UniversalClassLoader implements a "universal" autoloader for PHP 5.3.
*
* It is able to load classes that use either:
*
* * The technical interoperability standards for PHP 5.3 namespaces and
* class names (https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md);
*
* * The PEAR naming convention for classes (http://pear.php.net/).
*
* Classes from a sub-namespace or a sub-hierarchy of PEAR classes can be
* looked for in a list of locations to ease the vendoring of a sub-set of
* classes for large projects.
*
* Example usage:
*
* $loader = new UniversalClassLoader();
*
* // register classes with namespaces
* $loader->registerNamespaces(array(
* 'Symfony\Component' => __DIR__.'/component',
* 'Symfony' => __DIR__.'/framework',
* 'Sensio' => array(__DIR__.'/src', __DIR__.'/vendor'),
* ));
*
* // register a library using the PEAR naming convention
* $loader->registerPrefixes(array(
* 'Swift_' => __DIR__.'/Swift',
* ));
*
*
* // to enable searching the include path (eg. for PEAR packages)
* $loader->useIncludePath(true);
*
* // activate the autoloader
* $loader->register();
*
* In this example, if you try to use a class in the Symfony\Component
* namespace or one of its children (Symfony\Component\Console for instance),
* the autoloader will first look for the class under the component/
* directory, and it will then fallback to the framework/ directory if not
* found before giving up.
*
* @author Fabien Potencier <fabien@symfony.com>
*
* @api
*/
class UniversalClassLoader
{
private $namespaces = array();
private $prefixes = array();
private $namespaceFallbacks = array();
private $prefixFallbacks = array();
private $useIncludePath = false;
/**
* Turns on searching the include for class files. Allows easy loading
* of installed PEAR packages
*
* @param Boolean $useIncludePath
*/
public function useIncludePath($useIncludePath)
{
$this->useIncludePath = $useIncludePath;
}
/**
* Can be used to check if the autoloader uses the include path to check
* for classes.
*
* @return Boolean
*/
public function getUseIncludePath()
{
return $this->useIncludePath;
}
/**
* Gets the configured namespaces.
*
* @return array A hash with namespaces as keys and directories as values
*/
public function getNamespaces()
{
return $this->namespaces;
}
/**
* Gets the configured class prefixes.
*
* @return array A hash with class prefixes as keys and directories as values
*/
public function getPrefixes()
{
return $this->prefixes;
}
/**
* Gets the directory(ies) to use as a fallback for namespaces.
*
* @return array An array of directories
*/
public function getNamespaceFallbacks()
{
return $this->namespaceFallbacks;
}
/**
* Gets the directory(ies) to use as a fallback for class prefixes.
*
* @return array An array of directories
*/
public function getPrefixFallbacks()
{
return $this->prefixFallbacks;
}
/**
* Registers the directory to use as a fallback for namespaces.
*
* @param array $dirs An array of directories
*
* @api
*/
public function registerNamespaceFallbacks(array $dirs)
{
$this->namespaceFallbacks = $dirs;
}
/**
* Registers a directory to use as a fallback for namespaces.
*
* @param string $dir A directory
*/
public function registerNamespaceFallback($dir)
{
$this->namespaceFallbacks[] = $dir;
}
/**
* Registers directories to use as a fallback for class prefixes.
*
* @param array $dirs An array of directories
*
* @api
*/
public function registerPrefixFallbacks(array $dirs)
{
$this->prefixFallbacks = $dirs;
}
/**
* Registers a directory to use as a fallback for class prefixes.
*
* @param string $dir A directory
*/
public function registerPrefixFallback($dir)
{
$this->prefixFallbacks[] = $dir;
}
/**
* Registers an array of namespaces
*
* @param array $namespaces An array of namespaces (namespaces as keys and locations as values)
*
* @api
*/
public function registerNamespaces(array $namespaces)
{
foreach ($namespaces as $namespace => $locations) {
$this->namespaces[$namespace] = (array) $locations;
}
}
/**
* Registers a namespace.
*
* @param string $namespace The namespace
* @param array|string $paths The location(s) of the namespace
*
* @api
*/
public function registerNamespace($namespace, $paths)
{
$this->namespaces[$namespace] = (array) $paths;
}
/**
* Registers an array of classes using the PEAR naming convention.
*
* @param array $classes An array of classes (prefixes as keys and locations as values)
*
* @api
*/
public function registerPrefixes(array $classes)
{
foreach ($classes as $prefix => $locations) {
$this->prefixes[$prefix] = (array) $locations;
}
}
/**
* Registers a set of classes using the PEAR naming convention.
*
* @param string $prefix The classes prefix
* @param array|string $paths The location(s) of the classes
*
* @api
*/
public function registerPrefix($prefix, $paths)
{
$this->prefixes[$prefix] = (array) $paths;
}
/**
* Registers this instance as an autoloader.
*
* @param Boolean $prepend Whether to prepend the autoloader or not
*
* @api
*/
public function register($prepend = false)
{
spl_autoload_register(array($this, 'loadClass'), true, $prepend);
}
/**
* Loads the given class or interface.
*
* @param string $class The name of the class
*/
public function loadClass($class)
{
if ($file = $this->findFile($class)) {
require $file;
}
}
/**
* Finds the path to the file where the class is defined.
*
* @param string $class The name of the class
*
* @return string|null The path, if found
*/
public function findFile($class)
{
if ('\\' == $class[0]) {
$class = substr($class, 1);
}
if (false !== $pos = strrpos($class, '\\')) {
// namespaced class name
$namespace = substr($class, 0, $pos);
$className = substr($class, $pos + 1);
$normalizedClass = str_replace('\\', DIRECTORY_SEPARATOR, $namespace).DIRECTORY_SEPARATOR.str_replace('_', DIRECTORY_SEPARATOR, $className).'.php';
foreach ($this->namespaces as $ns => $dirs) {
if (0 !== strpos($namespace, $ns)) {
continue;
}
foreach ($dirs as $dir) {
$file = $dir.DIRECTORY_SEPARATOR.$normalizedClass;
if (is_file($file)) {
return $file;
}
}
}
foreach ($this->namespaceFallbacks as $dir) {
$file = $dir.DIRECTORY_SEPARATOR.$normalizedClass;
if (is_file($file)) {
return $file;
}
}
} else {
// PEAR-like class name
$normalizedClass = str_replace('_', DIRECTORY_SEPARATOR, $class).'.php';
foreach ($this->prefixes as $prefix => $dirs) {
if (0 !== strpos($class, $prefix)) {
continue;
}
foreach ($dirs as $dir) {
$file = $dir.DIRECTORY_SEPARATOR.$normalizedClass;
if (is_file($file)) {
return $file;
}
}
}
foreach ($this->prefixFallbacks as $dir) {
$file = $dir.DIRECTORY_SEPARATOR.$normalizedClass;
if (is_file($file)) {
return $file;
}
}
}
if ($this->useIncludePath && $file = stream_resolve_include_path($normalizedClass)) {
return $file;
}
}
}

30
vendor/Symfony/Component/ClassLoader/composer.json vendored
View File

@ -1,30 +0,0 @@
{
"name": "symfony/class-loader",
"type": "library",
"description": "Symfony ClassLoader Component",
"keywords": [],
"homepage": "http://symfony.com",
"license": "MIT",
"authors": [
{
"name": "Fabien Potencier",
"email": "fabien@symfony.com"
},
{
"name": "Symfony Community",
"homepage": "http://symfony.com/contributors"
}
],
"require": {
"php": ">=5.3.2"
},
"autoload": {
"psr-0": { "Symfony\\Component\\ClassLoader": "" }
},
"target-dir": "Symfony/Component/ClassLoader",
"extra": {
"branch-alias": {
"dev-master": "2.1-dev"
}
}
}

1007
vendor/Symfony/Component/Console/Application.php vendored
View File

File diff suppressed because it is too large Load Diff

612
vendor/Symfony/Component/Console/Command/Command.php vendored
View File

@ -1,612 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Console\Command;
use Symfony\Component\Console\Input\InputDefinition;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Helper\HelperSet;
/**
* Base class for all commands.
*
* @author Fabien Potencier <fabien@symfony.com>
*
* @api
*/
class Command
{
private $application;
private $name;
private $aliases;
private $definition;
private $help;
private $description;
private $ignoreValidationErrors;
private $applicationDefinitionMerged;
private $code;
private $synopsis;
private $helperSet;
/**
* Constructor.
*
* @param string $name The name of the command
*
* @throws \LogicException When the command name is empty
*
* @api
*/
public function __construct($name = null)
{
$this->definition = new InputDefinition();
$this->ignoreValidationErrors = false;
$this->applicationDefinitionMerged = false;
$this->aliases = array();
if (null !== $name) {
$this->setName($name);
}
$this->configure();
if (!$this->name) {
throw new \LogicException('The command name cannot be empty.');
}
}
/**
* Ignores validation errors.
*
* This is mainly useful for the help command.
*/
public function ignoreValidationErrors()
{
$this->ignoreValidationErrors = true;
}
/**
* Sets the application instance for this command.
*
* @param Application $application An Application instance
*
* @api
*/
public function setApplication(Application $application = null)
{
$this->application = $application;
if ($application) {
$this->setHelperSet($application->getHelperSet());
} else {
$this->helperSet = null;
}
}
/**
* Sets the helper set.
*
* @param HelperSet $helperSet A HelperSet instance
*/
public function setHelperSet(HelperSet $helperSet)
{
$this->helperSet = $helperSet;
}
/**
* Gets the helper set.
*
* @return HelperSet A HelperSet instance
*/
public function getHelperSet()
{
return $this->helperSet;
}
/**
* Gets the application instance for this command.
*
* @return Application An Application instance
*
* @api
*/
public function getApplication()
{
return $this->application;
}
/**
* Checks whether the command is enabled or not in the current environment
*
* Override this to check for x or y and return false if the command can not
* run properly under the current conditions.
*
* @return Boolean
*/
public function isEnabled()
{
return true;
}
/**
* Configures the current command.
*/
protected function configure()
{
}
/**
* Executes the current command.
*
* This method is not abstract because you can use this class
* as a concrete class. In this case, instead of defining the
* execute() method, you set the code to execute by passing
* a Closure to the setCode() method.
*
* @param InputInterface $input An InputInterface instance
* @param OutputInterface $output An OutputInterface instance
*
* @return integer 0 if everything went fine, or an error code
*
* @throws \LogicException When this abstract method is not implemented
* @see setCode()
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
throw new \LogicException('You must override the execute() method in the concrete command class.');
}
/**
* Interacts with the user.
*
* @param InputInterface $input An InputInterface instance
* @param OutputInterface $output An OutputInterface instance
*/
protected function interact(InputInterface $input, OutputInterface $output)
{
}
/**
* Initializes the command just after the input has been validated.
*
* This is mainly useful when a lot of commands extends one main command
* where some things need to be initialized based on the input arguments and options.
*
* @param InputInterface $input An InputInterface instance
* @param OutputInterface $output An OutputInterface instance
*/
protected function initialize(InputInterface $input, OutputInterface $output)
{
}
/**
* Runs the command.
*
* The code to execute is either defined directly with the
* setCode() method or by overriding the execute() method
* in a sub-class.
*
* @param InputInterface $input An InputInterface instance
* @param OutputInterface $output An OutputInterface instance
*
* @see setCode()
* @see execute()
*
* @api
*/
public function run(InputInterface $input, OutputInterface $output)
{
// force the creation of the synopsis before the merge with the app definition
$this->getSynopsis();
// add the application arguments and options
$this->mergeApplicationDefinition();
// bind the input against the command specific arguments/options
try {
$input->bind($this->definition);
} catch (\Exception $e) {
if (!$this->ignoreValidationErrors) {
throw $e;
}
}
$this->initialize($input, $output);
if ($input->isInteractive()) {
$this->interact($input, $output);
}
$input->validate();
if ($this->code) {
return call_user_func($this->code, $input, $output);
}
return $this->execute($input, $output);
}
/**
* Sets the code to execute when running this command.
*
* If this method is used, it overrides the code defined
* in the execute() method.
*
* @param \Closure $code A \Closure
*
* @return Command The current instance
*
* @see execute()
*
* @api
*/
public function setCode(\Closure $code)
{
$this->code = $code;
return $this;
}
/**
* Merges the application definition with the command definition.
*/
private function mergeApplicationDefinition()
{
if (null === $this->application || true === $this->applicationDefinitionMerged) {
return;
}
$currentArguments = $this->definition->getArguments();
$this->definition->setArguments($this->application->getDefinition()->getArguments());
$this->definition->addArguments($currentArguments);
$this->definition->addOptions($this->application->getDefinition()->getOptions());
$this->applicationDefinitionMerged = true;
}
/**
* Sets an array of argument and option instances.
*
* @param array|InputDefinition $definition An array of argument and option instances or a definition instance
*
* @return Command The current instance
*
* @api
*/
public function setDefinition($definition)
{
if ($definition instanceof InputDefinition) {
$this->definition = $definition;
} else {
$this->definition->setDefinition($definition);
}
$this->applicationDefinitionMerged = false;
return $this;
}
/**
* Gets the InputDefinition attached to this Command.
*
* @return InputDefinition An InputDefinition instance
*
* @api
*/
public function getDefinition()
{
return $this->definition;
}
/**
* Gets the InputDefinition to be used to create XML and Text representations of this Command.
*
* Can be overridden to provide the original command representation when it would otherwise
* be changed by merging with the application InputDefinition.
*
* @return InputDefinition An InputDefinition instance
*/
protected function getNativeDefinition()
{
return $this->getDefinition();
}
/**
* Adds an argument.
*
* @param string $name The argument name
* @param integer $mode The argument mode: InputArgument::REQUIRED or InputArgument::OPTIONAL
* @param string $description A description text
* @param mixed $default The default value (for InputArgument::OPTIONAL mode only)
*
* @return Command The current instance
*
* @api
*/
public function addArgument($name, $mode = null, $description = '', $default = null)
{
$this->definition->addArgument(new InputArgument($name, $mode, $description, $default));
return $this;
}
/**
* Adds an option.
*
* @param string $name The option name
* @param string $shortcut The shortcut (can be null)
* @param integer $mode The option mode: One of the InputOption::VALUE_* constants
* @param string $description A description text
* @param mixed $default The default value (must be null for InputOption::VALUE_REQUIRED or InputOption::VALUE_NONE)
*
* @return Command The current instance
*
* @api
*/
public function addOption($name, $shortcut = null, $mode = null, $description = '', $default = null)
{
$this->definition->addOption(new InputOption($name, $shortcut, $mode, $description, $default));
return $this;
}
/**
* Sets the name of the command.
*
* This method can set both the namespace and the name if
* you separate them by a colon (:)
*
* $command->setName('foo:bar');
*
* @param string $name The command name
*
* @return Command The current instance
*
* @throws \InvalidArgumentException When command name given is empty
*
* @api
*/
public function setName($name)
{
$this->validateName($name);
$this->name = $name;
return $this;
}
/**
* Returns the command name.
*
* @return string The command name
*
* @api
*/
public function getName()
{
return $this->name;
}
/**
* Sets the description for the command.
*
* @param string $description The description for the command
*
* @return Command The current instance
*
* @api
*/
public function setDescription($description)
{
$this->description = $description;
return $this;
}
/**
* Returns the description for the command.
*
* @return string The description for the command
*
* @api
*/
public function getDescription()
{
return $this->description;
}
/**
* Sets the help for the command.
*
* @param string $help The help for the command
*
* @return Command The current instance
*
* @api
*/
public function setHelp($help)
{
$this->help = $help;
return $this;
}
/**
* Returns the help for the command.
*
* @return string The help for the command
*
* @api
*/
public function getHelp()
{
return $this->help;
}
/**
* Returns the processed help for the command replacing the %command.name% and
* %command.full_name% patterns with the real values dynamically.
*
* @return string The processed help for the command
*/
public function getProcessedHelp()
{
$name = $this->name;
$placeholders = array(
'%command.name%',
'%command.full_name%'
);
$replacements = array(
$name,
$_SERVER['PHP_SELF'].' '.$name
);
return str_replace($placeholders, $replacements, $this->getHelp());
}
/**
* Sets the aliases for the command.
*
* @param array $aliases An array of aliases for the command
*
* @return Command The current instance
*
* @api
*/
public function setAliases($aliases)
{
foreach ($aliases as $alias) {
$this->validateName($alias);
}
$this->aliases = $aliases;
return $this;
}
/**
* Returns the aliases for the command.
*
* @return array An array of aliases for the command
*
* @api
*/
public function getAliases()
{
return $this->aliases;
}
/**
* Returns the synopsis for the command.
*
* @return string The synopsis
*/
public function getSynopsis()
{
if (null === $this->synopsis) {
$this->synopsis = trim(sprintf('%s %s', $this->name, $this->definition->getSynopsis()));
}
return $this->synopsis;
}
/**
* Gets a helper instance by name.
*
* @param string $name The helper name
*
* @return mixed The helper value
*
* @throws \InvalidArgumentException if the helper is not defined
*
* @api
*/
public function getHelper($name)
{
return $this->helperSet->get($name);
}
/**
* Returns a text representation of the command.
*
* @return string A string representing the command
*/
public function asText()
{
$messages = array(
'<comment>Usage:</comment>',
' '.$this->getSynopsis(),
'',
);
if ($this->getAliases()) {
$messages[] = '<comment>Aliases:</comment> <info>'.implode(', ', $this->getAliases()).'</info>';
}
$messages[] = $this->getNativeDefinition()->asText();
if ($help = $this->getProcessedHelp()) {
$messages[] = '<comment>Help:</comment>';
$messages[] = ' '.str_replace("\n", "\n ", $help)."\n";
}
return implode("\n", $messages);
}
/**
* Returns an XML representation of the command.
*
* @param Boolean $asDom Whether to return a DOM or an XML string
*
* @return string|DOMDocument An XML string representing the command
*/
public function asXml($asDom = false)
{
$dom = new \DOMDocument('1.0', 'UTF-8');
$dom->formatOutput = true;
$dom->appendChild($commandXML = $dom->createElement('command'));
$commandXML->setAttribute('id', $this->name);
$commandXML->setAttribute('name', $this->name);
$commandXML->appendChild($usageXML = $dom->createElement('usage'));
$usageXML->appendChild($dom->createTextNode(sprintf($this->getSynopsis(), '')));
$commandXML->appendChild($descriptionXML = $dom->createElement('description'));
$descriptionXML->appendChild($dom->createTextNode(str_replace("\n", "\n ", $this->getDescription())));
$commandXML->appendChild($helpXML = $dom->createElement('help'));
$helpXML->appendChild($dom->createTextNode(str_replace("\n", "\n ", $this->getProcessedHelp())));
$commandXML->appendChild($aliasesXML = $dom->createElement('aliases'));
foreach ($this->getAliases() as $alias) {
$aliasesXML->appendChild($aliasXML = $dom->createElement('alias'));
$aliasXML->appendChild($dom->createTextNode($alias));
}
$definition = $this->getNativeDefinition()->asXml(true);
$commandXML->appendChild($dom->importNode($definition->getElementsByTagName('arguments')->item(0), true));
$commandXML->appendChild($dom->importNode($definition->getElementsByTagName('options')->item(0), true));
return $asDom ? $dom : $dom->saveXml();
}
private function validateName($name)
{
if (!preg_match('/^[^\:]+(\:[^\:]+)*$/', $name)) {
throw new \InvalidArgumentException(sprintf('Command name "%s" is invalid.', $name));
}
}
}

84
vendor/Symfony/Component/Console/Command/HelpCommand.php vendored
View File

@ -1,84 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Console\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Output\Output;
use Symfony\Component\Console\Command\Command;
/**
* HelpCommand displays the help for a given command.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
class HelpCommand extends Command
{
private $command;
/**
* {@inheritdoc}
*/
protected function configure()
{
$this->ignoreValidationErrors();
$this
->setName('help')
->setDefinition(array(
new InputArgument('command_name', InputArgument::OPTIONAL, 'The command name', 'help'),
new InputOption('xml', null, InputOption::VALUE_NONE, 'To output help as XML'),
))
->setDescription('Displays help for a command')
->setHelp(<<<EOF
The <info>%command.name%</info> command displays help for a given command:
<info>php %command.full_name% list</info>
You can also output the help as XML by using the <comment>--xml</comment> option:
<info>php %command.full_name% --xml list</info>
EOF
)
;
}
/**
* Sets the command
*
* @param Command $command The command to set
*/
public function setCommand(Command $command)
{
$this->command = $command;
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
if (null === $this->command) {
$this->command = $this->getApplication()->get($input->getArgument('command_name'));
}
if ($input->getOption('xml')) {
$output->writeln($this->command->asXml(), OutputInterface::OUTPUT_RAW);
} else {
$output->writeln($this->command->asText());
}
$this->command = null;
}
}

87
vendor/Symfony/Component/Console/Command/ListCommand.php vendored
View File

@ -1,87 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Console\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Output\Output;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputDefinition;
/**
* ListCommand displays the list of all available commands for the application.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
class ListCommand extends Command
{
/**
* {@inheritdoc}
*/
protected function configure()
{
$this
->setName('list')
->setDefinition($this->createDefinition())
->setDescription('Lists commands')
->setHelp(<<<EOF
The <info>%command.name%</info> command lists all commands:
<info>php %command.full_name%</info>
You can also display the commands for a specific namespace:
<info>php %command.full_name% test</info>
You can also output the information as XML by using the <comment>--xml</comment> option:
<info>php %command.full_name% --xml</info>
It's also possible to get raw list of commands (useful for embedding command runner):
<info>php %command.full_name% --raw</info>
EOF
)
;
}
/**
* {@inheritdoc}
*/
protected function getNativeDefinition()
{
return $this->createDefinition();
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
if ($input->getOption('xml')) {
$output->writeln($this->getApplication()->asXml($input->getArgument('namespace')), OutputInterface::OUTPUT_RAW);
} else {
$output->writeln($this->getApplication()->asText($input->getArgument('namespace'), $input->getOption('raw')));
}
}
private function createDefinition()
{
return new InputDefinition(array(
new InputArgument('namespace', InputArgument::OPTIONAL, 'The namespace name'),
new InputOption('xml', null, InputOption::VALUE_NONE, 'To output help as XML'),
new InputOption('raw', null, InputOption::VALUE_NONE, 'To output raw command list'),
));
}
}

192
vendor/Symfony/Component/Console/Formatter/OutputFormatter.php vendored
View File

@ -1,192 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Console\Formatter;
/**
* Formatter class for console output.
*
* @author Konstantin Kudryashov <ever.zet@gmail.com>
*
* @api
*/
class OutputFormatter implements OutputFormatterInterface
{
/**
* The pattern to phrase the format.
*/
const FORMAT_PATTERN = '#<([a-z][a-z0-9_=;-]+)>(.*?)</\\1?>#is';
private $decorated;
private $styles = array();
/**
* Initializes console output formatter.
*
* @param Boolean $decorated Whether this formatter should actually decorate strings
* @param array $styles Array of "name => FormatterStyle" instances
*
* @api
*/
public function __construct($decorated = null, array $styles = array())
{
$this->decorated = (Boolean) $decorated;
$this->setStyle('error', new OutputFormatterStyle('white', 'red'));
$this->setStyle('info', new OutputFormatterStyle('green'));
$this->setStyle('comment', new OutputFormatterStyle('yellow'));
$this->setStyle('question', new OutputFormatterStyle('black', 'cyan'));
foreach ($styles as $name => $style) {
$this->setStyle($name, $style);
}
}
/**
* Sets the decorated flag.
*
* @param Boolean $decorated Whether to decorate the messages or not
*
* @api
*/
public function setDecorated($decorated)
{
$this->decorated = (Boolean) $decorated;
}
/**
* Gets the decorated flag.
*
* @return Boolean true if the output will decorate messages, false otherwise
*
* @api
*/
public function isDecorated()
{
return $this->decorated;
}
/**
* Sets a new style.
*
* @param string $name The style name
* @param OutputFormatterStyleInterface $style The style instance
*
* @api
*/
public function setStyle($name, OutputFormatterStyleInterface $style)
{
$this->styles[strtolower($name)] = $style;
}
/**
* Checks if output formatter has style with specified name.
*
* @param string $name
*
* @return Boolean
*
* @api
*/
public function hasStyle($name)
{
return isset($this->styles[strtolower($name)]);
}
/**
* Gets style options from style with specified name.
*
* @param string $name
*
* @return OutputFormatterStyleInterface
*
* @throws \InvalidArgumentException When style isn't defined
*
* @api
*/
public function getStyle($name)
{
if (!$this->hasStyle($name)) {
throw new \InvalidArgumentException('Undefined style: '.$name);
}
return $this->styles[strtolower($name)];
}
/**
* Formats a message according to the given styles.
*
* @param string $message The message to style
*
* @return string The styled message
*
* @api
*/
public function format($message)
{
return preg_replace_callback(self::FORMAT_PATTERN, array($this, 'replaceStyle'), $message);
}
/**
* Replaces style of the output.
*
* @param array $match
*
* @return string The replaced style
*/
private function replaceStyle($match)
{
if (!$this->isDecorated()) {
return $match[2];
}
if (isset($this->styles[strtolower($match[1])])) {
$style = $this->styles[strtolower($match[1])];
} else {
$style = $this->createStyleFromString($match[1]);
if (false === $style) {
return $match[0];
}
}
return $style->apply($this->format($match[2]));
}
/**
* Tries to create new style instance from string.
*
* @param string $string
*
* @return Symfony\Component\Console\Format\FormatterStyle|Boolean false if string is not format string
*/
private function createStyleFromString($string)
{
if (!preg_match_all('/([^=]+)=([^;]+)(;|$)/', strtolower($string), $matches, PREG_SET_ORDER)) {
return false;
}
$style = new OutputFormatterStyle();
foreach ($matches as $match) {
array_shift($match);
if ('fg' == $match[0]) {
$style->setForeground($match[1]);
} elseif ('bg' == $match[0]) {
$style->setBackground($match[1]);
} else {
$style->setOption($match[1]);
}
}
return $style;
}
}

83
vendor/Symfony/Component/Console/Formatter/OutputFormatterInterface.php vendored
View File

@ -1,83 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Console\Formatter;
/**
* Formatter interface for console output.
*
* @author Konstantin Kudryashov <ever.zet@gmail.com>
*
* @api
*/
interface OutputFormatterInterface
{
/**
* Sets the decorated flag.
*
* @param Boolean $decorated Whether to decorate the messages or not
*
* @api
*/
function setDecorated($decorated);
/**
* Gets the decorated flag.
*
* @return Boolean true if the output will decorate messages, false otherwise
*
* @api
*/
function isDecorated();
/**
* Sets a new style.
*
* @param string $name The style name
* @param OutputFormatterStyleInterface $style The style instance
*
* @api
*/
function setStyle($name, OutputFormatterStyleInterface $style);
/**
* Checks if output formatter has style with specified name.
*
* @param string $name
*
* @return Boolean
*
* @api
*/
function hasStyle($name);
/**
* Gets style options from style with specified name.
*
* @param string $name
*
* @return OutputFormatterStyleInterface
*
* @api
*/
function getStyle($name);
/**
* Formats a message according to the given styles.
*
* @param string $message The message to style
*
* @return string The styled message
*
* @api
*/
function format($message);
}

218
vendor/Symfony/Component/Console/Formatter/OutputFormatterStyle.php vendored
View File

@ -1,218 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Console\Formatter;
/**
* Formatter style class for defining styles.
*
* @author Konstantin Kudryashov <ever.zet@gmail.com>
*
* @api
*/
class OutputFormatterStyle implements OutputFormatterStyleInterface
{
static private $availableForegroundColors = array(
'black' => 30,
'red' => 31,
'green' => 32,
'yellow' => 33,
'blue' => 34,
'magenta' => 35,
'cyan' => 36,
'white' => 37
);
static private $availableBackgroundColors = array(
'black' => 40,
'red' => 41,
'green' => 42,
'yellow' => 43,
'blue' => 44,
'magenta' => 45,
'cyan' => 46,
'white' => 47
);
static private $availableOptions = array(
'bold' => 1,
'underscore' => 4,
'blink' => 5,
'reverse' => 7,
'conceal' => 8
);
private $foreground;
private $background;
private $options = array();
/**
* Initializes output formatter style.
*
* @param string $foreground style foreground color name
* @param string $background style background color name
* @param array $options style options
*
* @api
*/
public function __construct($foreground = null, $background = null, array $options = array())
{
if (null !== $foreground) {
$this->setForeground($foreground);
}
if (null !== $background) {
$this->setBackground($background);
}
if (count($options)) {
$this->setOptions($options);
}
}
/**
* Sets style foreground color.
*
* @param string $color color name
*
* @throws \InvalidArgumentException When the color name isn't defined
*
* @api
*/
public function setForeground($color = null)
{
if (null === $color) {
$this->foreground = null;
return;
}
if (!isset(static::$availableForegroundColors[$color])) {
throw new \InvalidArgumentException(sprintf(
'Invalid foreground color specified: "%s". Expected one of (%s)',
$color,
implode(', ', array_keys(static::$availableForegroundColors))
));
}
$this->foreground = static::$availableForegroundColors[$color];
}
/**
* Sets style background color.
*
* @param string $color color name
*
* @throws \InvalidArgumentException When the color name isn't defined
*
* @api
*/
public function setBackground($color = null)
{
if (null === $color) {
$this->background = null;
return;
}
if (!isset(static::$availableBackgroundColors[$color])) {
throw new \InvalidArgumentException(sprintf(
'Invalid background color specified: "%s". Expected one of (%s)',
$color,
implode(', ', array_keys(static::$availableBackgroundColors))
));
}
$this->background = static::$availableBackgroundColors[$color];
}
/**
* Sets some specific style option.
*
* @param string $option option name
*
* @throws \InvalidArgumentException When the option name isn't defined
*
* @api
*/
public function setOption($option)
{
if (!isset(static::$availableOptions[$option])) {
throw new \InvalidArgumentException(sprintf(
'Invalid option specified: "%s". Expected one of (%s)',
$option,
implode(', ', array_keys(static::$availableOptions))
));
}
if (false === array_search(static::$availableOptions[$option], $this->options)) {
$this->options[] = static::$availableOptions[$option];
}
}
/**
* Unsets some specific style option.
*
* @param string $option option name
*
* @throws \InvalidArgumentException When the option name isn't defined
*
*/
public function unsetOption($option)
{
if (!isset(static::$availableOptions[$option])) {
throw new \InvalidArgumentException(sprintf(
'Invalid option specified: "%s". Expected one of (%s)',
$option,
implode(', ', array_keys(static::$availableOptions))
));
}
$pos = array_search(static::$availableOptions[$option], $this->options);
if (false !== $pos) {
unset($this->options[$pos]);
}
}
/**
* Sets multiple style options at once.
*
* @param array $options
*/
public function setOptions(array $options)
{
$this->options = array();
foreach ($options as $option) {
$this->setOption($option);
}
}
/**
* Applies the style to a given text.
*
* @param string $text The text to style
*
* @return string
*/
public function apply($text)
{
$codes = array();
if (null !== $this->foreground) {
$codes[] = $this->foreground;
}
if (null !== $this->background) {
$codes[] = $this->background;
}
if (count($this->options)) {
$codes = array_merge($codes, $this->options);
}
return sprintf("\033[%sm%s\033[0m", implode(';', $codes), $text);
}
}

72
vendor/Symfony/Component/Console/Formatter/OutputFormatterStyleInterface.php vendored
View File

@ -1,72 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Console\Formatter;
/**
* Formatter style interface for defining styles.
*
* @author Konstantin Kudryashov <ever.zet@gmail.com>
*
* @api
*/
interface OutputFormatterStyleInterface
{
/**
* Sets style foreground color.
*
* @param string $color color name
*
* @api
*/
function setForeground($color = null);
/**
* Sets style background color.
*
* @param string $color color name
*
* @api
*/
function setBackground($color = null);
/**
* Sets some specific style option.
*
* @param string $option option name
*
* @api
*/
function setOption($option);
/**
* Unsets some specific style option.
*
* @param string $option option name
*/
function unsetOption($option);
/**
* Sets multiple style options at once.
*
* @param array $options
*/
function setOptions(array $options);
/**
* Applies the style to a given text.
*
* @param string $text The text to style
*
* @return string
*/
function apply($text);
}

139
vendor/Symfony/Component/Console/Helper/DialogHelper.php vendored
View File

@ -1,139 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Console\Helper;
use Symfony\Component\Console\Output\OutputInterface;
/**
* The Dialog class provides helpers to interact with the user.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
class DialogHelper extends Helper
{
private $inputStream;
/**
* Asks a question to the user.
*
* @param OutputInterface $output An Output instance
* @param string|array $question The question to ask
* @param string $default The default answer if none is given by the user
*
* @return string The user answer
*
* @throws \RuntimeException If there is no data to read in the input stream
*/
public function ask(OutputInterface $output, $question, $default = null)
{
$output->write($question);
$ret = fgets($this->inputStream ?: STDIN, 4096);
if (false === $ret) {
throw new \RuntimeException('Aborted');
}
$ret = trim($ret);
return strlen($ret) > 0 ? $ret : $default;
}
/**
* Asks a confirmation to the user.
*
* The question will be asked until the user answers by nothing, yes, or no.
*
* @param OutputInterface $output An Output instance
* @param string|array $question The question to ask
* @param Boolean $default The default answer if the user enters nothing
*
* @return Boolean true if the user has confirmed, false otherwise
*/
public function askConfirmation(OutputInterface $output, $question, $default = true)
{
$answer = 'z';
while ($answer && !in_array(strtolower($answer[0]), array('y', 'n'))) {
$answer = $this->ask($output, $question);
}
if (false === $default) {
return $answer && 'y' == strtolower($answer[0]);
}
return !$answer || 'y' == strtolower($answer[0]);
}
/**
* Asks for a value and validates the response.
*
* The validator receives the data to validate. It must return the
* validated data when the data is valid and throw an exception
* otherwise.
*
* @param OutputInterface $output An Output instance
* @param string|array $question The question to ask
* @param callback $validator A PHP callback
* @param integer $attempts Max number of times to ask before giving up (false by default, which means infinite)
* @param string $default The default answer if none is given by the user
*
* @return mixed
*
* @throws \Exception When any of the validators return an error
*/
public function askAndValidate(OutputInterface $output, $question, $validator, $attempts = false, $default = null)
{
$error = null;
while (false === $attempts || $attempts--) {
if (null !== $error) {
$output->writeln($this->getHelperSet()->get('formatter')->formatBlock($error->getMessage(), 'error'));
}
$value = $this->ask($output, $question, $default);
try {
return call_user_func($validator, $value);
} catch (\Exception $error) {
}
}
throw $error;
}
/**
* Sets the input stream to read from when interacting with the user.
*
* This is mainly useful for testing purpose.
*
* @param resource $stream The input stream
*/
public function setInputStream($stream)
{
$this->inputStream = $stream;
}
/**
* Returns the helper's input stream
*
* @return string
*/
public function getInputStream()
{
return $this->inputStream;
}
/**
* Returns the helper's canonical name.
*/
public function getName()
{
return 'dialog';
}
}

97
vendor/Symfony/Component/Console/Helper/FormatterHelper.php vendored
View File

@ -1,97 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Console\Helper;
/**
* The Formatter class provides helpers to format messages.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
class FormatterHelper extends Helper
{
/**
* Formats a message within a section.
*
* @param string $section The section name
* @param string $message The message
* @param string $style The style to apply to the section
*/
public function formatSection($section, $message, $style = 'info')
{
return sprintf('<%s>[%s]</%s> %s', $style, $section, $style, $message);
}
/**
* Formats a message as a block of text.
*
* @param string|array $messages The message to write in the block
* @param string $style The style to apply to the whole block
* @param Boolean $large Whether to return a large block
*
* @return string The formatter message
*/
public function formatBlock($messages, $style, $large = false)
{
$messages = (array) $messages;
$len = 0;
$lines = array();
foreach ($messages as $message) {
$lines[] = sprintf($large ? ' %s ' : ' %s ', $message);
$len = max($this->strlen($message) + ($large ? 4 : 2), $len);
}
$messages = $large ? array(str_repeat(' ', $len)) : array();
foreach ($lines as $line) {
$messages[] = $line.str_repeat(' ', $len - $this->strlen($line));
}
if ($large) {
$messages[] = str_repeat(' ', $len);
}
foreach ($messages as &$message) {
$message = sprintf('<%s>%s</%s>', $style, $message, $style);
}
return implode("\n", $messages);
}
/**
* Returns the length of a string, using mb_strlen if it is available.
*
* @param string $string The string to check its length
*
* @return integer The length of the string
*/
private function strlen($string)
{
if (!function_exists('mb_strlen')) {
return strlen($string);
}
if (false === $encoding = mb_detect_encoding($string)) {
return strlen($string);
}
return mb_strlen($string, $encoding);
}
/**
* Returns the helper's canonical name.
*
* @return string The canonical name of the helper
*/
public function getName()
{
return 'formatter';
}
}

42
vendor/Symfony/Component/Console/Helper/Helper.php vendored
View File

@ -1,42 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Console\Helper;
/**
* Helper is the base class for all helper classes.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
abstract class Helper implements HelperInterface
{
protected $helperSet = null;
/**
* Sets the helper set associated with this helper.
*
* @param HelperSet $helperSet A HelperSet instance
*/
public function setHelperSet(HelperSet $helperSet = null)
{
$this->helperSet = $helperSet;
}
/**
* Gets the helper set associated with this helper.
*
* @return HelperSet A HelperSet instance
*/
public function getHelperSet()
{
return $this->helperSet;
}
}

Some files were not shown because too many files have changed in this diff Show More