airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ndo...@apache.org
Subject [06/57] [partial] airavata-php-gateway git commit: AIRAVATA 1632 + Job Description for Admin Dashboard
Date Fri, 01 May 2015 21:32:53 GMT
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Routing/Router.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Routing/Router.php b/vendor/laravel/framework/src/Illuminate/Routing/Router.php
new file mode 100755
index 0000000..002ebaa
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Routing/Router.php
@@ -0,0 +1,1748 @@
+<?php namespace Illuminate\Routing;
+
+use Closure;
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use Illuminate\Events\Dispatcher;
+use Illuminate\Container\Container;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+use Symfony\Component\HttpFoundation\Request as SymfonyRequest;
+use Symfony\Component\HttpFoundation\Response as SymfonyResponse;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+class Router implements HttpKernelInterface, RouteFiltererInterface {
+
+	/**
+	 * The event dispatcher instance.
+	 *
+	 * @var \Illuminate\Events\Dispatcher
+	 */
+	protected $events;
+
+	/**
+	 * The IoC container instance.
+	 *
+	 * @var \Illuminate\Container\Container
+	 */
+	protected $container;
+
+	/**
+	 * The route collection instance.
+	 *
+	 * @var \Illuminate\Routing\RouteCollection
+	 */
+	protected $routes;
+
+	/**
+	 * The currently dispatched route instance.
+	 *
+	 * @var \Illuminate\Routing\Route
+	 */
+	protected $current;
+
+	/**
+	 * The request currently being dispatched.
+	 *
+	 * @var \Illuminate\Http\Request
+	 */
+	protected $currentRequest;
+
+	/**
+	 * The controller dispatcher instance.
+	 *
+	 * @var \Illuminate\Routing\ControllerDispatcher
+	 */
+	protected $controllerDispatcher;
+
+	/**
+	 * The controller inspector instance.
+	 *
+	 * @var \Illuminate\Routing\ControllerInspector
+	 */
+	protected $inspector;
+
+	/**
+	 * Indicates if the router is running filters.
+	 *
+	 * @var bool
+	 */
+	protected $filtering = true;
+
+	/**
+	 * The registered pattern based filters.
+	 *
+	 * @var array
+	 */
+	protected $patternFilters = array();
+
+	/**
+	 * The registered regular expression based filters.
+	 *
+	 * @var array
+	 */
+	protected $regexFilters = array();
+
+	/**
+	 * The registered route value binders.
+	 *
+	 * @var array
+	 */
+	protected $binders = array();
+
+	/**
+	 * The globally available parameter patterns.
+	 *
+	 * @var array
+	 */
+	protected $patterns = array();
+
+	/**
+	 * The route group attribute stack.
+	 *
+	 * @var array
+	 */
+	protected $groupStack = array();
+
+	/**
+	 * All of the verbs supported by the router.
+	 *
+	 * @var array
+	 */
+	public static $verbs = array('GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS');
+
+	/**
+	 * The default actions for a resourceful controller.
+	 *
+	 * @var array
+	 */
+	protected $resourceDefaults = array('index', 'create', 'store', 'show', 'edit', 'update', 'destroy');
+
+	/**
+	 * Create a new Router instance.
+	 *
+	 * @param  \Illuminate\Events\Dispatcher  $events
+	 * @param  \Illuminate\Container\Container  $container
+	 * @return void
+	 */
+	public function __construct(Dispatcher $events, Container $container = null)
+	{
+		$this->events = $events;
+		$this->routes = new RouteCollection;
+		$this->container = $container ?: new Container;
+
+		$this->bind('_missing', function($v) { return explode('/', $v); });
+	}
+
+	/**
+	 * Register a new GET route with the router.
+	 *
+	 * @param  string  $uri
+	 * @param  \Closure|array|string  $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	public function get($uri, $action)
+	{
+		return $this->addRoute(['GET', 'HEAD'], $uri, $action);
+	}
+
+	/**
+	 * Register a new POST route with the router.
+	 *
+	 * @param  string  $uri
+	 * @param  \Closure|array|string  $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	public function post($uri, $action)
+	{
+		return $this->addRoute('POST', $uri, $action);
+	}
+
+	/**
+	 * Register a new PUT route with the router.
+	 *
+	 * @param  string  $uri
+	 * @param  \Closure|array|string  $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	public function put($uri, $action)
+	{
+		return $this->addRoute('PUT', $uri, $action);
+	}
+
+	/**
+	 * Register a new PATCH route with the router.
+	 *
+	 * @param  string  $uri
+	 * @param  \Closure|array|string  $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	public function patch($uri, $action)
+	{
+		return $this->addRoute('PATCH', $uri, $action);
+	}
+
+	/**
+	 * Register a new DELETE route with the router.
+	 *
+	 * @param  string  $uri
+	 * @param  \Closure|array|string  $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	public function delete($uri, $action)
+	{
+		return $this->addRoute('DELETE', $uri, $action);
+	}
+
+	/**
+	 * Register a new OPTIONS route with the router.
+	 *
+	 * @param  string  $uri
+	 * @param  \Closure|array|string  $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	public function options($uri, $action)
+	{
+		return $this->addRoute('OPTIONS', $uri, $action);
+	}
+
+	/**
+	 * Register a new route responding to all verbs.
+	 *
+	 * @param  string  $uri
+	 * @param  \Closure|array|string  $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	public function any($uri, $action)
+	{
+		$verbs = array('GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE');
+
+		return $this->addRoute($verbs, $uri, $action);
+	}
+
+	/**
+	 * Register a new route with the given verbs.
+	 *
+	 * @param  array|string  $methods
+	 * @param  string  $uri
+	 * @param  \Closure|array|string  $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	public function match($methods, $uri, $action)
+	{
+		return $this->addRoute(array_map('strtoupper', (array) $methods), $uri, $action);
+	}
+
+	/**
+	 * Register an array of controllers with wildcard routing.
+	 *
+	 * @param  array  $controllers
+	 * @return void
+	 */
+	public function controllers(array $controllers)
+	{
+		foreach ($controllers as $uri => $name)
+		{
+			$this->controller($uri, $name);
+		}
+	}
+
+	/**
+	 * Route a controller to a URI with wildcard routing.
+	 *
+	 * @param  string  $uri
+	 * @param  string  $controller
+	 * @param  array   $names
+	 * @return void
+	 */
+	public function controller($uri, $controller, $names = array())
+	{
+		$prepended = $controller;
+
+		// First, we will check to see if a controller prefix has been registered in
+		// the route group. If it has, we will need to prefix it before trying to
+		// reflect into the class instance and pull out the method for routing.
+		if ( ! empty($this->groupStack))
+		{
+			$prepended = $this->prependGroupUses($controller);
+		}
+
+		$routable = $this->getInspector()->getRoutable($prepended, $uri);
+
+		// When a controller is routed using this method, we use Reflection to parse
+		// out all of the routable methods for the controller, then register each
+		// route explicitly for the developers, so reverse routing is possible.
+		foreach ($routable as $method => $routes)
+		{
+			foreach ($routes as $route)
+			{
+				$this->registerInspected($route, $controller, $method, $names);
+			}
+		}
+
+		$this->addFallthroughRoute($controller, $uri);
+	}
+
+	/**
+	 * Register an inspected controller route.
+	 *
+	 * @param  array   $route
+	 * @param  string  $controller
+	 * @param  string  $method
+	 * @param  array   $names
+	 * @return void
+	 */
+	protected function registerInspected($route, $controller, $method, &$names)
+	{
+		$action = array('uses' => $controller.'@'.$method);
+
+		// If a given controller method has been named, we will assign the name to the
+		// controller action array, which provides for a short-cut to method naming
+		// so you don't have to define an individual route for these controllers.
+		$action['as'] = array_get($names, $method);
+
+		$this->{$route['verb']}($route['uri'], $action);
+	}
+
+	/**
+	 * Add a fallthrough route for a controller.
+	 *
+	 * @param  string  $controller
+	 * @param  string  $uri
+	 * @return void
+	 */
+	protected function addFallthroughRoute($controller, $uri)
+	{
+		$missing = $this->any($uri.'/{_missing}', $controller.'@missingMethod');
+
+		$missing->where('_missing', '(.*)');
+	}
+
+	/**
+	 * Route a resource to a controller.
+	 *
+	 * @param  string  $name
+	 * @param  string  $controller
+	 * @param  array   $options
+	 * @return void
+	 */
+	public function resource($name, $controller, array $options = array())
+	{
+		// If the resource name contains a slash, we will assume the developer wishes to
+		// register these resource routes with a prefix so we will set that up out of
+		// the box so they don't have to mess with it. Otherwise, we will continue.
+		if (str_contains($name, '/'))
+		{
+			$this->prefixedResource($name, $controller, $options);
+
+			return;
+		}
+
+		// We need to extract the base resource from the resource name. Nested resources
+		// are supported in the framework, but we need to know what name to use for a
+		// place-holder on the route wildcards, which should be the base resources.
+		$base = $this->getResourceWildcard(last(explode('.', $name)));
+
+		$defaults = $this->resourceDefaults;
+
+		foreach ($this->getResourceMethods($defaults, $options) as $m)
+		{
+			$this->{'addResource'.ucfirst($m)}($name, $base, $controller, $options);
+		}
+	}
+
+	/**
+	 * Build a set of prefixed resource routes.
+	 *
+	 * @param  string  $name
+	 * @param  string  $controller
+	 * @param  array   $options
+	 * @return void
+	 */
+	protected function prefixedResource($name, $controller, array $options)
+	{
+		list($name, $prefix) = $this->getResourcePrefix($name);
+
+		// We need to extract the base resource from the resource name. Nested resources
+		// are supported in the framework, but we need to know what name to use for a
+		// place-holder on the route wildcards, which should be the base resources.
+		$callback = function($me) use ($name, $controller, $options)
+		{
+			$me->resource($name, $controller, $options);
+		};
+
+		return $this->group(compact('prefix'), $callback);
+	}
+
+	/**
+	 * Extract the resource and prefix from a resource name.
+	 *
+	 * @param  string  $name
+	 * @return array
+	 */
+	protected function getResourcePrefix($name)
+	{
+		$segments = explode('/', $name);
+
+		// To get the prefix, we will take all of the name segments and implode them on
+		// a slash. This will generate a proper URI prefix for us. Then we take this
+		// last segment, which will be considered the final resources name we use.
+		$prefix = implode('/', array_slice($segments, 0, -1));
+
+		return array(end($segments), $prefix);
+	}
+
+	/**
+	 * Get the applicable resource methods.
+	 *
+	 * @param  array  $defaults
+	 * @param  array  $options
+	 * @return array
+	 */
+	protected function getResourceMethods($defaults, $options)
+	{
+		if (isset($options['only']))
+		{
+			return array_intersect($defaults, (array) $options['only']);
+		}
+		elseif (isset($options['except']))
+		{
+			return array_diff($defaults, (array) $options['except']);
+		}
+
+		return $defaults;
+	}
+
+	/**
+	 * Get the base resource URI for a given resource.
+	 *
+	 * @param  string  $resource
+	 * @return string
+	 */
+	public function getResourceUri($resource)
+	{
+		if ( ! str_contains($resource, '.')) return $resource;
+
+		// Once we have built the base URI, we'll remove the wildcard holder for this
+		// base resource name so that the individual route adders can suffix these
+		// paths however they need to, as some do not have any wildcards at all.
+		$segments = explode('.', $resource);
+
+		$uri = $this->getNestedResourceUri($segments);
+
+		return str_replace('/{'.$this->getResourceWildcard(last($segments)).'}', '', $uri);
+	}
+
+	/**
+	 * Get the URI for a nested resource segment array.
+	 *
+	 * @param  array   $segments
+	 * @return string
+	 */
+	protected function getNestedResourceUri(array $segments)
+	{
+		// We will spin through the segments and create a place-holder for each of the
+		// resource segments, as well as the resource itself. Then we should get an
+		// entire string for the resource URI that contains all nested resources.
+		return implode('/', array_map(function($s)
+		{
+			return $s.'/{'.$this->getResourceWildcard($s).'}';
+
+		}, $segments));
+	}
+
+	/**
+	 * Get the action array for a resource route.
+	 *
+	 * @param  string  $resource
+	 * @param  string  $controller
+	 * @param  string  $method
+	 * @param  array   $options
+	 * @return array
+	 */
+	protected function getResourceAction($resource, $controller, $method, $options)
+	{
+		$name = $this->getResourceName($resource, $method, $options);
+
+		return array('as' => $name, 'uses' => $controller.'@'.$method);
+	}
+
+	/**
+	 * Get the name for a given resource.
+	 *
+	 * @param  string  $resource
+	 * @param  string  $method
+	 * @param  array   $options
+	 * @return string
+	 */
+	protected function getResourceName($resource, $method, $options)
+	{
+		if (isset($options['names'][$method])) return $options['names'][$method];
+
+		// If a global prefix has been assigned to all names for this resource, we will
+		// grab that so we can prepend it onto the name when we create this name for
+		// the resource action. Otherwise we'll just use an empty string for here.
+		$prefix = isset($options['as']) ? $options['as'].'.' : '';
+
+		if (empty($this->groupStack))
+		{
+			return $prefix.$resource.'.'.$method;
+		}
+
+		return $this->getGroupResourceName($prefix, $resource, $method);
+	}
+
+	/**
+	 * Get the resource name for a grouped resource.
+	 *
+	 * @param  string  $prefix
+	 * @param  string  $resource
+	 * @param  string  $method
+	 * @return string
+	 */
+	protected function getGroupResourceName($prefix, $resource, $method)
+	{
+		$group = str_replace('/', '.', $this->getLastGroupPrefix());
+
+		if (empty($group))
+		{
+			return trim("{$prefix}{$resource}.{$method}", '.');
+		}
+
+		return trim("{$prefix}{$group}.{$resource}.{$method}", '.');
+	}
+
+	/**
+	 * Format a resource wildcard for usage.
+	 *
+	 * @param  string  $value
+	 * @return string
+	 */
+	public function getResourceWildcard($value)
+	{
+		return str_replace('-', '_', $value);
+	}
+
+	/**
+	 * Add the index method for a resourceful route.
+	 *
+	 * @param  string  $name
+	 * @param  string  $base
+	 * @param  string  $controller
+	 * @param  array   $options
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function addResourceIndex($name, $base, $controller, $options)
+	{
+		$uri = $this->getResourceUri($name);
+
+		$action = $this->getResourceAction($name, $controller, 'index', $options);
+
+		return $this->get($uri, $action);
+	}
+
+	/**
+	 * Add the create method for a resourceful route.
+	 *
+	 * @param  string  $name
+	 * @param  string  $base
+	 * @param  string  $controller
+	 * @param  array   $options
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function addResourceCreate($name, $base, $controller, $options)
+	{
+		$uri = $this->getResourceUri($name).'/create';
+
+		$action = $this->getResourceAction($name, $controller, 'create', $options);
+
+		return $this->get($uri, $action);
+	}
+
+	/**
+	 * Add the store method for a resourceful route.
+	 *
+	 * @param  string  $name
+	 * @param  string  $base
+	 * @param  string  $controller
+	 * @param  array   $options
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function addResourceStore($name, $base, $controller, $options)
+	{
+		$uri = $this->getResourceUri($name);
+
+		$action = $this->getResourceAction($name, $controller, 'store', $options);
+
+		return $this->post($uri, $action);
+	}
+
+	/**
+	 * Add the show method for a resourceful route.
+	 *
+	 * @param  string  $name
+	 * @param  string  $base
+	 * @param  string  $controller
+	 * @param  array   $options
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function addResourceShow($name, $base, $controller, $options)
+	{
+		$uri = $this->getResourceUri($name).'/{'.$base.'}';
+
+		$action = $this->getResourceAction($name, $controller, 'show', $options);
+
+		return $this->get($uri, $action);
+	}
+
+	/**
+	 * Add the edit method for a resourceful route.
+	 *
+	 * @param  string  $name
+	 * @param  string  $base
+	 * @param  string  $controller
+	 * @param  array   $options
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function addResourceEdit($name, $base, $controller, $options)
+	{
+		$uri = $this->getResourceUri($name).'/{'.$base.'}/edit';
+
+		$action = $this->getResourceAction($name, $controller, 'edit', $options);
+
+		return $this->get($uri, $action);
+	}
+
+	/**
+	 * Add the update method for a resourceful route.
+	 *
+	 * @param  string  $name
+	 * @param  string  $base
+	 * @param  string  $controller
+	 * @param  array   $options
+	 * @return void
+	 */
+	protected function addResourceUpdate($name, $base, $controller, $options)
+	{
+		$this->addPutResourceUpdate($name, $base, $controller, $options);
+
+		return $this->addPatchResourceUpdate($name, $base, $controller);
+	}
+
+	/**
+	 * Add the update method for a resourceful route.
+	 *
+	 * @param  string  $name
+	 * @param  string  $base
+	 * @param  string  $controller
+	 * @param  array   $options
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function addPutResourceUpdate($name, $base, $controller, $options)
+	{
+		$uri = $this->getResourceUri($name).'/{'.$base.'}';
+
+		$action = $this->getResourceAction($name, $controller, 'update', $options);
+
+		return $this->put($uri, $action);
+	}
+
+	/**
+	 * Add the update method for a resourceful route.
+	 *
+	 * @param  string  $name
+	 * @param  string  $base
+	 * @param  string  $controller
+	 * @return void
+	 */
+	protected function addPatchResourceUpdate($name, $base, $controller)
+	{
+		$uri = $this->getResourceUri($name).'/{'.$base.'}';
+
+		$this->patch($uri, $controller.'@update');
+	}
+
+	/**
+	 * Add the destroy method for a resourceful route.
+	 *
+	 * @param  string  $name
+	 * @param  string  $base
+	 * @param  string  $controller
+	 * @param  array   $options
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function addResourceDestroy($name, $base, $controller, $options)
+	{
+		$uri = $this->getResourceUri($name).'/{'.$base.'}';
+
+		$action = $this->getResourceAction($name, $controller, 'destroy', $options);
+
+		return $this->delete($uri, $action);
+	}
+
+	/**
+	 * Create a route group with shared attributes.
+	 *
+	 * @param  array     $attributes
+	 * @param  \Closure  $callback
+	 * @return void
+	 */
+	public function group(array $attributes, Closure $callback)
+	{
+		$this->updateGroupStack($attributes);
+
+		// Once we have updated the group stack, we will execute the user Closure and
+		// merge in the groups attributes when the route is created. After we have
+		// run the callback, we will pop the attributes off of this group stack.
+		call_user_func($callback, $this);
+
+		array_pop($this->groupStack);
+	}
+
+	/**
+	 * Update the group stack with the given attributes.
+	 *
+	 * @param  array  $attributes
+	 * @return void
+	 */
+	protected function updateGroupStack(array $attributes)
+	{
+		if ( ! empty($this->groupStack))
+		{
+			$attributes = $this->mergeGroup($attributes, last($this->groupStack));
+		}
+
+		$this->groupStack[] = $attributes;
+	}
+
+	/**
+	 * Merge the given array with the last group stack.
+	 *
+	 * @param  array  $new
+	 * @return array
+	 */
+	public function mergeWithLastGroup($new)
+	{
+		return $this->mergeGroup($new, last($this->groupStack));
+	}
+
+	/**
+	 * Merge the given group attributes.
+	 *
+	 * @param  array  $new
+	 * @param  array  $old
+	 * @return array
+	 */
+	public static function mergeGroup($new, $old)
+	{
+		$new['namespace'] = static::formatUsesPrefix($new, $old);
+
+		$new['prefix'] = static::formatGroupPrefix($new, $old);
+
+		if (isset($new['domain'])) unset($old['domain']);
+
+		$new['where'] = array_merge(array_get($old, 'where', []), array_get($new, 'where', []));
+
+		return array_merge_recursive(array_except($old, array('namespace', 'prefix', 'where')), $new);
+	}
+
+	/**
+	 * Format the uses prefix for the new group attributes.
+	 *
+	 * @param  array  $new
+	 * @param  array  $old
+	 * @return string
+	 */
+	protected static function formatUsesPrefix($new, $old)
+	{
+		if (isset($new['namespace']) && isset($old['namespace']))
+		{
+			return trim(array_get($old, 'namespace'), '\\').'\\'.trim($new['namespace'], '\\');
+		}
+		elseif (isset($new['namespace']))
+		{
+			return trim($new['namespace'], '\\');
+		}
+
+		return array_get($old, 'namespace');
+	}
+
+	/**
+	 * Format the prefix for the new group attributes.
+	 *
+	 * @param  array  $new
+	 * @param  array  $old
+	 * @return string
+	 */
+	protected static function formatGroupPrefix($new, $old)
+	{
+		if (isset($new['prefix']))
+		{
+			return trim(array_get($old, 'prefix'), '/').'/'.trim($new['prefix'], '/');
+		}
+
+		return array_get($old, 'prefix');
+	}
+
+	/**
+	 * Get the prefix from the last group on the stack.
+	 *
+	 * @return string
+	 */
+	protected function getLastGroupPrefix()
+	{
+		if ( ! empty($this->groupStack))
+		{
+			$last = end($this->groupStack);
+			return isset($last['prefix']) ? $last['prefix'] : '';
+		}
+
+		return '';
+	}
+
+	/**
+	 * Add a route to the underlying route collection.
+	 *
+	 * @param  array|string  $methods
+	 * @param  string  $uri
+	 * @param  \Closure|array|string  $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function addRoute($methods, $uri, $action)
+	{
+		return $this->routes->add($this->createRoute($methods, $uri, $action));
+	}
+
+	/**
+	 * Create a new route instance.
+	 *
+	 * @param  array|string  $methods
+	 * @param  string  $uri
+	 * @param  mixed   $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function createRoute($methods, $uri, $action)
+	{
+		// If the route is routing to a controller we will parse the route action into
+		// an acceptable array format before registering it and creating this route
+		// instance itself. We need to build the Closure that will call this out.
+		if ($this->routingToController($action))
+		{
+			$action = $this->getControllerAction($action);
+		}
+
+		$route = $this->newRoute(
+			$methods, $uri = $this->prefix($uri), $action
+		);
+
+		// If we have groups that need to be merged, we will merge them now after this
+		// route has already been created and is ready to go. After we're done with
+		// the merge we will be ready to return the route back out to the caller.
+		if ( ! empty($this->groupStack))
+		{
+			$this->mergeController($route);
+		}
+
+		$this->addWhereClausesToRoute($route);
+
+		return $route;
+	}
+
+	/**
+	 * Create a new Route object.
+	 *
+	 * @param  array|string  $methods
+	 * @param  string  $uri
+	 * @param  mixed   $action
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function newRoute($methods, $uri, $action)
+	{
+		return new Route($methods, $uri, $action);
+	}
+
+	/**
+	 * Prefix the given URI with the last prefix.
+	 *
+	 * @param  string  $uri
+	 * @return string
+	 */
+	protected function prefix($uri)
+	{
+		return trim(trim($this->getLastGroupPrefix(), '/').'/'.trim($uri, '/'), '/') ?: '/';
+	}
+
+	/**
+	 * Add the necessary where clauses to the route based on its initial registration.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function addWhereClausesToRoute($route)
+	{
+		$route->where(
+			array_merge($this->patterns, array_get($route->getAction(), 'where', []))
+		);
+
+		return $route;
+	}
+
+	/**
+	 * Merge the group stack with the controller action.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @return void
+	 */
+	protected function mergeController($route)
+	{
+		$action = $this->mergeWithLastGroup($route->getAction());
+
+		$route->setAction($action);
+	}
+
+	/**
+	 * Determine if the action is routing to a controller.
+	 *
+	 * @param  array  $action
+	 * @return bool
+	 */
+	protected function routingToController($action)
+	{
+		if ($action instanceof Closure) return false;
+
+		return is_string($action) || is_string(array_get($action, 'uses'));
+	}
+
+	/**
+	 * Add a controller based route action to the action array.
+	 *
+	 * @param  array|string  $action
+	 * @return array
+	 */
+	protected function getControllerAction($action)
+	{
+		if (is_string($action)) $action = array('uses' => $action);
+
+		// Here we'll get an instance of this controller dispatcher and hand it off to
+		// the Closure so it will be used to resolve the class instances out of our
+		// IoC container instance and call the appropriate methods on the class.
+		if ( ! empty($this->groupStack))
+		{
+			$action['uses'] = $this->prependGroupUses($action['uses']);
+		}
+
+		// Here we'll get an instance of this controller dispatcher and hand it off to
+		// the Closure so it will be used to resolve the class instances out of our
+		// IoC container instance and call the appropriate methods on the class.
+		$action['controller'] = $action['uses'];
+
+		$closure = $this->getClassClosure($action['uses']);
+
+		return array_set($action, 'uses', $closure);
+	}
+
+	/**
+	 * Get the Closure for a controller based action.
+	 *
+	 * @param  string  $controller
+	 * @return \Closure
+	 */
+	protected function getClassClosure($controller)
+	{
+		// Here we'll get an instance of this controller dispatcher and hand it off to
+		// the Closure so it will be used to resolve the class instances out of our
+		// IoC container instance and call the appropriate methods on the class.
+		$d = $this->getControllerDispatcher();
+
+		return function() use ($d, $controller)
+		{
+			$route = $this->current();
+
+			$request = $this->getCurrentRequest();
+
+			// Now we can split the controller and method out of the action string so that we
+			// can call them appropriately on the class. This controller and method are in
+			// in the Class@method format and we need to explode them out then use them.
+			list($class, $method) = explode('@', $controller);
+
+			return $d->dispatch($route, $request, $class, $method);
+		};
+	}
+
+	/**
+	 * Prepend the last group uses onto the use clause.
+	 *
+	 * @param  string  $uses
+	 * @return string
+	 */
+	protected function prependGroupUses($uses)
+	{
+		$group = last($this->groupStack);
+
+		return isset($group['namespace']) ? $group['namespace'].'\\'.$uses : $uses;
+	}
+
+	/**
+	 * Dispatch the request to the application.
+	 *
+	 * @param  \Illuminate\Http\Request  $request
+	 * @return \Illuminate\Http\Response
+	 */
+	public function dispatch(Request $request)
+	{
+		$this->currentRequest = $request;
+
+		// If no response was returned from the before filter, we will call the proper
+		// route instance to get the response. If no route is found a response will
+		// still get returned based on why no routes were found for this request.
+		$response = $this->callFilter('before', $request);
+
+		if (is_null($response))
+		{
+			$response = $this->dispatchToRoute($request);
+		}
+
+		$response = $this->prepareResponse($request, $response);
+
+		// Once this route has run and the response has been prepared, we will run the
+		// after filter to do any last work on the response or for this application
+		// before we will return the response back to the consuming code for use.
+		$this->callFilter('after', $request, $response);
+
+		return $response;
+	}
+
+	/**
+	 * Dispatch the request to a route and return the response.
+	 *
+	 * @param  \Illuminate\Http\Request  $request
+	 * @return mixed
+	 */
+	public function dispatchToRoute(Request $request)
+	{
+		$route = $this->findRoute($request);
+
+		$this->events->fire('router.matched', array($route, $request));
+
+		// Once we have successfully matched the incoming request to a given route we
+		// can call the before filters on that route. This works similar to global
+		// filters in that if a response is returned we will not call the route.
+		$response = $this->callRouteBefore($route, $request);
+
+		if (is_null($response))
+		{
+			$response = $route->run($request);
+		}
+
+		$response = $this->prepareResponse($request, $response);
+
+		// After we have a prepared response from the route or filter we will call to
+		// the "after" filters to do any last minute processing on this request or
+		// response object before the response is returned back to the consumer.
+		$this->callRouteAfter($route, $request, $response);
+
+		return $response;
+	}
+
+	/**
+	 * Find the route matching a given request.
+	 *
+	 * @param  \Illuminate\Http\Request  $request
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function findRoute($request)
+	{
+		$this->current = $route = $this->routes->match($request);
+
+		return $this->substituteBindings($route);
+	}
+
+	/**
+	 * Substitute the route bindings onto the route.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @return \Illuminate\Routing\Route
+	 */
+	protected function substituteBindings($route)
+	{
+		foreach ($route->parameters() as $key => $value)
+		{
+			if (isset($this->binders[$key]))
+			{
+				$route->setParameter($key, $this->performBinding($key, $value, $route));
+			}
+		}
+
+		return $route;
+	}
+
+	/**
+	 * Call the binding callback for the given key.
+	 *
+	 * @param  string  $key
+	 * @param  string  $value
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @return mixed
+	 */
+	protected function performBinding($key, $value, $route)
+	{
+		return call_user_func($this->binders[$key], $value, $route);
+	}
+
+	/**
+	 * Register a route matched event listener.
+	 *
+	 * @param  string|callable  $callback
+	 * @return void
+	 */
+	public function matched($callback)
+	{
+		$this->events->listen('router.matched', $callback);
+	}
+
+	/**
+	 * Register a new "before" filter with the router.
+	 *
+	 * @param  string|callable  $callback
+	 * @return void
+	 */
+	public function before($callback)
+	{
+		$this->addGlobalFilter('before', $callback);
+	}
+
+	/**
+	 * Register a new "after" filter with the router.
+	 *
+	 * @param  string|callable  $callback
+	 * @return void
+	 */
+	public function after($callback)
+	{
+		$this->addGlobalFilter('after', $callback);
+	}
+
+	/**
+	 * Register a new global filter with the router.
+	 *
+	 * @param  string  $filter
+	 * @param  string|callable   $callback
+	 * @return void
+	 */
+	protected function addGlobalFilter($filter, $callback)
+	{
+		$this->events->listen('router.'.$filter, $this->parseFilter($callback));
+	}
+
+	/**
+	 * Register a new filter with the router.
+	 *
+	 * @param  string  $name
+	 * @param  string|callable  $callback
+	 * @return void
+	 */
+	public function filter($name, $callback)
+	{
+		$this->events->listen('router.filter: '.$name, $this->parseFilter($callback));
+	}
+
+	/**
+	 * Parse the registered filter.
+	 *
+	 * @param  callable|string  $callback
+	 * @return mixed
+	 */
+	protected function parseFilter($callback)
+	{
+		if (is_string($callback) && ! str_contains($callback, '@'))
+		{
+			return $callback.'@filter';
+		}
+
+		return $callback;
+	}
+
+	/**
+	 * Register a pattern-based filter with the router.
+	 *
+	 * @param  string  $pattern
+	 * @param  string  $name
+	 * @param  array|null  $methods
+	 * @return void
+	 */
+	public function when($pattern, $name, $methods = null)
+	{
+		if ( ! is_null($methods)) $methods = array_map('strtoupper', (array) $methods);
+
+		$this->patternFilters[$pattern][] = compact('name', 'methods');
+	}
+
+	/**
+	 * Register a regular expression based filter with the router.
+	 *
+	 * @param  string     $pattern
+	 * @param  string     $name
+	 * @param  array|null $methods
+	 * @return void
+	 */
+	public function whenRegex($pattern, $name, $methods = null)
+	{
+		if ( ! is_null($methods)) $methods = array_map('strtoupper', (array) $methods);
+
+		$this->regexFilters[$pattern][] = compact('name', 'methods');
+	}
+
+	/**
+	 * Register a model binder for a wildcard.
+	 *
+	 * @param  string  $key
+	 * @param  string  $class
+	 * @param  \Closure  $callback
+	 * @return void
+	 *
+	 * @throws NotFoundHttpException
+	 */
+	public function model($key, $class, Closure $callback = null)
+	{
+		$this->bind($key, function($value) use ($class, $callback)
+		{
+			if (is_null($value)) return null;
+
+			// For model binders, we will attempt to retrieve the models using the find
+			// method on the model instance. If we cannot retrieve the models we'll
+			// throw a not found exception otherwise we will return the instance.
+			if ($model = (new $class)->find($value))
+			{
+				return $model;
+			}
+
+			// If a callback was supplied to the method we will call that to determine
+			// what we should do when the model is not found. This just gives these
+			// developer a little greater flexibility to decide what will happen.
+			if ($callback instanceof Closure)
+			{
+				return call_user_func($callback);
+			}
+
+			throw new NotFoundHttpException;
+		});
+	}
+
+	/**
+	 * Add a new route parameter binder.
+	 *
+	 * @param  string  $key
+	 * @param  string|callable  $binder
+	 * @return void
+	 */
+	public function bind($key, $binder)
+	{
+		if (is_string($binder))
+		{
+			$binder = $this->createClassBinding($binder);
+		}
+
+		$this->binders[str_replace('-', '_', $key)] = $binder;
+	}
+
+	/**
+	 * Create a class based binding using the IoC container.
+	 *
+	 * @param  string    $binding
+	 * @return \Closure
+	 */
+	public function createClassBinding($binding)
+	{
+		return function($value, $route) use ($binding)
+		{
+			// If the binding has an @ sign, we will assume it's being used to delimit
+			// the class name from the bind method name. This allows for bindings
+			// to run multiple bind methods in a single class for convenience.
+			$segments = explode('@', $binding);
+
+			$method = count($segments) == 2 ? $segments[1] : 'bind';
+
+			$callable = [$this->container->make($segments[0]), $method];
+
+			return call_user_func($callable, $value, $route);
+		};
+	}
+
+	/**
+	 * Set a global where pattern on all routes
+	 *
+	 * @param  string  $key
+	 * @param  string  $pattern
+	 * @return void
+	 */
+	public function pattern($key, $pattern)
+	{
+		$this->patterns[$key] = $pattern;
+	}
+
+	/**
+	 * Set a group of global where patterns on all routes
+	 *
+	 * @param  array  $patterns
+	 * @return void
+	 */
+	public function patterns($patterns)
+	{
+		foreach ($patterns as $key => $pattern)
+		{
+			$this->pattern($key, $pattern);
+		}
+	}
+
+	/**
+	 * Call the given filter with the request and response.
+	 *
+	 * @param  string  $filter
+	 * @param  \Illuminate\Http\Request   $request
+	 * @param  \Illuminate\Http\Response  $response
+	 * @return mixed
+	 */
+	protected function callFilter($filter, $request, $response = null)
+	{
+		if ( ! $this->filtering) return null;
+
+		return $this->events->until('router.'.$filter, array($request, $response));
+	}
+
+	/**
+	 * Call the given route's before filters.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @param  \Illuminate\Http\Request  $request
+	 * @return mixed
+	 */
+	public function callRouteBefore($route, $request)
+	{
+		$response = $this->callPatternFilters($route, $request);
+
+		return $response ?: $this->callAttachedBefores($route, $request);
+	}
+
+	/**
+	 * Call the pattern based filters for the request.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @param  \Illuminate\Http\Request  $request
+	 * @return mixed|null
+	 */
+	protected function callPatternFilters($route, $request)
+	{
+		foreach ($this->findPatternFilters($request) as $filter => $parameters)
+		{
+			$response = $this->callRouteFilter($filter, $parameters, $route, $request);
+
+			if ( ! is_null($response)) return $response;
+		}
+	}
+
+	/**
+	 * Find the patterned filters matching a request.
+	 *
+	 * @param  \Illuminate\Http\Request  $request
+	 * @return array
+	 */
+	public function findPatternFilters($request)
+	{
+		$results = array();
+
+		list($path, $method) = array($request->path(), $request->getMethod());
+
+		foreach ($this->patternFilters as $pattern => $filters)
+		{
+			// To find the patterned middlewares for a request, we just need to check these
+			// registered patterns against the path info for the current request to this
+			// applications, and when it matches we will merge into these middlewares.
+			if (str_is($pattern, $path))
+			{
+				$merge = $this->patternsByMethod($method, $filters);
+
+				$results = array_merge($results, $merge);
+			}
+		}
+
+		foreach ($this->regexFilters as $pattern => $filters)
+		{
+			// To find the patterned middlewares for a request, we just need to check these
+			// registered patterns against the path info for the current request to this
+			// applications, and when it matches we will merge into these middlewares.
+			if (preg_match($pattern, $path))
+			{
+				$merge = $this->patternsByMethod($method, $filters);
+
+				$results = array_merge($results, $merge);
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Filter pattern filters that don't apply to the request verb.
+	 *
+	 * @param  string  $method
+	 * @param  array   $filters
+	 * @return array
+	 */
+	protected function patternsByMethod($method, $filters)
+	{
+		$results = array();
+
+		foreach ($filters as $filter)
+		{
+			// The idea here is to check and see if the pattern filter applies to this HTTP
+			// request based on the request methods. Pattern filters might be limited by
+			// the request verb to make it simply to assign to the given verb at once.
+			if ($this->filterSupportsMethod($filter, $method))
+			{
+				$parsed = Route::parseFilters($filter['name']);
+
+				$results = array_merge($results, $parsed);
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Determine if the given pattern filters applies to a given method.
+	 *
+	 * @param  array  $filter
+	 * @param  array  $method
+	 * @return bool
+	 */
+	protected function filterSupportsMethod($filter, $method)
+	{
+		$methods = $filter['methods'];
+
+		return (is_null($methods) || in_array($method, $methods));
+	}
+
+	/**
+	 * Call the given route's before (non-pattern) filters.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @param  \Illuminate\Http\Request  $request
+	 * @return mixed
+	 */
+	protected function callAttachedBefores($route, $request)
+	{
+		foreach ($route->beforeFilters() as $filter => $parameters)
+		{
+			$response = $this->callRouteFilter($filter, $parameters, $route, $request);
+
+			if ( ! is_null($response)) return $response;
+		}
+	}
+
+	/**
+	 * Call the given route's before filters.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @param  \Illuminate\Http\Request  $request
+	 * @param  \Illuminate\Http\Response  $response
+	 * @return mixed
+	 */
+	public function callRouteAfter($route, $request, $response)
+	{
+		foreach ($route->afterFilters() as $filter => $parameters)
+		{
+			$this->callRouteFilter($filter, $parameters, $route, $request, $response);
+		}
+	}
+
+	/**
+	 * Call the given route filter.
+	 *
+	 * @param  string  $filter
+	 * @param  array  $parameters
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @param  \Illuminate\Http\Request  $request
+	 * @param  \Illuminate\Http\Response|null $response
+	 * @return mixed
+	 */
+	public function callRouteFilter($filter, $parameters, $route, $request, $response = null)
+	{
+		if ( ! $this->filtering) return null;
+
+		$data = array_merge(array($route, $request, $response), $parameters);
+
+		return $this->events->until('router.filter: '.$filter, $this->cleanFilterParameters($data));
+	}
+
+	/**
+	 * Clean the parameters being passed to a filter callback.
+	 *
+	 * @param  array  $parameters
+	 * @return array
+	 */
+	protected function cleanFilterParameters(array $parameters)
+	{
+		return array_filter($parameters, function($p)
+		{
+			return ! is_null($p) && $p !== '';
+		});
+	}
+
+	/**
+	 * Create a response instance from the given value.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @param  mixed  $response
+	 * @return \Illuminate\Http\Response
+	 */
+	protected function prepareResponse($request, $response)
+	{
+		if ( ! $response instanceof SymfonyResponse)
+		{
+			$response = new Response($response);
+		}
+
+		return $response->prepare($request);
+	}
+
+	/**
+	 * Run a callback with filters disable on the router.
+	 *
+	 * @param  callable  $callback
+	 * @return void
+	 */
+	public function withoutFilters(callable $callback)
+	{
+		$this->disableFilters();
+
+		call_user_func($callback);
+
+		$this->enableFilters();
+	}
+
+	/**
+	 * Enable route filtering on the router.
+	 *
+	 * @return void
+	 */
+	public function enableFilters()
+	{
+		$this->filtering = true;
+	}
+
+	/**
+	 * Disable route filtering on the router.
+	 *
+	 * @return void
+	 */
+	public function disableFilters()
+	{
+		$this->filtering = false;
+	}
+
+	/**
+	 * Get a route parameter for the current route.
+	 *
+	 * @param  string  $key
+	 * @param  string  $default
+	 * @return mixed
+	 */
+	public function input($key, $default = null)
+	{
+		return $this->current()->parameter($key, $default);
+	}
+
+	/**
+	 * Get the currently dispatched route instance.
+	 *
+	 * @return \Illuminate\Routing\Route
+	 */
+	public function getCurrentRoute()
+	{
+		return $this->current();
+	}
+
+	/**
+	 * Get the currently dispatched route instance.
+	 *
+	 * @return \Illuminate\Routing\Route
+	 */
+	public function current()
+	{
+		return $this->current;
+	}
+
+	/**
+	 * Check if a route with the given name exists.
+	 *
+	 * @param  string  $name
+	 * @return bool
+	 */
+	public function has($name)
+	{
+		return $this->routes->hasNamedRoute($name);
+	}
+
+	/**
+	 * Get the current route name.
+	 *
+	 * @return string|null
+	 */
+	public function currentRouteName()
+	{
+		return ($this->current()) ? $this->current()->getName() : null;
+	}
+
+	/**
+	 * Alias for the "currentRouteNamed" method.
+	 *
+	 * @param  mixed  string
+	 * @return bool
+	 */
+	public function is()
+	{
+		foreach (func_get_args() as $pattern)
+		{
+			if (str_is($pattern, $this->currentRouteName()))
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Determine if the current route matches a given name.
+	 *
+	 * @param  string  $name
+	 * @return bool
+	 */
+	public function currentRouteNamed($name)
+	{
+		return ($this->current()) ? $this->current()->getName() == $name : false;
+	}
+
+	/**
+	 * Get the current route action.
+	 *
+	 * @return string|null
+	 */
+	public function currentRouteAction()
+	{
+		if ( ! $this->current()) return;
+
+		$action = $this->current()->getAction();
+
+		return isset($action['controller']) ? $action['controller'] : null;
+	}
+
+	/**
+	 * Alias for the "currentRouteUses" method.
+	 *
+	 * @param  mixed  string
+	 * @return bool
+	 */
+	public function uses()
+	{
+		foreach (func_get_args() as $pattern)
+		{
+			if (str_is($pattern, $this->currentRouteAction()))
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Determine if the current route action matches a given action.
+	 *
+	 * @param  string  $action
+	 * @return bool
+	 */
+	public function currentRouteUses($action)
+	{
+		return $this->currentRouteAction() == $action;
+	}
+
+	/**
+	 * Get the request currently being dispatched.
+	 *
+	 * @return \Illuminate\Http\Request
+	 */
+	public function getCurrentRequest()
+	{
+		return $this->currentRequest;
+	}
+
+	/**
+	 * Get the underlying route collection.
+	 *
+	 * @return \Illuminate\Routing\RouteCollection
+	 */
+	public function getRoutes()
+	{
+		return $this->routes;
+	}
+
+	/**
+	 * Get the controller dispatcher instance.
+	 *
+	 * @return \Illuminate\Routing\ControllerDispatcher
+	 */
+	public function getControllerDispatcher()
+	{
+		if (is_null($this->controllerDispatcher))
+		{
+			$this->controllerDispatcher = new ControllerDispatcher($this, $this->container);
+		}
+
+		return $this->controllerDispatcher;
+	}
+
+	/**
+	 * Set the controller dispatcher instance.
+	 *
+	 * @param  \Illuminate\Routing\ControllerDispatcher  $dispatcher
+	 * @return void
+	 */
+	public function setControllerDispatcher(ControllerDispatcher $dispatcher)
+	{
+		$this->controllerDispatcher = $dispatcher;
+	}
+
+	/**
+	 * Get a controller inspector instance.
+	 *
+	 * @return \Illuminate\Routing\ControllerInspector
+	 */
+	public function getInspector()
+	{
+		return $this->inspector ?: $this->inspector = new ControllerInspector;
+	}
+
+	/**
+	 * Get the global "where" patterns.
+	 *
+	 * @return array
+	 */
+	public function getPatterns()
+	{
+		return $this->patterns;
+	}
+
+	/**
+	 * Get the response for a given request.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @param  int   $type
+	 * @param  bool  $catch
+	 * @return \Illuminate\Http\Response
+	 */
+	public function handle(SymfonyRequest $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
+	{
+		return $this->dispatch(Request::createFromBase($request));
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Routing/RoutingServiceProvider.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Routing/RoutingServiceProvider.php b/vendor/laravel/framework/src/Illuminate/Routing/RoutingServiceProvider.php
new file mode 100755
index 0000000..f08b9f2
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Routing/RoutingServiceProvider.php
@@ -0,0 +1,88 @@
+<?php namespace Illuminate\Routing;
+
+use Illuminate\Support\ServiceProvider;
+
+class RoutingServiceProvider extends ServiceProvider {
+
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->registerRouter();
+
+		$this->registerUrlGenerator();
+
+		$this->registerRedirector();
+	}
+
+	/**
+	 * Register the router instance.
+	 *
+	 * @return void
+	 */
+	protected function registerRouter()
+	{
+		$this->app['router'] = $this->app->share(function($app)
+		{
+			$router = new Router($app['events'], $app);
+
+			// If the current application environment is "testing", we will disable the
+			// routing filters, since they can be tested independently of the routes
+			// and just get in the way of our typical controller testing concerns.
+			if ($app['env'] == 'testing')
+			{
+				$router->disableFilters();
+			}
+
+			return $router;
+		});
+	}
+
+	/**
+	 * Register the URL generator service.
+	 *
+	 * @return void
+	 */
+	protected function registerUrlGenerator()
+	{
+		$this->app['url'] = $this->app->share(function($app)
+		{
+			// The URL generator needs the route collection that exists on the router.
+			// Keep in mind this is an object, so we're passing by references here
+			// and all the registered routes will be available to the generator.
+			$routes = $app['router']->getRoutes();
+
+			return new UrlGenerator($routes, $app->rebinding('request', function($app, $request)
+			{
+				$app['url']->setRequest($request);
+			}));
+		});
+	}
+
+	/**
+	 * Register the Redirector service.
+	 *
+	 * @return void
+	 */
+	protected function registerRedirector()
+	{
+		$this->app['redirect'] = $this->app->share(function($app)
+		{
+			$redirector = new Redirector($app['url']);
+
+			// If the session is set on the application instance, we'll inject it into
+			// the redirector instance. This allows the redirect responses to allow
+			// for the quite convenient "with" methods that flash to the session.
+			if (isset($app['session.store']))
+			{
+				$redirector->setSession($app['session.store']);
+			}
+
+			return $redirector;
+		});
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Routing/UrlGenerator.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Routing/UrlGenerator.php b/vendor/laravel/framework/src/Illuminate/Routing/UrlGenerator.php
new file mode 100755
index 0000000..b9c93a2
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Routing/UrlGenerator.php
@@ -0,0 +1,527 @@
+<?php namespace Illuminate\Routing;
+
+use Illuminate\Http\Request;
+use InvalidArgumentException;
+
+class UrlGenerator {
+
+	/**
+	 * The route collection.
+	 *
+	 * @var \Illuminate\Routing\RouteCollection
+	 */
+	protected $routes;
+
+	/**
+	 * The request instance.
+	 *
+	 * @var \Illuminate\Http\Request
+	 */
+	protected $request;
+
+	/**
+	 * The force URL root.
+	 *
+	 * @var string
+	 */
+	protected $forcedRoot;
+
+	/**
+	 * The forced schema for URLs.
+	 *
+	 * @var string
+	 */
+	protected $forceSchema;
+
+	/**
+	 * Characters that should not be URL encoded.
+	 *
+	 * @var array
+	 */
+	protected $dontEncode = array(
+		'%2F' => '/',
+		'%40' => '@',
+		'%3A' => ':',
+		'%3B' => ';',
+		'%2C' => ',',
+		'%3D' => '=',
+		'%2B' => '+',
+		'%21' => '!',
+		'%2A' => '*',
+		'%7C' => '|',
+	);
+
+	/**
+	 * Create a new URL Generator instance.
+	 *
+	 * @param  \Illuminate\Routing\RouteCollection  $routes
+	 * @param  \Symfony\Component\HttpFoundation\Request   $request
+	 * @return void
+	 */
+	public function __construct(RouteCollection $routes, Request $request)
+	{
+		$this->routes = $routes;
+
+		$this->setRequest($request);
+	}
+
+	/**
+	 * Get the full URL for the current request.
+	 *
+	 * @return string
+	 */
+	public function full()
+	{
+		return $this->request->fullUrl();
+	}
+
+	/**
+	 * Get the current URL for the request.
+	 *
+	 * @return string
+	 */
+	public function current()
+	{
+		return $this->to($this->request->getPathInfo());
+	}
+
+	/**
+	 * Get the URL for the previous request.
+	 *
+	 * @return string
+	 */
+	public function previous()
+	{
+		return $this->to($this->request->headers->get('referer'));
+	}
+
+	/**
+	 * Generate a absolute URL to the given path.
+	 *
+	 * @param  string  $path
+	 * @param  mixed  $extra
+	 * @param  bool|null  $secure
+	 * @return string
+	 */
+	public function to($path, $extra = array(), $secure = null)
+	{
+		// First we will check if the URL is already a valid URL. If it is we will not
+		// try to generate a new one but will simply return the URL as is, which is
+		// convenient since developers do not always have to check if it's valid.
+		if ($this->isValidUrl($path)) return $path;
+
+		$scheme = $this->getScheme($secure);
+
+		$tail = implode('/', array_map(
+			'rawurlencode', (array) $extra)
+		);
+
+		// Once we have the scheme we will compile the "tail" by collapsing the values
+		// into a single string delimited by slashes. This just makes it convenient
+		// for passing the array of parameters to this URL as a list of segments.
+		$root = $this->getRootUrl($scheme);
+
+		return $this->trimUrl($root, $path, $tail);
+	}
+
+	/**
+	 * Generate a secure, absolute URL to the given path.
+	 *
+	 * @param  string  $path
+	 * @param  array   $parameters
+	 * @return string
+	 */
+	public function secure($path, $parameters = array())
+	{
+		return $this->to($path, $parameters, true);
+	}
+
+	/**
+	 * Generate a URL to an application asset.
+	 *
+	 * @param  string  $path
+	 * @param  bool|null  $secure
+	 * @return string
+	 */
+	public function asset($path, $secure = null)
+	{
+		if ($this->isValidUrl($path)) return $path;
+
+		// Once we get the root URL, we will check to see if it contains an index.php
+		// file in the paths. If it does, we will remove it since it is not needed
+		// for asset paths, but only for routes to endpoints in the application.
+		$root = $this->getRootUrl($this->getScheme($secure));
+
+		return $this->removeIndex($root).'/'.trim($path, '/');
+	}
+
+	/**
+	 * Remove the index.php file from a path.
+	 *
+	 * @param  string  $root
+	 * @return string
+	 */
+	protected function removeIndex($root)
+	{
+		$i = 'index.php';
+
+		return str_contains($root, $i) ? str_replace('/'.$i, '', $root) : $root;
+	}
+
+	/**
+	 * Generate a URL to a secure asset.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function secureAsset($path)
+	{
+		return $this->asset($path, true);
+	}
+
+	/**
+	 * Get the scheme for a raw URL.
+	 *
+	 * @param  bool|null  $secure
+	 * @return string
+	 */
+	protected function getScheme($secure)
+	{
+		if (is_null($secure))
+		{
+			return $this->forceSchema ?: $this->request->getScheme().'://';
+		}
+
+		return $secure ? 'https://' : 'http://';
+	}
+
+	/**
+	 * Force the schema for URLs.
+	 *
+	 * @param  string  $schema
+	 * @return void
+	 */
+	public function forceSchema($schema)
+	{
+		$this->forceSchema = $schema.'://';
+	}
+
+	/**
+	 * Get the URL to a named route.
+	 *
+	 * @param  string  $name
+	 * @param  mixed   $parameters
+	 * @param  bool  $absolute
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @return string
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function route($name, $parameters = array(), $absolute = true, $route = null)
+	{
+		$route = $route ?: $this->routes->getByName($name);
+
+		$parameters = (array) $parameters;
+
+		if ( ! is_null($route))
+		{
+			return $this->toRoute($route, $parameters, $absolute);
+		}
+
+		throw new InvalidArgumentException("Route [{$name}] not defined.");
+	}
+
+	/**
+	 * Get the URL for a given route instance.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @param  array  $parameters
+	 * @param  bool  $absolute
+	 * @return string
+	 */
+	protected function toRoute($route, array $parameters, $absolute)
+	{
+		$domain = $this->getRouteDomain($route, $parameters);
+
+		$uri = strtr(rawurlencode($this->trimUrl(
+			$root = $this->replaceRoot($route, $domain, $parameters),
+			$this->replaceRouteParameters($route->uri(), $parameters)
+		)), $this->dontEncode).$this->getRouteQueryString($parameters);
+
+		return $absolute ? $uri : '/'.ltrim(str_replace($root, '', $uri), '/');
+	}
+
+	/**
+	 * Replace the parameters on the root path.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @param  string  $domain
+	 * @param  array  $parameters
+	 * @return string
+	 */
+	protected function replaceRoot($route, $domain, &$parameters)
+	{
+		return $this->replaceRouteParameters($this->getRouteRoot($route, $domain), $parameters);
+	}
+
+	/**
+	 * Replace all of the wildcard parameters for a route path.
+	 *
+	 * @param  string  $path
+	 * @param  array  $parameters
+	 * @return string
+	 */
+	protected function replaceRouteParameters($path, array &$parameters)
+	{
+		if (count($parameters))
+		{
+			$path = preg_replace_sub(
+				'/\{.*?\}/', $parameters, $this->replaceNamedParameters($path, $parameters)
+			);
+		}
+
+		return trim(preg_replace('/\{.*?\?\}/', '', $path), '/');
+	}
+
+	/**
+	 * Replace all of the named parameters in the path.
+	 *
+	 * @param  string  $path
+	 * @param  array  $parameters
+	 * @return string
+	 */
+	protected function replaceNamedParameters($path, &$parameters)
+	{
+		return preg_replace_callback('/\{(.*?)\??\}/', function($m) use (&$parameters)
+		{
+			return isset($parameters[$m[1]]) ? array_pull($parameters, $m[1]) : $m[0];
+
+		}, $path);
+	}
+
+	/**
+	 * Get the query string for a given route.
+	 *
+	 * @param  array  $parameters
+	 * @return string
+	 */
+	protected function getRouteQueryString(array $parameters)
+	{
+		// First we will get all of the string parameters that are remaining after we
+		// have replaced the route wildcards. We'll then build a query string from
+		// these string parameters then use it as a starting point for the rest.
+		if (count($parameters) == 0) return '';
+
+		$query = http_build_query(
+			$keyed = $this->getStringParameters($parameters)
+		);
+
+		// Lastly, if there are still parameters remaining, we will fetch the numeric
+		// parameters that are in the array and add them to the query string or we
+		// will make the initial query string if it wasn't started with strings.
+		if (count($keyed) < count($parameters))
+		{
+			$query .= '&'.implode(
+				'&', $this->getNumericParameters($parameters)
+			);
+		}
+
+		return '?'.trim($query, '&');
+	}
+
+	/**
+	 * Get the string parameters from a given list.
+	 *
+	 * @param  array  $parameters
+	 * @return array
+	 */
+	protected function getStringParameters(array $parameters)
+	{
+		return array_where($parameters, function($k, $v) { return is_string($k); });
+	}
+
+	/**
+	 * Get the numeric parameters from a given list.
+	 *
+	 * @param  array  $parameters
+	 * @return array
+	 */
+	protected function getNumericParameters(array $parameters)
+	{
+		return array_where($parameters, function($k, $v) { return is_numeric($k); });
+	}
+
+	/**
+	 * Get the formatted domain for a given route.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @param  array  $parameters
+	 * @return string
+	 */
+	protected function getRouteDomain($route, &$parameters)
+	{
+		return $route->domain() ? $this->formatDomain($route, $parameters) : null;
+	}
+
+	/**
+	 * Format the domain and port for the route and request.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @param  array  $parameters
+	 * @return string
+	 */
+	protected function formatDomain($route, &$parameters)
+	{
+		return $this->addPortToDomain($this->getDomainAndScheme($route));
+	}
+
+	/**
+	 * Get the domain and scheme for the route.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @return string
+	 */
+	protected function getDomainAndScheme($route)
+	{
+		return $this->getRouteScheme($route).$route->domain();
+	}
+
+	/**
+	 * Add the port to the domain if necessary.
+	 *
+	 * @param  string  $domain
+	 * @return string
+	 */
+	protected function addPortToDomain($domain)
+	{
+		if (in_array($this->request->getPort(), array('80', '443')))
+		{
+			return $domain;
+		}
+
+		return $domain.':'.$this->request->getPort();
+	}
+
+	/**
+	 * Get the root of the route URL.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @param  string  $domain
+	 * @return string
+	 */
+	protected function getRouteRoot($route, $domain)
+	{
+		return $this->getRootUrl($this->getRouteScheme($route), $domain);
+	}
+
+	/**
+	 * Get the scheme for the given route.
+	 *
+	 * @param  \Illuminate\Routing\Route  $route
+	 * @return string
+	 */
+	protected function getRouteScheme($route)
+	{
+		if ($route->httpOnly())
+		{
+			return $this->getScheme(false);
+		}
+		elseif ($route->httpsOnly())
+		{
+			return $this->getScheme(true);
+		}
+
+		return $this->getScheme(null);
+	}
+
+	/**
+	 * Get the URL to a controller action.
+	 *
+	 * @param  string  $action
+	 * @param  mixed   $parameters
+	 * @param  bool    $absolute
+	 * @return string
+	 */
+	public function action($action, $parameters = array(), $absolute = true)
+	{
+		return $this->route($action, $parameters, $absolute, $this->routes->getByAction($action));
+	}
+
+	/**
+	 * Get the base URL for the request.
+	 *
+	 * @param  string  $scheme
+	 * @param  string  $root
+	 * @return string
+	 */
+	protected function getRootUrl($scheme, $root = null)
+	{
+		if (is_null($root))
+		{
+			$root = $this->forcedRoot ?: $this->request->root();
+		}
+
+		$start = starts_with($root, 'http://') ? 'http://' : 'https://';
+
+		return preg_replace('~'.$start.'~', $scheme, $root, 1);
+	}
+
+	/**
+	 * Set the forced root URL.
+	 *
+	 * @param  string  $root
+	 * @return void
+	 */
+	public function forceRootUrl($root)
+	{
+		$this->forcedRoot = $root;
+	}
+
+	/**
+	 * Determine if the given path is a valid URL.
+	 *
+	 * @param  string  $path
+	 * @return bool
+	 */
+	public function isValidUrl($path)
+	{
+		if (starts_with($path, ['#', '//', 'mailto:', 'tel:', 'http://', 'https://'])) return true;
+
+		return filter_var($path, FILTER_VALIDATE_URL) !== false;
+	}
+
+	/**
+	 * Format the given URL segments into a single URL.
+	 *
+	 * @param  string  $root
+	 * @param  string  $path
+	 * @param  string  $tail
+	 * @return string
+	 */
+	protected function trimUrl($root, $path, $tail = '')
+	{
+		return trim($root.'/'.trim($path.'/'.$tail, '/'), '/');
+	}
+
+	/**
+	 * Get the request instance.
+	 *
+	 * @return \Symfony\Component\HttpFoundation\Request
+	 */
+	public function getRequest()
+	{
+		return $this->request;
+	}
+
+	/**
+	 * Set the current request instance.
+	 *
+	 * @param  \Illuminate\Http\Request  $request
+	 * @return void
+	 */
+	public function setRequest(Request $request)
+	{
+		$this->request = $request;
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Routing/composer.json
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Routing/composer.json b/vendor/laravel/framework/src/Illuminate/Routing/composer.json
new file mode 100755
index 0000000..29df7f0
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Routing/composer.json
@@ -0,0 +1,36 @@
+{
+    "name": "illuminate/routing",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylorotwell@gmail.com"
+        }
+    ],
+    "require": {
+        "php": ">=5.4.0",
+        "illuminate/container": "4.2.*",
+        "illuminate/http": "4.2.*",
+        "illuminate/session": "4.2.*",
+        "illuminate/support": "4.2.*",
+        "symfony/http-foundation": "2.5.*",
+        "symfony/http-kernel": "2.5.*",
+        "symfony/routing": "2.5.*"
+    },
+    "require-dev": {
+        "illuminate/console": "4.2.*",
+        "illuminate/filesystem": "4.2.*"
+    },
+    "autoload": {
+        "psr-0": {
+            "Illuminate\\Routing": ""
+        }
+    },
+    "target-dir": "Illuminate/Routing",
+    "extra": {
+        "branch-alias": {
+            "dev-master": "4.2-dev"
+        }
+    },
+    "minimum-stability": "dev"
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Session/CacheBasedSessionHandler.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Session/CacheBasedSessionHandler.php b/vendor/laravel/framework/src/Illuminate/Session/CacheBasedSessionHandler.php
new file mode 100755
index 0000000..712d072
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Session/CacheBasedSessionHandler.php
@@ -0,0 +1,92 @@
+<?php namespace Illuminate\Session;
+
+use Illuminate\Cache\Repository;
+
+class CacheBasedSessionHandler implements \SessionHandlerInterface {
+
+	/**
+	 * The cache repository instance.
+	 *
+	 * @var \Illuminate\Cache\Repository
+	 */
+	protected $cache;
+
+	/**
+	 * The number of minutes to store the data in the cache.
+	 *
+	 * @var int
+	 */
+	protected $minutes;
+
+	/**
+	 * Create a new cache driven handler instance.
+	 *
+	 * @param  \Illuminate\Cache\Repository  $cache
+	 * @param  int  $minutes
+	 * @return void
+	 */
+	public function __construct(Repository $cache, $minutes)
+	{
+		$this->cache = $cache;
+		$this->minutes = $minutes;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function open($savePath, $sessionName)
+	{
+		return true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function close()
+	{
+		return true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function read($sessionId)
+	{
+		return $this->cache->get($sessionId, '');
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function write($sessionId, $data)
+	{
+		return $this->cache->put($sessionId, $data, $this->minutes);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function destroy($sessionId)
+	{
+		return $this->cache->forget($sessionId);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function gc($lifetime)
+	{
+		return true;
+	}
+
+	/**
+	 * Get the underlying cache repository.
+	 *
+	 * @return \Illuminate\Cache\Repository
+	 */
+	public function getCache()
+	{
+		return $this->cache;
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Session/CommandsServiceProvider.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Session/CommandsServiceProvider.php b/vendor/laravel/framework/src/Illuminate/Session/CommandsServiceProvider.php
new file mode 100755
index 0000000..bafed8d
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Session/CommandsServiceProvider.php
@@ -0,0 +1,39 @@
+<?php namespace Illuminate\Session;
+
+use Illuminate\Support\ServiceProvider;
+
+class CommandsServiceProvider extends ServiceProvider {
+
+	/**
+	 * Indicates if loading of the provider is deferred.
+	 *
+	 * @var bool
+	 */
+	protected $defer = true;
+
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->app->bindShared('command.session.database', function($app)
+		{
+			return new Console\SessionTableCommand($app['files']);
+		});
+
+		$this->commands('command.session.database');
+	}
+
+	/**
+	 * Get the services provided by the provider.
+	 *
+	 * @return array
+	 */
+	public function provides()
+	{
+		return array('command.session.database');
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Session/Console/SessionTableCommand.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Session/Console/SessionTableCommand.php b/vendor/laravel/framework/src/Illuminate/Session/Console/SessionTableCommand.php
new file mode 100644
index 0000000..be99053
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Session/Console/SessionTableCommand.php
@@ -0,0 +1,72 @@
+<?php namespace Illuminate\Session\Console;
+
+use Illuminate\Console\Command;
+use Illuminate\Filesystem\Filesystem;
+
+class SessionTableCommand extends Command {
+
+	/**
+	 * The console command name.
+	 *
+	 * @var string
+	 */
+	protected $name = 'session:table';
+
+	/**
+	 * The console command description.
+	 *
+	 * @var string
+	 */
+	protected $description = 'Create a migration for the session database table';
+
+	/**
+	 * The filesystem instance.
+	 *
+	 * @var \Illuminate\Filesystem\Filesystem
+	 */
+	protected $files;
+
+	/**
+	 * Create a new session table command instance.
+	 *
+	 * @param  \Illuminate\Filesystem\Filesystem  $files
+	 * @return void
+	 */
+	public function __construct(Filesystem $files)
+	{
+		parent::__construct();
+
+		$this->files = $files;
+	}
+
+	/**
+	 * Execute the console command.
+	 *
+	 * @return void
+	 */
+	public function fire()
+	{
+		$fullPath = $this->createBaseMigration();
+
+		$this->files->put($fullPath, $this->files->get(__DIR__.'/stubs/database.stub'));
+
+		$this->info('Migration created successfully!');
+
+		$this->call('dump-autoload');
+	}
+
+	/**
+	 * Create a base migration file for the session.
+	 *
+	 * @return string
+	 */
+	protected function createBaseMigration()
+	{
+		$name = 'create_session_table';
+
+		$path = $this->laravel['path'].'/database/migrations';
+
+		return $this->laravel['migration.creator']->create($name, $path);
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Session/Console/stubs/database.stub
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Session/Console/stubs/database.stub b/vendor/laravel/framework/src/Illuminate/Session/Console/stubs/database.stub
new file mode 100755
index 0000000..2aac433
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Session/Console/stubs/database.stub
@@ -0,0 +1,32 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+
+class CreateSessionTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('sessions', function($t)
+		{
+			$t->string('id')->unique();
+			$t->text('payload');
+			$t->integer('last_activity');
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('sessions');
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Session/CookieSessionHandler.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Session/CookieSessionHandler.php b/vendor/laravel/framework/src/Illuminate/Session/CookieSessionHandler.php
new file mode 100755
index 0000000..0a10290
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Session/CookieSessionHandler.php
@@ -0,0 +1,94 @@
+<?php namespace Illuminate\Session;
+
+use Illuminate\Cookie\CookieJar;
+use Symfony\Component\HttpFoundation\Request;
+
+class CookieSessionHandler implements \SessionHandlerInterface {
+
+	/**
+	 * The cookie jar instance.
+	 *
+	 * @var \Illuminate\Cookie\CookieJar
+	 */
+	protected $cookie;
+
+	/**
+	 * The request instance.
+	 *
+	 * @var \Symfony\Component\HttpFoundation\Request
+	 */
+	protected $request;
+
+	/**
+	 * Create a new cookie driven handler instance.
+	 *
+	 * @param  \Illuminate\Cookie\CookieJar  $cookie
+	 * @param  int  $minutes
+	 * @return void
+	 */
+	public function __construct(CookieJar $cookie, $minutes)
+	{
+		$this->cookie = $cookie;
+		$this->minutes = $minutes;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function open($savePath, $sessionName)
+	{
+		return true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function close()
+	{
+		return true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function read($sessionId)
+	{
+		return $this->request->cookies->get($sessionId) ?: '';
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function write($sessionId, $data)
+	{
+		$this->cookie->queue($sessionId, $data, $this->minutes);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function destroy($sessionId)
+	{
+		$this->cookie->queue($this->cookie->forget($sessionId));
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function gc($lifetime)
+	{
+		return true;
+	}
+
+	/**
+	 * Set the request instance.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @return void
+	 */
+	public function setRequest(Request $request)
+	{
+		$this->request = $request;
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Session/DatabaseSessionHandler.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Session/DatabaseSessionHandler.php b/vendor/laravel/framework/src/Illuminate/Session/DatabaseSessionHandler.php
new file mode 100644
index 0000000..dca8979
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Session/DatabaseSessionHandler.php
@@ -0,0 +1,132 @@
+<?php namespace Illuminate\Session;
+
+use Illuminate\Database\Connection;
+
+class DatabaseSessionHandler implements \SessionHandlerInterface, ExistenceAwareInterface {
+
+	/**
+	 * The database connection instance.
+	 *
+	 * @var \Illuminate\Database\Connection
+	 */
+	protected $connection;
+
+	/**
+	 * The name of the session table.
+	 *
+	 * @var string
+	 */
+	protected $table;
+
+	/**
+	 * The existence state of the session.
+	 *
+	 * @var bool
+	 */
+	protected $exists;
+
+	/**
+	 * Create a new database session handler instance.
+	 *
+	 * @param  \Illuminate\Database\Connection  $connection
+	 * @param  string  $table
+	 * @return void
+	 */
+	public function __construct(Connection $connection, $table)
+	{
+		$this->table = $table;
+		$this->connection = $connection;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function open($savePath, $sessionName)
+	{
+		return true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function close()
+	{
+		return true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function read($sessionId)
+	{
+		$session = (object) $this->getQuery()->find($sessionId);
+
+		if (isset($session->payload))
+		{
+			$this->exists = true;
+
+			return base64_decode($session->payload);
+		}
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function write($sessionId, $data)
+	{
+		if ($this->exists)
+		{
+			$this->getQuery()->where('id', $sessionId)->update([
+				'payload' => base64_encode($data), 'last_activity' => time(),
+			]);
+		}
+		else
+		{
+			$this->getQuery()->insert([
+				'id' => $sessionId, 'payload' => base64_encode($data), 'last_activity' => time(),
+			]);
+		}
+
+		$this->exists = true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function destroy($sessionId)
+	{
+		$this->getQuery()->where('id', $sessionId)->delete();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function gc($lifetime)
+	{
+		$this->getQuery()->where('last_activity', '<=', time() - $lifetime)->delete();
+	}
+
+	/**
+	 * Get a fresh query builder instance for the table.
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	protected function getQuery()
+	{
+		return $this->connection->table($this->table);
+	}
+
+	/**
+	 * Set the existence state for the session.
+	 *
+	 * @param  bool  $value
+	 * @return $this
+	 */
+	public function setExists($value)
+	{
+		$this->exists = $value;
+
+		return $this;
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Session/ExistenceAwareInterface.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Session/ExistenceAwareInterface.php b/vendor/laravel/framework/src/Illuminate/Session/ExistenceAwareInterface.php
new file mode 100644
index 0000000..8826531
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Session/ExistenceAwareInterface.php
@@ -0,0 +1,13 @@
+<?php namespace Illuminate\Session;
+
+interface ExistenceAwareInterface {
+
+	/**
+	 * Set the existence state for the session.
+	 *
+	 * @param  bool  $value
+	 * @return \SessionHandlerInterface
+	 */
+	public function setExists($value);
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Session/FileSessionHandler.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Session/FileSessionHandler.php b/vendor/laravel/framework/src/Illuminate/Session/FileSessionHandler.php
new file mode 100644
index 0000000..3fc74ca
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Session/FileSessionHandler.php
@@ -0,0 +1,97 @@
+<?php namespace Illuminate\Session;
+
+use Symfony\Component\Finder\Finder;
+use Illuminate\Filesystem\Filesystem;
+
+class FileSessionHandler implements \SessionHandlerInterface {
+
+	/**
+	 * The filesystem instance.
+	 *
+	 * @var \Illuminate\Filesystem\Filesystem
+	 */
+	protected $files;
+
+	/**
+	 * The path where sessions should be stored.
+	 *
+	 * @var string
+	 */
+	protected $path;
+
+	/**
+	 * Create a new file driven handler instance.
+	 *
+	 * @param  \Illuminate\Filesystem\Filesystem  $files
+	 * @param  string  $path
+	 * @return void
+	 */
+	public function __construct(Filesystem $files, $path)
+	{
+		$this->path = $path;
+		$this->files = $files;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function open($savePath, $sessionName)
+	{
+		return true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function close()
+	{
+		return true;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function read($sessionId)
+	{
+		if ($this->files->exists($path = $this->path.'/'.$sessionId))
+		{
+			return $this->files->get($path);
+		}
+
+		return '';
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function write($sessionId, $data)
+	{
+		$this->files->put($this->path.'/'.$sessionId, $data, true);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function destroy($sessionId)
+	{
+		$this->files->delete($this->path.'/'.$sessionId);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function gc($lifetime)
+	{
+		$files = Finder::create()
+					->in($this->path)
+					->files()
+					->ignoreDotFiles(true)
+					->date('<= now - '.$lifetime.' seconds');
+
+		foreach ($files as $file)
+		{
+			$this->files->delete($file->getRealPath());
+		}
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Session/Middleware.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Session/Middleware.php b/vendor/laravel/framework/src/Illuminate/Session/Middleware.php
new file mode 100644
index 0000000..1af20aa
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Session/Middleware.php
@@ -0,0 +1,258 @@
+<?php namespace Illuminate\Session;
+
+use Closure;
+use Carbon\Carbon;
+use Symfony\Component\HttpFoundation\Cookie;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+
+class Middleware implements HttpKernelInterface {
+
+	/**
+	 * The wrapped kernel implementation.
+	 *
+	 * @var \Symfony\Component\HttpKernel\HttpKernelInterface
+	 */
+	protected $app;
+
+	/**
+	 * The session manager.
+	 *
+	 * @var \Illuminate\Session\SessionManager
+	 */
+	protected $manager;
+
+	/**
+	 * The callback to determine to use session arrays.
+	 *
+	 * @var \Closure|null
+	 */
+	protected $reject;
+
+	/**
+	 * Create a new session middleware.
+	 *
+	 * @param  \Symfony\Component\HttpKernel\HttpKernelInterface  $app
+	 * @param  \Illuminate\Session\SessionManager  $manager
+	 * @param  \Closure|null  $reject
+	 * @return void
+	 */
+	public function __construct(HttpKernelInterface $app, SessionManager $manager, Closure $reject = null)
+	{
+		$this->app = $app;
+		$this->reject = $reject;
+		$this->manager = $manager;
+	}
+
+	/**
+	 * Handle the given request and get the response.
+	 *
+	 * @implements HttpKernelInterface::handle
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @param  int   $type
+	 * @param  bool  $catch
+	 * @return \Symfony\Component\HttpFoundation\Response
+	 */
+	public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
+	{
+		$this->checkRequestForArraySessions($request);
+
+		// If a session driver has been configured, we will need to start the session here
+		// so that the data is ready for an application. Note that the Laravel sessions
+		// do not make use of PHP "native" sessions in any way since they are crappy.
+		if ($this->sessionConfigured())
+		{
+			$session = $this->startSession($request);
+
+			$request->setSession($session);
+		}
+
+		$response = $this->app->handle($request, $type, $catch);
+
+		// Again, if the session has been configured we will need to close out the session
+		// so that the attributes may be persisted to some storage medium. We will also
+		// add the session identifier cookie to the application response headers now.
+		if ($this->sessionConfigured())
+		{
+			$this->closeSession($session);
+
+			$this->addCookieToResponse($response, $session);
+		}
+
+		return $response;
+	}
+
+	/**
+	 * Check the request and reject callback for array sessions.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @return void
+	 */
+	public function checkRequestForArraySessions(Request $request)
+	{
+		if (is_null($this->reject)) return;
+
+		if (call_user_func($this->reject, $request))
+		{
+			$this->manager->setDefaultDriver('array');
+		}
+	}
+
+	/**
+	 * Start the session for the given request.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @return \Illuminate\Session\SessionInterface
+	 */
+	protected function startSession(Request $request)
+	{
+		with($session = $this->getSession($request))->setRequestOnHandler($request);
+
+		$session->start();
+
+		return $session;
+	}
+
+	/**
+	 * Close the session handling for the request.
+	 *
+	 * @param  \Illuminate\Session\SessionInterface  $session
+	 * @return void
+	 */
+	protected function closeSession(SessionInterface $session)
+	{
+		$session->save();
+
+		$this->collectGarbage($session);
+	}
+
+	/**
+	 * Get the full URL for the request.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @return string
+	 */
+	protected function getUrl(Request $request)
+	{
+		$url = rtrim(preg_replace('/\?.*/', '', $request->getUri()), '/');
+
+		return $request->getQueryString() ? $url.'?'.$request->getQueryString() : $url;
+	}
+
+	/**
+	 * Remove the garbage from the session if necessary.
+	 *
+	 * @param  \Illuminate\Session\SessionInterface  $session
+	 * @return void
+	 */
+	protected function collectGarbage(SessionInterface $session)
+	{
+		$config = $this->manager->getSessionConfig();
+
+		// Here we will see if this request hits the garbage collection lottery by hitting
+		// the odds needed to perform garbage collection on any given request. If we do
+		// hit it, we'll call this handler to let it delete all the expired sessions.
+		if ($this->configHitsLottery($config))
+		{
+			$session->getHandler()->gc($this->getLifetimeSeconds());
+		}
+	}
+
+	/**
+	 * Determine if the configuration odds hit the lottery.
+	 *
+	 * @param  array  $config
+	 * @return bool
+	 */
+	protected function configHitsLottery(array $config)
+	{
+		return mt_rand(1, $config['lottery'][1]) <= $config['lottery'][0];
+	}
+
+	/**
+	 * Add the session cookie to the application response.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Response  $response
+	 * @param  \Symfony\Component\HttpFoundation\Session\SessionInterface  $session
+	 * @return void
+	 */
+	protected function addCookieToResponse(Response $response, SessionInterface $session)
+	{
+		$s = $session;
+
+		if ($this->sessionIsPersistent($c = $this->manager->getSessionConfig()))
+		{
+			$secure = array_get($c, 'secure', false);
+
+			$response->headers->setCookie(new Cookie(
+				$s->getName(), $s->getId(), $this->getCookieLifetime(), $c['path'], $c['domain'], $secure
+			));
+		}
+	}
+
+	/**
+	 * Get the session lifetime in seconds.
+	 *
+	 *
+	 */
+	protected function getLifetimeSeconds()
+	{
+		return array_get($this->manager->getSessionConfig(), 'lifetime') * 60;
+	}
+
+	/**
+	 * Get the cookie lifetime in seconds.
+	 *
+	 * @return int
+	 */
+	protected function getCookieLifetime()
+	{
+		$config = $this->manager->getSessionConfig();
+
+		return $config['expire_on_close'] ? 0 : Carbon::now()->addMinutes($config['lifetime']);
+	}
+
+	/**
+	 * Determine if a session driver has been configured.
+	 *
+	 * @return bool
+	 */
+	protected function sessionConfigured()
+	{
+		return ! is_null(array_get($this->manager->getSessionConfig(), 'driver'));
+	}
+
+	/**
+	 * Determine if the configured session driver is persistent.
+	 *
+	 * @param  array|null  $config
+	 * @return bool
+	 */
+	protected function sessionIsPersistent(array $config = null)
+	{
+		// Some session drivers are not persistent, such as the test array driver or even
+		// when the developer don't have a session driver configured at all, which the
+		// session cookies will not need to get set on any responses in those cases.
+		$config = $config ?: $this->manager->getSessionConfig();
+
+		return ! in_array($config['driver'], array(null, 'array'));
+	}
+
+	/**
+	 * Get the session implementation from the manager.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @return \Illuminate\Session\SessionInterface
+	 */
+	public function getSession(Request $request)
+	{
+		$session = $this->manager->driver();
+
+		$session->setId($request->cookies->get($session->getName()));
+
+		return $session;
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/01413d65/vendor/laravel/framework/src/Illuminate/Session/SessionInterface.php
----------------------------------------------------------------------
diff --git a/vendor/laravel/framework/src/Illuminate/Session/SessionInterface.php b/vendor/laravel/framework/src/Illuminate/Session/SessionInterface.php
new file mode 100644
index 0000000..43537d4
--- /dev/null
+++ b/vendor/laravel/framework/src/Illuminate/Session/SessionInterface.php
@@ -0,0 +1,30 @@
+<?php namespace Illuminate\Session;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Session\SessionInterface as BaseSessionInterface;
+
+interface SessionInterface extends BaseSessionInterface {
+
+	/**
+	 * Get the session handler instance.
+	 *
+	 * @return \SessionHandlerInterface
+	 */
+	public function getHandler();
+
+	/**
+	 * Determine if the session handler needs a request.
+	 *
+	 * @return bool
+	 */
+	public function handlerNeedsRequest();
+
+	/**
+	 * Set the request on the handler instance.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @return void
+	 */
+	public function setRequestOnHandler(Request $request);
+
+}


Mime
View raw message