move to repo

Author: Jamie Hannaford

.gitignore

@@ -0,0 +1,10 @@
+.idea/
+.test/
+coverage/
+vendor/
+
+*.pyc
+
+phpunit.xml
+coverage.xml
+composer.lock

composer.json

@@ -0,0 +1,36 @@
+{
+    "name": "php-opencloud/common",
+    "authors": [
+        {
+            "name": "Jamie Hannaford",
+            "email": "jamie.hannaford@rackspace.com",
+            "homepage" : "https://github.com/jamiehannaford"
+        }
+    ],
+    "autoload": {
+        "psr-4": {
+            "OpenCloud\\": "src/",
+            "OpenCloud\\Test\\": "tests/unit/",
+            "OpenCloud\\Integration\\": "tests/integration/"
+        }
+    },
+    "repositories": [
+        {
+            "type": "vcs",
+            "url": "https://github.com/php-opencloud/Sami"
+        }
+    ],
+    "require": {
+        "php": "~7.0",
+        "guzzlehttp/guzzle": "~6.1",
+        "justinrainbow/json-schema": "~1.3"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "~4.0",
+        "sami/sami": "dev-master",
+        "psr/log": "~1.0",
+        "satooshi/php-coveralls": "~1.0",
+        "jakub-onderka/php-parallel-lint": "0.*",
+        "fabpot/php-cs-fixer": "~1.0"
+    }
+}

phpunit.xml.dist

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit bootstrap="./vendor/autoload.php" colors="true">
+
+    <testsuites>
+        <testsuite name="OpenStack">
+            <directory>tests/unit</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory suffix=".php">./src</directory>
+            <exclude>
+                <directory suffix="Interface.php">./src</directory>
+                <directory suffix="Api.php">./src</directory>
+                <directory suffix="Params.php">./src</directory>
+            </exclude>
+        </whitelist>
+    </filter>
+
+</phpunit>

src/Common/Api/AbstractApi.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace OpenCloud\Common\Api;
+
+abstract class AbstractApi implements ApiInterface
+{
+    protected $params;
+
+    protected function isRequired(array $param)
+    {
+        return array_merge($param, ['required' => true]);
+    }
+
+    protected function notRequired(array $param)
+    {
+        return array_merge($param, ['required' => false]);
+    }
+
+    protected function query(array $param)
+    {
+        return array_merge($param, ['location' => AbstractParams::QUERY]);
+    }
+
+    protected function url(array $param)
+    {
+        return array_merge($param, ['location' => AbstractParams::URL]);
+    }
+
+    public function documented(array $param)
+    {
+        return array_merge($param, ['required' => true]);
+    }
+}

src/Common/Api/AbstractParams.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace OpenCloud\Common\Api;
+
+abstract class AbstractParams
+{
+    // locations
+    const QUERY = 'query';
+    const HEADER = 'header';
+    const URL = 'url';
+    const JSON = 'json';
+    const RAW = 'raw';
+
+    // types
+    const STRING_TYPE = "string";
+    const BOOL_TYPE = "boolean";
+    const BOOLEAN_TYPE = self::BOOL_TYPE;
+    const OBJECT_TYPE = "object";
+    const ARRAY_TYPE = "array";
+    const NULL_TYPE = "NULL";
+    const INT_TYPE = 'integer';
+    const INTEGER_TYPE = self::INT_TYPE;
+
+    public static function isSupportedLocation($val)
+    {
+        return in_array($val, [self::QUERY, self::HEADER, self::URL, self::JSON, self::RAW]);
+    }
+
+    public function limit()
+    {
+        return [
+            'type'        => self::INT_TYPE,
+            'location'    => 'query',
+            'description' => <<<DESC
+This will limit the total amount of elements returned in a list up to the number specified. For example, specifying a
+limit of 10 will return 10 elements, regardless of the actual count.
+DESC
+        ];
+    }
+
+    public function marker()
+    {
+        return [
+            'type'        => 'string',
+            'location'    => 'query',
+            'description' => <<<DESC
+Specifying a marker will begin the list from the value specified. Elements will have a particular attribute that
+identifies them, such as a name or ID. The marker value will search for an element whose identifying attribute matches
+the marker value, and begin the list from there.
+DESC
+        ];
+    }
+
+    public function id($type)
+    {
+        return [
+            'description' => sprintf("The unique ID, or identifier, for the %s", $type),
+            'type'        => self::STRING_TYPE,
+            'location'    => self::JSON,
+        ];
+    }
+
+    public function idPath()
+    {
+        return [
+            'type'        => self::STRING_TYPE,
+            'location'    => self::URL,
+            'description' => 'The unique ID of the resource',
+        ];
+    }
+
+    public function name($resource)
+    {
+        return [
+            'description' => sprintf("The name of the %s", $resource),
+            'type'        => self::STRING_TYPE,
+            'location'    => self::JSON,
+        ];
+    }
+
+
+    public function sortDir()
+    {
+        return [
+            'type'        => self::STRING_TYPE,
+            'location'    => self::QUERY,
+            'description' => "Sorts by one or more sets of attribute and sort direction combinations.",
+            'enum'        => ['asc', 'desc']
+        ];
+    }
+
+    public function sortKey()
+    {
+        return [
+            'type'     => self::STRING_TYPE,
+            'location' => self::QUERY,
+            'description' => "Sorts by one or more sets of attribute and sort direction combinations.",
+        ];
+    }
+}

