diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..adb2b52c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,13 @@
+/.phpcs-cache
+/clover.xml
+/composer.lock
+/coveralls-upload.json
+/docs/html/
+/mkdocs.site.yml
+/phpcs.log
+/phpcs.xml
+/phpunit.xml
+/test/fix/
+/vendor/
+/zf-mkdoc-theme.tgz
+/zf-mkdoc-theme/
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..bd9d5fec
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,45 @@
+sudo: false
+language: php
+
+php:
+- 7.1
+- 7.2
+- nightly
+
+cache:
+  directories:
+    - $HOME/.composer/cache
+
+before_install:
+  - composer self-update
+
+install: travis_retry composer update --prefer-dist
+
+script:
+  - vendor/bin/phpcs
+  - vendor/bin/phpcs $(find test/fixable/* | sort) --report=summary --report-file=phpcs.log; diff test/expected-report.txt phpcs.log
+
+stages:
+  - Validate against schema
+  - Validate fixes
+  - Test
+
+jobs:
+  allow_failures:
+    - php: nightly
+
+  include:
+    - stage: Validate against schema
+      addons:
+        apt:
+          packages:
+          - libxml2-utils
+      script: xmllint --noout --schema vendor/squizlabs/php_codesniffer/phpcs.xsd src/ZendCodingStandard/ruleset.xml
+
+    - stage: Validate fixes
+      before_script:
+      - cp -R test/fixable/ test/fix/
+      script: vendor/bin/phpcbf test/fix; diff test/fix test/fixed
+
+notifications:
+  email: false
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f7fd6df6..2508c7df 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,141 @@
 
 All notable changes to this project will be documented in this file, in reverse chronological order by release.
 
+## 2.0.0 - TBD
+
+### Added
+
+- [#5](https://github.com/zendframework/zend-coding-standard/pull/5) adds 
+  online documentation: https://docs.zendframework.com/zend-coding-standard/
+- [#5](https://github.com/zendframework/zend-coding-standard/pull/5) adds 
+  PSR-12 rules.
+  
+  *NOTE:* PSR-12 is not finalized. e.g. The `!` operator and `:` placement for
+  return values are still under discussion. We will change these rules, and, 
+  when PSR-12 is finalized, adapt them.
+- [#5](https://github.com/zendframework/zend-coding-standard/pull/5) extends 
+  PSR-12 with ZendFramework specific rules:
+  
+  *NOTE:* Most of these rules should look familiar as they are already being
+  used in components rewritten for PHP 7.1. 
+    
+  - There should be one space on either side of an equals sign used to assign 
+    a value to a variable. In case of a block of related assignments, more 
+    space may be inserted before the equal sign to promote readability.
+  - Short array syntax must be used to define arrays. 
+  - All values in multiline arrays must be indented with 4 spaces. 
+  - All array values must be followed by a comma, including the last value. 
+  - Whitespace is not allowed around the opening bracket or before the 
+    closing bracket when referencing an array.
+  - The `global` keyword may not be used.
+  - The `PHP_SAPI` constant must be used instead of the `php_sapi_name()` 
+    function.
+  - PHP function calls must be in lowercase.
+  - PHP functions which are an alias may not be used.
+  - Deprecated functions should not be used.
+  - Comments may be omitted and should not be used for typehinted arguments.
+  - Comments may not start with `#`.
+  - Comments may not be empty.
+  - The words _private_, _protected_, _static_, _constructor_, _deconstructor_,
+    _Created by_, _getter_ and _setter_, may not be used in comments.
+  - The annotations `@api`, `@author`, `@category`, `@created`, `@package`,
+    `@subpackage` and `@version` may not be used in comments. Git commits 
+    provide accurate information.
+  - The asterisks in a doc comment should align, and there should be one space 
+    between the asterisk and tag.
+  - Comment tags `@param`, `@throws` and `@return` should not be aligned or 
+    contain multiple spaces between the tag, type and description.
+  - If a function throws any exceptions, they should be documented in `@throws` 
+    tags.
+  - The `@var` tag may be used in inline comments to document the _Type_ of 
+    properties.
+  - Single-line comments with a `@var` tag should be written as one-liners.
+  - Shorthand scalar typehint variants must be used in docblocks.
+  - Each PHP file should have a page level docblock with `@see`, `@copyright` 
+    and `@license`. The copyright date should only be adjusted if the file has 
+    changed.
+  - Each PHP file should have a strict type declaration at the top after the 
+    page level docblock.
+  - Import statements should be alphabetically sorted.
+  - Import statements should not be grouped.
+  - Each import statement should be on its own line.
+  - Absolute class name references, functions and constants should be imported.
+  - Unused import statements are not allowed.
+  - Classes and function within the same namespace should not be imported.
+  - Imports should not have an alias with the same name.
+  - A class should not have unused private constants, (or write-only) 
+    properties and methods.
+  - Class name resolution via `::class` should be used instead of 
+    `__CLASS__`, `get_class()`, `get_class($this)`, `get_called_class()` and 
+    `get_parent_class()`.
+  - Methods may not have the final declaration in classes declared as final.
+  - The colon used with return type declarations MUST be surrounded with 1 
+    space.
+  - Nullable and optional arguments, which are marked as `= null`, must have 
+    the `?` symbol present.
+  - Control Structures must have at least one statement inside of the body.    
+  - Catch blocks may be empty.
+  - Catch blocks must be reachable.
+  - Catch blocks must use `Throwable` instead of `Exception`.    
+  - The not (`!`) operator must be followed by exactly one space.
+  - The `&&` and `||` operators must be used instead of `AND` and `OR`.
+  - The null  coalescing operator `??` should be used when possible.
+  - Assignment operators (eg `+=`, `.=`) should be used when possible.
+  - Unused variables should not be passed to closures via `use`.    
+  - The code may not contain unreachable code.
+  - The backtick operator may not be used for execution of shell commands.
+  - Class and Interface names should be unique in a project and must have a 
+    unique fully qualified name.
+  - Methods that only call the parent method should not be defined.
+  - Files that contain PHP code should only have PHP code and should not have
+    any _"inline HTML"_.
+  - There must be exactly one space after a type cast. 
+  - Constructors should be named `__construct`, not after the class.
+  - The opening PHP tag should be the first item in the file. 
+  - Strings should not be concatenated together unless used in multiline for 
+    readability. 
+  - Loose `==` and `!=` comparison operators should not be used. Use `===` 
+    and `!==` instead.
+  - Language constructs must be used without parentheses where possible.
+  - Short list syntax `[...]` should be used instead of `list(...)`.
+  - Short form of type keywords must be used. i.e. `bool` instead of 
+    `boolean`, `int` instead of `integer`, etc. The `binary` and `unset` cast 
+    operators are not allowed.
+  - Parentheses should not be used if they can be omitted.
+  - Semicolons `;` should not be used if they can be omitted.
+  - Variables should be returned directly instead of assigned to a variable 
+    which is not used.
+  - The `self` keyword should be used instead of the current class name, and 
+    should not have spaces around `::`.
+  - Static methods should not use `$this`. 
+  - Double quote strings may only be used if they contain variables. 
+  - Strings should not be enclosed in parentheses when being echoed.
+  - Type casts should not have whitespace inside the parentheses.
+  - The opening brace for functions should be on a new line with no blank 
+    lines surrounding it.
+  - The PHP constructs `echo`, `print`, `return`, `include`, `include_once`, 
+    `require`, `require_once`, and `new`, should have one space after them.
+  - The object operator `->` should not have any spaces around it.
+  - Semicolons should not have spaces before them.
+  - The code should not contain superfluous whitespaces. e.g. multiple empty
+    lines, trailing spaces, etc.
+
+### Changed
+
+- Nothing.
+
+### Deprecated
+
+- Nothing.
+
+### Removed
+
+- Nothing.
+
+### Fixed
+
+- Nothing.
+
 ## 1.0.0 - 2016-11-09
 
 Initial public release. Incorporates rules for:
diff --git a/LICENSE.md b/LICENSE.md
index badc26ea..67ba2104 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,4 +1,4 @@
-Copyright (c) 2016, Zend Technologies USA, Inc.
+Copyright (c) 2016-2018, Zend Technologies USA, Inc.
 
 All rights reserved.
 
diff --git a/README.md b/README.md
index 2a7e94a8..5922b094 100644
--- a/README.md
+++ b/README.md
@@ -1,11 +1,28 @@
-Zend Framework Coding Standard
-==============================
+# zend-coding-standard
 
-Repository with all coding standard ruleset for Zend Framework repositories.
+[![Build Status](https://secure.travis-ci.org/zendframework/zend-coding-standard.svg?branch=master)](https://secure.travis-ci.org/zendframework/zend-coding-standard)
 
+The coding standard ruleset for Zend Framework components.
 
-Installation
-------------
+This specification extends and expands [PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md), 
+the extended coding style guide and requires adherence to [PSR-1](https://www.php-fig.org/psr/psr-1), 
+the basic coding standard. These are minimal specifications and don't address all factors, including things like:
+
+- whitespace around operators
+- alignment of array keys and operators
+- alignment of object operations
+- how to format multi-line conditionals
+- what and what not to import, and how
+- etc.
+
+Contributors have different coding styles and so do the maintainers. During code reviews there are regularly 
+discussions about spaces and alignments, where and when was said that a function needs to be imported. And 
+that's where this coding standard comes in: To have internal consistency in a component and between components.
+
+> Note: PSR-12 is not finalized. e.g. The `!` operator and `:` placement for return values are still under  discussion. 
+We will change these rules, and, when PSR-12 is finalized, adapt them.
+
+## Installation
 
 1. Install the module via composer by running:
 
@@ -22,26 +39,36 @@ Installation
    }
    ```
 
-3. Create file `phpcs.xml` on base path of your repository with content:
+3. Create file `phpcs.xml` on base path of your repository with this content:
 
    ```xml
    <?xml version="1.0"?>
-   <ruleset name="Zend Framework Coding Standard">
-       <rule ref="./vendor/zendframework/zend-coding-standard/ruleset.xml"/>
-
+   <ruleset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xsi:noNamespaceSchemaLocation="vendor/squizlabs/php_codesniffer/phpcs.xsd">
+   
+       <arg name="basepath" value="."/>
+       <arg name="cache" value=".phpcs-cache"/>
+       <arg name="colors"/>
+       <arg name="extensions" value="php"/>
+       <arg name="parallel" value="80"/>
+       
+       <!-- Show progress -->
+       <arg value="p"/>
+   
        <!-- Paths to check -->
        <file>config</file>
        <file>src</file>
        <file>test</file>
+   
+       <!-- Include all rules from the Zend Coding Standard -->
+       <rule ref="ZendCodingStandard"/>
    </ruleset>
    ```
 
 You can add or exclude some locations in that file.
 For a reference please see: https://github.com/squizlabs/PHP_CodeSniffer/wiki/Annotated-ruleset.xml
 
-
-Usage
------
+## Usage
 
 * To run checks only:
 
@@ -50,7 +77,62 @@ Usage
   ```
 
 * To automatically fix many CS issues:
- 
+
   ```bash
   $ composer cs-fix
   ```
+
+## Ignoring parts of a File
+
+> Note: Before PHP_CodeSniffer version 3.2.0, `// @codingStandardsIgnoreStart` and `// @codingStandardsIgnoreEnd` were
+> used. These are deprecated and will be removed in PHP_CodeSniffer version 4.0.
+
+Disable parts of a file:
+```php
+$xmlPackage = new XMLPackage;
+// phpcs:disable
+$xmlPackage['error_code'] = get_default_error_code_value();
+$xmlPackage->send();
+// phpcs:enable
+```
+
+Disable a specific rule:
+```php
+// phpcs:disable Generic.Commenting.Todo.Found
+$xmlPackage = new XMLPackage;
+$xmlPackage['error_code'] = get_default_error_code_value();
+// TODO: Add an error message here.
+$xmlPackage->send();
+// phpcs:enable
+```
+
+## Development
+
+> **New rules or Sniffs may not be introduced in minor or bugfix releases and should always be based on the develop 
+branch and queued for the next major release, unless considered a bugfix for existing rules.**
+
+If you want to test changes against ZendFramework components or your own projects, install your forked 
+zend-coding-standard globally with composer: 
+```bash
+$ composer global config repositories.zend-coding-standard vcs git@github.com:<FORK_NAMESPACE>/zend-coding-standard.git
+$ composer global require --dev zendframework/zend-coding-standard:dev-<FORKED_BRANCH>
+
+# For this to work, add this to your path: ~/.composer/vendor/bin
+# Using `-s` prints the rules that triggered the errors so they can be reviewed easily. `-p` is for progress display.
+$ phpcs -sp --standard=ZendCodingStandard src test
+```
+Make sure you remove the global installation after testing from your global composer.json file!!!
+
+Documentation can be previewed locally by installing [MkDocs](https://www.mkdocs.org/#installation) and run 
+`mkdocs serve`. This will start a server where you can read the docs.
+
+## Reference
+
+Rules can be added, excluded or tweaked locally, depending on your preferences. More information on how to do this can
+be found here:
+
+- [Coding Standard Tutorial](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Coding-Standard-Tutorial)
+- [Configuration Options](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Configuration-Options)
+- [Selectively Applying Rules](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Annotated-Ruleset#selectively-applying-rules)
+- [Customisable Sniff Properties](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Customisable-Sniff-Properties)
+- [Slevomat Coding Standard](https://github.com/slevomat/coding-standard)
diff --git a/composer.json b/composer.json
index 89f82020..024cd1b5 100644
--- a/composer.json
+++ b/composer.json
@@ -1,12 +1,52 @@
 {
     "name": "zendframework/zend-coding-standard",
-    "description": "Zend Framework coding standard",
+    "type": "phpcodesniffer-standard",
+    "description": "Zend Framework Coding Standard",
     "license": "BSD-3-Clause",
     "keywords": [
         "zf",
+        "zendframework",
         "coding standard"
     ],
+    "support": {
+        "docs": "https://docs.zendframework.com/zend-coding-standard/",
+        "issues": "https://github.com/zendframework/zend-coding-standard/issues",
+        "source": "https://github.com/zendframework/zend-coding-standard",
+        "rss": "https://github.com/zendframework/zend-coding-standard/releases.atom",
+        "chat": "https://zendframework-slack.herokuapp.com",
+        "forum": "https://discourse.zendframework.com/c/questions/components"
+    },
     "require": {
-        "squizlabs/php_codesniffer": "^2.7"
+        "php": "^7.1",
+        "dealerdirect/phpcodesniffer-composer-installer": "^0.4.4",
+        "slevomat/coding-standard": "^4.8.0",
+        "squizlabs/php_codesniffer": "^3.3.2",
+        "webimpress/coding-standard": "dev-master"
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.0.x-dev"
+        }
+    },
+    "autoload": {
+        "psr-4": {
+            "ZendCodingStandard\\": "src/ZendCodingStandard"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "ZendCodingStandardTest\\": "test/"
+        }
+    },
+    "scripts": {
+        "check": [
+            "@test-prepare",
+            "@test-fix",
+            "@test-diff"
+        ],
+        "create-report": "phpcs $(find test/fixable/* | sort) --report=summary --report-file=test/expected-report.txt",
+        "test-prepare": "rm -rf test/fix/; cp -R test/fixable/ test/fix/;",
+        "test-fix": "phpcbf test/fix > /dev/null || true",
+        "test-diff": "diff test/fix test/fixed"
     }
 }
diff --git a/CONDUCT.md b/docs/CODE_OF_CONDUCT.md
similarity index 96%
rename from CONDUCT.md
rename to docs/CODE_OF_CONDUCT.md
index c663d2be..02fafcd1 100644
--- a/CONDUCT.md
+++ b/docs/CODE_OF_CONDUCT.md
@@ -1,6 +1,6 @@
 # Contributor Code of Conduct
 
-The Zend Framework project adheres to [The Code Manifesto](http://codemanifesto.com)
+This project adheres to [The Code Manifesto](http://codemanifesto.com)
 as its guidelines for contributor interactions.
 
 ## The Code Manifesto
diff --git a/docs/CONTRIBUTING.md b/docs/CONTRIBUTING.md
new file mode 100644
index 00000000..84009e8a
--- /dev/null
+++ b/docs/CONTRIBUTING.md
@@ -0,0 +1,189 @@
+# CONTRIBUTING
+
+## RESOURCES
+
+If you wish to contribute to this project, please be sure to
+read/subscribe to the following resources:
+
+ - [Coding Standards](https://github.com/zendframework/zend-coding-standard)
+ - [Forums](https://discourse.zendframework.com/c/contributors)
+ - [Chat](https://zendframework-slack.herokuapp.com)
+ - [Code of Conduct](CODE_OF_CONDUCT.md)
+
+If you are working on new features or refactoring
+[create a proposal](https://github.com/zendframework/zend-coding-standard/issues/new).
+
+## RUNNING TESTS
+
+To run tests:
+
+- Clone the repository:
+
+  ```console
+  $ git clone git://github.com/zendframework/zend-coding-standard.git
+  $ cd zend-coding-standard
+  ```
+
+- Install dependencies via composer:
+
+  ```console
+  $ composer install
+  ```
+
+  If you don't have `composer` installed, please download it from https://getcomposer.org/download/
+
+- Run the tests using the "test" command shipped in the `composer.json`:
+
+  ```console
+  $ composer test
+  ```
+
+You can turn on conditional tests with the `phpunit.xml` file.
+To do so:
+
+ -  Copy `phpunit.xml.dist` file to `phpunit.xml`
+ -  Edit `phpunit.xml` to enable any specific functionality you
+    want to test, as well as to provide test values to utilize.
+
+## Running Coding Standards Checks
+
+First, ensure you've installed dependencies via composer, per the previous
+section on running tests.
+
+To run CS checks only:
+
+```console
+$ composer cs-check
+```
+
+To attempt to automatically fix common CS issues:
+
+```console
+$ composer cs-fix
+```
+
+If the above fixes any CS issues, please re-run the tests to ensure
+they pass, and make sure you add and commit the changes after verification.
+
+## Recommended Workflow for Contributions
+
+Your first step is to establish a public repository from which we can
+pull your work into the master repository. We recommend using
+[GitHub](https://github.com), as that is where the component is already hosted.
+
+1. Setup a [GitHub account](https://github.com/), if you haven't yet
+2. Fork the repository (https://github.com/zendframework/zend-coding-standard)
+3. Clone the canonical repository locally and enter it.
+
+   ```console
+   $ git clone git://github.com/zendframework/zend-coding-standard.git
+   $ cd zend-coding-standard
+   ```
+
+4. Add a remote to your fork; substitute your GitHub username in the command
+   below.
+
+   ```console
+   $ git remote add {username} git@github.com:{username}/zend-coding-standard.git
+   $ git fetch {username}
+   ```
+
+### Keeping Up-to-Date
+
+Periodically, you should update your fork or personal repository to
+match the canonical ZF repository. Assuming you have setup your local repository
+per the instructions above, you can do the following:
+
+
+```console
+$ git checkout master
+$ git fetch origin
+$ git rebase origin/master
+# OPTIONALLY, to keep your remote up-to-date -
+$ git push {username} master:master
+```
+
+If you're tracking other branches -- for example, the "develop" branch, where
+new feature development occurs -- you'll want to do the same operations for that
+branch; simply substitute  "develop" for "master".
+
+### Working on a patch
+
+We recommend you do each new feature or bugfix in a new branch. This simplifies
+the task of code review as well as the task of merging your changes into the
+canonical repository.
+
+A typical workflow will then consist of the following:
+
+1. Create a new local branch based off either your master or develop branch.
+2. Switch to your new local branch. (This step can be combined with the
+   previous step with the use of `git checkout -b`.)
+3. Do some work, commit, repeat as necessary.
+4. Push the local branch to your remote repository.
+5. Send a pull request.
+
+The mechanics of this process are actually quite trivial. Below, we will
+create a branch for fixing an issue in the tracker.
+
+```console
+$ git checkout -b hotfix/9295
+Switched to a new branch 'hotfix/9295'
+```
+
+... do some work ...
+
+
+```console
+$ git commit
+```
+
+... write your log message ...
+
+
+```console
+$ git push {username} hotfix/9295:hotfix/9295
+Counting objects: 38, done.
+Delta compression using up to 2 threads.
+Compression objects: 100% (18/18), done.
+Writing objects: 100% (20/20), 8.19KiB, done.
+Total 20 (delta 12), reused 0 (delta 0)
+To ssh://git@github.com/{username}/zend-coding-standard.git
+   b5583aa..4f51698  HEAD -> master
+```
+
+To send a pull request, you have two options.
+
+If using GitHub, you can do the pull request from there. Navigate to
+your repository, select the branch you just created, and then select the
+"Pull Request" button in the upper right. Select the user/organization
+"zendframework" (or whatever the upstream organization is) as the recipient.
+
+#### What branch to issue the pull request against?
+
+Which branch should you issue a pull request against?
+
+- For fixes against the stable release, issue the pull request against the
+  "master" branch.
+- For new features, or fixes that introduce new elements to the public API (such
+  as new public methods or properties), issue the pull request against the
+  "develop" branch.
+
+### Branch Cleanup
+
+As you might imagine, if you are a frequent contributor, you'll start to
+get a ton of branches both locally and on your remote.
+
+Once you know that your changes have been accepted to the master
+repository, we suggest doing some cleanup of these branches.
+
+-  Local branch cleanup
+
+   ```console
+   $ git branch -d <branchname>
+   ```
+
+-  Remote branch removal
+
+   ```console
+   $ git push {username} :<branchname>
+   ```
diff --git a/docs/ISSUE_TEMPLATE.md b/docs/ISSUE_TEMPLATE.md
new file mode 100644
index 00000000..03ff5a14
--- /dev/null
+++ b/docs/ISSUE_TEMPLATE.md
@@ -0,0 +1,19 @@
+ - [ ] I was not able to find an [open](https://github.com/zendframework/zend-coding-standard/issues?q=is%3Aopen) or [closed](https://github.com/zendframework/zend-coding-standard/issues?q=is%3Aclosed) issue matching what I'm seeing.
+ - [ ] This is not a question. (Questions should be asked on [chat](https://zendframework.slack.com/) ([Signup here](https://zendframework-slack.herokuapp.com/)) or our [forums](https://discourse.zendframework.com/).)
+
+Provide a narrative description of what you are trying to accomplish.
+
+### Code to reproduce the issue
+
+<!-- Please provide the minimum code necessary to recreate the issue -->
+
+```php
+```
+
+### Expected results
+
+<!-- What do you think should have happened? -->
+
+### Actual results
+
+<!-- What did you actually observe? -->
diff --git a/docs/PULL_REQUEST_TEMPLATE.md b/docs/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 00000000..f00d90c0
--- /dev/null
+++ b/docs/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,25 @@
+Provide a narrative description of what you are trying to accomplish:
+
+- [ ] Are you fixing a bug?
+  - [ ] Detail how the bug is invoked currently.
+  - [ ] Detail the original, incorrect behavior.
+  - [ ] Detail the new, expected behavior.
+  - [ ] Base your feature on the `master` branch, and submit against that branch.
+  - [ ] Add a regression test that demonstrates the bug, and proves the fix.
+  - [ ] Add a `CHANGELOG.md` entry for the fix.
+
+- [ ] Are you creating a new feature?
+  - [ ] Why is the new feature needed? What purpose does it serve?
+  - [ ] How will users use the new feature?
+  - [ ] Base your feature on the `develop` branch, and submit against that branch.
+  - [ ] Add only one feature per pull request; split multiple features over multiple pull requests
+  - [ ] Add tests for the new feature.
+  - [ ] Add documentation for the new feature.
+  - [ ] Add a `CHANGELOG.md` entry for the new feature.
+
+- [ ] Is this related to quality assurance?
+  <!-- Detail why the changes are necessary -->
+
+- [ ] Is this related to documentation?
+  <!-- Is it a typographical and/or grammatical fix? -->
+  <!-- Is it new documentation? -->
diff --git a/docs/SUPPORT.md b/docs/SUPPORT.md
new file mode 100644
index 00000000..369891d2
--- /dev/null
+++ b/docs/SUPPORT.md
@@ -0,0 +1,25 @@
+# Getting Support
+
+Zend Framework offers three support channels:
+
+- For real-time questions, use our
+  [chat](https://zendframework-slack.herokuapp.com)
+- For detailed questions (e.g., those requiring examples) use our
+  [forums](https://discourse.zendframework.com/c/questions/components)
+- To report issues, use this repository's
+  [issue tracker](https://github.com/zendframework/zend-coding-standard/issues/new)
+
+**DO NOT** use the issue tracker to ask questions; use chat or the forums for
+that. Questions posed to the issue tracker will be closed.
+
+When reporting an issue, please include the following details:
+
+- A narrative description of what you are trying to accomplish.
+- The minimum code necessary to reproduce the issue.
+- The expected results of exercising that code.
+- The actual results received.
+
+We may ask for additional details: what version of the library you are using,
+and what PHP version was used to reproduce the issue.
+
+You may also submit a failing test case as a pull request.
diff --git a/docs/book/index.md b/docs/book/index.md
new file mode 100644
index 00000000..fe840054
--- /dev/null
+++ b/docs/book/index.md
@@ -0,0 +1 @@
+../../README.md
\ No newline at end of file
diff --git a/docs/book/v1/index.md b/docs/book/v1/index.md
new file mode 100644
index 00000000..97635fa6
--- /dev/null
+++ b/docs/book/v1/index.md
@@ -0,0 +1 @@
+# The coding standard ruleset for Zend Framework components
diff --git a/docs/book/v1/intro.md b/docs/book/v1/intro.md
new file mode 100644
index 00000000..4a512141
--- /dev/null
+++ b/docs/book/v1/intro.md
@@ -0,0 +1,51 @@
+# zend-coding-standard
+
+This component provides the coding standard ruleset for Zend Framework components.
+
+## Installation
+
+1. Install the module via composer by running:
+
+   ```bash
+   $ composer require --dev zendframework/zend-coding-standard
+   ```
+
+2. Add composer scripts into your `composer.json`:
+
+   ```json
+   "scripts": {
+     "cs-check": "phpcs",
+     "cs-fix": "phpcbf"
+   }
+   ```
+
+3. Create file `phpcs.xml` on base path of your repository with content:
+
+   ```xml
+   <?xml version="1.0"?>
+   <ruleset name="Zend Framework Coding Standard">
+       <rule ref="./vendor/zendframework/zend-coding-standard/ruleset.xml"/>
+
+       <!-- Paths to check -->
+       <file>config</file>
+       <file>src</file>
+       <file>test</file>
+   </ruleset>
+   ```
+
+You can add or exclude some locations in that file.
+For a reference please see: https://github.com/squizlabs/PHP_CodeSniffer/wiki/Annotated-ruleset.xml
+
+## Usage
+
+* To run checks only:
+
+  ```bash
+  $ composer cs-check
+  ```
+
+* To automatically fix many CS issues:
+
+  ```bash
+  $ composer cs-fix
+  ```
diff --git a/docs/book/v1/ruleset.md b/docs/book/v1/ruleset.md
new file mode 100644
index 00000000..0e39c371
--- /dev/null
+++ b/docs/book/v1/ruleset.md
@@ -0,0 +1,16 @@
+# Ruleset
+
+## Use PSR-2 coding standard as a base
+*PSR2*
+
+## Disallow long array syntax
+*Generic.Arrays.DisallowLongArraySyntax*
+
+## Force whitespace after `!`
+*Generic.Formatting.SpaceAfterNot*
+
+## Forbid spaces before semicolon `;`
+*Squiz.WhiteSpace.SemicolonSpacing*
+
+## Forbid superfluous whitespaces
+*Squiz.WhiteSpace.SuperfluousWhitespace, Squiz.WhiteSpace.SuperfluousWhitespace.EmptyLines*
diff --git a/docs/book/v2/coding-style-guide.md b/docs/book/v2/coding-style-guide.md
new file mode 100644
index 00000000..aa23087b
--- /dev/null
+++ b/docs/book/v2/coding-style-guide.md
@@ -0,0 +1,384 @@
+# Zend Framework Coding Style Guide
+
+This specification extends and expands [PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md), 
+the extended coding style guide and requires adherence to [PSR-1](https://www.php-fig.org/psr/psr-1), 
+the basic coding standard.
+
+> Note: PSR-12 is not finalized. e.g. The `!` operator and `:` placement for return values are still under discussion. 
+We will change these rules, and, when PSR-12 is finalized, adapt them.
+
+## General
+
+### Basic Coding Standard
+
+Code MUST follow all rules outlined in [PSR-1](https://www.php-fig.org/psr/psr-1) and
+[PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md), except in 
+specific cases outlined in this specification, until PSR-12 is accepted as a standard.
+
+### Indenting and Alignment
+
+- There should be one space on either side of an equals sign used to assign a value to a variable. In case of a 
+  block of related assignments, more space may be inserted before the equal sign to promote readability.
+  [*](ruleset.md#genericformattingmultiplestatementalignment)
+
+```php
+<?php
+
+$shortVar        = (1 + 2);
+$veryLongVarName = 'string';
+$var             = foo($bar, $baz, $quux);
+```
+
+- Short array syntax must be used to define arrays. [*](ruleset.md#genericarraysdisallowlongarraysyntax)
+- All values in multiline arrays must be indented with 4 spaces. [*](ruleset.md#genericarraysarrayindent)
+- All array values must be followed by a comma, including the last value. [*](ruleset.md#slevomatcodingstandardarraystrailingarraycomma)
+- Whitespace is not allowed around the opening bracket or before the closing bracket when referencing an array.
+  [*](ruleset.md#squizarraysarraybracketspacing)
+- All double arrow symbols must be aligned to one space after the longest array key. [*](ruleset.md#squizarraysarraydeclaration)
+
+```php
+<?php
+
+$array = [
+    'key1'      => 'value1',
+    'key2'      => 'value2',
+    'keyTwenty' => 'value3',
+]; 
+
+$var = [
+    'one'   => function() {
+        $foo    = [1,2,3];
+        $barBar = [
+            1,
+            2,
+            3,
+        ];
+    },
+    'longer' => 2,
+    /* three */ 3 => 'three',
+];
+```
+
+### PHP Keywords, Types, Constants and Functions
+
+- The `global` keyword may not be used. [*](ruleset.md#squizphpglobalkeyword)
+- The `PHP_SAPI` constant must be used instead of the `php_sapi_name()` function. [*](ruleset.md#genericphpsapiusage)
+- PHP function calls must be in lowercase. [*](ruleset.md#squizphplowercasephpfunctions)
+- PHP functions which are an alias may not be used. [*](ruleset.md#genericphpforbiddenfunctions)
+- Deprecated functions should not be used. [*](ruleset.md#genericphpdeprecatedfunctions)
+
+### Commenting
+
+- Comments may be omitted and should not be used for typehinted arguments.
+- Comments may not start with `#`. [*](ruleset.md#pearcommentinginlinecomment)
+- Comments may not be empty. [*](ruleset.md#slevomatcodingstandardcommentingemptycomment)
+- The words _private_, _protected_, _static_, _constructor_, _deconstructor_, _Created by_, _getter_ and _setter_, 
+  may not be used in comments. [*](ruleset.md#slevomatcodingstandardcommentingforbiddencomments)
+- The annotations `@api`, `@author`, `@category`, `@created`, `@package`, `@subpackage` and `@version` may not
+  be used in comments. Git commits provide accurate information. [*](ruleset.md#slevomatcodingstandardcommentingforbiddenannotations)
+- The asterisks in a doc comment should align, and there should be one space between the asterisk and tag.
+  [*](ruleset.md#squizcommentingdoccommentalignment)
+- Comment tags `@param`, `@throws` and `@return` should not be aligned or contain multiple spaces between the tag, 
+  type and description. [*](ruleset.md#squizcommentingfunctioncomment)
+- If a function throws any exceptions, they should be documented in `@throws` tags.
+  [*](ruleset.md#squizcommentingfunctioncomment)
+- The `@var` tag may be used in inline comments to document the _Type_ of properties. [*](ruleset.md#slevomatcodingstandardcommentinginlinedoccommentdeclaration)
+- Single-line comments with a `@var` tag should be written as one-liners. [*](ruleset.md#slevomatcodingstandardcommentingrequireonelinepropertydoccomment)
+- Shorthand scalar typehint variants must be used in docblocks. [*](ruleset.md#slevomatcodingstandardtypehintslongtypehints)
+
+## Declare Statements, Namespace, and Import Statements
+
+In addition to [PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md#3-declare-statements-namespace-and-import-statements):
+
+- Each PHP file should have a page level docblock with `@see`, `@copyright` and `@license`. The copyright date should
+  only be adjusted if the file has changed.
+- Each PHP file should have a strict type declaration at the top after the page level docblock. [*](ruleset.md#slevomatcodingstandardtypehintsdeclarestricttypes)
+- Import statements should be alphabetically sorted. [*](ruleset.md#slevomatcodingstandardnamespacesalphabeticallysorteduses)
+- Import statements should not be grouped. [*](ruleset.md#slevomatcodingstandardnamespacesdisallowgroupuse)
+- Each import statement should be on its own line. [*](ruleset.md#slevomatcodingstandardnamespacesmultipleusesperline)
+- Absolute class name references, functions and constants should be imported. [*](ruleset.md#slevomatcodingstandardnamespacesreferenceusednamesonly)
+- Unused import statements are not allowed. [*](ruleset.md#slevomatcodingstandardnamespacesunuseduses)
+- Classes and function within the same namespace should not be imported. [*](ruleset.md#slevomatcodingstandardnamespacesusefromsamenamespace)
+- Imports should not have an alias with the same name. [*](ruleset.md#slevomatcodingstandardnamespacesuselessalias)
+- A class should not have unused private constants, (or write-only) properties and methods. [*](ruleset.md#slevomatcodingstandardclassesunusedprivateelements)
+
+```php
+<?php
+/**
+ * @see       https://github.com/zendframework/zend-coding-standard for the canonical source repository
+ * @copyright Copyright (c) 2016-2018 Zend Technologies USA Inc. (https://www.zend.com)
+ * @license   https://github.com/zendframework/zend-coding-standard/blob/master/LICENSE.md New BSD License
+ */
+
+declare(strict_types=1);
+
+namespace Vendor\Package;
+
+Use InvalidArgumentException;
+use Vendor\Package\ClassA;
+use Vendor\Package\SomeNamespace\ClassB as B;
+
+use function Another\Vendor\functionB;
+use function file_get_contents;
+use function Vendor\Package\functionA;
+
+use const Another\Vendor\CONSTANT_B;
+use const PASSWORD_DEFAULT;
+use const Vendor\Package\CONSTANT_A;
+
+/** FooBar is an example class. */
+class FooBar
+{
+    // ... additional PHP code ...
+}
+```
+
+## Classes, Properties, and Methods
+
+In addition to [PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md#4-classes-properties-and-methods):
+
+- Class name resolution via `::class` should be used instead of `__CLASS__`, `get_class()`, `get_class($this)`, 
+  `get_called_class()` and `get_parent_class()`. [*](ruleset.md#slevomatcodingstandardclassesmodernclassnamereference)
+- Methods may not have the final declaration in classes declared as final. [*](ruleset.md#genericcodeanalysisunnecessaryfinalmodifier)
+- The colon used with return type declarations MUST be surrounded with 1 space. [*](ruleset.md#slevomatcodingstandardtypehintsreturntypehintspacing)
+- Nullable and optional arguments, which are marked as `= null`, must have the `?` symbol present. [*](ruleset.md#slevomatcodingstandardtypehintsnullabletypefornulldefaultvalue)
+
+```php
+<?php
+
+namespace Vendor\Package;
+
+use ArrayAccess;
+use Countable;
+use Vendor\AnotherPackage\FirstInterface;
+use Vendor\AnotherPackage\Traits\ThirdTrait;
+
+class ClassName extends ParentClass implements ArrayAccess, Countable
+{
+    use FirstTrait;
+    use SecondTrait;
+    use ThirdTrait;
+    
+    public const CONSTANT = 'constant';
+    
+    private $property;
+    
+    public function fooBarBaz(int $arg1, &$arg2, array $arg3 = [], ?$arg4 = null) : void
+    {
+        return;
+    }
+    
+    public function aVeryLongMethodName(
+        FirstInterface $arg1,
+        &$arg2,
+        array $arg3 = [],
+        ?$arg4 = null
+    ) : string {
+        return 'foo';
+    }
+}
+```
+
+## Control Structures
+
+In addition to [PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md#5-control-structures):
+
+- Control Structures must have at least one statement inside of the body. [*](ruleset.md#genericcodeanalysisemptystatement)
+
+### if, elseif, else
+```php
+<?php
+
+if ($expr1) {
+    // if body
+} elseif ($expr2) {
+    // elseif body
+} else {
+    // else body;
+}
+```
+
+### switch, case
+```php
+<?php
+
+switch ($expr) {
+    case 0:
+        echo 'First case, with a break';
+        break;
+    case 1:
+        echo 'Second case, which falls through';
+        // no break
+    case 2:
+    case 3:
+    case 4:
+        echo 'Third case, return instead of break';
+        return;
+    default:
+        echo 'Default case';
+        break;
+}
+```
+
+### while, do while
+```php
+<?php
+
+while ($expr) {
+    // structure body
+}
+```
+
+```php
+<?php
+
+do {
+    // structure body;
+} while ($expr);
+```
+
+### for
+```php
+<?php
+
+for ($i = 0; $i < 10; $i++) {
+    // for body
+}
+```
+
+### foreach
+```php
+<?php
+
+foreach ($iterable as $key => $value) {
+    // foreach body
+}
+```
+
+### try, catch, finally
+
+- Catch blocks may be empty. [*](ruleset.md#genericcodeanalysisemptystatementdetectedcatch)
+- Catch blocks must be reachable. [*](ruleset.md#slevomatcodingstandardexceptionsdeadcatch)
+- Catch blocks must use `Throwable` instead of `Exception`. [*](ruleset.md#slevomatcodingstandardexceptionsreferencethrowableonly)
+
+```php
+<?php
+
+try {
+    // May not be empty
+} catch (FirstThrowableType $e) {
+} catch (OtherThrowableType $e) {
+    // Optionally do something
+} finally {
+    // Finally body
+}
+```
+
+## Operators
+
+In addition to [PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md#6-operators):
+
+- The not (`!`) operator must be followed by exactly one space. [*](ruleset.md#genericformattingspaceafternot)
+- The `&&` and `||` operators must be used instead of `AND` and `OR`. [*](ruleset.md#squizoperatorsvalidlogicaloperators)
+- The null  coalescing operator `??` should be used when possible. [*](ruleset.md#slevomatcodingstandardcontrolstructuresrequirenullcoalesceoperator)
+- Assignment operators (eg `+=`, `.=`) should be used when possible. [*](ruleset.md#slevomatcodingstandardoperatorsrequirecombinedassignmentoperator)
+
+```php
+<?php
+
+if ($a === $b) {
+    $foo = $bar ?? $a ?? $b;
+} elseif (! $a || $b > $c) {
+    $variable = $foo ? 'foo' : 'bar';
+}
+
+$var           = 'foo';
+$aVeryLongName = 'bar';
+$function      = function ($arg1, $arg2) {};
+```
+
+## Closures
+
+In addition to [PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md#7-closures):
+
+- Unused variables should not be passed to closures via `use`. [*](ruleset.md#slevomatcodingstandardfunctionsunusedinheritedvariablepassedtoclosure)
+
+```php
+<?php
+
+$closureWithArgs = function ($arg1, $arg2) {
+    // body
+};
+
+$closureWithArgsAndVars = function ($arg1, $arg2) use ($var1, $var2) {
+    // body
+};
+
+$longArgsAndLongVars = function (
+    $longArgument,
+    $longerArgument,
+    $muchLongerArgument
+) use (
+    $longVar1,
+    $longerVar2,
+    $muchLongerVar3
+) {
+   // body
+};
+```
+
+## Anonymous Classes
+
+In addition to [PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md#8-anonymous-classes):
+
+```php
+<?php
+
+$instance = new class {};
+
+// Brace on the same line
+$instance = new class extends Foo implements HandleableInterface {
+    // Class content
+};
+
+// Brace on the next line
+$instance = new class extends Foo implements
+    ArrayAccess,
+    Countable,
+    Serializable
+{
+    // Class content
+};
+```
+
+## Miscellaneous
+
+- The code may not contain unreachable code. [*](ruleset.md#squizphpnonexecutablecode)
+- The backtick operator may not be used for execution of shell commands. [*](ruleset.md#genericphpbacktickoperator)
+- Class and Interface names should be unique in a project and must have a unique fully qualified name. [*](ruleset.md#genericclassesduplicateclassname)
+- Methods that only call the parent method should not be defined. [*](ruleset.md#genericcodeanalysisuselessoverridingmethod)
+- Files that contain PHP code should only have PHP code and should not have any _"inline HTML"_. [*](ruleset.md#genericfilesinlinehtml)
+- There must be exactly one space after a type cast. [*](ruleset.md#genericformattingspaceaftercast)
+- Constructors should be named `__construct`, not after the class. [*](ruleset.md#genericnamingconventionsconstructorname)
+- The opening PHP tag should be the first item in the file. [*](ruleset.md#genericphpcharacterbeforephpopeningtag)
+- Strings should not be concatenated together unless used in multiline for readability. [*](ruleset.md#genericstringsunnecessarystringconcat)
+- Loose `==` and `!=` comparison operators should not be used. Use `===` and `!==` instead. [*](ruleset.md#slevomatcodingstandardcontrolstructuresdisallowequaloperators)
+- Language constructs must be used without parentheses where possible. [*](ruleset.md#slevomatcodingstandardcontrolstructureslanguageconstructwithparentheses)
+- Short list syntax `[...]` should be used instead of `list(...)`. [*](ruleset.md#slevomatcodingstandardphpshortlist)
+- Short form of type keywords must be used. i.e. `bool` instead of `boolean`, `int` instead of `integer`, etc.
+  The `binary` and `unset` cast operators are not allowed. [*](ruleset.md#slevomatcodingstandardphptypecast)
+- Parentheses should not be used if they can be omitted. [*](ruleset.md#slevomatcodingstandardphpuselessparentheses)
+- Semicolons `;` should not be used if they can be omitted. [*](ruleset.md#slevomatcodingstandardphpuselesssemicolon)
+- Variables should be returned directly instead of assigned to a variable which is not used. [*](ruleset.md#slevomatcodingstandardvariablesuselessvariable)
+- The `self` keyword should be used instead of the current class name, and should not have spaces around `::`.
+  [*](ruleset.md#squizclassesselfmemberreference)
+- Static methods should not use `$this`. [*](ruleset.md#squizscopestaticthisusage)
+- Double quote strings may only be used if they contain variables. [*](ruleset.md#squizstringsdoublequoteusage)
+- Strings should not be enclosed in parentheses when being echoed. [*](ruleset.md#squizstringsechoedstrings)
+- Type casts should not have whitespace inside the parentheses. [*](ruleset.md#squizwhitespacecastspacing)
+- The opening brace for functions should be on a new line with no blank lines surrounding it. [*](ruleset.md#squizwhitespacefunctionopeningbracespace)
+- The PHP constructs `echo`, `print`, `return`, `include`, `include_once`, `require`, `require_once`, and `new`, should 
+  have one space after them. [*](ruleset.md#squizwhitespacelanguageconstructspacing)
+- The object operator `->` should not have any spaces around it. [*](ruleset.md#squizwhitespaceobjectoperatorspacing)
+- Semicolons should not have spaces before them. [*](ruleset.md#squizwhitespacesemicolonspacing)
+- The code should not contain superfluous whitespaces. e.g. multiple empty lines, trailing spaces, etc. [*](ruleset.md#squizwhitespacesuperfluouswhitespace)
diff --git a/docs/book/v2/index.md b/docs/book/v2/index.md
new file mode 100644
index 00000000..97635fa6
--- /dev/null
+++ b/docs/book/v2/index.md
@@ -0,0 +1 @@
+# The coding standard ruleset for Zend Framework components
diff --git a/docs/book/v2/intro.md b/docs/book/v2/intro.md
new file mode 100644
index 00000000..7e19599f
--- /dev/null
+++ b/docs/book/v2/intro.md
@@ -0,0 +1,136 @@
+# zend-coding-standard
+
+The coding standard ruleset for Zend Framework components.
+
+This specification extends and expands [PSR-12](https://github.com/php-fig/fig-standards/blob/master/proposed/extended-coding-style-guide.md), 
+the extended coding style guide and requires adherence to [PSR-1](https://www.php-fig.org/psr/psr-1), 
+the basic coding standard. These are minimal specifications and don't address all factors, including things like:
+
+- whitespace around operators
+- alignment of array keys and operators
+- alignment of object operations
+- how to format multi-line conditionals
+- what and what not to import, and how
+- etc.
+
+Contributors have different coding styles and so do the maintainers. During code reviews there are regularly 
+discussions about spaces and alignments, where and when was said that a function needs to be imported. And 
+that's where this coding standard comes in: To have internal consistency in a component and between components.
+
+> Note: PSR-12 is not finalized. e.g. The `!` operator and `:` placement for return values are still under  discussion. 
+We will change these rules, and, when PSR-12 is finalized, adapt them.
+
+## Installation
+
+1. Install the module via composer by running:
+
+   ```bash
+   $ composer require --dev zendframework/zend-coding-standard
+   ```
+
+2. Add composer scripts into your `composer.json`:
+
+   ```json
+   "scripts": {
+     "cs-check": "phpcs",
+     "cs-fix": "phpcbf"
+   }
+   ```
+
+3. Create file `phpcs.xml` on base path of your repository with this content:
+
+   ```xml
+   <?xml version="1.0"?>
+   <ruleset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xsi:noNamespaceSchemaLocation="vendor/squizlabs/php_codesniffer/phpcs.xsd">
+   
+       <arg name="basepath" value="."/>
+       <arg name="cache" value=".phpcs-cache"/>
+       <arg name="colors"/>
+       <arg name="extensions" value="php"/>
+       <arg name="parallel" value="80"/>
+       
+       <!-- Show progress -->
+       <arg value="p"/>
+   
+       <!-- Paths to check -->
+       <file>config</file>
+       <file>src</file>
+       <file>test</file>
+   
+       <!-- Include all rules from the Zend Coding Standard -->
+       <rule ref="ZendCodingStandard"/>
+   </ruleset>
+   ```
+
+You can add or exclude some locations in that file.
+For a reference please see: https://github.com/squizlabs/PHP_CodeSniffer/wiki/Annotated-ruleset.xml
+
+## Usage
+
+* To run checks only:
+
+  ```bash
+  $ composer cs-check
+  ```
+
+* To automatically fix many CS issues:
+
+  ```bash
+  $ composer cs-fix
+  ```
+
+## Ignoring parts of a File
+
+> Note: Before PHP_CodeSniffer version 3.2.0, `// @codingStandardsIgnoreStart` and `// @codingStandardsIgnoreEnd` were
+> used. These are deprecated and will be removed in PHP_CodeSniffer version 4.0.
+
+Disable parts of a file:
+```php
+$xmlPackage = new XMLPackage;
+// phpcs:disable
+$xmlPackage['error_code'] = get_default_error_code_value();
+$xmlPackage->send();
+// phpcs:enable
+```
+
+Disable a specific rule:
+```php
+// phpcs:disable Generic.Commenting.Todo.Found
+$xmlPackage = new XMLPackage;
+$xmlPackage['error_code'] = get_default_error_code_value();
+// TODO: Add an error message here.
+$xmlPackage->send();
+// phpcs:enable
+```
+
+## Development
+
+> **New rules or Sniffs may not be introduced in minor or bugfix releases and should always be based on the develop 
+branch and queued for the next major release, unless considered a bugfix for existing rules.**
+
+If you want to test changes against ZendFramework components or your own projects, install your forked 
+zend-coding-standard globally with composer: 
+```bash
+$ composer global config repositories.zend-coding-standard vcs git@github.com:<FORK_NAMESPACE>/zend-coding-standard.git
+$ composer global require --dev zendframework/zend-coding-standard:dev-<FORKED_BRANCH>
+
+# For this to work, add this to your path: ~/.composer/vendor/bin
+# Using `-s` prints the rules that triggered the errors so they can be reviewed easily. `-p` is for progress display.
+$ phpcs -sp --standard=ZendCodingStandard src test
+```
+Make sure you remove the global installation after testing from your global composer.json file!!!
+
+Documentation can be previewed locally by installing [MkDocs](https://www.mkdocs.org/#installation) and run 
+`mkdocs serve`. This will start a server where you can read the docs.
+
+## Reference
+
+Rules can be added, excluded or tweaked locally, depending on your preferences. More information on how to do this can
+be found here:
+
+- [Coding Standard Tutorial](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Coding-Standard-Tutorial)
+- [Configuration Options](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Configuration-Options)
+- [Selectively Applying Rules](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Annotated-Ruleset#selectively-applying-rules)
+- [Customisable Sniff Properties](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Customisable-Sniff-Properties)
+- [Slevomat Coding Standard](https://github.com/slevomat/coding-standard)
diff --git a/docs/book/v2/ruleset.md b/docs/book/v2/ruleset.md
new file mode 100644
index 00000000..b470c39e
--- /dev/null
+++ b/docs/book/v2/ruleset.md
@@ -0,0 +1,1170 @@
+# Ruleset
+
+## PSR2
+Use PSR-2 coding standard as a base
+
+### PSR2.ControlStructures.ElseIfDeclaration.NotAllowed
+_PSR-12:_ The keyword `elseif` should be used instead of `else if` so that all control keywords look like single words.
+
+
+
+## Generic
+
+### Generic.Arrays.ArrayIndent
+All values in multiline arrays must be indented with 4 spaces.
+
+### Generic.Arrays.DisallowLongArraySyntax
+Short array syntax must be used to define arrays.
+
+```php
+<?php
+$foo = ['foo' => 'bar'];
+```
+
+### Generic.PHP.BacktickOperator
+The backtick operator may not be used for execution of shell commands.
+
+*Invalid: Using the backtick operator.*
+```php
+<?php
+$output = `ls -al`;
+```
+
+### Generic.Classes.DuplicateClassName
+Class and Interface names should be unique in a project and must have a unique fully qualified name. They should never 
+be duplicated.
+
+*Valid: Unique class names.*
+```php
+<?php
+// src/Vendor/Package/Foo.php
+namespace Vendor\Package {
+    class Foo
+    {
+    }
+}
+
+// src/Vendor/AnotherPackage/Foo.php
+namespace Vendor\AnotherPackage {
+    class Foo
+    {
+    }
+}
+```
+
+*Invalid: A class duplicated across multiple files.*
+```php
+<?php
+// src/Vendor/Package/Foo.php
+namespace Vendor\Package {
+    class Foo
+    {
+    }
+}
+
+// app/Vendor/Package/Foo.php
+namespace Vendor\Package {
+    class Foo
+    {
+    }
+}
+```
+
+### Generic.CodeAnalysis.EmptyStatement
+Control Structures must have at least one statement inside of the body.
+
+*Valid:*
+```php
+<?php
+for ($i; $i > 0; $i--) { 
+    echo 'hello';
+}
+```
+
+*Invalid:*
+```php
+<?php
+if ($something) echo 'hello';
+```
+#### Generic.CodeAnalysis.EmptyStatement.DetectedCatch
+Catch blocks may be empty.
+
+```php
+<?php
+try {
+    // Do something
+} catch (SomeThrowableType $e) {
+}
+```
+
+### Generic.CodeAnalysis.UnnecessaryFinalModifier
+Methods may not have the final declaration classes declared as final.
+
+*Valid: Only the class is marked as final.*
+```php
+<?php
+final class Foo
+{
+    public function bar()
+    {
+    }
+}
+```
+
+*Invalid: A method in a final class is also marked final.*
+```php
+<?php
+final class Foo
+{
+    final public function bar()
+    {
+    }
+}
+```
+
+### Generic.CodeAnalysis.UselessOverridingMethod
+Methods that only call the parent method should not be defined.
+
+*Valid: A method that extends functionality on a parent method.*
+```php
+<?php
+final class Foo
+{
+    public function bar() : void
+    {
+        parent::bar();
+        $this->doSomethingElse();
+    }
+}
+```
+
+*Invalid: An overriding method that only calls the parent.*
+```php
+<?php
+final class Foo
+{
+    public function bar() : void
+    {
+       parent::bar();
+    }
+}
+```
+
+### Generic.Files.InlineHTML
+Files that contain PHP code should only have PHP code and should not have any _"inline HTML"_.
+
+*Valid: A php file with only php code in it.*
+```php
+<?php
+$foo = 'bar';
+echo $foo . 'baz';
+```
+
+*Invalid: A php file with html in it outside of the php tags.*
+```php
+<strong>some string here</strong>
+<?php
+$foo = 'bar';
+echo $foo . 'baz';
+```
+
+### Generic.Files.LineEndings
+_PSR-12:_ All PHP files MUST use the Unix LF (linefeed) line ending only.
+
+### Generic.Formatting.MultipleStatementAlignment
+There should be one space on either side of an equals sign used to assign a value to a variable.
+
+*Valid: Equal signs are surrounded by one space.*
+```php
+<?php
+$shortVar = (1 + 2);
+$veryLongVarName = 'string';
+
+$foo = $bar;
+$result = foo($bar, $baz, $quux);
+```
+
+*Invalid: Equal signs are aligned.*
+```php
+<?php
+$shortVar        = (1 + 2);
+$veryLongVarName = 'string';
+
+$foo    = $bar;
+$result = foo($bar, $baz, $quux);
+```
+
+### Generic.Formatting.SpaceAfterCast
+There must be exactly one space after a type cast.
+
+*Valid: A cast operator is followed by one space.*
+```php
+<?php
+$foo = (string) 1;
+```
+
+*Invalid: A cast operator is not followed by whitespace.*
+```php
+<?php
+$foo = (string)1;
+```
+
+### Generic.Formatting.SpaceAfterNot
+The not `!` operator must be followed by exactly one space.
+
+*Valid: One space after `!`.*
+```php
+<?php
+if (! foo() && (! $x || true)) {}
+$var = ! ($x || $y);
+```
+
+*Invalid: No space after `!` or a space before.*
+```php
+<?php
+if (!foo() && ( ! $x || true)) {}
+$var = !($x || $y);
+```
+
+### Generic.NamingConventions.ConstructorName
+Constructors should be named `__construct`, not after the class.
+
+*Valid: The constructor is named __construct.*
+```php
+<?php
+class Foo
+{
+    function __construct()
+    {
+    }
+}
+```
+
+*Invalid: The PHP4 style class name constructor is used.*
+```php
+<?php
+class Foo
+{
+    function Foo()
+    {
+    }
+}
+```
+
+### Generic.PHP.CharacterBeforePHPOpeningTag
+The opening PHP tag should be the first item in the file.
+
+*Valid: A file starting with an opening php tag.*
+```php
+<?php
+echo 'Foo';
+```
+
+*Invalid: A file with content before the opening php tag.*
+```php
+<strong>Beginning content</em>
+<?php
+echo 'Foo';
+```
+
+### Generic.PHP.DeprecatedFunctions
+Deprecated functions should not be used.
+
+*Valid: A non-deprecated function is used.*
+```php
+<?php
+$foo = explode('a', $bar);
+```
+
+*Invalid: A deprecated function is used.*
+```php
+<?php
+$foo = split('a', $bar);
+```
+
+### Generic.PHP.DisallowShortOpenTag
+#### Generic.PHP.DisallowShortOpenTag.EchoFound
+_PSR-1:_ PHP code must use the long `<?php ?>` tags or the short-echo `<?= ?>` tags; it must not use the other tag 
+variations.
+
+### Generic.PHP.ForbiddenFunctions
+PHP functions which are an alias may not be used. _This can't be fixed automatically and need to be done manually._
+
+| Alias        | Replace with     |
+| ------------ | ---------------- |
+| chop         | rtrim            |
+| close        | closedir         |
+| compact      |                  |
+| delete       | unset            |
+| doubleval    | floatval         |
+| extract      |                  |
+| fputs        | fwrite           |
+| ini_alter    | ini_set          |
+| is_integer   | is_int           |
+| is_long      | is_int           |
+| is_null      | null ===         |
+| is_real      | is_float         |
+| is_writeable | is_writable      |
+| join         | implode          |
+| key_exists   | array_key_exists |
+| pos          | current          |
+| settype      |                  |
+| show_source  | highlight_file   |
+| sizeof       | count            |
+| strchr       | strstr           |
+
+### Generic.PHP.LowerCaseType
+_PSR-12:_ Any new types and keywords added to future PHP versions must be in lower case.
+
+### Generic.PHP.SAPIUsage
+The `PHP_SAPI` constant must be used instead of the `php_sapi_name()` function.
+
+*Valid: PHP_SAPI is used.*
+```php
+<?php
+if (PHP_SAPI === 'cli') {
+    echo 'Hello, CLI user.';
+}
+```
+
+*Invalid: php_sapi_name() is used.*
+```php
+<?php
+if (php_sapi_name() === 'cli') {
+    echo 'Hello, CLI user.';
+}
+```
+
+### Generic.Strings.UnnecessaryStringConcat
+Strings should not be concatenated together unless used in multiline for readability.
+
+*Valid: A string can be concatenated with an expression.*
+```php
+<?php
+echo '5 + 2 = ' . (5 + 2);
+```
+
+*Invalid: Strings should not be concatenated together.*
+```php
+<?php
+echo 'Hello' . ' ' . 'World';
+```
+
+## PEAR
+
+### PEAR.Commenting.InlineComment
+Perl-style `#` comments are not allowed.
+
+*Valid: A `//` style comment.*
+```php
+<?php
+// A comment.
+```
+
+*Invalid: A `#` style comment.*
+```php
+<?php
+# An invalid comment.
+```
+
+## SlevomatCodingStandard
+
+### SlevomatCodingStandard.Arrays.TrailingArrayComma
+All array values must be followed by a comma, including the last value. Commas after last element in an array make 
+adding a new element easier and result in a cleaner versioning diff.
+
+### SlevomatCodingStandard.Classes.ClassConstantVisibility
+_PSR-12:_ Visibility MUST be declared on all constants if your project PHP minimum version supports constant visibilities 
+(PHP 7.1 or later).
+
+### SlevomatCodingStandard.Classes.ModernClassNameReference
+Class name resolution via `::class` should be used instead of `__CLASS__`, `get_class()`, `get_class($this)`, 
+`get_called_class()` and `get_parent_class()`.
+
+### SlevomatCodingStandard.Classes.TraitUseDeclaration
+_PSR-12:_ Each individual Trait that is imported into a class MUST be included one-per-line.
+
+### SlevomatCodingStandard.Classes.UnusedPrivateElements
+A class should not have unused private constants, (or write-only) properties and methods.
+
+### SlevomatCodingStandard.Commenting.ForbiddenAnnotations
+The annotations `@api`, `@author`, `@category`, `@created`, `@package`, `@subpackage` and `@version` may not
+be used in comments. Git commits provide accurate information. 
+
+### SlevomatCodingStandard.Commenting.EmptyComment
+Comments may not be empty.
+
+### SlevomatCodingStandard.Commenting.ForbiddenComments
+To keep comments clean, the words _private_, _protected_, _static_, _constructor_, _deconstructor_, _Created by_, 
+_getter_ and _setter_ may not be used in comments
+
+### SlevomatCodingStandard.Commenting.InlineDocCommentDeclaration
+The `@var` tag may be used in inline comments to document the _Type_ of properties, sometimes called class variables.
+
+```php
+<?php
+class Foo
+{
+	/** @var string */
+	private $foo;
+	
+	public function __construct()
+	{
+        /** @var string $f */
+        foreach ($e as $f) {
+            // ...
+        }
+        
+        /** @var string[] $a */
+        $a = $this->get();
+    }
+}
+```
+
+### SlevomatCodingStandard.Commenting.RequireOneLinePropertyDocComment
+Single-line comments with a `@var` tag should be written as one-liners.
+
+*Valid: One-line comment*
+```php
+<?php
+/** @var array */
+private $foo;
+```
+
+*Invalid: Multiple lines for a single comment*
+```php
+<?php
+/**
+ * @var array
+ */
+private $foo;
+```
+
+### SlevomatCodingStandard.ControlStructures.DisallowEqualOperators
+Loose `==` and `!=` comparison operators should not be used. Use strict comparison `===` and `!==` instead, they are 
+much more secure and predictable.
+
+*Valid: Strict comparison is used.*
+```php
+<?php
+if ($a === $b || $c !== $d) {
+    // ...
+}
+```
+
+*Invalid: Loose comparison used.*
+```php
+<?php
+if ($a == $b || $c != $d) {
+    // ...
+}
+```
+
+### SlevomatCodingStandard.ControlStructures.LanguageConstructWithParentheses
+Language constructs must be used without parentheses where possible.
+
+*Valid: Use language constructs without parentheses.*
+```php
+<?php
+continue 1;
+break 1;
+echo 'a';
+print 'b';
+include 'file.php';
+return 'foo';
+yield [];
+throw new Exception();
+exit;
+```
+
+*Invalid: Language constructs with parentheses.*
+```php
+<?php
+continue(1);
+break(1);
+echo('a');
+print('b');
+include('file.php');
+return('foo');
+yield([]);
+throw(new Exception());
+exit();
+```
+
+### SlevomatCodingStandard.ControlStructures.NewWithParentheses
+_PSR-12:_ When instantiating a new class, parenthesis MUST always be present even when there are no arguments passed to 
+the constructor.
+
+*Valid: Parenthesis are used for instantiating a new class.*
+```php
+<?php
+new Foo();
+```
+
+*Invalid: Missing parenthesis.*
+```php
+<?php
+new Foo;
+```
+
+### SlevomatCodingStandard.ControlStructures.RequireNullCoalesceOperator
+The null coalescing operator `??` should be used when possible.
+
+*Valid: Used the null coalescing operator.*
+```php
+<?php
+$username = $user['name'] ?? 'nobody';
+```
+
+*Invalid: Using isset to check if a variable is set and return it.*
+```php
+<?php
+$username = isset($user['name']) ? $user['name'] : 'nobody';
+```
+
+### SlevomatCodingStandard.Exceptions.DeadCatch
+Catch blocks must be reachable.
+
+*Valid: All catch blocks are reachable.*
+```php
+<?php
+try {
+	doStuff();
+} catch (InvalidArgumentException $e) {
+	log($e);
+} catch (Throwable $e) {
+	// Reachable
+}
+```
+
+*Invalid: Last catch block is unreachable.*
+```php
+<?php
+try {
+	doStuff();
+} catch (Throwable $e) {
+	log($e);
+} catch (InvalidArgumentException $e) {
+	// Unreachable because `Throwable` catches everything!
+}
+```
+
+### SlevomatCodingStandard.Exceptions.ReferenceThrowableOnly
+Catch blocks must use `Throwable` instead of `Exception`.
+
+*Valid: Throwable is used to catch all errors and exceptions.*
+```php
+<?php
+try {
+	// ...
+} catch (Throwable $e) {
+    // ...
+}
+```
+
+*Invalid: Exception is used and will not catch other Throwables. e.g. internal PHP errors*
+```php
+<?php
+try {
+	// ...
+} catch (Exception $e) {
+    // ...
+}
+```
+
+### SlevomatCodingStandard.Functions.UnusedInheritedVariablePassedToClosure
+Unused variables should not be passed to closures via `use`.
+
+*Valid: All variables passed via `use` are used.*
+```php
+<?php
+$closure = function (string $arg1, string $arg2) use ($var1) : string {
+    return $arg1 . $arg2 . $var1;
+};
+```
+
+*Invalid: Un unused variable `$var2` is passed via `use`.*
+```php
+<?php
+$closure = function (string $arg1, string $arg2) use ($var1, $var2) : string {
+    return $arg1 . $arg2 . $var1;
+};
+```
+
+### SlevomatCodingStandard.Namespaces.AlphabeticallySortedUses
+Import statements should be alphabetically sorted.
+
+*Valid: The import statements are sorted alphabetically.*
+```php
+<?php
+use Example\A;
+use Example\B;
+use Vendor\Package\C;
+```
+
+*Invalid: The import statements are in a random order.*
+```php
+<?php
+use Example\A;
+use Vendor\Package\C;
+use Example\B;
+```
+
+### SlevomatCodingStandard.Namespaces.DisallowGroupUse
+Import statements should not be grouped.
+
+*Valid: Each import statement on its own line.*
+```php
+<?php
+use Example\A;
+use Example\B;
+use Vendor\Package\C;
+```
+
+*Invalid: Using import groups.*
+```php
+<?php
+use Example\{A, B};
+use Vendor\Package\C;
+```
+
+### SlevomatCodingStandard.Namespaces.MultipleUsesPerLine
+Each import statement should be on its own line.
+
+*Valid: Each import statement on its own line.*
+```php
+<?php
+use Bar;
+use Foo;
+```
+
+*Invalid: Multiple imports on one line.*
+```php
+<?php
+use Foo, Bar;
+```
+
+### SlevomatCodingStandard.Namespaces.NamespaceSpacing
+Require newlines around namespace declaration
+
+### SlevomatCodingStandard.Namespaces.ReferenceUsedNamesOnly
+Absolute class name references, functions and constants should be imported.
+
+### SlevomatCodingStandard.Namespaces.UnusedUses
+Unused import statements are not allowed.
+
+### SlevomatCodingStandard.Namespaces.UseDoesNotStartWithBackslash
+_PSR-12:_ Import statements MUST never begin with a leading backslash as they must always be fully qualified.
+
+### SlevomatCodingStandard.Namespaces.UseFromSameNamespace
+Classes and function within the same namespace should not be imported.
+
+*Valid: `Bar` is not imported.*
+```php
+<?php
+namespace Example;
+
+use Example\More\Baz;
+
+class Foo extends Bar
+{
+}
+```
+
+*Invalid: `Bar` is in the same namespace as `Foo`.*
+```php
+<?php
+namespace Example;
+
+use Example\Bar;
+use Example\More\Baz;
+
+class Foo extends Bar
+{
+}
+```
+
+### SlevomatCodingStandard.Namespaces.UseSpacing
+_PSR-12:_ Require empty newlines before and after uses
+
+### SlevomatCodingStandard.Namespaces.UselessAlias
+Imports should not have an alias with the same name.
+
+*Valid: The alias and imported class name are different.*
+```php
+<?php
+use Foo\Bar as MyBar; 
+```
+
+*Invalid: Alias has same name as imported class.*
+```php
+<?php
+use Foo\Bar as Bar;
+```
+
+### SlevomatCodingStandard.Operators.RequireCombinedAssignmentOperator
+Assignment operators (eg `+=`, `.=`) should be used when possible.
+
+```php
+<?php
+self::$a &= 2;
+static::$a |= 4;
+self::$$parameter .= '';
+parent::${'a'} /= 10;
+self::${'a'}[0] -= 100;
+Anything::$a **= 2;
+Something\Anything::$a %= 2;
+\Something\Anything::$a *= 1000;
+self::$a::$b += 4;
+$this::$a <<= 2;
+$this->a >>= 2;
+$this->$$parameter ^= 10;
+$this->{'a'} += 10;
+```
+
+### SlevomatCodingStandard.PHP.ShortList
+Short list syntax `[...]` should be used instead of `list(...)`.
+
+*Valid: The short list syntax is used for array destructuring assignment.*
+```php
+<?php
+[$a, $b, $c] = $array;
+['a' => $a, 'b' => $b, 'c' => $c] = $array;
+```
+
+*Invalid: Usage of `list`.*
+```php
+<?php
+list($a, $b, $c) = $array;
+list('a' => $a, 'b' => $b, 'c' => $c) = $array;
+```
+
+### SlevomatCodingStandard.PHP.TypeCast
+_PSR-12:_ Short form of type keywords must be used. i.e. `bool` instead of `boolean`, `int` instead of `integer`, etc.
+
+The `binary` and `unset` cast operators are not allowed.
+
+### SlevomatCodingStandard.TypeHints.DeclareStrictTypes
+Each PHP file should have a strict type declaration at the top after the page level docblock.
+
+_PSR-12:_ Declare statements MUST contain no spaces and MUST be exactly `declare(strict_types=1)`.
+
+```php
+<?php
+/**
+ * @see       https://github.com/zendframework/zend-coding-standard for the canonical source repository
+ * @copyright Copyright (c) 2016-2018 Zend Technologies USA Inc. (https://www.zend.com)
+ * @license   https://github.com/zendframework/zend-coding-standard/blob/master/LICENSE.md New BSD License
+ */
+
+declare(strict_types=1);
+
+// ...
+```
+
+### SlevomatCodingStandard.PHP.UselessParentheses
+Parentheses should not be used if they can be omitted.
+
+*Valid: No parentheses used.*
+```php
+<?php
+$x = $y !== null ? true : false;
+$a = $b ? 1 : 0;
+$c = $d ? 1 : 0;
+$x = self::$a;
+$x = Something\Anything::$a;
+$x = self::$a::$b;
+```
+
+*Invalid: Unneeded parentheses.*
+```php
+<?php
+$x = ($y !== null) ? true : false;
+$a = ($b) ? 1 : 0;
+$c = (   $d    ) ? 1 : 0;
+$x = (self::$a);
+$x = (Something\Anything::$a);
+$x = (self::$a::$b);
+```
+
+### SlevomatCodingStandard.PHP.UselessSemicolon
+Semicolons `;` should not be used if they can be omitted.
+
+*Valid: Semicolon used where needed.*
+```php
+<?php
+foo();
+
+class Whatever {
+}
+```
+
+*Invalid: Unneeded semicolons used.*
+```php
+<?php
+foo();;
+
+class Whatever {
+};
+```
+
+### SlevomatCodingStandard.TypeHints.LongTypeHints
+Shorthand scalar typehint variants must be used in docblocks: `bool` instead of `boolean`, `int` instead of `integer`, 
+etc. This is for consistency with _PSR-12_ native scalar typehints which also allow shorthand variants only.
+
+### SlevomatCodingStandard.TypeHints.NullableTypeForNullDefaultValue
+Nullable and optional arguments, which are marked as `= null`, must have the `?` symbol present.
+
+*Valid: Nullable argument has the `?` symbol.*
+```php
+<?php
+function foo(?int $bar = null) {
+}
+```
+
+*Invalid: Missing `?` before `int`*
+```php
+<?php
+function foo(int $foo = null) {
+}
+```
+
+### SlevomatCodingStandard.TypeHints.ParameterTypeHintSpacing
+_PSR-12:_ Method and function arguments must have one space between typehint and variable. Between the nullability sign 
+and typehint may not be a space. 
+
+### SlevomatCodingStandard.TypeHints.ReturnTypeHintSpacing
+The colon used with return type declarations MUST be surrounded with 1 space. This is different with the draft PSR-12 
+proposal and will be adjusted if needed when PSR-12 is accepted.
+```php
+public function foo($bar) : array;
+```
+
+### SlevomatCodingStandard.Types.EmptyLinesAroundTypeBraces
+- _PSR-12:_ The opening brace for the class MUST go on its own line; the closing brace for the class MUST go on the 
+  next line after the body.
+- _PSR-12:_ Any closing brace MUST NOT be followed by any comment or statement on the same line.
+- _PSR-12:_ Opening braces MUST be on their own line and MUST NOT be preceded or followed by a blank line.
+- _PSR-12:_ Closing braces MUST be on their own line and MUST NOT be preceded by a blank line.
+
+### SlevomatCodingStandard.Variables.UselessVariable
+Variables should be returned directly instead of assigned to a variable which is not used.
+
+*Valid: The value is returned directly.*
+```php
+<?php
+function () {
+	return true;
+};
+```
+
+*Invalid: An extra variable is used where its value could be returned directly.*
+```php
+<?php
+function () {
+	$a = true;
+	return $a;
+};
+```
+
+
+
+## Squiz
+
+### Squiz.Arrays.ArrayBracketSpacing
+Whitespace is not allowed around the opening bracket or before the closing bracket when referencing an array.
+
+*Valid: No extra spaces used.*
+```php
+<?php
+$foo['bar'];
+```
+
+*Invalid: Extra spaces.*
+```php
+<?php
+$foo [ 'bar' ] ;
+```
+
+### Squiz.Arrays.ArrayDeclaration
+All double arrow symbols must be aligned to one space after the longest array key.
+
+*Valid: Array is aligned.*
+```php
+<?php
+return [
+    ConfigAggregator::ENABLE_CACHE => true,
+    'debug'                        => false,
+    'zend-expressive' => [
+        'raise_throwables'      => true,
+        'programmatic_pipeline' => true,
+        'error_handler'         => [
+            'template_404'   => 'error::404',
+            'template_error' => 'error::error',
+        ],
+    ],
+];
+```
+
+*Invalid: Double arrow symbols are not aligned.*
+```php
+<?php
+return [
+    ConfigAggregator::ENABLE_CACHE => true,
+    'debug' => false,
+    'zend-expressive' => [
+        'raise_throwables' => true,
+        'programmatic_pipeline' => true,
+        'error_handler' => [
+            'template_404' => 'error::404',
+            'template_error' => 'error::error',
+        ],
+    ],
+];
+```
+
+### Squiz.Classes.ClassFileName
+_PSR-4:_ The class name must correspond to a file name ending in .php. The file name MUST match the case of the 
+terminating class name.
+
+### Squiz.Classes.SelfMemberReference
+The `self` keyword should be used instead of the current class name, and should not have spaces around `::`.
+
+*Valid:*
+```php
+<?php
+class Foo
+{
+    public static function bar()
+    {
+    }
+
+    public static function baz()
+    {
+        self::bar();
+    }
+}
+```
+
+### Squiz.Commenting.DocCommentAlignment
+The asterisks in a doc comment should align, and there should be one space between the asterisk and tag.
+
+*Valid:*
+```php
+<?php
+/**
+ * These lines are aligned.
+ * 
+ * @var array
+ */
+```
+
+### Squiz.Commenting.FunctionComment
+A function comment should be kept to a bare minimum. If the function and its arguments are self describing and have
+proper typehinting, tags like `@param`, `@throws`, and `@return` can be omitted.
+
+There should be no multiple spaces between the tag, type and description.
+
+*Valid:*
+```php
+<?php
+/**
+ * This is a summary
+ *
+ * This is a description.
+ * 
+ * @see http://example.com/my/bar URL to documentation.
+ * 
+ * @param array $argument1 This is the description.
+ * @param string $arg2 This is the description.
+ * @param null|string $longerArgument3 This is the description.
+ * @throws InvalidArgumentException on any invalid element.
+ * @return null|int Indicates the number of items.
+ */
+```
+
+### Squiz.Operators.ValidLogicalOperators
+The `&&` and `||` operators must be used instead of `AND` and `OR`.
+
+### Squiz.PHP.GlobalKeyword
+The `global` keyword may not be used.
+
+### Squiz.PHP.LowercasePHPFunctions
+PHP function calls must be in lowercase.
+
+### Squiz.PHP.NonExecutableCode
+The code may not contain unreachable code.
+
+### Squiz.Scope.StaticThisUsage
+Static methods should not use `$this`.
+
+*Valid: Using `self::` to access static variables.*
+```php
+<?php
+class Foo
+{
+    public static function bar()
+    {
+        return self::$staticMember;
+    }
+}
+```
+
+*Invalid: Using `$this->` to access static variables.*
+```php
+<?php
+class Foo
+{
+    public static function bar()
+    {
+        return $this->$staticMember;
+    }
+}
+```
+
+### Squiz.Strings.ConcatenationSpacing
+Force whitespace before and after concatenation
+
+### Squiz.Strings.DoubleQuoteUsage
+#### Squiz.Strings.DoubleQuoteUsage.ContainsVar
+Double quote strings may only be used if they contain variables. SQL queries containing single quotes are an exception 
+to the rule.
+
+*Valid: Double quote strings are only used when it contains a variable.*
+```php
+<?php
+$string = "Hello There\r\n";
+$string = "Hello $there";
+$string = 'Hello There';
+$string = 'Hello'.' There'."\n";
+$string = '\$var';
+$query = "SELECT * FROM table WHERE name =''";
+```
+
+*Invalid: There are no variables inside double quote strings.*
+```php
+<?php
+$string = "Hello There";
+$string = "Hello"." There"."\n";
+$string = "\$var";
+```
+
+### Squiz.Strings.EchoedStrings
+Strings should not be enclosed in parentheses when being echoed.
+
+*Valid: Using echo without parentheses.*
+```php
+<?php
+echo 'Hello';
+```
+
+*Invalid: Using echo with parentheses.*
+```php
+<?php
+echo('Hello');
+```
+
+### Squiz.WhiteSpace.CastSpacing
+Type casts should not have whitespace inside the parentheses.
+
+*Valid: No spaces.*
+```php
+<?php
+$foo = (int) '42';
+```
+
+*Invalid: Whitespace used inside parentheses.*
+```php
+<?php
+$foo = ( int ) '42';
+```
+
+### Squiz.WhiteSpace.FunctionOpeningBraceSpace
+The opening brace for functions should be on a new line with no blank lines surrounding it.
+
+*Valid: Opening brace is on a new line.*
+```php
+<?php
+function foo() : int
+{
+    return 42;
+}
+```
+
+*Invalid: Opening brace is on the same line as the function declaration and a blank line after the opening brace.*
+```php
+<?php
+function foo() {
+
+    return 42;
+}
+```
+
+### Squiz.WhiteSpace.LanguageConstructSpacing
+The PHP constructs `echo`, `print`, `return`, `include`, `include_once`, `require`, `require_once`, and `new` should 
+have one space after them.
+
+*Valid: echo statement with a single space after it.*
+```php
+<?php
+echo 'hi';
+```
+
+*Invalid: echo statement with no space after it.*
+```php
+<?php
+echo'hi';
+```
+
+### Squiz.WhiteSpace.LogicalOperatorSpacing
+_PSR-12:_ There must be one space around logical operators.
+
+### Squiz.WhiteSpace.ObjectOperatorSpacing
+The object operator `->` should not have any spaces around it.
+
+*Valid: No spaces around the object operator.*
+```php
+<?php
+$foo->bar();
+```
+
+*Invalid: Whitespace surrounding the object operator.*
+```php
+<?php
+$foo -> bar();
+```
+
+### Squiz.WhiteSpace.ObjectOperatorSpacing
+There should be one space before and after an operators.
+
+*Valid: One space around the operator.*
+```php
+<?php
+$foo = 'bar';
+```
+
+*Invalid: Multiple or none spaces around the operator.*
+```php
+<?php
+$foo  =  'bar';
+$bar='foo';
+```
+
+### Squiz.WhiteSpace.SemicolonSpacing
+Semicolons should not have spaces before them.
+
+*Valid: No space before the semicolon.*
+```php
+<?php
+echo 'hi';
+```
+
+*Valid: Invalid: Space before the semicolon.*
+```php
+<?php
+echo 'hi' ;
+```
+
+### Squiz.WhiteSpace.SuperfluousWhitespace
+#### Squiz.WhiteSpace.SuperfluousWhitespace.EmptyLines
+The code should not contain superfluous whitespaces. e.g. multiple empty lines, trailing spaces, etc.
diff --git a/mkdocs.yml b/mkdocs.yml
new file mode 100644
index 00000000..fe94352d
--- /dev/null
+++ b/mkdocs.yml
@@ -0,0 +1,17 @@
+docs_dir: docs/book
+site_dir: docs/html
+pages:
+    - index.md
+    - 'Introduction': v2/intro.md
+    - 'Coding Style Guide': v2/coding-style-guide.md
+    - 'Reference':
+        - 'Ruleset': v2/ruleset.md
+    - v1:
+        - v1/index.md
+        - 'Introduction': v1/intro.md
+        - 'Reference':
+            - 'Ruleset': v1/ruleset.md
+
+site_name: Zend Coding Standard
+site_description: 'The coding standard ruleset for Zend Framework components.'
+repo_url: 'https://github.com/zendframework/zend-coding-standard'
diff --git a/phpcs.xml.dist b/phpcs.xml.dist
new file mode 100644
index 00000000..c13f0a96
--- /dev/null
+++ b/phpcs.xml.dist
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<ruleset name="PHPCS Coding Standards for ZendCodingStandard"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="vendor/squizlabs/php_codesniffer/phpcs.xsd">
+    <description>The coding standard for ZendCodingStandard itself.</description>
+
+    <arg name="basepath" value="."/>
+    <arg name="cache" value=".phpcs-cache"/>
+    <arg name="colors"/>
+    <arg name="extensions" value="php"/>
+    <arg name="parallel" value="80"/>
+
+    <file>src</file>
+
+    <rule ref="ZendCodingStandard"/>
+</ruleset>
diff --git a/ruleset.xml b/ruleset.xml
deleted file mode 100644
index 2e2536e0..00000000
--- a/ruleset.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0"?>
-<ruleset name="Zend Framework Coding Standard">
-    <description>Zend Framework Coding Standard</description>
-
-    <!-- display progress -->
-    <arg value="p"/>
-    <arg name="colors"/>
-
-    <!-- inherit rules from: -->
-    <rule ref="PSR2"/>
-    <rule ref="Generic.Arrays.DisallowLongArraySyntax"/>
-    <rule ref="Generic.Formatting.SpaceAfterNot"/>
-    <rule ref="Squiz.WhiteSpace.OperatorSpacing">
-        <properties>
-            <property name="ignoreNewlines" value="true"/>
-        </properties>
-    </rule>
-    <rule ref="Squiz.WhiteSpace.SuperfluousWhitespace">
-        <properties>
-            <property name="ignoreBlankLines" value="false"/>
-        </properties>
-    </rule>
-</ruleset>
diff --git a/src/ZendCodingStandard/ruleset.xml b/src/ZendCodingStandard/ruleset.xml
new file mode 100644
index 00000000..43dd2702
--- /dev/null
+++ b/src/ZendCodingStandard/ruleset.xml
@@ -0,0 +1,371 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ruleset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="../../vendor/squizlabs/php_codesniffer/phpcs.xsd"
+         name="ZendCodingStandard">
+    <description>The ZendFramework coding standard.</description>
+
+    <!-- Import PSR-2 coding standard (base) -->
+    <rule ref="PSR2">
+        <!-- Checked by SlevomatCodingStandard.Namespaces.UseSpacing -->
+        <exclude name="PSR2.Namespaces.UseDeclaration.SpaceAfterLastUse"/>
+        <!-- Checked by SlevomatCodingStandard.Namespaces.NamespaceSpacing -->
+        <exclude name="PSR2.Namespaces.NamespaceDeclaration.BlankLineAfter"/>
+    </rule>
+
+    <!-- Force array element indentation with 4 spaces -->
+    <rule ref="Generic.Arrays.ArrayIndent"/>
+    <!-- Forbid `array(...)` -->
+    <rule ref="Generic.Arrays.DisallowLongArraySyntax"/>
+    <!-- Align double arrows -->
+    <rule ref="WebimpressCodingStandard.Arrays.DoubleArrow">
+        <properties>
+            <property name="maxPadding" value="50"/>
+        </properties>
+    </rule>
+    <!-- Format arrays -->
+    <rule ref="WebimpressCodingStandard.Arrays.Format"/>
+    <!-- Add trailing commas to all array elements -->
+    <rule ref="WebimpressCodingStandard.Arrays.TrailingArrayComma"/>
+
+    <!-- Forbid duplicate classes -->
+    <rule ref="Generic.Classes.DuplicateClassName"/>
+    <!-- Forbid empty statements -->
+    <rule ref="Generic.CodeAnalysis.EmptyStatement">
+        <!-- But allow empty catch -->
+        <exclude name="Generic.CodeAnalysis.EmptyStatement.DetectedCatch"/>
+    </rule>
+    <!-- Forbid final methods in final classes -->
+    <rule ref="Generic.CodeAnalysis.UnnecessaryFinalModifier"/>
+    <!-- Forbid useless empty method overrides -->
+    <rule ref="Generic.CodeAnalysis.UselessOverridingMethod"/>
+    <!-- Forbid inline HTML in PHP code -->
+    <rule ref="Generic.Files.InlineHTML"/>
+    <!-- Force Unix LF (linefeed) line ending -->
+    <rule ref="Generic.Files.LineEndings">
+        <properties>
+            <property name="eolChar" value="\n"/>
+        </properties>
+    </rule>
+    <!-- Allow 1 space around operators -->
+    <rule ref="Generic.Formatting.MultipleStatementAlignment">
+        <properties>
+            <property name="error" value="true"/>
+            <property name="maxPadding" value="50"/>
+        </properties>
+    </rule>
+    <!-- Force whitespace after a type cast -->
+    <rule ref="Generic.Formatting.SpaceAfterCast"/>
+    <!-- Force whitespace after `!` -->
+    <rule ref="Generic.Formatting.SpaceAfterNot"/>
+    <!-- Forbid PHP 4 constructors -->
+    <rule ref="Generic.NamingConventions.ConstructorName"/>
+    <!-- Forbid backtick operator -->
+    <rule ref="Generic.PHP.BacktickOperator"/>
+    <!-- Forbid any content before opening tag -->
+    <rule ref="Generic.PHP.CharacterBeforePHPOpeningTag"/>
+    <!-- Forbid deprecated functions -->
+    <rule ref="Generic.PHP.DeprecatedFunctions"/>
+    <!-- Forbid short open tag -->
+    <rule ref="Generic.PHP.DisallowShortOpenTag">
+        <!-- But allow short echo tags -->
+        <exclude name="Generic.PHP.DisallowShortOpenTag.EchoFound"/>
+    </rule>
+    <!-- Forbid alias functions, i.e. `sizeof()`, `delete()` -->
+    <rule ref="Generic.PHP.ForbiddenFunctions">
+        <properties>
+            <property name="forbiddenFunctions" type="array">
+                <element key="chop" value="rtrim"/>
+                <element key="close" value="closedir"/>
+                <element key="compact" value="null"/>
+                <element key="delete" value="unset"/>
+                <element key="doubleval" value="floatval"/>
+                <element key="extract" value="null"/>
+                <element key="fputs" value="fwrite"/>
+                <element key="ini_alter" value="ini_set"/>
+                <element key="is_double" value="is_float"/>
+                <element key="is_integer" value="is_int"/>
+                <element key="is_long" value="is_int"/>
+                <element key="is_null" value="null"/>
+                <element key="is_real" value="is_float"/>
+                <element key="is_writeable" value="is_writable"/>
+                <element key="join" value="implode"/>
+                <element key="key_exists" value="array_key_exists"/>
+                <element key="pos" value="current"/>
+                <element key="settype" value="null"/>
+                <element key="show_source" value="highlight_file"/>
+                <element key="sizeof" value="count"/>
+                <element key="strchr" value="strstr"/>
+            </property>
+        </properties>
+    </rule>
+    <!-- Force PHP 7 param and return types to be lowercased -->
+    <rule ref="Generic.PHP.LowerCaseType"/>
+    <!-- Forbid `php_sapi_name()` function, use PHP_SAPI -->
+    <rule ref="Generic.PHP.SAPIUsage"/>
+    <!-- Forbid useless inline string concatenation -->
+    <rule ref="Generic.Strings.UnnecessaryStringConcat">
+        <!-- But multiline is useful for readability -->
+        <properties>
+            <property name="allowMultiline" value="true"/>
+        </properties>
+    </rule>
+    <!-- Forbid comments starting with # -->
+    <rule ref="PEAR.Commenting.InlineComment"/>
+    <!-- Disallow else if in favor of elseif -->
+    <rule ref="PSR2.ControlStructures.ElseIfDeclaration.NotAllowed">
+        <type>error</type>
+    </rule>
+    <!-- Require presence of constant visibility -->
+    <rule ref="SlevomatCodingStandard.Classes.ClassConstantVisibility">
+        <properties>
+            <property name="fixable" value="true"/>
+        </properties>
+    </rule>
+    <!-- Require usage of ::class instead of __CLASS__, get_class(), get_class($this), get_called_class() and get_parent_class() -->
+    <rule ref="SlevomatCodingStandard.Classes.ModernClassNameReference"/>
+    <!-- Forbid uses of multiple traits separated by comma -->
+    <rule ref="SlevomatCodingStandard.Classes.TraitUseDeclaration"/>
+    <!-- Require no spaces before trait use, between trait uses and one space after trait uses -->
+    <rule ref="SlevomatCodingStandard.Classes.TraitUseSpacing">
+        <properties>
+            <property name="linesCountAfterLastUse" value="1"/>
+            <property name="linesCountAfterLastUseWhenLastInClass" value="0"/>
+            <property name="linesCountBeforeFirstUse" value="0"/>
+            <property name="linesCountBetweenUses" value="0"/>
+        </properties>
+    </rule>
+    <!-- Forbid dead code -->
+    <rule ref="SlevomatCodingStandard.Classes.UnusedPrivateElements"/>
+    <!-- Forbid useless annotations - Git and LICENCE file provide more accurate information -->
+    <rule ref="SlevomatCodingStandard.Commenting.ForbiddenAnnotations">
+        <properties>
+            <property name="forbiddenAnnotations" type="array">
+                <element value="@api"/>
+                <element value="@author"/>
+                <element value="@category"/>
+                <element value="@created"/>
+                <element value="@package"/>
+                <element value="@subpackage"/>
+                <element value="@version"/>
+            </property>
+        </properties>
+    </rule>
+    <!-- Forbid empty comments -->
+    <rule ref="SlevomatCodingStandard.Commenting.EmptyComment"/>
+    <!-- Forbid useless comments -->
+    <rule ref="SlevomatCodingStandard.Commenting.ForbiddenComments">
+        <properties>
+            <property name="forbiddenCommentPatterns" type="array">
+                <element value="~^(?:(?!private|protected|static)\S+ )?(?:con|de)structor\.\z~i"/>
+                <element value="~^Created by \S+\.\z~i"/>
+                <element value="~^\S+ [gs]etter\.\z~i"/>
+            </property>
+        </properties>
+    </rule>
+    <!-- report invalid format of inline phpDocs with @var -->
+    <rule ref="SlevomatCodingStandard.Commenting.InlineDocCommentDeclaration"/>
+    <!-- Require comments with single line @var written as one-liners -->
+    <rule ref="SlevomatCodingStandard.Commenting.RequireOneLinePropertyDocComment"/>
+    <!-- Forbid weak comparisons -->
+    <rule ref="SlevomatCodingStandard.ControlStructures.DisallowEqualOperators"/>
+    <!-- Require language constructs without parentheses -->
+    <rule ref="SlevomatCodingStandard.ControlStructures.LanguageConstructWithParentheses"/>
+    <!-- Require new instances with parentheses -->
+    <rule ref="SlevomatCodingStandard.ControlStructures.NewWithParentheses"/>
+    <!-- Require usage of null coalesce operator when possible -->
+    <rule ref="SlevomatCodingStandard.ControlStructures.RequireNullCoalesceOperator"/>
+    <!-- Forbid useless unreachable catch blocks -->
+    <rule ref="SlevomatCodingStandard.Exceptions.DeadCatch"/>
+    <!-- Require using Throwable instead of Exception -->
+    <rule ref="SlevomatCodingStandard.Exceptions.ReferenceThrowableOnly"/>
+    <!-- Forbid unused variables passed to closures via `use` -->
+    <rule ref="SlevomatCodingStandard.Functions.UnusedInheritedVariablePassedToClosure"/>
+    <!-- Require use statements to be alphabetically sorted -->
+    <rule ref="SlevomatCodingStandard.Namespaces.AlphabeticallySortedUses">
+        <properties>
+            <!-- Force PSR-12 order: classes, functions, constants with 1 emty line in between -->
+            <property name="psr12Compatible" value="true"/>
+        </properties>
+    </rule>
+    <!-- Forbid fancy group uses -->
+    <rule ref="SlevomatCodingStandard.Namespaces.DisallowGroupUse"/>
+    <!-- Forbid multiple use statements on same line -->
+    <rule ref="SlevomatCodingStandard.Namespaces.MultipleUsesPerLine"/>
+    <!-- Require newlines around namespace declaration -->
+    <rule ref="SlevomatCodingStandard.Namespaces.NamespaceSpacing"/>
+    <!-- Forbid using absolute class name references (except global ones) -->
+    <rule ref="SlevomatCodingStandard.Namespaces.ReferenceUsedNamesOnly">
+        <properties>
+            <property name="allowFallbackGlobalConstants" value="false"/>
+            <property name="allowFallbackGlobalFunctions" value="false"/>
+            <property name="allowFullyQualifiedGlobalClasses" value="false"/>
+            <property name="allowFullyQualifiedGlobalConstants" value="false"/>
+            <property name="allowFullyQualifiedGlobalFunctions" value="false"/>
+            <property name="allowFullyQualifiedNameForCollidingClasses" value="true"/>
+            <property name="allowFullyQualifiedNameForCollidingConstants" value="true"/>
+            <property name="allowFullyQualifiedNameForCollidingFunctions" value="true"/>
+            <property name="searchAnnotations" value="true"/>
+        </properties>
+    </rule>
+    <!-- Forbid unused use statements -->
+    <rule ref="SlevomatCodingStandard.Namespaces.UnusedUses">
+        <properties>
+            <property name="searchAnnotations" value="true"/>
+        </properties>
+    </rule>
+    <!-- Forbid superfluous leading backslash in use statements -->
+    <rule ref="SlevomatCodingStandard.Namespaces.UseDoesNotStartWithBackslash"/>
+    <!-- Forbid useless uses of the same namespace -->
+    <rule ref="SlevomatCodingStandard.Namespaces.UseFromSameNamespace"/>
+    <!-- Require empty newlines before and after uses -->
+    <rule ref="SlevomatCodingStandard.Namespaces.UseSpacing">
+        <properties>
+            <property name="linesCountAfterLastUse" value="1"/>
+            <property name="linesCountBeforeFirstUse" value="1"/>
+            <property name="linesCountBetweenUseTypes" value="1"/>
+        </properties>
+    </rule>
+    <!-- Forbid useless alias for classes, constants and functions -->
+    <rule ref="SlevomatCodingStandard.Namespaces.UselessAlias"/>
+    <!-- Require the usage of assignment operators, eg `+=`, `.=` when possible -->
+    <rule ref="SlevomatCodingStandard.Operators.RequireCombinedAssignmentOperator"/>
+    <!-- Forbid `list(...)` syntax, use [...] instead -->
+    <rule ref="SlevomatCodingStandard.PHP.ShortList"/>
+    <!-- Forbid use of longhand cast operators -->
+    <rule ref="SlevomatCodingStandard.PHP.TypeCast"/>
+    <!-- Require presence of declare(strict_types=1) -->
+    <rule ref="SlevomatCodingStandard.TypeHints.DeclareStrictTypes">
+        <properties>
+            <property name="newlinesCountBetweenOpenTagAndDeclare" value="2"/>
+            <property name="spacesCountAroundEqualsSign" value="0"/>
+            <property name="newlinesCountAfterDeclare" value="2"/>
+        </properties>
+    </rule>
+    <!-- Forbid useless parentheses -->
+    <rule ref="SlevomatCodingStandard.PHP.UselessParentheses"/>
+    <!-- Forbid useless semicolon `;` -->
+    <rule ref="SlevomatCodingStandard.PHP.UselessSemicolon"/>
+    <!-- Require use of short versions of scalar types (i.e. int instead of integer) -->
+    <rule ref="SlevomatCodingStandard.TypeHints.LongTypeHints"/>
+    <!-- Require ? when default value is null -->
+    <rule ref="SlevomatCodingStandard.TypeHints.NullableTypeForNullDefaultValue"/>
+    <!-- Require one space between typehint and variable, require no space between nullability sign and typehint -->
+    <rule ref="SlevomatCodingStandard.TypeHints.ParameterTypeHintSpacing"/>
+    <!-- Require space around colon in return types -->
+    <rule ref="SlevomatCodingStandard.TypeHints.ReturnTypeHintSpacing">
+        <properties>
+            <property name="spacesCountBeforeColon" value="1"/>
+        </properties>
+    </rule>
+    <!-- Forbid empty lines around type declarations -->
+    <rule ref="SlevomatCodingStandard.Types.EmptyLinesAroundTypeBraces">
+        <properties>
+            <property name="linesCountAfterOpeningBrace" value="0"/>
+            <property name="linesCountBeforeClosingBrace" value="0"/>
+        </properties>
+    </rule>
+    <!-- Forbid useless variables -->
+    <rule ref="SlevomatCodingStandard.Variables.UselessVariable"/>
+    <!-- Forbid class being in a file with different name -->
+    <rule ref="Squiz.Classes.ClassFileName"/>
+    <!-- Force `self::` for self-reference, force lower-case self, forbid spaces around `::` -->
+    <rule ref="Squiz.Classes.SelfMemberReference"/>
+    <!-- Force phpDoc alignment -->
+    <rule ref="Squiz.Commenting.DocCommentAlignment">
+        <!-- Allow extra spaces after star, i.e. for indented annotations -->
+        <exclude name="Squiz.Commenting.DocCommentAlignment.SpaceAfterStar"/>
+    </rule>
+    <!-- Force rules for function phpDoc -->
+    <rule ref="Squiz.Commenting.FunctionComment">
+        <!-- Allow `@throws` without description -->
+        <exclude name="Squiz.Commenting.FunctionComment.EmptyThrows"/>
+        <!-- Does not work properly with PHP 7 / short-named types -->
+        <exclude name="Squiz.Commenting.FunctionComment.IncorrectParamVarName"/>
+        <!-- Does not support collections, i.e. `string[]` -->
+        <exclude name="Squiz.Commenting.FunctionComment.IncorrectTypeHint"/>
+        <!-- Forces incorrect types -->
+        <exclude name="Squiz.Commenting.FunctionComment.InvalidReturn"/>
+        <!-- Breaks with compound return types, i.e. `string|null` -->
+        <exclude name="Squiz.Commenting.FunctionComment.InvalidReturnNotVoid"/>
+        <!-- Breaks when all params are not documented -->
+        <exclude name="Squiz.Commenting.FunctionComment.InvalidTypeHint"/>
+        <!-- Doc comment is not required for every method -->
+        <exclude name="Squiz.Commenting.FunctionComment.Missing"/>
+        <!-- Do not require comments for `@param` -->
+        <exclude name="Squiz.Commenting.FunctionComment.MissingParamComment"/>
+        <!-- Do not require `@param` for all parameters -->
+        <exclude name="Squiz.Commenting.FunctionComment.MissingParamTag"/>
+        <!-- Do not require `@return` for void methods -->
+        <exclude name="Squiz.Commenting.FunctionComment.MissingReturn"/>
+        <!-- Comments don't have to be sentences -->
+        <exclude name="Squiz.Commenting.FunctionComment.ParamCommentFullStop"/>
+        <!-- Comments don't have to be sentences -->
+        <exclude name="Squiz.Commenting.FunctionComment.ParamCommentNotCapital"/>
+        <!-- Breaks when all params are not documented -->
+        <exclude name="Squiz.Commenting.FunctionComment.ParamNameNoMatch"/>
+        <!-- Doesn't respect inheritance -->
+        <exclude name="Squiz.Commenting.FunctionComment.ScalarTypeHintMissing"/>
+        <!-- Throws comments can start without a capital and doesn't need a full stop -->
+        <exclude name="Squiz.Commenting.FunctionComment.ThrowsNoFullStop"/>
+        <exclude name="Squiz.Commenting.FunctionComment.ThrowsNotCapital"/>
+        <!-- Doesn't work with self as typehint -->
+        <exclude name="Squiz.Commenting.FunctionComment.TypeHintMissing"/>
+    </rule>
+    <!-- Forbid `AND` and `OR`, require `&&` and `||` -->
+    <rule ref="Squiz.Operators.ValidLogicalOperators"/>
+    <!-- Forbid `global` -->
+    <rule ref="Squiz.PHP.GlobalKeyword"/>
+    <!-- Require PHP function calls in lowercase -->
+    <rule ref="Squiz.PHP.LowercasePHPFunctions"/>
+    <!-- Forbid dead code -->
+    <rule ref="Squiz.PHP.NonExecutableCode"/>
+    <!-- Forbid `$this` inside static function -->
+    <rule ref="Squiz.Scope.StaticThisUsage"/>
+    <!-- Force whitespace before and after concatenation -->
+    <rule ref="Squiz.Strings.ConcatenationSpacing">
+        <properties>
+            <property name="spacing" value="1"/>
+            <property name="ignoreNewlines" value="true"/>
+        </properties>
+    </rule>
+    <!-- Forbid strings in `"` unless necessary -->
+    <rule ref="Squiz.Strings.DoubleQuoteUsage"/>
+    <rule ref="Squiz.Strings.DoubleQuoteUsage.ContainsVar">
+        <message>Variable "%s" not allowed in double quoted string; use sprintf() or concatenation instead</message>
+    </rule>
+    <!-- Forbid braces around string in `echo` -->
+    <rule ref="Squiz.Strings.EchoedStrings"/>
+    <!-- Forbid spaces in type casts -->
+    <rule ref="Squiz.WhiteSpace.CastSpacing"/>
+    <!-- Forbid blank line after function opening brace -->
+    <rule ref="Squiz.WhiteSpace.FunctionOpeningBraceSpace"/>
+    <!-- Require space after language constructs -->
+    <rule ref="Squiz.WhiteSpace.LanguageConstructSpacing"/>
+    <!-- Require space around logical operators -->
+    <rule ref="Squiz.WhiteSpace.LogicalOperatorSpacing"/>
+    <!-- Forbid spaces around `->` operator -->
+    <rule ref="Squiz.WhiteSpace.ObjectOperatorSpacing">
+        <properties>
+            <property name="ignoreNewlines" value="true"/>
+        </properties>
+    </rule>
+    <!-- Forbid multiple spaces before and after operators -->
+    <rule ref="Squiz.WhiteSpace.OperatorSpacing">
+        <properties>
+            <property name="ignoreNewlines" value="true"/>
+        </properties>
+    </rule>
+    <!-- Forbid spaces before semicolon `;` -->
+    <rule ref="Squiz.WhiteSpace.SemicolonSpacing"/>
+    <!-- Forbid superfluous whitespaces -->
+    <rule ref="Squiz.WhiteSpace.SuperfluousWhitespace">
+        <properties>
+            <!-- turned on by PSR2 -> turning back off -->
+            <property name="ignoreBlankLines" value="false"/>
+        </properties>
+    </rule>
+    <rule ref="Squiz.WhiteSpace.SuperfluousWhitespace.EmptyLines">
+        <!-- turned off by PSR2 -> turning back on -->
+        <severity>5</severity>
+    </rule>
+</ruleset>
diff --git a/test/expected-report.txt b/test/expected-report.txt
new file mode 100644
index 00000000..84d85f92
--- /dev/null
+++ b/test/expected-report.txt
@@ -0,0 +1,38 @@
+
+PHP CODE SNIFFER REPORT SUMMARY
+----------------------------------------------------------------------
+FILE                                                  ERRORS  WARNINGS
+----------------------------------------------------------------------
+test/fixable/anonymous-classes.php                    9       0
+test/fixable/array-indentation.php                    39      1
+test/fixable/class-name-resolution.php                12      0
+test/fixable/closures.php                             19      0
+test/fixable/commenting.php                           17      0
+test/fixable/concatenation-spacing.php                15      0
+test/fixable/example-class.php                        28      0
+test/fixable/extends-and-implements-multiline.php     10      0
+test/fixable/extends-and-implements.php               5       0
+test/fixable/forbidden-comments.php                   4       0
+test/fixable/forbidden-functions.php                  6       0
+test/fixable/LowCaseTypes.php                         2       0
+test/fixable/method-and-function-arguments.php        11      0
+test/fixable/method-and-function-calls.php            13      0
+test/fixable/namespaces-spacing.php                   3       0
+test/fixable/new-with-parentheses.php                 18      0
+test/fixable/not-spacing.php                          7       0
+test/fixable/operators.php                            7       0
+test/fixable/return-type-on-methods.php               17      0
+test/fixable/semicolon-spacing.php                    3       0
+test/fixable/statement-alignment.php                  18      0
+test/fixable/test-case.php                            4       0
+test/fixable/traits-uses.php                          10      0
+test/fixable/UnusedVariables.php                      1       0
+test/fixable/useless-semicolon.php                    2       0
+test/fixable/visibility-declaration.php               1       0
+----------------------------------------------------------------------
+A TOTAL OF 281 ERRORS AND 1 WARNING WERE FOUND IN 26 FILES
+----------------------------------------------------------------------
+PHPCBF CAN FIX 249 OF THESE SNIFF VIOLATIONS AUTOMATICALLY
+----------------------------------------------------------------------
+
+
diff --git a/test/fixable/LowCaseTypes.php b/test/fixable/LowCaseTypes.php
new file mode 100644
index 00000000..41f8803b
--- /dev/null
+++ b/test/fixable/LowCaseTypes.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Types;
+
+class LowCaseTypes
+{
+    public function stringToInt(String $string) : int
+    {
+        return (int) $string;
+    }
+
+    public function returnString() : String
+    {
+        return 'foo';
+    }
+}
diff --git a/test/fixable/UnusedVariables.php b/test/fixable/UnusedVariables.php
new file mode 100644
index 00000000..a8b5c301
--- /dev/null
+++ b/test/fixable/UnusedVariables.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Example;
+
+class UnusedVariables
+{
+    public function unusedInheritedVariablePassedToClosure() : void
+    {
+        $foo = 'foo';
+
+        $bar = static function () use ($foo) : int {
+            return 1;
+        };
+    }
+}
diff --git a/test/fixable/anonymous-classes.php b/test/fixable/anonymous-classes.php
new file mode 100644
index 00000000..d5a98641
--- /dev/null
+++ b/test/fixable/anonymous-classes.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+$instance = new class {};
+
+// Brace on the same line
+$instance = new class extends \Foo implements \HandleableInterface {
+    // Class content
+};
+
+// Brace on the next line
+$instance = new class extends \Foo implements
+    \ArrayAccess,
+    \Countable,
+    \Serializable
+{
+    // Class content
+};
diff --git a/test/fixable/array-indentation.php b/test/fixable/array-indentation.php
new file mode 100644
index 00000000..765756f8
--- /dev/null
+++ b/test/fixable/array-indentation.php
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+$array = [
+0,
+ 1,
+  2,
+   3,
+    4,
+     5,
+];
+
+$bar = [
+'foo' => 1,
+    'bar' => 2,
+        'baz' => 3,
+];
+
+$singleLine = [
+    1 => 2,
+];
+$singleLine2 =  [ 'foo' => 'bar' ] ;
+
+$serializedRequest = [
+    'method' => 'POST',
+    'request_target' => '/foo/bar?baz=bat',
+    'uri' => 'http://example.com/foo/bar?baz=bat',
+    'protocol_version' => '1.1',
+    'headers' => [
+        'Host'         => ['example.com'],
+        'Accept'       => ['application/json'],
+        'X-Foo-Bar'    => [
+            'Baz',
+            'Bat',
+        ],
+    ],
+
+    'body' => '{"test":"value"}',
+];
+
+// https://github.com/zendframework/zend-diactoros/blob/69dc20275fb8b9f7f8e05d556f6c0da5f36cac64/test/ServerRequestFactoryTest.php#L392-L398
+$files              = [ 'files' => [
+    'tmp_name'   => 'php://temp',
+    'size'     =>     0,
+    'error'   =>   0,
+    'name'   =>  'foo.bar',
+    'type'  => 'text/plain',
+]];
+
+// Long lines test
+$config = [
+    'dependencies' => [
+        'factories' => [
+            App\Domain\User\UserRepository::class      =>      App\Domain\User\Persistence\DoctrineUserRepositoryFactory::class,
+            App\Http\Auth\LoginHandler::class          => App\Http\Auth\LoginHandlerFactory::class,
+            App\Http\Auth\LogoutHandler::class  =>  App\Http\Auth\LogoutHandlerFactory::class,
+
+            App\Infrastructure\View\TemplateDefaultsMiddleware::class
+            => App\Infrastructure\View\TemplateDefaultsMiddlewareFactory::class,
+            App\Http\HomePageHandler::class   =>  App\Http\HomePageHandlerFactory::class,
+            App\Http\StaticPageHandler::class =>  App\Http\StaticPageHandlerFactory::class,
+        ],
+    ],
+];
diff --git a/test/fixable/class-name-resolution.php b/test/fixable/class-name-resolution.php
new file mode 100644
index 00000000..5d228873
--- /dev/null
+++ b/test/fixable/class-name-resolution.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+class Anything
+{
+}
+
+class Whatever extends Anything
+{
+    public function magicConstant() : string
+    {
+        return __CLASS__;
+    }
+
+    public function getClassWithoutArguments() : string
+    {
+        return get_class();
+    }
+
+    public function getClassWithThis() : string
+    {
+        return get_class($this);
+    }
+
+    public function getParentClass() : string
+    {
+        return get_parent_class();
+    }
+
+    public function getCalledClass() : string
+    {
+        return get_called_class();
+    }
+
+    public function getMethodWithFullyQualifiedName() : string
+    {
+        return \get_called_class();
+    }
+}
diff --git a/test/fixable/closures.php b/test/fixable/closures.php
new file mode 100644
index 00000000..216bfe3a
--- /dev/null
+++ b/test/fixable/closures.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+$closureWithArgs = function( string $arg1, string $arg2 ) {
+    // body
+};
+
+$closureWithArgsAndVars = function ( int $arg1 , int $arg2 ) use ( $var1, $var2 ): int {
+    return $arg1 * $var1 + $arg2 * $var2;
+};
+
+static function ():void
+{
+}
+
+static function ()    :    void
+{
+}
+
+static function (
+    int $a,
+    int $c,
+    int $d,
+    int $e,
+    int $b
+):void {
+}
+
+static function (
+    int $a,
+    int $c,
+    int $d,
+    int $e,
+    int $b
+)   :   void {
+}
diff --git a/test/fixable/commenting.php b/test/fixable/commenting.php
new file mode 100644
index 00000000..53453dc2
--- /dev/null
+++ b/test/fixable/commenting.php
@@ -0,0 +1,118 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Provides a test for comments and indentation.
+ *
+ * Lorem ipsum dolor sit amet, ei usu mundi similique. Malis regione voluptatum ei vel, per no labore blandit, at
+ * duo aeque vivendo vituperata. Eu his augue postea. Dicit praesent consulatu id per, eos propriae omnesque
+ * facilisis an.
+ */
+class Commenting
+{
+    /**
+     * Sub-delimiters used in user info, query strings and fragments.
+     *
+     * @const string
+     */
+    public const CHAR_SUB_DELIMS = '!\$&\'\(\)\*\+,;=';
+
+    /**
+     *
+     * @var int[] Array indexed by valid scheme names to their corresponding ports.
+     *
+     */
+    protected $allowedSchemes = [];
+
+    /**
+     * @var string
+     */
+    private $scheme = '';
+
+    /**
+     * generated uri string cache
+     *
+     * @var string|null
+     */
+    private $uriString;
+
+    /**
+     * @param string|resource|StreamInterface $body Stream identifier and/or actual stream resource
+     * @param int $status Status code for the response, if any.
+     * @param array $headers Headers for the response, if any.
+     * @throws Exception\InvalidArgumentException on any invalid element.
+     */
+    public function __construct($body = 'php://memory', int $status = 200, array $headers = [])
+    {
+        // ..
+    }
+
+    /**
+     * Create a request from the supplied superglobal values.
+     *
+     * If any argument is not supplied, the corresponding superglobal value will
+     * be used.
+     *
+     * The ServerRequest created is then passed to the fromServer() method in
+     * order to marshal the request URI and headers.
+     *
+     * @see fromServer()
+     * @param array $server $_SERVER superglobal
+     * @param array $query $_GET superglobal
+     * @param array $body $_POST superglobal
+     * @param array $cookies $_COOKIE superglobal
+     * @param array $files $_FILES superglobal
+     * @return ServerRequest
+     */
+    public static function fromGlobals(
+        ?array $server = null,
+        ?array $query = null,
+        ?array $body = null,
+        ?array $cookies = null,
+        ?array $files = null
+    ) : ServerRequest {
+        // ...
+    }
+
+    /**
+     * Is a given port non-standard for the current scheme?
+     */
+    private function isNonStandardPort(string $scheme, string $host, ?int $port) : bool
+    {
+        // ...
+    }
+
+    /**
+     * Retrieve the user-info part of the URI.
+     *
+     * This value is percent-encoded, per RFC 3986 Section 3.2.1.
+     *
+     * {@inheritdoc}
+     */
+    public function getUserInfo() : string
+    {
+        // ...
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getHost() : string
+    {
+        // ...
+    }
+
+    /**
+     * Filters a part of user info in a URI to ensure it is properly encoded.
+     *
+     * @param string $part
+     * @return string
+     */
+    private function filterUserInfoPart(string $part) : string
+    {
+        // Note the addition of `%` to initial charset; this allows `|` portion
+        // to match and thus prevent double-encoding.
+        return 'foo';
+    }
+}
diff --git a/test/fixable/concatenation-spacing.php b/test/fixable/concatenation-spacing.php
new file mode 100644
index 00000000..2fb62d07
--- /dev/null
+++ b/test/fixable/concatenation-spacing.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+$string = 'Hello'.$there.'. How are'.$you.$going.   "today $okay";
+$string = 'Hello' . $there . '. How are' . $you . $going . "today $okay";
+$string = 'Hello'.$there;
+$string = 'Hello'. $there;
+$string = 'Hello' .$there;
+
+$foo = 'foo';
+$bar    = 'bar';
+
+$string  = $foo . $bar. 'baz' .'quux'.$string;
+$string .= $foo;
+$string .= $foo;
+$string .= $foo;
+
+$string = '1'
+          . '2'
+      . '3';
+
+$string = '1' .
+          '2' .
+          '3';
diff --git a/test/fixable/example-class.php b/test/fixable/example-class.php
new file mode 100644
index 00000000..70f746e1
--- /dev/null
+++ b/test/fixable/example-class.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace Example;
+
+use function strlen as stringLength;
+use Fancy\TestCase as TestCase;
+use const PHP_RELEASE_VERSION as PHP_PATCH_VERSION;
+
+/**
+ * Description
+ * @author Invalid
+ */
+class Example implements \IteratorAggregate
+{
+    private const VERSION = \PHP_VERSION - (PHP_MINOR_VERSION * 100) - PHP_PATCH_VERSION;
+    public const ID     = 'id';
+    public const SKU = 'sku';
+
+    /**
+     * @var null|int
+     */
+    private $foo;
+
+    /**
+     * @var string[]
+     */
+    private $bar;
+
+    /**
+     * @var bool
+     */
+    private $baz;
+
+    /**
+     * @var int|string|null
+     */
+    private $baxBax;
+
+    public function __construct(int $foo = null, array $bar = [], bool $baz = false, $baxBax = 'unused')
+    {
+        $this->foo    = $foo;
+        $this->bar    = $bar;
+        $this->baz    = $baz;
+        $this->baxBax = $baxBax;
+    }
+
+    /**
+     * Description
+     */
+    public function getFoo(): ? int
+    {
+        return $this->foo;
+    }
+
+    /**
+     * @return iterable
+     */
+    public function getIterator():array
+    {
+        assert($this->bar !== null);
+        return new \ArrayIterator($this->bar);
+    }
+
+    public function isBaz() : bool
+    {
+        list($foo, $bar, $baz) = $this->bar;
+
+        return $this->baz;
+    }
+
+    public function mangleBar(int $length) : void
+    {
+        if (!$this->baz) {
+            throw new \InvalidArgumentException();
+        }
+
+        $this->bar = (string) $this->baxBax ?? \substr($this->bar, stringLength($this->bar - $length));
+    }
+
+    public static function getMinorVersion() : int
+    {
+        $version = self::VERSION;
+
+        return $version;
+    }
+
+    public static function getTestCase() : TestCase
+    {
+        return new TestCase();
+    }
+}
diff --git a/test/fixable/extends-and-implements-multiline.php b/test/fixable/extends-and-implements-multiline.php
new file mode 100644
index 00000000..fa85e018
--- /dev/null
+++ b/test/fixable/extends-and-implements-multiline.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vendor\Package;
+
+use ParentClass;
+use BarClass as Bar;
+use OtherVendor\OtherPackage\BazClass;
+use ArrayAccess;
+use Countable;
+use Serializable;
+
+class ClassName extends ParentClass implements
+    \ArrayAccess,
+    \Countable,
+    \Serializable
+{
+    // constants, properties, methods
+}
diff --git a/test/fixable/extends-and-implements.php b/test/fixable/extends-and-implements.php
new file mode 100644
index 00000000..a010af65
--- /dev/null
+++ b/test/fixable/extends-and-implements.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace Vendor\Package;
+
+use FooClass;
+use BarClass as Bar;
+use OtherVendor\OtherPackage\BazClass;
+
+class ClassName extends BazClass implements \ArrayAccess, \Countable
+{
+    public function __construct(FooClass $foo, Bar $bar)
+    {
+        // ...
+    }
+}
diff --git a/test/fixable/forbidden-comments.php b/test/fixable/forbidden-comments.php
new file mode 100644
index 00000000..24112344
--- /dev/null
+++ b/test/fixable/forbidden-comments.php
@@ -0,0 +1,34 @@
+<?php
+
+/** Created by PhpStorm. */
+
+declare(strict_types=1);
+
+namespace Test;
+
+class Foo
+{
+    /**
+     * Constructor.
+     */
+    public function __construct()
+    {
+        echo 'Hello';
+    }
+
+    /**
+     * Bar getter.
+     */
+    public function getBar() : int
+    {
+        return 123;
+    }
+
+    /**
+     * Very important getter.
+     */
+    public function getBaz() : int
+    {
+        return 456;
+    }
+}
diff --git a/test/fixable/forbidden-functions.php b/test/fixable/forbidden-functions.php
new file mode 100644
index 00000000..f951ca36
--- /dev/null
+++ b/test/fixable/forbidden-functions.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Test;
+
+use function chop;
+use function compact;
+use function extract;
+use function is_null;
+use function settype;
+use function sizeof;
+use function var_dump;
+
+echo chop('abc ');
+echo sizeof([1, 2, 3]);
+echo is_null(456) ? 'y' : 'n';
+
+$foo = '1';
+settype($foo, 'int');
+var_dump($foo);
+
+$bar = [
+    'foo' => 1,
+    'bar' => 2,
+    'baz' => 3,
+];
+extract($bar);
+
+compact('foo', 'bar');
diff --git a/test/fixable/method-and-function-arguments.php b/test/fixable/method-and-function-arguments.php
new file mode 100644
index 00000000..31ff340f
--- /dev/null
+++ b/test/fixable/method-and-function-arguments.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MethodsAndFunctionArguments;
+
+class ClassName
+{
+    public function foo(int $arg1, &$arg2, $arg3 = []):void
+    {
+    }
+
+    public function aVeryLongMethodName(
+        ClassTypeHint $arg1,
+        &$arg2,
+        array $arg3 = []
+    )  :  array {
+        return [];
+    }
+
+    public function functionName(int $arg1, $arg2): string
+    {
+        return'foo';
+    }
+
+    public function anotherFunction(
+        string $foo,
+        string $bar,
+        int $baz
+    ) : string {
+        return 'foo';
+    }
+
+    public function returnTypeVariations(string $arg1 = null, string $arg2 = null):?string
+    {
+        return $arg1 ?? $arg2;
+    }
+}
diff --git a/test/fixable/method-and-function-calls.php b/test/fixable/method-and-function-calls.php
new file mode 100644
index 00000000..81f51280
--- /dev/null
+++ b/test/fixable/method-and-function-calls.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+bar ( );
+$foo->bar ( $arg1 );
+Foo::bar ($arg2 , $arg3) ;
+
+$foo->bar(
+    $longArgument,
+    $longerArgument,
+    $muchLongerArgument
+);
+
+somefunction($foo, $bar, [
+    // ...
+], $baz);
+
+$app->get ('/hello/{name}' , function ($name) use ($app) {
+
+    return 'Hello ' . $app->escape($name);
+
+});
diff --git a/test/fixable/namespaces-spacing.php b/test/fixable/namespaces-spacing.php
new file mode 100644
index 00000000..430900ad
--- /dev/null
+++ b/test/fixable/namespaces-spacing.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Foo;
+
+use DateInterval;
+use DateTimeImmutable;
+use DateTimeZone;
+use const DATE_RFC3339;
+use function strrev;
+use function time;
+
+strrev(
+    (new DateTimeImmutable('@' . time(), new DateTimeZone('UTC')))
+        ->sub(new DateInterval('P1D'))
+        ->format(DATE_RFC3339)
+);
diff --git a/test/fixable/new-with-parentheses.php b/test/fixable/new-with-parentheses.php
new file mode 100644
index 00000000..5bdcbb0e
--- /dev/null
+++ b/test/fixable/new-with-parentheses.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+$foo = new \DateTimeImmutable;
+
+$barClassName = 'Bar';
+$bar = new $barClassName;
+
+$classNamesInArray = ['Baz'];
+$foo = new $classNamesInArray[0];
+
+$classNamesInObject = new stdClass();
+$classNamesInObject->foo = 'Foo';
+$foo = new $classNamesInObject->foo;
+
+$whitespaceBetweenClassNameAndParentheses = new stdClass   ;
+
+$x = [
+    new stdClass,
+];
+
+$y = [new stdClass];
+
+$z = new stdClass ? new stdClass : new stdClass;
+
+$q = $q ?: new stdClass;
+$e = $e ?? new stdClass;
+
+// The parentheses around `(new Response())` should not be removed
+// https://github.com/slevomat/coding-standard/issues/478
+$response = (new Response())
+    ->withStatus(200)
+    ->withAddedHeader('Content-Type', 'text/plain');
diff --git a/test/fixable/not-spacing.php b/test/fixable/not-spacing.php
new file mode 100644
index 00000000..d172d8b3
--- /dev/null
+++ b/test/fixable/not-spacing.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+$test = 1;
+
+if (!$test > 0) {
+    echo 1;
+} elseif ( !$test === 0) {
+    echo 0;
+} else {
+    echo 2;
+}
+
+while (    !    true) {
+    echo 1;
+}
+
+do {
+    echo 1;
+} while (    !    true);
diff --git a/test/fixable/operators.php b/test/fixable/operators.php
new file mode 100644
index 00000000..10758ba9
--- /dev/null
+++ b/test/fixable/operators.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+$foo = $foo . '';
+
+$bar = $bar + Something::count();
+
+$baz = $baz ** 2;
+
+$quux = $quux | Something::FOO;
+
+if ($a === $b) {
+    $foo = $bar ?? $a ?? $b;
+} elseif ($a > $b) {
+    $variable = $foo ? 'foo' : 'bar';
+}
+
+$foo = isset($_GET['foo']) ? $_GET['foo'] : 'foo';
+
+$bar = isset($bar) ? $bar : 'bar';
+
+$bar = isset($bar['baz']) ? $bar['baz'] : 'baz';
+
+if (isset($foo)) {
+    $bar = $foo;
+} else {
+    $bar = 'foo';
+}
+
+$fooBar = isset($foo, $bar) ? 'foo' : 'bar';
+
+$baz = ! isset($foo) ? 'foo' : 'baz';
diff --git a/test/fixable/return-type-on-methods.php b/test/fixable/return-type-on-methods.php
new file mode 100644
index 00000000..58bdb665
--- /dev/null
+++ b/test/fixable/return-type-on-methods.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Blah;
+
+class Test
+{
+    public function a():void
+    {
+    }
+
+    public function b(): void
+    {
+    }
+
+    public function c():     void
+    {
+    }
+
+    public function d() :void
+    {
+    }
+
+    public function e()     :void
+    {
+    }
+
+    public function f(
+        int $a,
+        int $c,
+        int $d,
+        int $e,
+        int $b
+    ):void {
+    }
+
+    public function g(
+        int $a,
+        int $c,
+        int $d,
+        int $e,
+        int $b
+    ) :void {
+    }
+
+    public function h(
+        int $a,
+        int $c,
+        int $d,
+        int $e,
+        int $b
+    )     :void {
+    }
+
+    public function i(
+        int $a,
+        int $c,
+        int $d,
+        int $e,
+        int $b
+    ): void {
+    }
+
+    public function j(
+        int $a,
+        int $c,
+        int $d,
+        int $e,
+        int $b
+    ):     void {
+    }
+}
diff --git a/test/fixable/semicolon-spacing.php b/test/fixable/semicolon-spacing.php
new file mode 100644
index 00000000..679f8100
--- /dev/null
+++ b/test/fixable/semicolon-spacing.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+echo 1    ;
+
+echo 'foo'
+;
+
+$qb->select()
+    ->from()
+    ->where()
+;
diff --git a/test/fixable/statement-alignment.php b/test/fixable/statement-alignment.php
new file mode 100644
index 00000000..14f5a601
--- /dev/null
+++ b/test/fixable/statement-alignment.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+$shortVar    = (1 + 2);
+$veryLongVarName   = 'string';
+
+$value      =     (string) $value;
+$length     =     strlen($value);
+$string     =     '';
+
+$headerNames[$normalized]   =   $header;
+$headers[$header]=   $value;
+
+$normalized   =strtolower($header);
+$original=$headerNames[$normalized];
diff --git a/test/fixable/test-case.php b/test/fixable/test-case.php
new file mode 100644
index 00000000..7f6521b4
--- /dev/null
+++ b/test/fixable/test-case.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fancy;
+
+use PHPUnit\Framework\TestCase as BaseTestCase;
+
+/**
+ * @package Quite useless
+ *
+ * @requires PHP 7.2
+ */
+final class TestCase extends BaseTestCase
+{
+    /**
+     * @beforeClass
+     * @afterClass
+     */
+    static public function doStuff(): void
+    {
+    }
+
+    /**
+     * @before
+     */
+    public function createDependencies()
+    {
+    }
+
+    /**
+     * @test
+     *
+     * @covers MyClass::test
+     *
+     * @uses MyClass::__construct
+     */
+    public function methodShouldDoStuff()
+    {
+    }
+}
diff --git a/test/fixable/traits-uses.php b/test/fixable/traits-uses.php
new file mode 100644
index 00000000..7db12ad3
--- /dev/null
+++ b/test/fixable/traits-uses.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TraitsUses;
+
+class Foo
+{
+    use FirstTrait;
+
+}
+
+class Bar
+{
+    use FirstTrait, SecondTrait;
+
+    use ThirdTrait {
+        x as public;
+    }
+
+    use FourthTrait;
+    public function __construct()
+    {
+    }
+}
diff --git a/test/fixable/useless-semicolon.php b/test/fixable/useless-semicolon.php
new file mode 100644
index 00000000..66149f36
--- /dev/null
+++ b/test/fixable/useless-semicolon.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+while (! true) {
+    echo 1;
+};
+
+do {
+    echo 1;
+} while (! false);
+
+for (;;) {
+    echo 'To infity and beyond';
+};
diff --git a/test/fixable/visibility-declaration.php b/test/fixable/visibility-declaration.php
new file mode 100644
index 00000000..bdba45df
--- /dev/null
+++ b/test/fixable/visibility-declaration.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace VisibilityDeclaration;
+
+abstract class ClassName
+{
+    protected static $foo;
+
+    abstract protected function zim() : string;
+
+    final public static function bar() : ClassName
+    {
+        // method body
+    }
+}
diff --git a/test/fixed/LowCaseTypes.php b/test/fixed/LowCaseTypes.php
new file mode 100644
index 00000000..4782ba1c
--- /dev/null
+++ b/test/fixed/LowCaseTypes.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Types;
+
+class LowCaseTypes
+{
+    public function stringToInt(string $string) : int
+    {
+        return (int) $string;
+    }
+
+    public function returnString() : string
+    {
+        return 'foo';
+    }
+}
diff --git a/test/fixed/UnusedVariables.php b/test/fixed/UnusedVariables.php
new file mode 100644
index 00000000..67e8500e
--- /dev/null
+++ b/test/fixed/UnusedVariables.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Example;
+
+class UnusedVariables
+{
+    public function unusedInheritedVariablePassedToClosure() : void
+    {
+        $foo = 'foo';
+
+        $bar = static function () : int {
+            return 1;
+        };
+    }
+}
diff --git a/test/fixed/anonymous-classes.php b/test/fixed/anonymous-classes.php
new file mode 100644
index 00000000..8fcfaa95
--- /dev/null
+++ b/test/fixed/anonymous-classes.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+$instance = new class {
+};
+
+// Brace on the same line
+$instance = new class extends Foo implements HandleableInterface {
+    // Class content
+};
+
+// Brace on the next line
+$instance = new class extends Foo implements
+    ArrayAccess,
+    Countable,
+    Serializable
+{
+    // Class content
+};
diff --git a/test/fixed/array-indentation.php b/test/fixed/array-indentation.php
new file mode 100644
index 00000000..4ccaa3d8
--- /dev/null
+++ b/test/fixed/array-indentation.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+$array = [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+];
+
+$bar = [
+    'foo' => 1,
+    'bar' => 2,
+    'baz' => 3,
+];
+
+$singleLine  = [
+    1 => 2,
+];
+$singleLine2 = ['foo' => 'bar'];
+
+$serializedRequest = [
+    'method'           => 'POST',
+    'request_target'   => '/foo/bar?baz=bat',
+    'uri'              => 'http://example.com/foo/bar?baz=bat',
+    'protocol_version' => '1.1',
+    'headers'          => [
+        'Host'      => ['example.com'],
+        'Accept'    => ['application/json'],
+        'X-Foo-Bar' => [
+            'Baz',
+            'Bat',
+        ],
+    ],
+
+    'body' => '{"test":"value"}',
+];
+
+// https://github.com/zendframework/zend-diactoros/blob/69dc20275fb8b9f7f8e05d556f6c0da5f36cac64/test/ServerRequestFactoryTest.php#L392-L398
+$files = [
+    'files' => [
+        'tmp_name' => 'php://temp',
+        'size'     => 0,
+        'error'    => 0,
+        'name'     => 'foo.bar',
+        'type'     => 'text/plain',
+    ],
+];
+
+// Long lines test
+$config = [
+    'dependencies' => [
+        'factories' => [
+            App\Domain\User\UserRepository::class => App\Domain\User\Persistence\DoctrineUserRepositoryFactory::class,
+            App\Http\Auth\LoginHandler::class     => App\Http\Auth\LoginHandlerFactory::class,
+            App\Http\Auth\LogoutHandler::class    => App\Http\Auth\LogoutHandlerFactory::class,
+
+            App\Infrastructure\View\TemplateDefaultsMiddleware::class
+            => App\Infrastructure\View\TemplateDefaultsMiddlewareFactory::class,
+            App\Http\HomePageHandler::class   => App\Http\HomePageHandlerFactory::class,
+            App\Http\StaticPageHandler::class => App\Http\StaticPageHandlerFactory::class,
+        ],
+    ],
+];
diff --git a/test/fixed/class-name-resolution.php b/test/fixed/class-name-resolution.php
new file mode 100644
index 00000000..0ffdd44b
--- /dev/null
+++ b/test/fixed/class-name-resolution.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+class Anything
+{
+}
+
+class Whatever extends Anything
+{
+    public function magicConstant() : string
+    {
+        return self::class;
+    }
+
+    public function getClassWithoutArguments() : string
+    {
+        return self::class;
+    }
+
+    public function getClassWithThis() : string
+    {
+        return static::class;
+    }
+
+    public function getParentClass() : string
+    {
+        return parent::class;
+    }
+
+    public function getCalledClass() : string
+    {
+        return static::class;
+    }
+
+    public function getMethodWithFullyQualifiedName() : string
+    {
+        return static::class;
+    }
+}
diff --git a/test/fixed/closures.php b/test/fixed/closures.php
new file mode 100644
index 00000000..9fde60bc
--- /dev/null
+++ b/test/fixed/closures.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+$closureWithArgs = function (string $arg1, string $arg2) {
+    // body
+};
+
+$closureWithArgsAndVars = function (int $arg1, int $arg2) use ($var1, $var2) : int {
+    return $arg1 * $var1 + $arg2 * $var2;
+};
+
+static function () : void {
+}
+
+static function () : void {
+}
+
+static function (
+    int $a,
+    int $c,
+    int $d,
+    int $e,
+    int $b
+) : void {
+}
+
+static function (
+    int $a,
+    int $c,
+    int $d,
+    int $e,
+    int $b
+) : void {
+}
diff --git a/test/fixed/commenting.php b/test/fixed/commenting.php
new file mode 100644
index 00000000..db40a2b3
--- /dev/null
+++ b/test/fixed/commenting.php
@@ -0,0 +1,112 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Provides a test for comments and indentation.
+ *
+ * Lorem ipsum dolor sit amet, ei usu mundi similique. Malis regione voluptatum ei vel, per no labore blandit, at
+ * duo aeque vivendo vituperata. Eu his augue postea. Dicit praesent consulatu id per, eos propriae omnesque
+ * facilisis an.
+ */
+class Commenting
+{
+    /**
+     * Sub-delimiters used in user info, query strings and fragments.
+     *
+     * @const string
+     */
+    public const CHAR_SUB_DELIMS = '!\$&\'\(\)\*\+,;=';
+
+    /** @var int[] Array indexed by valid scheme names to their corresponding ports. */
+    protected $allowedSchemes = [];
+
+    /** @var string */
+    private $scheme = '';
+
+    /**
+     * generated uri string cache
+     *
+     * @var string|null
+     */
+    private $uriString;
+
+    /**
+     * @param string|resource|StreamInterface $body    Stream identifier and/or actual stream resource
+     * @param int                             $status  Status code for the response, if any.
+     * @param array                           $headers Headers for the response, if any.
+     * @throws Exception\InvalidArgumentException on any invalid element.
+     */
+    public function __construct($body = 'php://memory', int $status = 200, array $headers = [])
+    {
+        // ..
+    }
+
+    /**
+     * Create a request from the supplied superglobal values.
+     *
+     * If any argument is not supplied, the corresponding superglobal value will
+     * be used.
+     *
+     * The ServerRequest created is then passed to the fromServer() method in
+     * order to marshal the request URI and headers.
+     *
+     * @see fromServer()
+     * @param array $server  $_SERVER superglobal
+     * @param array $query   $_GET superglobal
+     * @param array $body    $_POST superglobal
+     * @param array $cookies $_COOKIE superglobal
+     * @param array $files   $_FILES superglobal
+     * @return ServerRequest
+     */
+    public static function fromGlobals(
+        ?array $server = null,
+        ?array $query = null,
+        ?array $body = null,
+        ?array $cookies = null,
+        ?array $files = null
+    ) : ServerRequest {
+        // ...
+    }
+
+    /**
+     * Is a given port non-standard for the current scheme?
+     */
+    private function isNonStandardPort(string $scheme, string $host, ?int $port) : bool
+    {
+        // ...
+    }
+
+    /**
+     * Retrieve the user-info part of the URI.
+     *
+     * This value is percent-encoded, per RFC 3986 Section 3.2.1.
+     *
+     * {@inheritdoc}
+     */
+    public function getUserInfo() : string
+    {
+        // ...
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getHost() : string
+    {
+        // ...
+    }
+
+    /**
+     * Filters a part of user info in a URI to ensure it is properly encoded.
+     *
+     * @param string $part
+     * @return string
+     */
+    private function filterUserInfoPart(string $part) : string
+    {
+        // Note the addition of `%` to initial charset; this allows `|` portion
+        // to match and thus prevent double-encoding.
+        return 'foo';
+    }
+}
diff --git a/test/fixed/concatenation-spacing.php b/test/fixed/concatenation-spacing.php
new file mode 100644
index 00000000..90b46036
--- /dev/null
+++ b/test/fixed/concatenation-spacing.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+$string = 'Hello' . $there . '. How are' . $you . $going . "today $okay";
+$string = 'Hello' . $there . '. How are' . $you . $going . "today $okay";
+$string = 'Hello' . $there;
+$string = 'Hello' . $there;
+$string = 'Hello' . $there;
+
+$foo = 'foo';
+$bar = 'bar';
+
+$string  = $foo . $bar . 'baz' . 'quux' . $string;
+$string .= $foo;
+$string .= $foo;
+$string .= $foo;
+
+$string = '1'
+          . '2'
+      . '3';
+
+$string = '1' .
+          '2' .
+          '3';
diff --git a/test/fixed/example-class.php b/test/fixed/example-class.php
new file mode 100644
index 00000000..dcfe0644
--- /dev/null
+++ b/test/fixed/example-class.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Example;
+
+use ArrayIterator;
+use Fancy\TestCase;
+use InvalidArgumentException;
+use IteratorAggregate;
+
+use function assert;
+use function strlen as stringLength;
+use function substr;
+
+use const PHP_MINOR_VERSION;
+use const PHP_RELEASE_VERSION as PHP_PATCH_VERSION;
+use const PHP_VERSION;
+
+/**
+ * Description
+ */
+class Example implements IteratorAggregate
+{
+    private const VERSION = PHP_VERSION - (PHP_MINOR_VERSION * 100) - PHP_PATCH_VERSION;
+    public const ID       = 'id';
+    public const SKU      = 'sku';
+
+    /** @var null|int */
+    private $foo;
+
+    /** @var string[] */
+    private $bar;
+
+    /** @var bool */
+    private $baz;
+
+    /** @var int|string|null */
+    private $baxBax;
+
+    public function __construct(?int $foo = null, array $bar = [], bool $baz = false, $baxBax = 'unused')
+    {
+        $this->foo    = $foo;
+        $this->bar    = $bar;
+        $this->baz    = $baz;
+        $this->baxBax = $baxBax;
+    }
+
+    /**
+     * Description
+     */
+    public function getFoo() : ?int
+    {
+        return $this->foo;
+    }
+
+    /**
+     * @return iterable
+     */
+    public function getIterator() : array
+    {
+        assert($this->bar !== null);
+        return new ArrayIterator($this->bar);
+    }
+
+    public function isBaz() : bool
+    {
+        [$foo, $bar, $baz] = $this->bar;
+
+        return $this->baz;
+    }
+
+    public function mangleBar(int $length) : void
+    {
+        if (! $this->baz) {
+            throw new InvalidArgumentException();
+        }
+
+        $this->bar = (string) $this->baxBax ?? substr($this->bar, stringLength($this->bar - $length));
+    }
+
+    public static function getMinorVersion() : int
+    {
+        return self::VERSION;
+    }
+
+    public static function getTestCase() : TestCase
+    {
+        return new TestCase();
+    }
+}
diff --git a/test/fixed/extends-and-implements-multiline.php b/test/fixed/extends-and-implements-multiline.php
new file mode 100644
index 00000000..7de04ad8
--- /dev/null
+++ b/test/fixed/extends-and-implements-multiline.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vendor\Package;
+
+use ArrayAccess;
+use Countable;
+use ParentClass;
+use Serializable;
+
+class ClassName extends ParentClass implements
+    ArrayAccess,
+    Countable,
+    Serializable
+{
+    // constants, properties, methods
+}
diff --git a/test/fixed/extends-and-implements.php b/test/fixed/extends-and-implements.php
new file mode 100644
index 00000000..2a8a2800
--- /dev/null
+++ b/test/fixed/extends-and-implements.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Vendor\Package;
+
+use ArrayAccess;
+use BarClass as Bar;
+use Countable;
+use FooClass;
+use OtherVendor\OtherPackage\BazClass;
+
+class ClassName extends BazClass implements ArrayAccess, Countable
+{
+    public function __construct(FooClass $foo, Bar $bar)
+    {
+        // ...
+    }
+}
diff --git a/test/fixed/forbidden-comments.php b/test/fixed/forbidden-comments.php
new file mode 100644
index 00000000..67029f24
--- /dev/null
+++ b/test/fixed/forbidden-comments.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Test;
+
+class Foo
+{
+    public function __construct()
+    {
+        echo 'Hello';
+    }
+
+    public function getBar() : int
+    {
+        return 123;
+    }
+
+    /**
+     * Very important getter.
+     */
+    public function getBaz() : int
+    {
+        return 456;
+    }
+}
diff --git a/test/fixed/forbidden-functions.php b/test/fixed/forbidden-functions.php
new file mode 100644
index 00000000..f951ca36
--- /dev/null
+++ b/test/fixed/forbidden-functions.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Test;
+
+use function chop;
+use function compact;
+use function extract;
+use function is_null;
+use function settype;
+use function sizeof;
+use function var_dump;
+
+echo chop('abc ');
+echo sizeof([1, 2, 3]);
+echo is_null(456) ? 'y' : 'n';
+
+$foo = '1';
+settype($foo, 'int');
+var_dump($foo);
+
+$bar = [
+    'foo' => 1,
+    'bar' => 2,
+    'baz' => 3,
+];
+extract($bar);
+
+compact('foo', 'bar');
diff --git a/test/fixed/method-and-function-arguments.php b/test/fixed/method-and-function-arguments.php
new file mode 100644
index 00000000..c2d6ac79
--- /dev/null
+++ b/test/fixed/method-and-function-arguments.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MethodsAndFunctionArguments;
+
+class ClassName
+{
+    public function foo(int $arg1, &$arg2, $arg3 = []) : void
+    {
+    }
+
+    public function aVeryLongMethodName(
+        ClassTypeHint $arg1,
+        &$arg2,
+        array $arg3 = []
+    ) : array {
+        return [];
+    }
+
+    public function functionName(int $arg1, $arg2) : string
+    {
+        return 'foo';
+    }
+
+    public function anotherFunction(
+        string $foo,
+        string $bar,
+        int $baz
+    ) : string {
+        return 'foo';
+    }
+
+    public function returnTypeVariations(?string $arg1 = null, ?string $arg2 = null) : ?string
+    {
+        return $arg1 ?? $arg2;
+    }
+}
diff --git a/test/fixed/method-and-function-calls.php b/test/fixed/method-and-function-calls.php
new file mode 100644
index 00000000..5f90cf36
--- /dev/null
+++ b/test/fixed/method-and-function-calls.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+bar();
+$foo->bar($arg1);
+Foo::bar($arg2, $arg3);
+
+$foo->bar(
+    $longArgument,
+    $longerArgument,
+    $muchLongerArgument
+);
+
+somefunction($foo, $bar, [
+    // ...
+], $baz);
+
+$app->get('/hello/{name}', function ($name) use ($app) {
+    return 'Hello ' . $app->escape($name);
+});
diff --git a/test/fixed/namespaces-spacing.php b/test/fixed/namespaces-spacing.php
new file mode 100644
index 00000000..d42bbfef
--- /dev/null
+++ b/test/fixed/namespaces-spacing.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Foo;
+
+use DateInterval;
+use DateTimeImmutable;
+use DateTimeZone;
+
+use function strrev;
+use function time;
+
+use const DATE_RFC3339;
+
+strrev(
+    (new DateTimeImmutable('@' . time(), new DateTimeZone('UTC')))
+        ->sub(new DateInterval('P1D'))
+        ->format(DATE_RFC3339)
+);
diff --git a/test/fixed/new-with-parentheses.php b/test/fixed/new-with-parentheses.php
new file mode 100644
index 00000000..4684f85c
--- /dev/null
+++ b/test/fixed/new-with-parentheses.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+$foo = new DateTimeImmutable();
+
+$barClassName = 'Bar';
+$bar          = new $barClassName();
+
+$classNamesInArray = ['Baz'];
+$foo               = new $classNamesInArray[0]();
+
+$classNamesInObject      = new stdClass();
+$classNamesInObject->foo = 'Foo';
+$foo                     = new $classNamesInObject->foo();
+
+$whitespaceBetweenClassNameAndParentheses = new stdClass();
+
+$x = [
+    new stdClass(),
+];
+
+$y = [new stdClass()];
+
+$z = new stdClass() ? new stdClass() : new stdClass();
+
+$q = $q ?: new stdClass();
+$e = $e ?? new stdClass();
+
+// The parentheses around `(new Response())` should not be removed
+// https://github.com/slevomat/coding-standard/issues/478
+$response = (new Response())
+    ->withStatus(200)
+    ->withAddedHeader('Content-Type', 'text/plain');
diff --git a/test/fixed/not-spacing.php b/test/fixed/not-spacing.php
new file mode 100644
index 00000000..b0942488
--- /dev/null
+++ b/test/fixed/not-spacing.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+$test = 1;
+
+if (! $test > 0) {
+    echo 1;
+} elseif (! $test === 0) {
+    echo 0;
+} else {
+    echo 2;
+}
+
+while (! true) {
+    echo 1;
+}
+
+do {
+    echo 1;
+} while (! true);
diff --git a/test/fixed/operators.php b/test/fixed/operators.php
new file mode 100644
index 00000000..6addab0b
--- /dev/null
+++ b/test/fixed/operators.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+$foo .= '';
+
+$bar += Something::count();
+
+$baz **= 2;
+
+$quux |= Something::FOO;
+
+if ($a === $b) {
+    $foo = $bar ?? $a ?? $b;
+} elseif ($a > $b) {
+    $variable = $foo ? 'foo' : 'bar';
+}
+
+$foo = $_GET['foo'] ?? 'foo';
+
+$bar = $bar ?? 'bar';
+
+$bar = $bar['baz'] ?? 'baz';
+
+if (isset($foo)) {
+    $bar = $foo;
+} else {
+    $bar = 'foo';
+}
+
+$fooBar = isset($foo, $bar) ? 'foo' : 'bar';
+
+$baz = ! isset($foo) ? 'foo' : 'baz';
diff --git a/test/fixed/return-type-on-methods.php b/test/fixed/return-type-on-methods.php
new file mode 100644
index 00000000..67c377fa
--- /dev/null
+++ b/test/fixed/return-type-on-methods.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Blah;
+
+class Test
+{
+    public function a() : void
+    {
+    }
+
+    public function b() : void
+    {
+    }
+
+    public function c() : void
+    {
+    }
+
+    public function d() : void
+    {
+    }
+
+    public function e() : void
+    {
+    }
+
+    public function f(
+        int $a,
+        int $c,
+        int $d,
+        int $e,
+        int $b
+    ) : void {
+    }
+
+    public function g(
+        int $a,
+        int $c,
+        int $d,
+        int $e,
+        int $b
+    ) : void {
+    }
+
+    public function h(
+        int $a,
+        int $c,
+        int $d,
+        int $e,
+        int $b
+    ) : void {
+    }
+
+    public function i(
+        int $a,
+        int $c,
+        int $d,
+        int $e,
+        int $b
+    ) : void {
+    }
+
+    public function j(
+        int $a,
+        int $c,
+        int $d,
+        int $e,
+        int $b
+    ) : void {
+    }
+}
diff --git a/test/fixed/semicolon-spacing.php b/test/fixed/semicolon-spacing.php
new file mode 100644
index 00000000..3b198671
--- /dev/null
+++ b/test/fixed/semicolon-spacing.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+echo 1;
+
+echo 'foo';
+
+$qb->select()
+    ->from()
+    ->where();
diff --git a/test/fixed/statement-alignment.php b/test/fixed/statement-alignment.php
new file mode 100644
index 00000000..018efa9e
--- /dev/null
+++ b/test/fixed/statement-alignment.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+$shortVar        = (1 + 2);
+$veryLongVarName = 'string';
+
+$value  = (string) $value;
+$length = strlen($value);
+$string = '';
+
+$headerNames[$normalized] = $header;
+$headers[$header]         = $value;
+
+$normalized = strtolower($header);
+$original   = $headerNames[$normalized];
diff --git a/test/fixed/test-case.php b/test/fixed/test-case.php
new file mode 100644
index 00000000..9158171e
--- /dev/null
+++ b/test/fixed/test-case.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fancy;
+
+use PHPUnit\Framework\TestCase as BaseTestCase;
+
+/**
+ * @requires PHP 7.2
+ */
+final class TestCase extends BaseTestCase
+{
+    /**
+     * @beforeClass
+     * @afterClass
+     */
+    public static function doStuff() : void
+    {
+    }
+
+    /**
+     * @before
+     */
+    public function createDependencies()
+    {
+    }
+
+    /**
+     * @test
+     *
+     * @covers MyClass::test
+     *
+     * @uses MyClass::__construct
+     */
+    public function methodShouldDoStuff()
+    {
+    }
+}
diff --git a/test/fixed/traits-uses.php b/test/fixed/traits-uses.php
new file mode 100644
index 00000000..d071db8b
--- /dev/null
+++ b/test/fixed/traits-uses.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TraitsUses;
+
+class Foo
+{
+    use FirstTrait;
+}
+
+class Bar
+{
+    use FirstTrait;
+    use SecondTrait;
+    use ThirdTrait {
+        x as public;
+    }
+    use FourthTrait;
+
+    public function __construct()
+    {
+    }
+}
diff --git a/test/fixed/useless-semicolon.php b/test/fixed/useless-semicolon.php
new file mode 100644
index 00000000..358277bd
--- /dev/null
+++ b/test/fixed/useless-semicolon.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+while (! true) {
+    echo 1;
+}
+
+do {
+    echo 1;
+} while (! false);
+
+for (;;) {
+    echo 'To infity and beyond';
+}
diff --git a/test/fixed/visibility-declaration.php b/test/fixed/visibility-declaration.php
new file mode 100644
index 00000000..bdba45df
--- /dev/null
+++ b/test/fixed/visibility-declaration.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace VisibilityDeclaration;
+
+abstract class ClassName
+{
+    protected static $foo;
+
+    abstract protected function zim() : string;
+
+    final public static function bar() : ClassName
+    {
+        // method body
+    }
+}