├── src
    ├── ModeResolver
    │   ├── ModeResolverInterface.php
    │   ├── EmbedModeResolver.php
    │   ├── IdsModeResolver.php
    │   └── SideloadModeResolver.php
    ├── Utility.php
    └── Architect.php
├── composer.json
├── LICENSE
├── CONTRIBUTING.md
└── README.md


/src/ModeResolver/ModeResolverInterface.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Optimus\Architect\ModeResolver;
4 | 
5 | interface ModeResolverInterface
6 | {
7 |     public function resolve($property, &$object, &$root, $fullPropertyPath);
8 | }
9 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "optimus/architect",
 3 |     "autoload": {
 4 |         "psr-4": {
 5 |             "Optimus\\Architect\\": "src/"
 6 |         }
 7 |     },
 8 |     "require": {
 9 |         "laravel/framework": "~6.0|~7.0|~8.0|~9.0|~10.0|~11.0"
10 |     },
11 |     "require-dev": {
12 |         "mockery/mockery": "1.3.*",
13 |         "orchestra/testbench": "4.*",
14 |         "phpunit/phpunit": "~8.0",
15 |         "php-coveralls/php-coveralls": "2.2.*"
16 |     },
17 |     "minimum-stability": "dev",
18 |     "prefer-stable": true,
19 |     "license": "MIT"
20 | }
21 | 


