{{ $paste }}
41 | * // Put an item in the cache for 15 minutes
42 | * Cache::put('name', 'Taylor', 15);
43 | *
44 | *
45 | * @param string $key
46 | * @param mixed $value
47 | * @param int $minutes
48 | * @return void
49 | */
50 | public function put($key, $value, $minutes)
51 | {
52 | $this->storage[$key] = $value;
53 | }
54 |
55 | /**
56 | * Write an item to the cache that lasts forever.
57 | *
58 | * @param string $key
59 | * @param mixed $value
60 | * @return void
61 | */
62 | public function forever($key, $value)
63 | {
64 | $this->put($key, $value, 0);
65 | }
66 |
67 | /**
68 | * Delete an item from the cache.
69 | *
70 | * @param string $key
71 | * @return void
72 | */
73 | public function forget($key)
74 | {
75 | unset($this->storage[$key]);
76 | }
77 |
78 | /**
79 | * Flush the entire cache.
80 | *
81 | * @return void
82 | */
83 | public function flush()
84 | {
85 | $this->storage = array();
86 | }
87 |
88 | }
--------------------------------------------------------------------------------
/laravel/memcached.php:
--------------------------------------------------------------------------------
1 |
16 | * // Get the Memcache connection and get an item from the cache
17 | * $name = Memcached::connection()->get('name');
18 | *
19 | * // Get the Memcache connection and place an item in the cache
20 | * Memcached::connection()->set('name', 'Taylor');
21 | *
22 | *
23 | * @return Memcached
24 | */
25 | public static function connection()
26 | {
27 | if (is_null(static::$connection))
28 | {
29 | static::$connection = static::connect(Config::get('cache.memcached'));
30 | }
31 |
32 | return static::$connection;
33 | }
34 |
35 | /**
36 | * Create a new Memcached connection instance.
37 | *
38 | * @param array $servers
39 | * @return Memcached
40 | */
41 | protected static function connect($servers)
42 | {
43 | $memcache = new \Memcache;
44 |
45 | foreach ($servers as $server)
46 | {
47 | $memcache->addServer($server['host'], $server['port'], true, $server['weight']);
48 | }
49 |
50 | if ($memcache->getVersion() === false)
51 | {
52 | throw new \Exception('Could not establish memcached connection.');
53 | }
54 |
55 | return $memcache;
56 | }
57 |
58 | /**
59 | * Dynamically pass all other method calls to the Memcache instance.
60 | *
61 | *
62 | * // Get an item from the Memcache instance
63 | * $name = Memcached::get('name');
64 | *
65 | * // Store data on the Memcache server
66 | * Memcached::set('name', 'Taylor');
67 | *
68 | */
69 | public static function __callStatic($method, $parameters)
70 | {
71 | return call_user_func_array(array(static::instance(), $method), $parameters);
72 | }
73 |
74 | }
--------------------------------------------------------------------------------
/laravel/cache/drivers/apc.php:
--------------------------------------------------------------------------------
1 | key = $key;
21 | }
22 |
23 | /**
24 | * Determine if an item exists in the cache.
25 | *
26 | * @param string $key
27 | * @return bool
28 | */
29 | public function has($key)
30 | {
31 | return ( ! is_null($this->get($key)));
32 | }
33 |
34 | /**
35 | * Retrieve an item from the cache driver.
36 | *
37 | * @param string $key
38 | * @return mixed
39 | */
40 | protected function retrieve($key)
41 | {
42 | if (($cache = apc_fetch($this->key.$key)) !== false)
43 | {
44 | return $cache;
45 | }
46 | }
47 |
48 | /**
49 | * Write an item to the cache for a given number of minutes.
50 | *
51 | *
52 | * // Put an item in the cache for 15 minutes
53 | * Cache::put('name', 'Taylor', 15);
54 | *
55 | *
56 | * @param string $key
57 | * @param mixed $value
58 | * @param int $minutes
59 | * @return void
60 | */
61 | public function put($key, $value, $minutes)
62 | {
63 | apc_store($this->key.$key, $value, $minutes * 60);
64 | }
65 |
66 | /**
67 | * Write an item to the cache that lasts forever.
68 | *
69 | * @param string $key
70 | * @param mixed $value
71 | * @return void
72 | */
73 | public function forever($key, $value)
74 | {
75 | return $this->put($key, $value, 0);
76 | }
77 |
78 | /**
79 | * Delete an item from the cache.
80 | *
81 | * @param string $key
82 | * @return void
83 | */
84 | public function forget($key)
85 | {
86 | apc_delete($this->key.$key);
87 | }
88 |
89 | }
--------------------------------------------------------------------------------
/laravel/session/drivers/file.php:
--------------------------------------------------------------------------------
1 | path = $path;
21 | }
22 |
23 | /**
24 | * Load a session from storage by a given ID.
25 | *
26 | * If no session is found for the ID, null will be returned.
27 | *
28 | * @param string $id
29 | * @return array
30 | */
31 | public function load($id)
32 | {
33 | if (file_exists($path = $this->path.$id))
34 | {
35 | return unserialize(file_get_contents($path));
36 | }
37 | }
38 |
39 | /**
40 | * Save a given session to storage.
41 | *
42 | * @param array $session
43 | * @param array $config
44 | * @param bool $exists
45 | * @return void
46 | */
47 | public function save($session, $config, $exists)
48 | {
49 | file_put_contents($this->path.$session['id'], serialize($session), LOCK_EX);
50 | }
51 |
52 | /**
53 | * Delete a session from storage by a given ID.
54 | *
55 | * @param string $id
56 | * @return void
57 | */
58 | public function delete($id)
59 | {
60 | if (file_exists($this->path.$id))
61 | {
62 | @unlink($this->path.$id);
63 | }
64 | }
65 |
66 | /**
67 | * Delete all expired sessions from persistant storage.
68 | *
69 | * @param int $expiration
70 | * @return void
71 | */
72 | public function sweep($expiration)
73 | {
74 | $files = glob($this->path.'*');
75 |
76 | if ($files === false) return;
77 |
78 | foreach ($files as $file)
79 | {
80 | if (filetype($file) == 'file' and filemtime($file) < $expiration)
81 | {
82 | @unlink($file);
83 | }
84 | }
85 | }
86 |
87 | }
--------------------------------------------------------------------------------
/laravel/cache/drivers/redis.php:
--------------------------------------------------------------------------------
1 | redis = $redis;
21 | }
22 |
23 | /**
24 | * Determine if an item exists in the cache.
25 | *
26 | * @param string $key
27 | * @return bool
28 | */
29 | public function has($key)
30 | {
31 | return ( ! is_null($this->redis->get($key)));
32 | }
33 |
34 | /**
35 | * Retrieve an item from the cache driver.
36 | *
37 | * @param string $key
38 | * @return mixed
39 | */
40 | protected function retrieve($key)
41 | {
42 | if ( ! is_null($cache = $this->redis->get($key)))
43 | {
44 | return unserialize($cache);
45 | }
46 | }
47 |
48 | /**
49 | * Write an item to the cache for a given number of minutes.
50 | *
51 | *
52 | * // Put an item in the cache for 15 minutes
53 | * Cache::put('name', 'Taylor', 15);
54 | *
55 | *
56 | * @param string $key
57 | * @param mixed $value
58 | * @param int $minutes
59 | * @return void
60 | */
61 | public function put($key, $value, $minutes)
62 | {
63 | $this->forever($key, $value);
64 |
65 | $this->redis->expire($key, $minutes * 60);
66 | }
67 |
68 | /**
69 | * Write an item to the cache that lasts forever.
70 | *
71 | * @param string $key
72 | * @param mixed $value
73 | * @return void
74 | */
75 | public function forever($key, $value)
76 | {
77 | $this->redis->set($key, serialize($value));
78 | }
79 |
80 | /**
81 | * Delete an item from the cache.
82 | *
83 | * @param string $key
84 | * @return void
85 | */
86 | public function forget($key)
87 | {
88 | $this->redis->del($key);
89 | }
90 |
91 | }
--------------------------------------------------------------------------------
/vendor/Symfony/Component/Console/Formatter/OutputFormatterInterface.php:
--------------------------------------------------------------------------------
1 |
7 | *
8 | * For the full copyright and license information, please view the LICENSE
9 | * file that was distributed with this source code.
10 | */
11 |
12 | namespace Symfony\Component\Console\Formatter;
13 |
14 | /**
15 | * Formatter interface for console output.
16 | *
17 | * @author Konstantin Kudryashov
60 | * // Put an item in the cache for 15 minutes
61 | * Cache::put('name', 'Taylor', 15);
62 | *
63 | *
64 | * @param string $key
65 | * @param mixed $value
66 | * @param int $minutes
67 | * @return void
68 | */
69 | public function put($key, $value, $minutes)
70 | {
71 | $this->memcache->set($this->key.$key, $value, 0, $minutes * 60);
72 | }
73 |
74 | /**
75 | * Write an item to the cache that lasts forever.
76 | *
77 | * @param string $key
78 | * @param mixed $value
79 | * @return void
80 | */
81 | public function forever($key, $value)
82 | {
83 | return $this->put($key, $value, 0);
84 | }
85 |
86 | /**
87 | * Delete an item from the cache.
88 | *
89 | * @param string $key
90 | * @return void
91 | */
92 | public function forget($key)
93 | {
94 | $this->memcache->delete($this->key.$key);
95 | }
96 |
97 | }
--------------------------------------------------------------------------------
/laravel/cli/tasks/migrate/database.php:
--------------------------------------------------------------------------------
1 | table()->insert(compact('bundle', 'name', 'batch'));
19 | }
20 |
21 | /**
22 | * Delete a row from the migration table.
23 | *
24 | * @param string $bundle
25 | * @param string $name
26 | * @return void
27 | */
28 | public function delete($bundle, $name)
29 | {
30 | $this->table()->where_bundle_and_name($bundle, $name)->delete();
31 | }
32 |
33 | /**
34 | * Return an array of the last batch of migrations.
35 | *
36 | * @return array
37 | */
38 | public function last()
39 | {
40 | $table = $this->table();
41 |
42 | // First we need to grab the last batch ID from the migration table,
43 | // as this will allow us to grab the lastest batch of migrations
44 | // that need to be run for a rollback command.
45 | $id = $this->batch();
46 |
47 | // Once we have the batch ID, we will pull all of the rows for that
48 | // batch. Then we can feed the results into the resolve method to
49 | // get the migration instances for the command.
50 | return $table->where_batch($id)->order_by('name', 'desc')->get();
51 | }
52 |
53 | /**
54 | * Get all of the migrations that have run for a bundle.
55 | *
56 | * @param string $bundle
57 | * @return array
58 | */
59 | public function ran($bundle)
60 | {
61 | return $this->table()->where_bundle($bundle)->lists('name');
62 | }
63 |
64 | /**
65 | * Get the maximum batch ID from the migration table.
66 | *
67 | * @return int
68 | */
69 | public function batch()
70 | {
71 | return $this->table()->max('batch');
72 | }
73 |
74 | /**
75 | * Get a database query instance for the migration table.
76 | *
77 | * @return Laravel\Database\Query
78 | */
79 | protected function table()
80 | {
81 | return DB::connection(Request::server('cli.db'))->table('laravel_migrations');
82 | }
83 |
84 | }
--------------------------------------------------------------------------------
/laravel/fluent.php:
--------------------------------------------------------------------------------
1 |
16 | * Create a new fluent container with attributes
17 | * $fluent = new Fluent(array('name' => 'Taylor'));
18 | *
19 | *
20 | * @param array $attributes
21 | * @return void
22 | */
23 | public function __construct($attributes = array())
24 | {
25 | foreach ($attributes as $key => $value)
26 | {
27 | $this->$key = $value;
28 | }
29 | }
30 |
31 | /**
32 | * Get an attribute from the fluent container.
33 | *
34 | * @param string $attribute
35 | * @param mixed $default
36 | * @return mixed
37 | */
38 | public function get($attribute, $default = null)
39 | {
40 | return array_get($this->attributes, $attribute, $default);
41 | }
42 |
43 | /**
44 | * Handle dynamic calls to the container to set attributes.
45 | *
46 | *
47 | * // Fluently set the value of a few attributes
48 | * $fluent->name('Taylor')->age(25);
49 | *
50 | * // Set the value of an attribute to true (boolean)
51 | * $fluent->nullable()->name('Taylor');
52 | *
53 | */
54 | public function __call($method, $parameters)
55 | {
56 | $this->$method = (count($parameters) > 0) ? $parameters[0] : true;
57 |
58 | return $this;
59 | }
60 |
61 | /**
62 | * Dynamically retrieve the value of an attribute.
63 | */
64 | public function __get($key)
65 | {
66 | if (array_key_exists($key, $this->attributes))
67 | {
68 | return $this->attributes[$key];
69 | }
70 | }
71 |
72 | /**
73 | * Dynamically set the value of an attribute.
74 | */
75 | public function __set($key, $value)
76 | {
77 | $this->attributes[$key] = $value;
78 | }
79 |
80 | /**
81 | * Dynamically check if an attribute is set.
82 | */
83 | public function __isset($key)
84 | {
85 | return isset($this->attributes[$key]);
86 | }
87 |
88 | /**
89 | * Dynamically unset an attribute.
90 | */
91 | public function __unset($key)
92 | {
93 | unset($this->attributes[$key]);
94 | }
95 |
96 | }
--------------------------------------------------------------------------------
/laravel/cli/tasks/bundle/providers/provider.php:
--------------------------------------------------------------------------------
1 | download($url));
34 |
35 | $zip = new \ZipArchive;
36 |
37 | $zip->open($target);
38 |
39 | // Once we have the Zip archive, we can open it and extract it
40 | // into the working directory. By convention, we expect the
41 | // archive to contain one root directory with the bundle.
42 | mkdir($work.'zip');
43 |
44 | $zip->extractTo($work.'zip');
45 |
46 | $latest = File::latest($work.'zip')->getRealPath();
47 |
48 | @chmod($latest, 0777);
49 |
50 | // Once we have the latest modified directory, we should be
51 | // able to move its contents over into the bundles folder
52 | // so the bundle will be usable by the develoepr.
53 | File::mvdir($latest, $path);
54 |
55 | File::rmdir($work.'zip');
56 |
57 | @unlink($target);
58 | }
59 |
60 | /**
61 | * Download a remote zip archive from a URL.
62 | *
63 | * @param string $url
64 | * @return string
65 | */
66 | protected function download($url)
67 | {
68 | $remote = file_get_contents($url);
69 |
70 | // If we were unable to download the zip archive correctly
71 | // we'll bomb out since we don't want to extract the last
72 | // zip that was put in the storage directory.
73 | if ($remote === false)
74 | {
75 | throw new \Exception("Error downloading bundle [{$bundle}].");
76 | }
77 |
78 | return $remote;
79 | }
80 |
81 | }
--------------------------------------------------------------------------------
/license.txt:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) <2012>
60 | * // Put an item in the cache for 15 minutes
61 | * Cache::put('name', 'Taylor', 15);
62 | *
63 | *
64 | * @param string $key
65 | * @param mixed $value
66 | * @param int $minutes
67 | * @return void
68 | */
69 | public function put($key, $value, $minutes)
70 | {
71 | $value = $this->expiration($minutes).serialize($value);
72 |
73 | file_put_contents($this->path.$key, $value, LOCK_EX);
74 | }
75 |
76 | /**
77 | * Write an item to the cache for five years.
78 | *
79 | * @param string $key
80 | * @param mixed $value
81 | * @return void
82 | */
83 | public function forever($key, $value)
84 | {
85 | return $this->put($key, $value, 2628000);
86 | }
87 |
88 | /**
89 | * Delete an item from the cache.
90 | *
91 | * @param string $key
92 | * @return void
93 | */
94 | public function forget($key)
95 | {
96 | if (file_exists($this->path.$key)) @unlink($this->path.$key);
97 | }
98 |
99 | }
--------------------------------------------------------------------------------
/laravel/cache.php:
--------------------------------------------------------------------------------
1 |
18 | * // Get the default cache driver instance
19 | * $driver = Cache::driver();
20 | *
21 | * // Get a specific cache driver instance by name
22 | * $driver = Cache::driver('memcached');
23 | *
24 | *
25 | * @param string $driver
26 | * @return Cache\Drivers\Driver
27 | */
28 | public static function driver($driver = null)
29 | {
30 | if (is_null($driver)) $driver = Config::get('cache.driver');
31 |
32 | if ( ! isset(static::$drivers[$driver]))
33 | {
34 | static::$drivers[$driver] = static::factory($driver);
35 | }
36 |
37 | return static::$drivers[$driver];
38 | }
39 |
40 | /**
41 | * Create a new cache driver instance.
42 | *
43 | * @param string $driver
44 | * @return Cache\Drivers\Driver
45 | */
46 | protected static function factory($driver)
47 | {
48 | switch ($driver)
49 | {
50 | case 'apc':
51 | return new Cache\Drivers\APC(Config::get('cache.key'));
52 |
53 | case 'file':
54 | return new Cache\Drivers\File(path('storage').'cache'.DS);
55 |
56 | case 'memcached':
57 | return new Cache\Drivers\Memcached(Memcached::connection(), Config::get('cache.key'));
58 |
59 | case 'memory':
60 | return new Cache\Drivers\Memory;
61 |
62 | case 'redis':
63 | return new Cache\Drivers\Redis(Redis::db());
64 |
65 | case 'database':
66 | return new Cache\Drivers\Database(Config::get('cache.key'));
67 |
68 | default:
69 | throw new \Exception("Cache driver {$driver} is not supported.");
70 | }
71 | }
72 |
73 | /**
74 | * Magic Method for calling the methods on the default cache driver.
75 | *
76 | *
77 | * // Call the "get" method on the default cache driver
78 | * $name = Cache::get('name');
79 | *
80 | * // Call the "put" method on the default cache driver
81 | * Cache::put('name', 'Taylor', 15);
82 | *
83 | */
84 | public static function __callStatic($method, $parameters)
85 | {
86 | return call_user_func_array(array(static::driver(), $method), $parameters);
87 | }
88 |
89 | }
90 |
--------------------------------------------------------------------------------
/application/config/error.php:
--------------------------------------------------------------------------------
1 | array(),
17 |
18 | /*
19 | |--------------------------------------------------------------------------
20 | | Error Detail
21 | |--------------------------------------------------------------------------
22 | |
23 | | Detailed error messages contain information about the file in which an
24 | | error occurs, as well as a PHP stack trace containing the call stack.
25 | | You'll want them when you're trying to debug your application.
26 | |
27 | | If your application is in production, you'll want to turn off the error
28 | | details for enhanced security and user experience since the exception
29 | | stack trace could contain sensitive information.
30 | |
31 | */
32 |
33 | 'detail' => true,
34 |
35 | /*
36 | |--------------------------------------------------------------------------
37 | | Error Logging
38 | |--------------------------------------------------------------------------
39 | |
40 | | When error logging is enabled, the "logger" Closure defined below will
41 | | be called for every error in your application. You are free to log the
42 | | errors however you want. Enjoy the flexibility.
43 | |
44 | */
45 |
46 | 'log' => false,
47 |
48 | /*
49 | |--------------------------------------------------------------------------
50 | | Error Logger
51 | |--------------------------------------------------------------------------
52 | |
53 | | Because of the various ways of managing error logging, you get complete
54 | | flexibility to manage error logging as you see fit. This function will
55 | | be called anytime an error occurs within your application and error
56 | | logging is enabled.
57 | |
58 | | You may log the error message however you like; however, a simple log
59 | | solution has been setup for you which will log all error messages to
60 | | text files within the application storage directory.
61 | |
62 | */
63 |
64 | 'logger' => function($exception)
65 | {
66 | Log::exception($exception);
67 | },
68 |
69 | );
--------------------------------------------------------------------------------
/application/views/error/500.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | 93 | Something went wrong on our servers while we were processing your request. 94 | We're really sorry about this, and will work hard to get this resolved as 95 | soon as possible. 96 |
97 | 98 |99 | Perhaps you would like to go to our ? 100 |
101 |93 | We couldn't find the page you requested on our servers. We're really sorry 94 | about that. It's our fault, not yours. We'll work hard to get this page 95 | back online as soon as possible. 96 |
97 | 98 |99 | Perhaps you would like to go to our ? 100 |
101 |
31 | * // Write an "error" messge to the log file
32 | * Log::write('error', 'Something went horribly wrong!');
33 | *
34 | * // Write an "error" message using the class' magic method
35 | * Log::error('Something went horribly wrong!');
36 | *
37 | *
38 | * @param string $type
39 | * @param string $message
40 | * @return void
41 | */
42 | public static function write($type, $message)
43 | {
44 | // If there is a listener for the log event, we'll delegate the logging
45 | // to the event and not write to the log files. This allows for quick
46 | // swapping of log implementations for debugging.
47 | if (Event::listeners('laravel.log'))
48 | {
49 | Event::fire('laravel.log', array($type, $message));
50 | }
51 |
52 | // If there aren't listeners on the log event, we'll just write to the
53 | // log files using the default conventions, writing one log file per
54 | // day so they files don't get too crowded.
55 | else
56 | {
57 | $message = static::format($type, $message);
58 |
59 | File::append(path('storage').'logs/'.date('Y-m-d').'.log', $message);
60 | }
61 | }
62 |
63 | /**
64 | * Format a log message for logging.
65 | *
66 | * @param string $type
67 | * @param
68 | */
69 | protected static function format($type, $message)
70 | {
71 | return date('Y-m-d H:i:s').' '.Str::upper($type)." - {$message}".PHP_EOL;
72 | }
73 |
74 | /**
75 | * Dynamically write a log message.
76 | *
77 | *
78 | * // Write an "error" message to the log file
79 | * Log::error('This is an error!');
80 | *
81 | * // Write a "warning" message to the log file
82 | * Log::warning('This is a warning!');
83 | *
84 | */
85 | public static function __callStatic($method, $parameters)
86 | {
87 | static::write($method, $parameters[0]);
88 | }
89 |
90 | }
--------------------------------------------------------------------------------
/application/config/cache.php:
--------------------------------------------------------------------------------
1 | 'file',
23 |
24 | /*
25 | |--------------------------------------------------------------------------
26 | | Cache Key
27 | |--------------------------------------------------------------------------
28 | |
29 | | This key will be prepended to item keys stored using Memcached and APC
30 | | to prevent collisions with other applications on the server. Since the
31 | | memory based stores could be shared by other applications, we need to
32 | | be polite and use a prefix to uniquely identifier our items.
33 | |
34 | */
35 |
36 | 'key' => 'laravel',
37 |
38 | /*
39 | |--------------------------------------------------------------------------
40 | | Cache Database
41 | |--------------------------------------------------------------------------
42 | |
43 | | When using the database cache driver, this database table will be used
44 | | to store the cached item. You may also add a "connection" option to
45 | | the array to specify which database connection should be used.
46 | |
47 | */
48 |
49 | 'database' => array('table' => 'laravel_cache'),
50 |
51 | /*
52 | |--------------------------------------------------------------------------
53 | | Memcached Servers
54 | |--------------------------------------------------------------------------
55 | |
56 | | The Memcached servers used by your application. Memcached is a free and
57 | | open source, high-performance, distributed memory caching system. It is
58 | | generic in nature but intended for use in speeding up web applications
59 | | by alleviating database load.
60 | |
61 | | For more information, check out: http://memcached.org
62 | |
63 | */
64 |
65 | 'memcached' => array(
66 |
67 | array('host' => '127.0.0.1', 'port' => 11211, 'weight' => 100),
68 |
69 | ),
70 |
71 | );
--------------------------------------------------------------------------------
/laravel/session/drivers/database.php:
--------------------------------------------------------------------------------
1 | connection = $connection;
24 | }
25 |
26 | /**
27 | * Load a session from storage by a given ID.
28 | *
29 | * If no session is found for the ID, null will be returned.
30 | *
31 | * @param string $id
32 | * @return array
33 | */
34 | public function load($id)
35 | {
36 | $session = $this->table()->find($id);
37 |
38 | if ( ! is_null($session))
39 | {
40 | return array(
41 | 'id' => $session->id,
42 | 'last_activity' => $session->last_activity,
43 | 'data' => unserialize($session->data)
44 | );
45 | }
46 | }
47 |
48 | /**
49 | * Save a given session to storage.
50 | *
51 | * @param array $session
52 | * @param array $config
53 | * @param bool $exists
54 | * @return void
55 | */
56 | public function save($session, $config, $exists)
57 | {
58 | if ($exists)
59 | {
60 | $this->table()->where('id', '=', $session['id'])->update(array(
61 | 'last_activity' => $session['last_activity'],
62 | 'data' => serialize($session['data']),
63 | ));
64 | }
65 | else
66 | {
67 | $this->table()->insert(array(
68 | 'id' => $session['id'],
69 | 'last_activity' => $session['last_activity'],
70 | 'data' => serialize($session['data'])
71 | ));
72 | }
73 | }
74 |
75 | /**
76 | * Delete a session from storage by a given ID.
77 | *
78 | * @param string $id
79 | * @return void
80 | */
81 | public function delete($id)
82 | {
83 | $this->table()->delete($id);
84 | }
85 |
86 | /**
87 | * Delete all expired sessions from persistant storage.
88 | *
89 | * @param int $expiration
90 | * @return void
91 | */
92 | public function sweep($expiration)
93 | {
94 | $this->table()->where('last_activity', '<', $expiration)->delete();
95 | }
96 |
97 | /**
98 | * Get a session database query.
99 | *
100 | * @return Query
101 | */
102 | private function table()
103 | {
104 | return $this->connection->table(Config::get('session.table'));
105 | }
106 |
107 | }
--------------------------------------------------------------------------------
/vendor/Symfony/Component/Console/Command/HelpCommand.php:
--------------------------------------------------------------------------------
1 |
7 | *
8 | * For the full copyright and license information, please view the LICENSE
9 | * file that was distributed with this source code.
10 | */
11 |
12 | namespace Symfony\Component\Console\Command;
13 |
14 | use Symfony\Component\Console\Input\InputArgument;
15 | use Symfony\Component\Console\Input\InputOption;
16 | use Symfony\Component\Console\Input\InputInterface;
17 | use Symfony\Component\Console\Output\OutputInterface;
18 | use Symfony\Component\Console\Output\Output;
19 | use Symfony\Component\Console\Command\Command;
20 |
21 | /**
22 | * HelpCommand displays the help for a given command.
23 | *
24 | * @author Fabien Potencier
45 | * // Put an item in the cache for 15 minutes
46 | * Cache::put('name', 'Taylor', 15);
47 | *
48 | *
49 | * @param string $key
50 | * @param mixed $value
51 | * @param int $minutes
52 | * @return void
53 | */
54 | abstract public function put($key, $value, $minutes);
55 |
56 | /**
57 | * Get an item from the cache, or cache and return the default value.
58 | *
59 | *
60 | * // Get an item from the cache, or cache a value for 15 minutes
61 | * $name = Cache::remember('name', 'Taylor', 15);
62 | *
63 | * // Use a closure for deferred execution
64 | * $count = Cache::remember('count', function() { return User::count(); }, 15);
65 | *
66 | *
67 | * @param string $key
68 | * @param mixed $default
69 | * @param int $minutes
70 | * @return mixed
71 | */
72 | public function remember($key, $default, $minutes)
73 | {
74 | if ( ! is_null($item = $this->get($key, null))) return $item;
75 |
76 | $this->put($key, $default = value($default), $minutes);
77 |
78 | return $default;
79 | }
80 |
81 | /**
82 | * Delete an item from the cache.
83 | *
84 | * @param string $key
85 | * @return void
86 | */
87 | abstract public function forget($key);
88 |
89 | /**
90 | * Get the expiration time as a UNIX timestamp.
91 | *
92 | * @param int $minutes
93 | * @return int
94 | */
95 | protected function expiration($minutes)
96 | {
97 | return time() + ($minutes * 60);
98 | }
99 |
100 | }
101 |
--------------------------------------------------------------------------------
/vendor/Symfony/Component/Console/Output/ConsoleOutput.php:
--------------------------------------------------------------------------------
1 |
7 | *
8 | * For the full copyright and license information, please view the LICENSE
9 | * file that was distributed with this source code.
10 | */
11 |
12 | namespace Symfony\Component\Console\Output;
13 |
14 | use Symfony\Component\Console\Formatter\OutputFormatter;
15 | use Symfony\Component\Console\Formatter\OutputFormatterInterface;
16 | use Symfony\Component\Console\Output\ConsoleOutputInterface;
17 |
18 | /**
19 | * ConsoleOutput is the default class for all CLI output. It uses STDOUT.
20 | *
21 | * This class is a convenient wrapper around `StreamOutput`.
22 | *
23 | * $output = new ConsoleOutput();
24 | *
25 | * This is equivalent to:
26 | *
27 | * $output = new StreamOutput(fopen('php://stdout', 'w'));
28 | *
29 | * @author Fabien Potencier
52 | * // Inject inline content into the "header" section
53 | * Section::inject('header', 'Laravel ');
54 | *
55 | *
56 | * @param string $section
57 | * @param string $content
58 | * @return void
59 | */
60 | public static function inject($section, $content)
61 | {
62 | static::start($section, $content);
63 | }
64 |
65 | /**
66 | * Stop injecting content into a section and return its contents.
67 | *
68 | * @return string
69 | */
70 | public static function yield_section()
71 | {
72 | return static::yield(static::stop());
73 | }
74 |
75 | /**
76 | * Stop injecting content into a section.
77 | *
78 | * @return string
79 | */
80 | public static function stop()
81 | {
82 | static::append($last = array_pop(static::$last), ob_get_clean());
83 |
84 | return $last;
85 | }
86 |
87 | /**
88 | * Append content to a given section.
89 | *
90 | * @param string $section
91 | * @param string $content
92 | * @return void
93 | */
94 | protected static function append($section, $content)
95 | {
96 | if (isset(static::$sections[$section]))
97 | {
98 | static::$sections[$section] = str_replace('@parent', $content, static::$sections[$section]);
99 | }
100 | else
101 | {
102 | static::$sections[$section] = $content;
103 | }
104 | }
105 |
106 | /**
107 | * Get the string contents of a section.
108 | *
109 | * @param string $section
110 | * @return string
111 | */
112 | public static function yield($section)
113 | {
114 | return (isset(static::$sections[$section])) ? static::$sections[$section] : '';
115 | }
116 |
117 | }
--------------------------------------------------------------------------------
/vendor/Symfony/Component/Console/Command/ListCommand.php:
--------------------------------------------------------------------------------
1 |
7 | *
8 | * For the full copyright and license information, please view the LICENSE
9 | * file that was distributed with this source code.
10 | */
11 |
12 | namespace Symfony\Component\Console\Command;
13 |
14 | use Symfony\Component\Console\Input\InputArgument;
15 | use Symfony\Component\Console\Input\InputOption;
16 | use Symfony\Component\Console\Input\InputInterface;
17 | use Symfony\Component\Console\Output\OutputInterface;
18 | use Symfony\Component\Console\Output\Output;
19 | use Symfony\Component\Console\Command\Command;
20 | use Symfony\Component\Console\Input\InputDefinition;
21 |
22 | /**
23 | * ListCommand displays the list of all available commands for the application.
24 | *
25 | * @author Fabien Potencier ".$exception->getMessage()."25 |
".$exception->getFile()." on line ".$exception->getLine()."27 |
".$exception->getTraceAsString()."