Laravel version update

Laravel version update

vendor/container-interop/container-interop/docs/ContainerInterface-meta.md

@@ -54,7 +54,7 @@ The summary of the analysis showed that:
 - all containers offer a method to get an entry by its id
 - a large majority name such method `get()`
 - for all containers, the `get()` method has 1 mandatory parameter of type string
-- some containers have an optional additional argument for `get()`, but it doesn't same the same purpose between containers
+- some containers have an optional additional argument for `get()`, but it doesn't have the same purpose between containers
 - a large majority of the containers offer a method to test if it can return an entry by its id
 - a majority name such method `has()`
 - for all containers offering `has()`, the method has exactly 1 parameter of type string

vendor/container-interop/container-interop/docs/ContainerInterface.md

@@ -11,8 +11,8 @@ The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD",
 interpreted as described in [RFC 2119][].
 
 The word `implementor` in this document is to be interpreted as someone
-implementing the `ContainerInterface` in a depency injection-related library or framework.
-Users of dependency injections containers (DIC) are refered to as `user`.
+implementing the `ContainerInterface` in a dependency injection-related library or framework.
+Users of dependency injections containers (DIC) are referred to as `user`.
 
 [RFC 2119]: http://tools.ietf.org/html/rfc2119
 
@@ -31,50 +31,52 @@ Users of dependency injections containers (DIC) are refered to as `user`.
   `user` SHOULD NOT rely on getting the same value on 2 successive calls.
   While `ContainerInterface` only defines one mandatory parameter in `get()`, implementations
   MAY accept additional optional parameters.
-  
+
 - `has` takes one unique parameter: an entry identifier. It MUST return `true`
   if an entry identifier is known to the container and `false` if it is not.
-  
+  `has($id)` returning true does not mean that `get($id)` will not throw an exception.
+  It does however mean that `get($id)` will not throw a `NotFoundException`.
+
 ### 1.2 Exceptions
 
-Exceptions directly thrown by the container MUST implement the 
+Exceptions directly thrown by the container MUST implement the
 [`Interop\Container\Exception\ContainerException`](../src/Interop/Container/Exception/ContainerException.php).
 
-A call to the `get` method with a non-existing id should throw a
+A call to the `get` method with a non-existing id SHOULD throw a
 [`Interop\Container\Exception\NotFoundException`](../src/Interop/Container/Exception/NotFoundException.php).
 
 ### 1.3 Additional features
 
-This section describes additional features that MAY be added to a container. Containers are not 
+This section describes additional features that MAY be added to a container. Containers are not
 required to implement these features to respect the ContainerInterface.
 
 #### 1.3.1 Delegate lookup feature
 
-The goal of the *delegate lookup* feature is to allow several containers to share entries. 
+The goal of the *delegate lookup* feature is to allow several containers to share entries.
 Containers implementing this feature can perform dependency lookups in other containers.
 
-Containers implementing this feature will offer a greater lever of interoperability 
+Containers implementing this feature will offer a greater lever of interoperability
 with other containers. Implementation of this feature is therefore RECOMMENDED.
 
 A container implementing this feature:
 
 - MUST implement the `ContainerInterface`
