Merge pull request #14 from tuyakhov/member_naming

tuyakhov · web-flow · commit acea2ed93197 · 2017-02-19T19:42:46.000+02:00
member names
diff --git a/README.md b/README.md
@@ -46,7 +46,7 @@ class Controller extends \yii\rest\Controller
 ```
 By default, the value of `type` is automatically pluralized. 
 You can change this behavior by setting `tuyakhov\jsonapi\Serializer::$pluralize` property:
-```
+```php
 class Controller extends \yii\rest\Controller
 {
     public $serializer = [
@@ -166,7 +166,7 @@ As the result:
   }
 }
 ```
-Enabling JSON Input
+Enabling JSON API Input
 ---------------------------
 To let the API accept input data in JSON API format, configure the [[yii\web\Request::$parsers|parsers]] property of the request application component to use the [[tuyakhov\jsonapi\JsonApiParser]] for JSON input
 ```php
@@ -176,3 +176,35 @@ To let the API accept input data in JSON API format, configure the [[yii\web\Req
   ]
 ]
 ```
+By default it parses a HTTP request body so that you can populate model attributes with user inputs.
+For example the request body:
+```javascript
+{
+  "data": {
+    "type": "users",
+    "id": "1",
+    "attributes": {
+        "first-name": "Bob",
+        "last-name": "Homster"
+    }
+  }
+}
+```
+Will be resolved into the following array:
+```php
+// var_dump($_POST);
+[
+    "User" => [
+        "first_name" => "Bob", 
+        "last_name" => "Homster"
+    ]
+]
+```
+So you can access request body by calling `\Yii::$app->request->post()` and simply populate the model with input data:
+```php
+$model = new User();
+$model->load(\Yii::$app->request->post());
+```
+By default type `users` will be converted into `User` (singular, camelCase) which corresponds to the model's `formName()` method (which you may override).
+You can override the `JsonApiParser::formNameCallback` property which refers to a callback that converts 'type' member to form name.
+Also you could change the default behavior for conversion of member names to variable names ('first-name' converts into 'first_name') by setting `JsonApiParser::memberNameCallback` property.
diff --git a/src/Inflector.php b/src/Inflector.php
@@ -0,0 +1,47 @@
+<?php
+/**
+ * @author Anton Tuyakhov <atuyakhov@gmail.com>
+ */
+
+namespace tuyakhov\jsonapi;
+
+use yii\helpers\BaseInflector;
+
+class Inflector extends BaseInflector
+{
+    /**
+     * Format member names according to recommendations for JSON API implementations.
+     * For example, both 'firstName' and 'first_name' will be converted to 'first-name'.
+     * @link http://jsonapi.org/format/#document-member-names
+     * @param $var string
+     * @return string
+     */
+    public static function var2member($var)
+    {
+        return self::camel2id(self::variablize($var));
+    }
+
+    /**
+     * Converts member names to variable names
+     * All special characters will be replaced by underscore
+     * For example, 'first-name' will be converted to 'first_name'
+     * @param $member string
+     * @return mixed
+     */
+    public static function member2var($member)
+    {
+        return str_replace(' ', '_', preg_replace('/[^A-Za-z0-9]+/', ' ', $member));
+    }
+
+    /**
+     * Converts 'type' member to form name
+     * Will be converted to singular form.
+     * For example, 'articles' will be converted to 'Article'
+     * @param $type string 'type' member of the document
+     * @return string
+     */
+    public static function type2form($type)
+    {
+        return self::id2camel(self::singularize($type));
+    }
+}
diff --git a/src/JsonApiParser.php b/src/JsonApiParser.php
@@ -5,30 +5,26 @@
 
 namespace tuyakhov\jsonapi;
 
-use yii\base\InvalidConfigException;
 use yii\helpers\ArrayHelper;