src/Common/Api/ApiInterface.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace OpenCloud\Common\Api;
+
+/**
+ * All classes which implement this interface are a data representation of a remote OpenCloud API.
+ * They do not execute functionality, but instead return data for each API operation for other parts
+ * of the SDK to use. Usually, the data is injected into {@see OpenCloud\Common\Api\Operation} objects.
+ * The operation is then serialized into a {@see GuzzleHttp\Message\Request} and sent to the API.
+ *
+ * The reason for storing all the API-specific data is to decouple service information from client
+ * HTTP functionality. Too often it is mixed all across different layers, leading to duplication and
+ * no separation of concerns. The choice was made for storage in PHP classes, rather than YAML or JSON
+ * syntax, due to performance concerns.
+ *
+ * @package OpenCloud\Common\Api
+ */
+interface ApiInterface
+{
+}

src/Common/Api/Operation.php

@@ -0,0 +1,136 @@
+<?php
+
+namespace OpenCloud\Common\Api;
+
+use GuzzleHttp\Utils;
+
+/**
+ * This class represents an OpenCloud API operation. It encapsulates most aspects of the REST operation: its HTTP
+ * method, the URL path, its top-level JSON key, and all of its {@see Parameter} objects.
+ *
+ * An operation not only represents a remote operation, but it also provides the mechanism for executing it
+ * over HTTP. To do this, it uses a {@see ClientInterface} that allows a {@see GuzzleHttp\Message\Request}
+ * to be created from the user values provided. Once this request is assembled, it is then sent to the
+ * remote API and the response is returned to whoever first invoked the Operation class.
+ *
+ * @package OpenCloud\Common\Api
+ */
+class Operation
+{
+    /** @var string The HTTP method */
+    private $method;
+
+    /** @var string The URL path */
+    private $path;
+
+    /** @var string The top-level JSON key */
+    private $jsonKey;
+
+    /** @var []Parameter The parameters of this operation */
+    private $params;
+
+    /**
+     * @param array $definition The data definition (in array form) that will populate this
+     *                          operation. Usually this is retrieved from an {@see ApiInterface}
+     *                          object method.
+     */
+    public function __construct(array $definition)
+    {
+        $this->method = $definition['method'];
+        $this->path = $definition['path'];
+
+        if (isset($definition['jsonKey'])) {
+            $this->jsonKey = $definition['jsonKey'];
+        }
+
+        $this->params = self::toParamArray($definition['params']);
+    }
+
+    /**
+     * @return string
+     */
+    public function getPath()
+    {
+        return $this->path;
+    }
+
+    /**
+     * @return string
+     */
+    public function getMethod()
+    {
+        return $this->method;
+    }
+
+    /**
+     * Indicates whether this operation supports a parameter.
+     *
+     * @param $key The name of a parameter
+     *
+     * @return bool
+     */
+    public function hasParam($key)
+    {
+        return isset($this->params[$key]);
+    }
+
+    /**
+     * @param $name
+     *
+     * @return Parameter
+     */
+    public function getParam($name)
+    {
+        return isset($this->params[$name]) ? $this->params[$name] : null;
+    }
+
+    /**
+     * @return string
+     */
+    public function getJsonKey()
+    {
+        return $this->jsonKey;
+    }
+
+    /**
+     * A convenience method that will take a generic array of data and convert it into an array of
+     * {@see Parameter} objects.
+     *
+     * @param array $data A generic data array
+     *
+     * @return array
+     */
+    public static function toParamArray(array $data)
+    {
+        $params = [];
+
+        foreach ($data as $name => $param) {
+            $params[$name] = new Parameter($param + ['name' => $name]);
+        }
+
+        return $params;
+    }
+
+    /**
+     * This method will validate all of the user-provided values and throw an exception if any
+     * failures are detected. This is useful for basic sanity-checking before a request is
+     * serialized and sent to the API.
+     *
+     * @param array $userValues The user-defined values
+     *
+     * @return bool       TRUE if validation passes
+     * @throws \Exception If validate fails
+     */
+    public function validate(array $userValues)
+    {
+        foreach ($this->params as $paramName => $param) {
+            if (array_key_exists($paramName, $userValues)) {
+                $param->validate($userValues[$paramName]);
+            } elseif ($param->isRequired()) {
+                throw new \Exception(sprintf('"%s" is a required option, but it was not provided', $paramName));
+            }
+        }
+
+        return true;
+    }
+}