-- MUST provide a way to register a delegate container (using a constructor parameter, or a setter, 
+- MUST provide a way to register a delegate container (using a constructor parameter, or a setter,
   or any possible way). The delegate container MUST implement the `ContainerInterface`.
 
 When a container is configured to use a delegate container for dependencies:
 
-- Calls to the `get` method should only return an entry if the entry is part of the container. 
-  If the entry is not part of the container, an exception should be thrown 
+- Calls to the `get` method should only return an entry if the entry is part of the container.
+  If the entry is not part of the container, an exception should be thrown
   (as requested by the `ContainerInterface`).
 - Calls to the `has` method should only return `true` if the entry is part of the container.
   If the entry is not part of the container, `false` should be returned.
-- If the fetched entry has dependencies, **instead** of performing 
+- If the fetched entry has dependencies, **instead** of performing
   the dependency lookup in the container, the lookup is performed on the *delegate container*.
 
 Important! By default, the lookup SHOULD be performed on the delegate container **only**, not on the container itself.
 
-It is however allowed for containers to provide exception cases for special entries, and a way to lookup 
+It is however allowed for containers to provide exception cases for special entries, and a way to lookup
 into the same container (or another container) instead of the delegate container.
 
 2. Package
@@ -114,6 +116,9 @@ interface ContainerInterface
      * Returns true if the container can return an entry for the given identifier.
      * Returns false otherwise.
      *
+     * `has($id)` returning true does not mean that `get($id)` will not throw an exception.
+     * It does however mean that `get($id)` will not throw a `NotFoundException`.
+     *
      * @param string $id Identifier of the entry to look for.
      *
      * @return boolean

vendor/container-interop/container-interop/docs/Delegate-lookup-meta.md

@@ -89,16 +89,16 @@ In the example above, "container 2" contains a controller "myController" and the
 Without the *delegate lookup* feature, when requesting the "myController" instance to container 2, it would take 
 in charge the instanciation of both entries.
 
-However, using the *delegate lookup* feature, here is what happens when we ask the composite controller for the 
+However, using the *delegate lookup* feature, here is what happens when we ask the composite container for the 
 "myController" instance:
 
-- The composite controller asks container 1 if if contains the "myController" instance. The answer is no.
-- The composite controller asks container 2 if if contains the "myController" instance. The answer is yes.
-- The composite controller performs a `get` call on container 2 for the "myController" instance.
+- The composite container asks container 1 if if contains the "myController" instance. The answer is no.
+- The composite container asks container 2 if if contains the "myController" instance. The answer is yes.
+- The composite container performs a `get` call on container 2 for the "myController" instance.
 - Container 2 sees that "myController" has a dependency on "entityManager".
-- Container 2 delegates the lookup of "entityManager" to the composite controller.
-- The composite controller asks container 1 if if contains the "entityManager" instance. The answer is yes.
-- The composite controller performs a `get` call on container 1 for the "entityManager" instance.
+- Container 2 delegates the lookup of "entityManager" to the composite container.
+- The composite container asks container 1 if if contains the "entityManager" instance. The answer is yes.
+- The composite container performs a `get` call on container 1 for the "entityManager" instance.
 
 In the end, we get a controller instanciated by container 2 that references an entityManager instanciated
 by container 1.

vendor/container-interop/container-interop/docs/Delegate-lookup.md

@@ -3,10 +3,10 @@ Delegate lookup feature
 
 This document describes a standard for dependency injection containers.
 
-The goal set by the *delegate lookup* feature is to allow several containers to share entries. 
+The goal set by the *delegate lookup* feature is to allow several containers to share entries.
 Containers implementing this feature can perform dependency lookups in other containers.
 
-Containers implementing this feature will offer a greater lever of interoperability 
+Containers implementing this feature will offer a greater lever of interoperability
 with other containers. Implementation of this feature is therefore RECOMMENDED.
 
 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD",
@@ -15,7 +15,7 @@ interpreted as described in [RFC 2119][].
 
 The word `implementor` in this document is to be interpreted as someone
 implementing the delegate lookup feature in a dependency injection-related library or framework.
-Users of dependency injections containers (DIC) are refered to as `user`.
+Users of dependency injections containers (DIC) are referred to as `user`.
 
 [RFC 2119]: http://tools.ietf.org/html/rfc2119
 
@@ -36,22 +36,22 @@ fetching the dependencies from.
 A container implementing the *delegate lookup* feature:
 
 - MUST implement the [`ContainerInterface`](ContainerInterface.md)
-- MUST provide a way to register a delegate container (using a constructor parameter, or a setter, 
+- MUST provide a way to register a delegate container (using a constructor parameter, or a setter,
   or any possible way). The delegate container MUST implement the [`ContainerInterface`](ContainerInterface.md).
 
 When a container is configured to use a delegate container for dependencies:
 
 - Calls to the `get` method should only return an entry if the entry is part of the container.
-  If the entry is not part of the container, an exception should be thrown 
+  If the entry is not part of the container, an exception should be thrown
   (as requested by the [`ContainerInterface`](ContainerInterface.md)).
 - Calls to the `has` method should only return `true` if the entry is part of the container.
   If the entry is not part of the container, `false` should be returned.
-- If the fetched entry has dependencies, **instead** of performing 
+- If the fetched entry has dependencies, **instead** of performing
   the dependency lookup in the container, the lookup is performed on the *delegate container*.
 
 Important: By default, the dependency lookups SHOULD be performed on the delegate container **only**, not on the container itself.
 
-It is however allowed for containers to provide exception cases for special entries, and a way to lookup 
+It is however allowed for containers to provide exception cases for special entries, and a way to lookup
 into the same container (or another container) instead of the delegate container.
 
 3. Package / Interface