-use yii\helpers\Inflector;
 use \yii\web\JsonParser;
 
 class JsonApiParser extends JsonParser
 {
     /**
-     * @var array|callable|null
+     * Converts 'type' member to form name
+     * If not set, type will be converted to singular form.
+     * For example, 'articles' will be converted to 'Article'
+     * @var callable
      */
-    protected $formNameCallback;
-
-    public function __construct($formNameCallback = null)
-    {
-        if ($formNameCallback === null) {
-            $formNameCallback = [$this, 'typeToFormName'];
-        }
-        if (!is_callable($formNameCallback, true)) {
-            throw new InvalidConfigException('JsonApiParser::formNameCallback should be callable');
-        }
-
-        $this->formNameCallback = $formNameCallback;
-    }
+    public $formNameCallback = ['tuyakhov\jsonapi\Inflector', 'type2form'];
 
+    /**
+     * Converts member names to variable names
+     * If not set, all special characters will be replaced by underscore
+     * For example, 'first-name' will be converted to 'first_name'
+     * @var callable
+     */
+    public $memberNameCallback = ['tuyakhov\jsonapi\Inflector', 'member2var'];
 
     /**
      * Parse resource object into the input data to populates the model
@@ -38,9 +34,9 @@ public function parse($rawBody, $contentType)
     {
         $array = parent::parse($rawBody, $contentType);
         if ($type = ArrayHelper::getValue($array, 'data.type')) {
-            $formName = call_user_func($this->formNameCallback, $type);
+            $formName = $this->typeToFormName($type);
             if ($attributes = ArrayHelper::getValue($array, 'data.attributes')) {
-                $result[$formName] = $attributes;
+                $result[$formName] = array_combine($this->parseMemberNames(array_keys($attributes)), array_values($attributes));
             } elseif ($id = ArrayHelper::getValue($array, 'data.id')) {
                 $result[$formName] = ['id' => $id, 'type' => $type];
             }
@@ -49,12 +45,12 @@ public function parse($rawBody, $contentType)
                     if (isset($relationship[0])) {
                         foreach ($relationship as $item) {
                             if (isset($item['type']) && isset($item['id'])) {
-                                $formName = call_user_func($this->formNameCallback, $item['type']);
+                                $formName = $this->typeToFormName($item['type']);
                                 $result[$name][$formName][] = $item;
                             }
                         }
                     } elseif (isset($relationship['type']) && isset($relationship['id'])) {
-                        $formName = call_user_func($this->formNameCallback, $relationship['type']);
+                        $formName = $this->typeToFormName($relationship['type']);
                         $result[$name][$formName] = $relationship;
                     }
                 }
@@ -63,16 +59,29 @@ public function parse($rawBody, $contentType)
             $data = ArrayHelper::getValue($array, 'data', []);
             foreach ($data as $relationLink) {
                 if (isset($relationLink['type']) && isset($relationLink['id'])) {
-                    $formName = call_user_func($this->formNameCallback, $relationLink['type']);
+                    $formName = $this->typeToFormName($relationLink['type']);
                     $result[$formName][] = $relationLink;
                 }
             }
         }
         return isset($result) ? $result : $array;
     }
 
+    /**
+     * @param $type 'type' member of the document
+     * @return string form name
+     */
     protected function typeToFormName($type)
     {
-        return Inflector::id2camel(Inflector::singularize($type));
+        return call_user_func($this->formNameCallback, $type);
+    }
+
+    /**
+     * @param array $memberNames
+     * @return array variable names
+     */
+    protected function parseMemberNames(array $memberNames = [])
+    {
+        return array_map($this->memberNameCallback, $memberNames);
     }
 }
diff --git a/src/ResourceTrait.php b/src/ResourceTrait.php
@@ -7,7 +7,6 @@
 
 use yii\base\Arrayable;
 use yii\db\ActiveRecordInterface;
-use yii\helpers\Inflector;
 use yii\web\Link;
 use yii\web\Linkable;
 
@@ -120,6 +119,7 @@ protected function resolveFields(array $fields, array $fieldSet = [])
             if (is_int($field)) {
                 $field = $definition;
             }
+            $field = Inflector::camel2id(Inflector::variablize($field), '_');
             if (empty($fieldSet) || in_array($field, $fieldSet, true)) {
                 $result[$field] = $definition;
             }
diff --git a/src/Serializer.php b/src/Serializer.php
@@ -14,7 +14,6 @@
 use yii\web\Linkable;
 use yii\web\Request;
 use yii\web\Response;
