Fix mistake

composer.json

@@ -20,8 +20,8 @@
     ],
     "require": {
         "php": "^7.0",
-        "illuminate/contracts": "5.1.* || 5.2.* || 5.3.* || 5.4.* || 5.5.*",
-        "illuminate/support": "5.1.* || 5.2.* || 5.3.* || 5.4.* || 5.5.*",
+        "illuminate/contracts": "5.1.* || 5.2.* || 5.3.* || 5.4.* || 5.5.* || 5.6.*",
+        "illuminate/support": "5.1.* || 5.2.* || 5.3.* || 5.4.* || 5.5.* || 5.6.*",
         "league/fractal": "^0.16.0"
     },
     "require-dev": {

src/Http/Responses/Decorators/PrettyPrintDecorator.php

@@ -30,4 +30,3 @@ public function make(array $data, int $status, array $headers = []): JsonRespons
         return $response;
     }
 }
-}

src/TransformBuilder.php

@@ -272,7 +272,8 @@ protected function includeTransformerRelations(BaseTransformer $transformer)
         $this->with(Collection::make($transformer->defaultRelations())
             ->filter(function ($constrain, $relation) use ($relations) {
                 return ! in_array(is_numeric($relation) ? $constrain : $relation, $relations);
-            })->all());
+            })
+            ->all());
     }
 
     /**
@@ -289,29 +290,24 @@ protected function stripEagerLoadConstraints(array $relations): array
     }
 
     /**
-     * Remove parameters from relations that must be eager loaded and
-     * filter out the relations which have an includeXxx method.
+     * Remove parameters from relations that must be eager loaded and filter
+     * out the relations which have an includeXxx method.
      *
-     * @param array                                                             $relations
-     * @param \Flugg\Responder\Transformers\Transformer|callable|string|null    $transformer
+     * @param array                                                          $relations
+     * @param \Flugg\Responder\Transformers\Transformer|callable|string|null $transformer
      * @return array
      */
     protected function prepareEagerLoadableRelations(array $relations, $transformer): array
     {
         $cleanedRelations = [];
+
         foreach ($relations as $key => $value) {
-            // Strip out parameters from relation name
             $relationName = explode(':', is_numeric($key) ? $value : $key)[0];
-            // Ignores all relation which have a includeXxx method
-            // method_exists does not care if the $transformer is actually an object or not
             if (method_exists($transformer, 'include' . ucfirst($relationName))) {
                 continue;
             }
 
-            // If the key is numeric, value is the relation name: return it
-            // Otherwise the key is the relation name and the value is a custom scope:
-            //  return the relation with the value untouched
-            if(is_numeric($key)) {
+            if (is_numeric($key)) {
                 $cleanedRelations[$key] = $relationName;
             } else {
                 $cleanedRelations[$relationName] = $value;

tests/Unit/TransformBuilderTest.php

@@ -327,14 +327,8 @@ public function testTransformMethodExtractsAndEagerLoadsRelationsWhenThereAreRel
         $this->resource->shouldReceive('getTransformer')->andReturn($transformer = Mockery::mock(Transformer::class));
         $transformer->shouldReceive('defaultRelations')->andReturn([]);
 
-        $this->builder->resource()->with(['foo:first(aa|bb)', 'bar:second(cc|dd)' => function() {}])->transform();
-
-        // Model should receive the relations names without parameters,
-        //  while the transformFactory should receive also parameters to let Fractal use them
-        // We must use the Mockery::on() method because with() method will try to do a strict match
-        //  for the closure resulting in a failure, because it will check
-        //  if it's the same closure reference but no closure are alike, even when they are defined identically.
-        // Here we just check that 'bar' element contains a closure.
+        $this->builder->resource()->with(['foo:first(aa|bb)', 'bar:second(cc|dd)' => function () { }])->transform();
+
         $model->shouldHaveReceived('load')->with(Mockery::on(function (array $relations) {
             return ($relations[0] == 'foo') && ($relations['bar'] instanceof \Closure);
         }))->once();
@@ -346,15 +340,44 @@ public function testTransformMethodExtractsAndEagerLoadsRelationsWhenThereAreRel
     }
 
     /**
-     * Assert that the [transform] method do not eager load relations for which is present an include method.
+     * Assert that the [transform] method doesn't eager load relations not present in the $relations list.
+     */
+    /*public function testTransformMethodDoesntEagerLoadNonListedRelations()
+    {
+        $this->transformFactory->shouldReceive('make')->andReturn([]);
+        $this->resource->shouldReceive('getData')->andReturn($model = Mockery::mock(Model::class));
+        $model->shouldReceive('load')->andReturnSelf();
+        $this->resource->shouldReceive('getTransformer')->andReturn($transformer = new class extends Transformer
+        {
+            protected $relations = ['foo'];
+        });
+
+        $this->builder->resource()->with(['foo', 'bar'])->transform();
+
+        $model->shouldHaveReceived('load')->with(['foo'])->once();
+        $this->transformFactory->shouldHaveReceived('make')->with($this->resource, $this->serializer, [
+            'includes' => ['foo'],
+            'excludes' => [],
+            'fieldsets' => [],
+        ])->once();
+    }*/
+
+    /**
+     * Assert that the [transform] method doesn't eager load relations which has an include method.
      */
-    public function testTransformMethodDoNotEagerLoadsRelationsForWhichAnIncludeMethodExists()
+    public function testTransformMethodDoesntEagerLoadRelationsWithAnIncludeMethod()
     {
         $this->transformFactory->shouldReceive('make')->andReturn([]);
         $this->resource->shouldReceive('getData')->andReturn($model = Mockery::mock(Model::class));
         $model->shouldReceive('load')->andReturnSelf();
-        // It's not possible to easily mock method_exists with mockery so we must rely on a stub
-        $this->resource->shouldReceive('getTransformer')->andReturn(new TransformerWithIncludeMethods());
+        $this->resource->shouldReceive('getTransformer')->andReturn(new class extends Transformer
+        {
+            protected $relations = ['foo', 'bar'];
+            protected $load = ['baz'];
+
+            public function includeBar() { }
+            public function includeBaz() { }
+        });
 
         $this->builder->resource()->with($relations = ['foo', 'bar'])->transform();
 
@@ -399,18 +422,4 @@ public function testOnlyMethodAllowsMultipleCallsAndStrings()
             'fieldsets' => ['foo', 'bar', 'baz'],
         ])->once();
     }
-}
-
-class TransformerWithIncludeMethods extends Transformer {
-    protected $relations = ['foo', 'bar'];
-
-    protected $load = ['baz'];
-
-    public function includeBar() {
-        //
-    }
-
-    public function includeBaz() {
-        //
-    }
 }