--------------------------------------------------------------------------------
/src/ModeResolver/EmbedModeResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Optimus\Architect\ModeResolver;
 4 | 
 5 | use Optimus\Architect\ModeResolver\ModeResolverInterface;
 6 | 
 7 | class EmbedModeResolver implements ModeResolverInterface
 8 | {
 9 |     /**
10 |      * Simply returns the object since embedded is the default
11 |      * transformation
12 |      * @param  string $property
13 |      * @param  object $object
14 |      * @param  array $root
15 |      * @param  string $fullPropertyPath
16 |      * @return object                   
17 |      */
18 |     public function resolve($property, &$object, &$root, $fullPropertyPath)
19 |     {
20 |         return $object;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Esben Petersen
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/ModeResolver/IdsModeResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Optimus\Architect\ModeResolver;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | use Illuminate\Support\Collection;
 7 | use Optimus\Architect\ModeResolver\ModeResolverInterface;
 8 | use Optimus\Architect\Utility;
 9 | 
10 | class IdsModeResolver implements ModeResolverInterface
11 | {
12 |     /**
13 |      * Map through the collection and convert it to a collection
14 |      * of ids
15 |      * @param  string $property
16 |      * @param  object $object
17 |      * @param  array $root
18 |      * @param  string $fullPropertyPath
19 |      * @return mixed
20 |      */
21 |     public function resolve($property, &$object, &$root, $fullPropertyPath)
22 |     {
23 |         if (is_array($object)) {
24 |             // We need to determine if this is a singular relationship or
25 |             // a collection of models
26 |             $arrayCopy = $object;
27 |             $firstElement = array_shift($arrayCopy);
28 | 
29 |             // The object was not a collection, and was rather a single
30 |             // model, because the first item returned was a property
31 |             // We therefore just return the single ID
32 |             if (Utility::isPrimitive($firstElement)) {
33 |                 return (int) Utility::getProperty($object, 'id');
34 |             }
35 | 
36 |             return array_map(function ($entry) {
37 |                 return (int) Utility::getProperty($entry, 'id');
38 |             }, $object);
39 |         } elseif ($object instanceof Collection) {
40 |             return $object->map(function ($entry) {
41 |                 return (int) Utility::getProperty($entry, 'id');
42 |             });
43 |         // The relation is not a collection, but rather
44 |         // a singular relation
45 |         } elseif ($object instanceof Model) {
46 |             return $object->id;
47 |         }
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | ### Commit Message Format
 2 | 
 3 | [Angular.js commit message style](https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y/edit#)
 4 | 
 5 | Each commit message consists of a **header**, a **body** and a **footer**.  The header has a special
 6 | format that includes a **type**, a **scope** and a **subject**:
 7 | 
 8 | ```
 9 | <type>(<scope>): <subject>
10 | <BLANK LINE>
11 | <body>
12 | <BLANK LINE>
13 | <footer>
14 | ```
15 | 
16 | Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
17 | to read on github as well as in various git tools.
18 | 
19 | ### Type
20 | Must be one of the following:
21 | 
22 | * **feat**: A new feature
23 | * **fix**: A bug fix
24 | * **docs**: Documentation only changes
25 | * **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing
26 |   semi-colons, etc)
27 | * **refactor**: A code change that neither fixes a bug or adds a feature
28 | * **perf**: A code change that improves performance
29 | * **test**: Adding missing tests
30 | * **chore**: Changes to the build process or auxiliary tools and libraries such as documentation
31 |   generation
32 | 
33 | ### Scope
34 | The scope could be anything specifying place of the commit change. For example `$location`,
35 | `$browser`, `$compile`, `$rootScope`, `ngHref`, `ngClick`, `ngView`, etc...
36 | 
37 | ### Subject
38 | The subject contains succinct description of the change:
39 | 
40 | * use the imperative, present tense: "change" not "changed" nor "changes"
41 | * don't capitalize first letter
42 | * no dot (.) at the end
43 | 
44 | ### Body
45 | Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes"
46 | The body should include the motivation for the change and contrast this with previous behavior.
47 | 
48 | ### Footer
49 | The footer should contain any information about **Breaking Changes** and is also the place to
50 | reference GitHub issues that this commit **Closes**.
51 | 


--------------------------------------------------------------------------------
/src/Utility.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Optimus\Architect;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model as EloquentModel;
 6 | use Illuminate\Support\Collection;
 7 | 
 8 | class Utility
 9 | {
10 |     /**
11 |      * Get a property of an array or object
12 |      * @param  mixed $objectOrArray object or array
13 |      * @param  string $property
14 |      * @return mixed
15 |      */
16 |     public static function getProperty($objectOrArray, $property)
17 |     {
18 |         if (is_array($objectOrArray)) {
19 |             return $objectOrArray[$property];
20 |         } else {
21 |             return $objectOrArray->{$property};
22 |         }
23 |     }
24 | 
25 |     /**
26 |      * Set a property of an Eloquent model, normal object or array
27 |      * @param mixed $objectOrArray model, object or array
28 |      * @param string $property
29 |      * @param void
30 |      */
31 |     public static function setProperty(&$objectOrArray, $property, $value)
32 |     {
33 |         // Eloquent models are also instances of ArrayAccess, and therefore
34 |         // we check for that first
35 |         if ($objectOrArray instanceof EloquentModel) {
36 |             // Does relation exist?
37 |             // If so, only set the relation if not primitive. Keeping a attribute
38 |             // as a relation will allow for it to be converted to arrays during
39 |             // serialization
40 |             if ($property) {
41 |                 if ($objectOrArray->relationLoaded($property) && !Utility::isPrimitive($value)) {
42 |                     $objectOrArray->setRelation($property, $value);
43 | 
44 |             // If attribute is not a relation we just set it on
45 |             // the model directly. If it is a primitive relation (a relation
46 |             // converted to IDs) we unset the relation and set it as an attribute
47 |                 } else {
48 |                     unset($objectOrArray[$property]);
49 |                     $objectOrArray->setAttribute($property, $value);
50 |                 }
51 |             }
52 |         } elseif (is_array($objectOrArray)) {
53 |             $objectOrArray[$property] = $value;
54 |         } else {
55 |             $objectOrArray->{$property} = $value;
56 |         }
57 |     }
58 | 
59 |     /**
60 |      * Is the variable a primitive type
61 |      * @param  mixed  $input
62 |      * @return boolean
63 |      */
64 |     public static function isPrimitive($input)
65 |     {
66 |         return !is_array($input) && !($input instanceof EloquentModel) && !($input instanceof Collection);
67 |     }
68 | 
69 |     /**
70 |      * Is the input a collection of resources?
71 |      * @param  mixed  $input
72 |      * @return boolean
73 |      */
74 |     public static function isCollection($input)
75 |     {
76 |         return is_array($input) || $input instanceof Collection;
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Architect
  2 | 
  3 | [![Latest Version](https://img.shields.io/github/release/esbenp/architect.svg?style=flat-square)](https://github.com/esbenp/architect/releases)
  4 | [![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE)
  5 | [![Build Status](https://img.shields.io/travis/esbenp/architect/master.svg?style=flat-square)](https://travis-ci.org/esbenp/architect)
  6 | [![Coverage Status](https://img.shields.io/coveralls/esbenp/architect.svg?style=flat-square)](https://coveralls.io/github/esbenp/architect)
  7 | [![Total Downloads](https://img.shields.io/packagist/dt/optimus/architect.svg?style=flat-square)](https://packagist.org/packages/optimus/architect)
  8 | 
  9 | ## Introduction
 10 | 
 11 | Architect is used for dynamically creating new structures for API resource relationships.
 12 | Sounds confusing and pretentious?
 13 | 
 14 | Imagine you have a resource `Book` with a related resource `Author`.
 15 | 
 16 | ```
 17 | Book 1-----n Author
 18 | ```
 19 | 
 20 | ### Normal embedded mode
 21 | 
 22 | This is how related resources are loaded by default using embedded mode.
 23 | 
 24 | ```json
 25 | {
 26 |    "books":[
 27 |       {
 28 |          "id":1,
 29 |          "author_id":1,
 30 |          "title":"How to save the world from evil",
 31 |          "pages":100,
 32 |          "author":{
 33 |             "id":1,
 34 |             "name":"Optimus Prime"
 35 |          }
 36 |       },
 37 |       {
 38 |          "id":2,
 39 |          "author_id":2,
 40 |          "title":"How to take over the world",
 41 |          "pages":100,
 42 |          "author":{
 43 |             "id":2,
 44 |             "name":"Megatron"
 45 |          }
 46 |       }
 47 |    ]
 48 | }
 49 | ```
 50 | 
 51 | With Architect now you can load related resources using `ids` mode and
 52 | `sideloading` mode
 53 | 
 54 | ### Ids mode
 55 | 
 56 | Only load the IDs of the related resource.
 57 | [Using the primary key property of Eloquent models is in the roadmap.](https://github.com/esbenp/architect/issues/1)
 58 | 
 59 | ```json
 60 | {
 61 |    "books":[
 62 |       {
 63 |          "id":1,
 64 |          "author_id":1,
 65 |          "title":"How to save the world from evil",
 66 |          "pages":100,
 67 |          "author":1
 68 |       },
 69 |       {
 70 |          "id":2,
 71 |          "author_id":2,
 72 |          "title":"How to take over the world",
 73 |          "pages":100,
 74 |          "author":2
 75 |       }
 76 |    ]
 77 | }
 78 | ```
 79 | 
 80 | ### Sideloading mode
 81 | 
 82 | Hoist the related resources into the global scope and leave behind the IDs
 83 | using the ID mode resolver.
 84 | 
 85 | ```json
 86 | {
 87 |    "author":[
 88 |       {
 89 |          "id":1,
 90 |          "name":"Optimus Prime"
 91 |       },
 92 |       {
 93 |          "id":2,
 94 |          "name":"Megatron"
 95 |       }
 96 |    ],
 97 |    "books":[
 98 |       {
 99 |          "id":1,
100 |          "author_id":1,
101 |          "title":"How to save the world from evil",
102 |          "pages":100,
103 |          "author":1
104 |       },
105 |       {
106 |          "id":2,
107 |          "author_id":2,
108 |          "title":"How to take over the world",
109 |          "pages":100,
110 |          "author":2
111 |       }
112 |    ]
113 | }
114 | ```
115 | 
116 | ## Usage
117 | 
118 | Architect works with normal array's (collections and resources), `Illuminate\Support\Collection`
119 | and `Illuminate\Database\Eloquent\Model`.
120 | 
121 | ```php
122 | <?php
123 | 
124 | $books = Book::with('Author')->get();
125 | 
126 | $architect = new \Optimus\Architect\Architect;
127 | $parsed = $architect->parseData($books, [
128 |     'author' => 'sideload' // can also be embed or ids (embed is default)
129 | ], 'books');
130 | ```
131 | 
132 | [Optimus\LaravelController](https://github.com/esbenp/laravel-controller) gives
133 | nice convenience methods to define the Architect relationships in query parameters.
134 | 
135 | ## Installation
136 | ```bash
137 | composer require optimus/architect
138 | ```
139 | 
140 | ## Standards
141 | 
142 | This package is compliant with [PSR-1], [PSR-2] and [PSR-4]. If you notice compliance oversights,
143 | please send a patch via pull request.
144 | 
145 | [PSR-1]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md
146 | [PSR-2]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md
147 | [PSR-4]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md
148 | 
149 | ## Testing
150 | 
151 | ``` bash
152 | $ phpunit
153 | ```
154 | 
155 | ## Contributing
156 | 
157 | Please see [CONTRIBUTING](https://github.com/esbenp/architect/blob/master/CONTRIBUTING.md) for details.
158 | 
159 | ## License
160 | 
161 | The MIT License (MIT). Please see [License File](https://github.com/esbenp/architect/blob/master/LICENSE) for more information.
162 | 


--------------------------------------------------------------------------------
/src/ModeResolver/SideloadModeResolver.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Optimus\Architect\ModeResolver;
  4 | 
  5 | use Illuminate\Database\Eloquent\Model as EloquentModel;
  6 | use Illuminate\Support\Collection;
  7 | use Optimus\Architect\ModeResolver\IdsModeResolver;
  8 | use Optimus\Architect\ModeResolver\ModeResolverInterface;
  9 | use Optimus\Architect\Utility;
 10 | 
 11 | class SideloadModeResolver implements ModeResolverInterface
 12 | {
 13 |     private $idsResolver;
 14 | 
 15 |     public function __construct()
 16 |     {
 17 |         $this->idsResolver = new IdsModeResolver;
 18 |     }
 19 | 
 20 |     /**
 21 |      * Move all relational resources to the root element and
 22 |      * use idsResolver to replace them with a collection of identifiers
 23 |      * @param  string $property The property to resolve
 24 |      * @param  object $object The object which has the property
 25 |      * @param  array $root The root array which will contain the object
 26 |      * @param  string $fullPropertyPath The full dotnotation path to this property
 27 |      * @return mixed
 28 |      */
 29 |     public function resolve($property, &$object, &$root, $fullPropertyPath)
 30 |     {
 31 |         $this->addCollectionToRoot($root, $object, $fullPropertyPath);
 32 | 
 33 |         return $this->idsResolver->resolve($property, $object, $root, $fullPropertyPath);
 34 |     }
 35 | 
 36 |     /**
 37 |      * Add the collection to the root array
 38 |      * @param array $root
 39 |      * @param object $object
 40 |      * @param string $fullPropertyPath
 41 |      * @return void
 42 |      */
 43 |     private function addCollectionToRoot(&$root, &$object, $fullPropertyPath)
 44 |     {
 45 |         // First determine if the $object is a resource or a
 46 |         // collection of resources
 47 |         $isResource = false;
 48 |         if (is_array($object)) {
 49 |             $copy = $object;
 50 |             $values = array_values($copy);
 51 |             $firstPropertyOrResource = array_shift($values);
 52 | 
 53 |             if (Utility::isPrimitive($firstPropertyOrResource)) {
 54 |                 $isResource = true;
 55 |             }
 56 |         } elseif ($object instanceof EloquentModel) {
 57 |             $isResource = true;
 58 |         }
 59 | 
 60 |         $newCollection = $isResource ? [$object] : $object;
 61 | 
 62 |         // Does existing collections use arrays or Collections
 63 |         $copy = $root;
 64 |         $values = array_values($copy);
 65 |         $existingRootCollection = array_shift($values);
 66 | 
 67 |         $newCollection = $existingRootCollection instanceof Collection ?
 68 |                                 new Collection($newCollection) : $newCollection;
 69 | 
 70 |         if (!array_key_exists($fullPropertyPath, $root)) {
 71 |             $root[$fullPropertyPath] = $newCollection;
 72 |         } else {
 73 |             $this->mergeRootCollection($root[$fullPropertyPath], $newCollection);
 74 |         }
 75 |     }
 76 | 
 77 |     /**
 78 |      * If a collection for this resource has already begun (i.e. multiple
 79 |      * resources share this type of resource), then merge with the existing collection
 80 |      * @param  mixed $collection
 81 |      * @param  object $object
 82 |      * @return void
 83 |      */
 84 |     private function mergeRootCollection(&$collection, $object)
 85 |     {
 86 |         if (is_array($object)) {
 87 |             foreach ($object as $resource) {
 88 |                 $this->addResourceToRootCollectionIfNonExistant($collection, $resource);
 89 |             }
 90 |         } elseif ($object instanceof Collection) {
 91 |             $object->each(function ($resource) use (&$collection) {
 92 |                 $this->addResourceToRootCollectionIfNonExistant($collection, $resource);
 93 |             });
 94 |         }
 95 |     }
 96 | 
 97 |     /**
 98 |      * Check if the resource already exists in the root collection by id
 99 |      * TODO: https://github.com/esbenp/laravel-controller/issues/2
100 |      * @param mixed $collection
101 |      * @param mixed $resource
102 |      */
103 |     private function addResourceToRootCollectionIfNonExistant(&$collection, $resource)
104 |     {
105 |         $identifier = Utility::getProperty($resource, 'id');
106 |         $exists = false;
107 | 
108 |         $copy = $collection instanceof Collection ? $collection->toArray() : $collection;
109 | 
110 |         foreach ($copy as $rootResource) {
111 |             if ((int) Utility::getProperty($rootResource, 'id') === (int) $identifier) {
112 |                 $exists = true;
113 |                 break;
114 |             }
115 |         }
116 | 
117 |         if ($exists === false) {
118 |             if (is_array($collection)) {
119 |                 $collection[] = $resource;
120 |             } elseif ($collection instanceof Collection) {
121 |                 $collection->push($resource);
122 |             }
123 |         }
124 |     }
125 | }
126 | 


--------------------------------------------------------------------------------
/src/Architect.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Optimus\Architect;
  4 | 
  5 | use InvalidArgumentException;
  6 | use Illuminate\Support\Collection;
  7 | 
  8 | class Architect
  9 | {
 10 |     private $modeResolvers = [];
 11 | 
 12 |     /**
 13 |      * Parse a collection using given modes.
 14 |      * @param  mixed $data The collection to be parsed
 15 |      * @param  array  $modes The modes to be used, format is ['relation' => 'mode']
 16 |      * @param  string $key A key to hoist the collection into the root array
 17 |      * @return array
 18 |      */
 19 |     public function parseData($data, array $modes, $key = null)
 20 |     {
 21 |         $return = [];
 22 | 
 23 |         uksort($modes, function ($a, $b) {
 24 |             return substr_count($b, '.')-substr_count($a, '.');
 25 |         });
 26 | 
 27 |         if (Utility::isCollection($data)) {
 28 |             $parsed = $this->parseCollection($modes, $data, $return);
 29 |         } else {
 30 |             $parsed = $this->parseResource($modes, $data, $return);
 31 |         }
 32 | 
 33 |         if ($key !== null) {
 34 |             $return[$key] = $parsed;
 35 |         } else {
 36 |             if (in_array('sideload', $modes)) {
 37 |                 throw new InvalidArgumentException('$key cannot be null when ' .
 38 |                                     'resources are transformed using sideload.');
 39 |             }
 40 | 
 41 |             $return = $parsed;
 42 |         }
 43 | 
 44 |         return $return;
 45 |     }
 46 | 
 47 |     /**
 48 |      * Parse a collection using given modes
 49 |      * @param  array  $modes
 50 |      * @param  mixed $collection
 51 |      * @param  array $root
 52 |      * @param  string $fullPropertyPath
 53 |      * @return mixed
 54 |      */
 55 |     private function parseCollection(array $modes, $collection, &$root, $fullPropertyPath = '')
 56 |     {
 57 |         if (is_array($collection)) {
 58 |             foreach ($collection as $i => $resource) {
 59 |                 $collection[$i] = $this->parseResource($modes, $resource, $root, $fullPropertyPath);
 60 |             }
 61 |         } elseif ($collection instanceof Collection) {
 62 |             $collection = $collection->map(function ($resource) use ($modes, &$root, $fullPropertyPath) {
 63 |                 return $this->parseResource($modes, $resource, $root, $fullPropertyPath);
 64 |             });
 65 |         }
 66 | 
 67 |         return $collection;
 68 |     }
 69 | 
 70 |     /**
 71 |      * Parse a single resource using given modes
 72 |      * @param  array  $modes
 73 |      * @param  mixed $resource
 74 |      * @param  array $root
 75 |      * @param  string $fullPropertyPath
 76 |      * @return mixed
 77 |      */
 78 |     private function parseResource(array $modes, &$resource, &$root, $fullPropertyPath = '')
 79 |     {
 80 |         foreach ($modes as $relation => $mode) {
 81 |             $modeResolver = $this->resolveMode($mode);
 82 | 
 83 |             $steps = explode('.', $relation);
 84 | 
 85 |             // Get the first resource in the relation
 86 |             // TODO: Refactor
 87 |             $property = array_shift($steps);
 88 |             if (is_array($resource)) {
 89 |                 if ($resource[$property] === null) {
 90 |                     continue;
 91 |                 }
 92 | 
 93 |                 $object = &$resource[$property];
 94 |             } else {
 95 |                 if ($resource->{$property} === null) {
 96 |                     continue;
 97 |                 }
 98 | 
 99 |                 $object = &$resource->{$property};
100 |             }
101 | 
102 |             if (empty($steps)) {
103 |                 // This is the deepest level. Resolve it.
104 |                 $fullPropertyPath .= $relation;
105 |                 $object = $this->modeResolvers[$mode]->resolve($relation, $object, $root, $fullPropertyPath);
106 |             } else {
107 |                 // More levels exist in this relation.
108 |                 // We want a drill down and resolve the deepest level first.
109 | 
110 |                 $path = implode('.', $steps);
111 |                 $modes = [
112 |                     $path => $mode
113 |                 ];
114 | 
115 |                 // Add the previous levels to the full path so it can be used
116 |                 // to populate the root level properly.
117 |                 $fullPropertyPath .= $property . '.';
118 | 
119 |                 if (Utility::isCollection($object)) {
120 |                     $object = $this->parseCollection($modes, $object, $root, $fullPropertyPath);
121 |                 } else {
122 |                     $object = $this->parseResource($modes, $object, $root, $fullPropertyPath);
123 |                 }
124 |             }
125 | 
126 |             // Reset the full property path after running a full relation
127 |             $fullPropertyPath = '';
128 |             Utility::setProperty($resource, $property, $object);
129 |         }
130 | 
131 |         return $resource;
132 |     }
133 | 
134 |     /**
135 |      * Resolve a mode resolver class if it has not been resolved before
136 |      * @param  string $mode The mode to be resolved
137 |      * @return Optimus\Architect\ModeResolver\ModeResolverInterface
138 |      */
139 |     private function resolveMode($mode)
140 |     {
141 |         if (!isset($this->modeResolers[$mode])) {
142 |             $this->modeResolvers[$mode] = $this->createModeResolver($mode);
143 |         }
144 | 
145 |         return $this->modeResolvers[$mode];
146 |     }
147 | 
148 |     /**
149 |      * Instantiate a mode resolver class
150 |      * @param  string $mode [description]
151 |      * @return Optimus\Architect\ModeResolver\ModeResolverInterface
152 |      */
153 |     private function createModeResolver($mode)
154 |     {
155 |         $class = 'Optimus\Architect\ModeResolver\\';
156 |         switch ($mode) {
157 |             default:
158 |             case 'embed':
159 |                 $class .= 'EmbedModeResolver';
160 |                 break;
161 |             case 'ids':
162 |                 $class .= 'IdsModeResolver';
163 |                 break;
164 |             case 'sideload':
165 |                 $class .= 'SideloadModeResolver';
166 |                 break;
167 |         }
168 | 
169 |         return new $class;
170 |     }
171 | }
172 | 


--------------------------------------------------------------------------------