-use yii\helpers\Inflector;
 
 class Serializer extends Component
 {
@@ -54,6 +53,21 @@ class Serializer extends Component
      */
     public $pluralize = true;
 
+    /**
+     * Prepares the member name that should be returned.
+     * If not set, all member names will be converted to recommended format.
+     * For example, both 'firstName' and 'first_name' will be converted to 'first-name'.
+     * @var callable
+     */
+    public $prepareMemberName = ['tuyakhov\jsonapi\Inflector', 'var2member'];
+
+    /**
+     * Converts a member name to an attribute name.
+     * @var callable
+     */
+    public $formatMemberName = ['tuyakhov\jsonapi\Inflector', 'member2var'];
+
+
     /**
      * @inheritdoc
      */
@@ -94,10 +108,14 @@ public function serialize($data)
     protected function serializeModel(ResourceInterface $model)
     {
         $fields = $this->getRequestedFields();
+        $type = $this->pluralize ? Inflector::pluralize($model->getType()) : $model->getType();
+        $fields = isset($fields[$type]) ? $fields[$type] : [];
+
+        $attributes = $model->getResourceAttributes($fields);
+        $attributes = array_combine($this->prepareMemberNames(array_keys($attributes)), array_values($attributes));
 
-        $attributes = isset($fields[$model->getType()]) ? $fields[$model->getType()] : [];
         $data = array_merge($this->serializeIdentifier($model), [
-            'attributes' => $model->getResourceAttributes($attributes),
+            'attributes' => $attributes,
         ]);
 
         $included = $this->getIncluded();
@@ -114,16 +132,17 @@ protected function serializeModel(ResourceInterface $model)
                 } elseif ($items instanceof ResourceIdentifierInterface) {
                     $relationship = $this->serializeIdentifier($items);
                 }
-
                 if (!empty($relationship)) {
+                    $memberName = $this->prepareMemberNames([$name]);
+                    $memberName = reset($memberName);
                     if (in_array($name, $included)) {
-                        $data['relationships'][$name]['data'] = $relationship;
+                        $data['relationships'][$memberName]['data'] = $relationship;
                     }
-                }
-                if ($model instanceof LinksInterface) {
-                    $links = $model->getRelationshipLinks($name);
-                    if (!empty($links)) {
-                        $data['relationships'][$name]['links'] = Link::serialize($links);
+                    if ($model instanceof LinksInterface) {
+                        $links = $model->getRelationshipLinks($memberName);
+                        if (!empty($links)) {
+                            $data['relationships'][$memberName]['links'] = Link::serialize($links);
+                        }
                     }
                 }
             }
@@ -291,14 +310,26 @@ protected function getRequestedFields()
             $fields = [];
         }
         foreach ($fields as $key => $field) {
-            $fields[$key] = preg_split('/\s*,\s*/', $fields, -1, PREG_SPLIT_NO_EMPTY);
+            $fields[$key] = array_map($this->formatMemberName, preg_split('/\s*,\s*/', $field, -1, PREG_SPLIT_NO_EMPTY));
         }
         return $fields;
     }
 
     protected function getIncluded()
     {
         $include = $this->request->get($this->expandParam);
-        return is_string($include) ? preg_split('/\s*,\s*/', $include, -1, PREG_SPLIT_NO_EMPTY) : [];
+        return is_string($include) ? array_map($this->formatMemberName, preg_split('/\s*,\s*/', $include, -1, PREG_SPLIT_NO_EMPTY)) : [];
+    }
+
+
+    /**
+     * Format member names according to recommendations for JSON API implementations
+     * @link http://jsonapi.org/format/#document-member-names
+     * @param array $memberNames
+     * @return array
+     */
+    protected function prepareMemberNames(array $memberNames = [])
+    {
+        return array_map($this->prepareMemberName, $memberNames);
     }
 }
diff --git a/tests/JsonApiParserTest.php b/tests/JsonApiParserTest.php
@@ -21,6 +21,7 @@ public function testParse()
                'attributes' => [
                    'field1' => 'test',
                    'field2' => 2,
+                   'first-name' => 'Bob'
                ],
                'relationships' => [
                    'author' => [
@@ -33,7 +34,8 @@ public function testParse()
         $this->assertEquals([
             'ResourceModel' => [
                 'field1' => 'test',
-                'field2' => 2
+                'field2' => 2,
+                'first_name' => 'Bob',
             ],
             'author' => [
                 'ResourceModel' => [
diff --git a/tests/SerializerTest.php b/tests/SerializerTest.php
diff --git a/tests/data/ResourceModel.php b/tests/data/ResourceModel.php

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,6 @@`
`7`	`7`
`8`	`8`	`use yii\base\Arrayable;`
`9`	`9`	`use yii\db\ActiveRecordInterface;`
`10`		`-use yii\helpers\Inflector;`
`11`	`10`	`use yii\web\Link;`
`12`	`11`	`use yii\web\Linkable;`
`13`	`12`
`@@ -120,6 +119,7 @@ protected function resolveFields(array $fields, array $fieldSet = [])`
`120`	`119`	`if (is_int($field)) {`
`121`	`120`	`$field = $definition;`
`122`	`121`	`}`
	`122`	`+ $field = Inflector::camel2id(Inflector::variablize($field), '_');`
`123`	`123`	`if (empty($fieldSet) \|\| in_array($field, $fieldSet, true)) {`
`124`	`124`	`$result[$field] = $definition;`
`125`	`125`	`}`