v2: Updates

* Simplifies & beautifies everything
* Introduces a new Class system.
* Errors are defaulted to AWS's handler.
* New function names & more efficient handling.
* Should fix a majority of the errors.

Please read the README for more!

aws/Aws/Api/ErrorParser/AbstractErrorParser.php

@@ -0,0 +1,95 @@
+<?php
+namespace Aws\Api\ErrorParser;
+
+use Aws\Api\Parser\MetadataParserTrait;
+use Aws\Api\Parser\PayloadParserTrait;
+use Aws\Api\Service;
+use Aws\Api\StructureShape;
+use Aws\CommandInterface;
+use Psr\Http\Message\ResponseInterface;
+
+abstract class AbstractErrorParser
+{
+    use MetadataParserTrait;
+    use PayloadParserTrait;
+
+    /**
+     * @var Service
+     */
+    protected $api;
+
+    /**
+     * @param Service $api
+     */
+    public function __construct(Service $api = null)
+    {
+        $this->api = $api;
+    }
+
+    abstract protected function payload(
+        ResponseInterface $response,
+        StructureShape $member
+    );
+
+    protected function extractPayload(
+        StructureShape $member,
+        ResponseInterface $response
+    ) {
+        if ($member instanceof StructureShape) {
+            // Structure members parse top-level data into a specific key.
+            return $this->payload($response, $member);
+        } else {
+            // Streaming data is just the stream from the response body.
+            return $response->getBody();
+        }
+    }
+
+    protected function populateShape(
+        array &$data,
+        ResponseInterface $response,
+        CommandInterface $command = null
+    ) {
+        $data['body'] = [];
+
+        if (!empty($command) && !empty($this->api)) {
+
+            // If modeled error code is indicated, check for known error shape
+            if (!empty($data['code'])) {
+
+                $errors = $this->api->getOperation($command->getName())->getErrors();
+                foreach ($errors as $key => $error) {
+
+                    // If error code matches a known error shape, populate the body
+                    if ($data['code'] == $error['name']
+                        && $error instanceof StructureShape
+                    ) {
+                        $modeledError = $error;
+                        $data['body'] = $this->extractPayload(
+                            $modeledError,
+                            $response
+                        );
+                        $data['error_shape'] = $modeledError;
+
+                        foreach ($error->getMembers() as $name => $member) {
+                            switch ($member['location']) {
+                                case 'header':
+                                    $this->extractHeader($name, $member, $response, $data['body']);
+                                    break;
+                                case 'headers':
+                                    $this->extractHeaders($name, $member, $response, $data['body']);
+                                    break;
+                                case 'statusCode':
+                                    $this->extractStatus($name, $response, $data['body']);
+                                    break;
+                            }
+                        }
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        return $data;
+    }
+}

aws/Aws/Api/ErrorParser/JsonParserTrait.php

@@ -2,6 +2,7 @@
 namespace Aws\Api\ErrorParser;
 
 use Aws\Api\Parser\PayloadParserTrait;
+use Aws\Api\StructureShape;
 use Psr\Http\Message\ResponseInterface;
 
 /**
@@ -20,7 +21,18 @@ trait JsonParserTrait
             'code'        => null,
             'message'     => null,
             'type'        => $code[0] == '4' ? 'client' : 'server',
-            'parsed'      => $this->parseJson($response->getBody())
+            'parsed'      => $this->parseJson($response->getBody(), $response)
         ];
     }
+
+    protected function payload(
+        ResponseInterface $response,
+        StructureShape $member
+    ) {
+        $jsonBody = $this->parseJson($response->getBody(), $response);
+
+        if ($jsonBody) {
+            return $this->parser->parse($member, $jsonBody);
+        }
+    }
 }

aws/Aws/Api/ErrorParser/JsonRpcErrorParser.php

@@ -1,18 +1,32 @@
 <?php
 namespace Aws\Api\ErrorParser;
 
+use Aws\Api\Parser\JsonParser;
+use Aws\Api\Service;
+use Aws\CommandInterface;
 use Psr\Http\Message\ResponseInterface;
 
 /**
  * Parsers JSON-RPC errors.
  */
-class JsonRpcErrorParser
+class JsonRpcErrorParser extends AbstractErrorParser
 {
     use JsonParserTrait;
 
-    public function __invoke(ResponseInterface $response)
+    private $parser;
+
+    public function __construct(Service $api = null, JsonParser $parser = null)
     {
+        parent::__construct($api);
+        $this->parser = $parser ?: new JsonParser();
+    }
+
+    public function __invoke(
+        ResponseInterface $response,
+        CommandInterface $command = null
+    ) {
         $data = $this->genericHandler($response);
+
         // Make the casing consistent across services.
         if ($data['parsed']) {
             $data['parsed'] = array_change_key_case($data['parsed']);
@@ -26,6 +40,8 @@ class JsonRpcErrorParser
                 : null;
         }
 
+        $this->populateShape($data, $response, $command);
+
         return $data;
     }
 }

aws/Aws/Api/ErrorParser/RestJsonErrorParser.php

@@ -1,17 +1,31 @@
 <?php
 namespace Aws\Api\ErrorParser;
 
+use Aws\Api\Parser\JsonParser;
+use Aws\Api\Service;
+use Aws\Api\StructureShape;
+use Aws\CommandInterface;
 use Psr\Http\Message\ResponseInterface;
 
 /**
  * Parses JSON-REST errors.
  */
-class RestJsonErrorParser
+class RestJsonErrorParser extends AbstractErrorParser
 {
     use JsonParserTrait;
 
-    public function __invoke(ResponseInterface $response)
+    private $parser;
+
+    public function __construct(Service $api = null, JsonParser $parser = null)
     {
+        parent::__construct($api);
+        $this->parser = $parser ?: new JsonParser();
+    }
+
+    public function __invoke(
+        ResponseInterface $response,
+        CommandInterface $command = null
+    ) {
         $data = $this->genericHandler($response);
 
         // Merge in error data from the JSON body
@@ -30,6 +44,15 @@ class RestJsonErrorParser
             $data['code'] = $colon ? substr($code, 0, $colon) : $code;
         }
 
+        // Retrieve error message directly
+        $data['message'] = isset($data['parsed']['message'])
+            ? $data['parsed']['message']
+            : (isset($data['parsed']['Message'])
+                ? $data['parsed']['Message']
+                : null);
+
+        $this->populateShape($data, $response, $command);
+
         return $data;
     }
 }

aws/Aws/Api/ErrorParser/XmlErrorParser.php

@@ -2,34 +2,50 @@
 namespace Aws\Api\ErrorParser;
 
 use Aws\Api\Parser\PayloadParserTrait;
+use Aws\Api\Parser\XmlParser;
+use Aws\Api\Service;
+use Aws\Api\StructureShape;
+use Aws\CommandInterface;
 use Psr\Http\Message\ResponseInterface;
 
 /**
  * Parses XML errors.
  */
-class XmlErrorParser
+class XmlErrorParser extends AbstractErrorParser
 {
     use PayloadParserTrait;
 
-    public function __invoke(ResponseInterface $response)
+    protected $parser;
+
+    public function __construct(Service $api = null, XmlParser $parser = null)
     {
+        parent::__construct($api);
+        $this->parser = $parser ?: new XmlParser();
+    }
+
+    public function __invoke(
+        ResponseInterface $response,
+        CommandInterface $command = null
+    ) {
         $code = (string) $response->getStatusCode();
 
         $data = [
-            'type'        => $code[0] == '4' ? 'client' : 'server',
-            'request_id'  => null,
-            'code'        => null,
-            'message'     => null,
-            'parsed'      => null
+            'type' => $code[0] == '4' ? 'client' : 'server',
+            'request_id' => null,
+            'code' => null,
+            'message' => null,
+            'parsed' => null
         ];
 
         $body = $response->getBody();
         if ($body->getSize() > 0) {
-            $this->parseBody($this->parseXml($body), $data);
+            $this->parseBody($this->parseXml($body, $response), $data);
         } else {
             $this->parseHeaders($response, $data);
         }
 
+        $this->populateShape($data, $response, $command);
+
         return $data;
     }
 
@@ -51,16 +67,7 @@ class XmlErrorParser
     private function parseBody(\SimpleXMLElement $body, array &$data)
     {
         $data['parsed'] = $body;
-
-        $namespaces = $body->getDocNamespaces();
-        if (!isset($namespaces[''])) {
-            $prefix = '';
-        } else {
-            // Account for the default namespace being defined and PHP not
-            // being able to handle it :(.
-            $body->registerXPathNamespace('ns', $namespaces['']);
-            $prefix = 'ns:';
-        }
+        $prefix = $this->registerNamespacePrefix($body);
 
         if ($tempXml = $body->xpath("//{$prefix}Code[1]")) {
             $data['code'] = (string) $tempXml[0];
@@ -71,12 +78,34 @@ class XmlErrorParser
         }
 
         $tempXml = $body->xpath("//{$prefix}RequestId[1]");
-        if (empty($tempXml)) {
-            $tempXml = $body->xpath("//{$prefix}RequestID[1]");
-        }
-
         if (isset($tempXml[0])) {
-            $data['request_id'] = (string) $tempXml[0];
+            $data['request_id'] = (string)$tempXml[0];
+        }
+    }
+
+    protected function registerNamespacePrefix(\SimpleXMLElement $element)
+    {
+        $namespaces = $element->getDocNamespaces();
+        if (!isset($namespaces[''])) {
+            return '';
+        } 
+        
+        // Account for the default namespace being defined and PHP not
+        // being able to handle it :(.
+        $element->registerXPathNamespace('ns', $namespaces['']);
+        return 'ns:';
+    }
+
+    protected function payload(
+        ResponseInterface $response,
+        StructureShape $member
+    ) {
+        $xmlBody = $this->parseXml($response->getBody(), $response);
+        $prefix = $this->registerNamespacePrefix($xmlBody);
+        $errorBody = $xmlBody->xpath("//{$prefix}Error");
+
+        if (is_array($errorBody) && !empty($errorBody[0])) {
+            return $this->parser->parse($member, $errorBody[0]);
         }
     }
 }