You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by nd...@apache.org on 2015/05/01 23:32:53 UTC
[06/57] [partial] airavata-php-gateway git commit: AIRAVATA 1632 +
Job Description for Admin Dashboard
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);
+
+}