├── bin
    ├── box
    ├── phpunit
    ├── build-image.sh
    ├── php-cs-fixer
    ├── php-cli.sh
    ├── build.sh
    └── idx
├── docs
    ├── cookbook.rst
    ├── _themes
    │   └── sphinx_rtd_theme
    │   │   ├── static
    │   │       ├── fonts
    │   │       │   ├── Lato-Bold.ttf
    │   │       │   ├── FontAwesome.otf
    │   │       │   ├── Lato-Regular.ttf
    │   │       │   ├── RobotoSlab-Bold.ttf
    │   │       │   ├── Inconsolata-Bold.ttf
    │   │       │   ├── RobotoSlab-Regular.ttf
    │   │       │   ├── Inconsolata-Regular.ttf
    │   │       │   ├── fontawesome-webfont.eot
    │   │       │   ├── fontawesome-webfont.ttf
    │   │       │   └── fontawesome-webfont.woff
    │   │       ├── css
    │   │       │   ├── badge_only.css.map
    │   │       │   └── badge_only.css
    │   │       └── js
    │   │       │   └── theme.js
    │   │   ├── theme.conf
    │   │   ├── __init__.py
    │   │   ├── searchbox.html
    │   │   ├── versions.html
    │   │   ├── search.html
    │   │   ├── footer.html
    │   │   ├── breadcrumbs.html
    │   │   ├── layout.html
    │   │   └── layout_old.html
    ├── migrating_idx_file.rst
    ├── Cookbook
    │   └── Deploy
    │   │   ├── idxrc.php
    │   │   └── idxfile.php
    ├── recipes
    │   └── deploy.rst
    ├── getting_started.rst
    ├── configuration.rst
    ├── index.rst
    ├── writing_extensions.rst
    ├── Makefile
    ├── make.bat
    ├── conf.py
    └── writing_tasks.rst
├── Dockerfile
├── src
    └── Idephix
    │   ├── Exception
    │       ├── MissingMethodException.php
    │       ├── FailedCommandException.php
    │       ├── InvalidIdxFileException.php
    │       └── InvalidConfigurationException.php
    │   ├── Extension
    │       ├── Method.php
    │       ├── IdephixAwareInterface.php
    │       ├── CallableMethod.php
    │       ├── MethodCollection.php
    │       ├── Project
    │       │   └── Rsync.php
    │       └── Slack
    │       │   └── Slack.php
    │   ├── DictionaryAccess.php
    │   ├── Task
    │       ├── Parameter
    │       │   ├── UserDefinedCollection.php
    │       │   ├── ParameterInterface.php
    │       │   ├── Context.php
    │       │   ├── Collection.php
    │       │   └── UserDefined.php
    │       ├── Task.php
    │       ├── CollectionIterator.php
    │       ├── Parsing
    │       │   └── TaskCollector.php
    │       ├── CallableTask.php
    │       ├── TaskCollection.php
    │       └── Builtin
    │       │   ├── SelfUpdate.php
    │       │   └── InitIdxFile.php
    │   ├── Extension.php
    │   ├── Phar
    │       └── Compactor
    │       │   └── Php.php
    │   ├── Builder.php
    │   ├── SSH
    │       ├── BaseProxy.php
    │       ├── ProxyInterface.php
    │       ├── PeclSsh2Proxy.php
    │       ├── SshClient.php
    │       └── CLISshProxy.php
    │   ├── Console
    │       ├── InputFactory.php
    │       ├── Application.php
    │       ├── Descriptor
    │       │   ├── DescriptorHelper.php
    │       │   └── TextDescriptor.php
    │       ├── Command
    │       │   └── ListCommand.php
    │       └── Command.php
    │   ├── Cookbook
    │       └── Deploy
    │       │   ├── idxrc.php
    │       │   └── idxfile.php
    │   ├── TaskExecutor.php
    │   ├── bootstrap.php
    │   ├── Test
    │       ├── SSH
    │       │   └── StubProxy.php
    │       ├── DummyExtension.php
    │       └── Console
    │       │   └── IdephixCommandTester.php
    │   ├── Dictionary.php
    │   ├── Util
    │       └── DocBlockParser.php
    │   ├── Config.php
    │   └── Context.php
├── .php_cs
├── box.json
├── composer.json
├── README.md
├── CONTRIBUTING.md
├── idxfile.php
└── composer.lock


/bin/box:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/bin/box


--------------------------------------------------------------------------------
/bin/phpunit:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/bin/phpunit


--------------------------------------------------------------------------------
/bin/build-image.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | docker build -t idephix-build .
4 | 


--------------------------------------------------------------------------------
/bin/php-cs-fixer:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/bin/php-cs-fixer


--------------------------------------------------------------------------------
/docs/cookbook.rst:
--------------------------------------------------------------------------------
1 | ========
2 | Cookbook
3 | ========
4 | 
5 | .. toctree::
6 | 
7 |    Deploy <recipes/deploy>


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM php:7.1-cli-alpine
2 | 
3 | RUN apk add --no-cache git
4 | COPY --from=composer /usr/bin/composer /usr/bin/composer
5 | 


--------------------------------------------------------------------------------
/bin/php-cli.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | docker run -it --rm --name idephix-build \
4 |   -v "$PWD":/usr/src/myapp -w /usr/src/myapp \
5 |   idephix-build "$@"
6 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/Lato-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/docs/_themes/sphinx_rtd_theme/static/fonts/Lato-Bold.ttf


--------------------------------------------------------------------------------
/src/Idephix/Exception/MissingMethodException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace Idephix\Exception;
3 | 
4 | class MissingMethodException extends \RuntimeException
5 | {
6 | }
7 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/FontAwesome.otf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/docs/_themes/sphinx_rtd_theme/static/fonts/FontAwesome.otf


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/Lato-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/docs/_themes/sphinx_rtd_theme/static/fonts/Lato-Regular.ttf


--------------------------------------------------------------------------------
/src/Idephix/Exception/FailedCommandException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace Idephix\Exception;
5 | 
6 | class FailedCommandException extends \Exception
7 | {
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Idephix/Exception/InvalidIdxFileException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace Idephix\Exception;
3 | 
4 | class InvalidIdxFileException extends \RuntimeException
5 | {
6 | }
7 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/RobotoSlab-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/docs/_themes/sphinx_rtd_theme/static/fonts/RobotoSlab-Bold.ttf


--------------------------------------------------------------------------------
/bin/build.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | docker run -it --rm --name idephix-build \
4 |   -v "$PWD":/usr/src/myapp -w /usr/src/myapp \
5 |   idephix-build bin/idephix.phar build
6 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/Inconsolata-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/docs/_themes/sphinx_rtd_theme/static/fonts/Inconsolata-Bold.ttf


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/RobotoSlab-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/docs/_themes/sphinx_rtd_theme/static/fonts/RobotoSlab-Regular.ttf


--------------------------------------------------------------------------------
/src/Idephix/Exception/InvalidConfigurationException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace Idephix\Exception;
3 | 
4 | class InvalidConfigurationException extends \RuntimeException
5 | {
6 | }
7 | 


--------------------------------------------------------------------------------
/src/Idephix/Extension/Method.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace Idephix\Extension;
3 | 
4 | interface Method
5 | {
6 |     public function name();
7 |     public function __invoke();
8 | }
9 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/Inconsolata-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/docs/_themes/sphinx_rtd_theme/static/fonts/Inconsolata-Regular.ttf


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/flowingis/Idephix/HEAD/docs/_themes/sphinx_rtd_theme/static/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/src/Idephix/DictionaryAccess.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Idephix;
 5 | 
 6 | interface DictionaryAccess extends \ArrayAccess
 7 | {
 8 |     public function get($offset, $default = null);
 9 |     public function set($key, $value);
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Idephix/Task/Parameter/UserDefinedCollection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Task\Parameter;
 3 | 
 4 | class UserDefinedCollection extends \FilterIterator
 5 | {
 6 |     public function accept()
 7 |     {
 8 |         return parent::current() instanceof UserDefined;
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/theme.conf:
--------------------------------------------------------------------------------
 1 | [theme]
 2 | inherit = basic
 3 | stylesheet = css/theme.css
 4 | 
 5 | [options]
 6 | typekit_id = hiw1hhg
 7 | analytics_id = 
 8 | sticky_navigation = False
 9 | logo_only =
10 | collapse_navigation = False
11 | display_version = True
12 | navigation_depth = 4
13 | 


--------------------------------------------------------------------------------
/src/Idephix/Extension/IdephixAwareInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\Extension;
 4 | 
 5 | use Idephix\Idephix;
 6 | 
 7 | interface IdephixAwareInterface
 8 | {
 9 |     /**
10 |      * @param Idephix $idx
11 |      * @return
12 |      */
13 |     public function setIdephix(Idephix $idx);
14 | }
15 | 


--------------------------------------------------------------------------------
/.php_cs:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $finder = \Symfony\CS\Finder\DefaultFinder::create()
 4 |     ->in(array(__DIR__ . '/src', __DIR__ . '/tests'));
 5 | 
 6 | return \Symfony\CS\Config\Config::create()
 7 |     ->fixers(array('long_array_syntax', 'single_quote', 'unused_use'))
 8 |     ->level(\Symfony\CS\FixerInterface::PSR2_LEVEL)
 9 |     ->finder($finder);
10 | 


--------------------------------------------------------------------------------
/src/Idephix/Task/Parameter/ParameterInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Task\Parameter;
 3 | 
 4 | interface ParameterInterface
 5 | {
 6 |     public function isFlagOption();
 7 | 
 8 |     public function isOptional();
 9 | 
10 |     public function name();
11 | 
12 |     public function description();
13 | 
14 |     public function defaultValue();
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Idephix/Extension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Idephix;
 5 | 
 6 | use Idephix\Extension\MethodCollection;
 7 | use Idephix\Task\TaskCollection;
 8 | 
 9 | interface Extension
10 | {
11 |     /** @return TaskCollection */
12 |     public function tasks();
13 | 
14 |     /** @return MethodCollection */
15 |     public function methods();
16 | 
17 |     public function name();
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Idephix/Phar/Compactor/Php.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Phar\Compactor;
 3 | 
 4 | use Herrera\Box\Compactor\Php as HerreraPhpCompactor;
 5 | 
 6 | class Php extends HerreraPhpCompactor
 7 | {
 8 |     public function supports($file)
 9 |     {
10 |         if (0 === strpos($file, 'src/Idephix/Cookbook/')) {
11 |             return false;
12 |         }
13 | 
14 |         return parent::supports($file);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/__init__.py:
--------------------------------------------------------------------------------
 1 | """Sphinx ReadTheDocs theme.
 2 | 
 3 | From https://github.com/ryan-roemer/sphinx-bootstrap-theme.
 4 | 
 5 | """
 6 | import os
 7 | 
 8 | __version__ = '0.1.10-alpha'
 9 | __version_full__ = __version__
10 | 
11 | 
12 | def get_html_theme_path():
13 |     """Return list of HTML theme paths."""
14 |     cur_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
15 |     return cur_dir
16 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/searchbox.html:
--------------------------------------------------------------------------------
 1 | {%- if builder != 'singlehtml' %}
 2 | <div role="search">
 3 |   <form id="rtd-search-form" class="wy-form" action="{{ pathto('search') }}" method="get">
 4 |     <input type="text" name="q" placeholder="Search docs" />
 5 |     <input type="hidden" name="check_keywords" value="yes" />
 6 |     <input type="hidden" name="area" value="default" />
 7 |   </form>
 8 | </div>
 9 | {%- endif %}
10 | 


--------------------------------------------------------------------------------
/src/Idephix/Task/Task.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Task;
 3 | 
 4 | use Idephix\Task\Parameter\Collection;
 5 | 
 6 | interface Task
 7 | {
 8 |     public function name();
 9 | 
10 |     public function description();
11 | 
12 |     /**
13 |      * @return Collection
14 |      */
15 |     public function parameters();
16 | 
17 |     public function userDefinedParameters();
18 | 
19 |     /**
20 |      * @return callable
21 |      */
22 |     public function code();
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Idephix/Builder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix;
 4 | 
 5 | use Idephix\Task\Task;
 6 | 
 7 | interface Builder
 8 | {
 9 |     /**
10 |      * @return null|integer
11 |      */
12 |     public function run();
13 | 
14 |     /**
15 |      * Add a Task to the application.
16 |      *
17 |      * @param Task $task
18 |      * @return Builder
19 |      */
20 |     public function addTask(Task $task);
21 | 
22 |     /**
23 |      * @param Extension $extension
24 |      * @return
25 |      */
26 |     public function addExtension(Extension $extension);
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Idephix/Extension/CallableMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Extension;
 3 | 
 4 | class CallableMethod implements Method
 5 | {
 6 |     private $name;
 7 |     private $callable;
 8 | 
 9 |     public function __construct($name, $callable)
10 |     {
11 |         $this->name = $name;
12 |         $this->callable = $callable;
13 |     }
14 | 
15 | 
16 |     public function name()
17 |     {
18 |         return $this->name;
19 |     }
20 | 
21 |     public function __invoke()
22 |     {
23 |         return call_user_func_array($this->callable, func_get_args());
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/bin/idx:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env php
 2 | <?php
 3 | 
 4 | foreach (array(__DIR__ . '/../../../autoload.php', __DIR__ . '/../vendor/autoload.php') as $file) {
 5 |     if (file_exists($file)) {
 6 |         define('IDEPHIX_COMPOSER_INSTALL', $file);
 7 |         break;
 8 |     }
 9 | }
10 | 
11 | if (!defined('IDEPHIX_COMPOSER_INSTALL')) {
12 |     die(
13 |         'You need to set up the project dependencies using the following commands:' . PHP_EOL .
14 |         'wget http://getcomposer.org/composer.phar' . PHP_EOL .
15 |         'php composer.phar install' . PHP_EOL
16 |     );
17 | }
18 | 
19 | require IDEPHIX_COMPOSER_INSTALL;
20 | 
21 | exit(Idephix\run());
22 | 


--------------------------------------------------------------------------------
/src/Idephix/SSH/BaseProxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\SSH;
 4 | 
 5 | abstract class BaseProxy implements ProxyInterface
 6 | {
 7 |     protected $connection = null;
 8 |     protected $lastError;
 9 |     protected $lastOutput;
10 |     protected $exitCode;
11 | 
12 |     public function disconnect()
13 |     {
14 |         $this->connection = null;
15 |     }
16 | 
17 |     public function getLastError()
18 |     {
19 |         return $this->lastError;
20 |     }
21 | 
22 |     public function getLastOutput()
23 |     {
24 |         return $this->lastOutput;
25 |     }
26 | 
27 |     public function getExitCode()
28 |     {
29 |         return $this->exitCode;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/box.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "bootstrap": "vendor/autoload.php",
 3 |   "alias": "idephix.phar",
 4 |   "chmod": "0755",
 5 |   "compactors": [
 6 |     "Herrera\\Box\\Compactor\\Json",
 7 |     "Idephix\\Phar\\Compactor\\Php"
 8 |   ],
 9 |   "directories": [
10 |     "src/Idephix"
11 |   ],
12 |   "extract": true,
13 |   "files": [
14 |     "README.md"
15 |   ],
16 |   "finder": [
17 |     {
18 |       "name": "*.php",
19 |       "exclude": [
20 |         "tests",
21 |         "test",
22 |         "Test",
23 |         "Tests"
24 |       ],
25 |       "in": "vendor"
26 |     }
27 |   ],
28 |   "git-tag": "package_version",
29 |   "git-version": "git-version",
30 |   "datetime": "release_date",
31 |   "main": "bin\/idx",
32 |   "output": "idephix.phar",
33 |   "stub": true
34 | }


--------------------------------------------------------------------------------
/docs/migrating_idx_file.rst:
--------------------------------------------------------------------------------
 1 | =======================
 2 | Migrating your idx file
 3 | =======================
 4 | 
 5 | Since version 0.2.0 we started supporting a new idxfile format. We think the new format is more easy to write
 6 | and we will drop support for the old format soon. If you're still using the old idxfile format you can avoid migrating
 7 | right now, just be sure to create an instance of `\Idephix\Config` to construct your Idephix instance instead of the
 8 | array you're using right now.
 9 | 
10 | Implementing this should be easy enough as the `\Idephix\Config` object can be created from an array, see
11 | :ref:`idx_config` for more information.
12 | 
13 | If you're brave enough and want to jump on the innovation wagon right now read :ref:`writing_tasks` on how to update
14 | your idxfile.


--------------------------------------------------------------------------------
/src/Idephix/Task/Parameter/Context.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Task\Parameter;
 3 | 
 4 | class Context implements ParameterInterface
 5 | {
 6 |     private $name;
 7 | 
 8 |     private function __construct()
 9 |     {
10 |     }
11 | 
12 |     public static function create()
13 |     {
14 |         $param = new static();
15 |         $param->name = 'idx';
16 | 
17 |         return $param;
18 |     }
19 | 
20 |     public function isFlagOption()
21 |     {
22 |         return false;
23 |     }
24 | 
25 |     public function isOptional()
26 |     {
27 |         return false;
28 |     }
29 | 
30 |     public function name()
31 |     {
32 |         return $this->name;
33 |     }
34 | 
35 |     public function description()
36 |     {
37 |         return '';
38 |     }
39 | 
40 |     public function defaultValue()
41 |     {
42 |         throw new \RuntimeException('This parameter is injected at runtime, it cannot have a default value');
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Idephix/Task/Parameter/Collection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Task\Parameter;
 3 | 
 4 | use Idephix\Task\CollectionIterator;
 5 | 
 6 | class Collection extends CollectionIterator
 7 | {
 8 |     public static function createFromArray($parametersData)
 9 |     {
10 |         $parameters = array();
11 |         foreach ($parametersData as $name => $data) {
12 |             $defaultValue = array_key_exists('defaultValue', $data) ? $data['defaultValue'] : null;
13 |             $parameters[] = UserDefined::create($name, $data['description'], $defaultValue);
14 |         }
15 | 
16 |         return new static(new \ArrayIterator($parameters));
17 |     }
18 |     
19 |     public function offsetSet($offset, $value)
20 |     {
21 |         if (!$value instanceof ParameterInterface) {
22 |             throw new \DomainException('ParameterCollection can only accept \Idephix\Task\Parameter object');
23 |         }
24 | 
25 |         $this->getInnerIterator()->offsetSet($offset, $value);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Idephix/Console/InputFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Console;
 3 | 
 4 | use Idephix\Task\Task;
 5 | use Symfony\Component\Console\Input\ArrayInput;
 6 | 
 7 | class InputFactory
 8 | {
 9 |     /**
10 |      * @param $arguments
11 |      * @param Task $task
12 |      * @return ArrayInput
13 |      */
14 |     public function buildFromUserArgsForTask($arguments, Task $task)
15 |     {
16 |         $defaultArguments = array('command' => null);
17 | 
18 |         foreach ($task->userDefinedParameters() as $parameter) {
19 |             if ($parameter->isFlagOption()) {
20 |                 $defaultArguments['--' . $parameter->name()] = $parameter->defaultValue();
21 |             } else {
22 |                 $defaultArguments[$parameter->name()] = $parameter->defaultValue();
23 |             }
24 |         }
25 | 
26 |         $values = array_replace(array_values($defaultArguments), $arguments);
27 |         $inputArguments = array_combine(array_keys($defaultArguments), $values);
28 | 
29 |         $input = new ArrayInput($inputArguments);
30 | 
31 |         return $input;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "ideato/idephix",
 3 |     "description": "PHP automation and deploy tool.",
 4 |     "type": "library",
 5 |     "keywords": ["idephix", "idx", "automation", "deploy"],
 6 |     "homepage": "http://getidephix.com/",
 7 |     "license": "MIT",
 8 |     "authors": [
 9 |         {
10 |             "name": "Manuel Baldassarri",
11 |             "email": "mb@ideato.it",
12 |             "role": "lead"
13 |         }
14 |     ],
15 |     "support": {
16 |         "issues": "https://github.com/ideato/idephix/issues"
17 |     },
18 |     "require": {
19 |         "php": ">=5.3.9",
20 |         "symfony/console": "~2.3",
21 |         "symfony/process": "~2.3",
22 |         "nikic/php-parser": "^1.3",
23 |         "symfony/options-resolver": "^2.1"
24 |     },
25 |     "require-dev": {
26 |         "mikey179/vfsstream": "1.3.*@dev"
27 |     },
28 |     "bin": [
29 |         "bin/idx"
30 |     ],
31 |     "config": {
32 |         "bin-dir": "bin"
33 |     },
34 |     "autoload": {
35 |         "files": ["src/Idephix/bootstrap.php"],
36 |         "psr-0": {"Idephix": "src/"}
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/docs/Cookbook/Deploy/idxrc.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $environments = array(
 4 |     'prod' => array(
 5 |         'hosts' => array('127.0.0.1'),
 6 |         'ssh_params' => array(
 7 |             'user' => 'ideato',
 8 | //            'password'             => '',
 9 | //            'public_key_file'      => '',
10 | //            'private_key_file'     => '',
11 | //            'private_key_file_pwd' => '',
12 | //            'ssh_port'             => '22'
13 |         ),
14 |         'deploy' => array(
15 |             'repository' => './',
16 |             'branch' => 'origin/master',
17 |             'shared_files' => array('app/config/parameters.yml'),
18 |             'shared_folders' => array('app/cache', 'app/logs'),
19 |             'remote_base_dir' => '/var/www/testidx',
20 |             'rsync_exclude' => './rsync_exclude.txt',
21 |         )
22 |     ),
23 | );
24 | 
25 | return
26 |     array(
27 |         'envs' => $environments,
28 |         'ssh_client' => new \Idephix\SSH\SshClient(),
29 |         'extensions' => array(
30 |             'rsync' => new \Idephix\Extension\Project\Rsync(),
31 |         ),
32 |     );
33 | 


--------------------------------------------------------------------------------
/src/Idephix/Cookbook/Deploy/idxrc.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $environments = array(
 4 |     'prod' => array(
 5 |         'hosts' => array('127.0.0.1'),
 6 |         'ssh_params' => array(
 7 |             'user' => 'ideato',
 8 | //            'password'             => '',
 9 | //            'public_key_file'      => '',
10 | //            'private_key_file'     => '',
11 | //            'private_key_file_pwd' => '',
12 | //            'ssh_port'             => '22'
13 |         ),
14 |         'deploy' => array(
15 |             'repository' => './',
16 |             'branch' => 'origin/master',
17 |             'shared_files' => array('app/config/parameters.yml'),
18 |             'shared_folders' => array('app/cache', 'app/logs'),
19 |             'remote_base_dir' => '/var/www/testidx',
20 |             'rsync_exclude' => './rsync_exclude.txt',
21 |         )
22 |     ),
23 | );
24 | 
25 | return
26 |     array(
27 |         'envs' => $environments,
28 |         'ssh_client' => new \Idephix\SSH\SshClient(),
29 |         'extensions' => array(
30 |             'rsync' => new \Idephix\Extension\Project\Rsync(),
31 |         ),
32 |     );
33 | 


--------------------------------------------------------------------------------
/src/Idephix/TaskExecutor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix;
 3 | 
 4 | interface TaskExecutor
 5 | {
 6 |     const OUTPUT_NORMAL = 0;
 7 |     const OUTPUT_RAW    = 1;
 8 |     const OUTPUT_PLAIN  = 2;
 9 | 
10 |     /**
11 |      * @param $name
12 |      * @return integer 0 success, 1 fail
13 |      */
14 |     public function execute($name);
15 | 
16 |     /**
17 |      * Execute remote command.
18 |      *
19 |      * @param string  $cmd    command
20 |      * @param boolean $dryRun
21 |      * @return void
22 |      */
23 |     public function remote($cmd, $dryRun = false);
24 | 
25 |     /**
26 |      * Execute local command.
27 |      *
28 |      * @param string $cmd Command
29 |      * @param boolean $dryRun
30 |      * @param integer $timeout
31 |      *
32 |      * @return string the command output
33 |      */
34 |     public function local($cmd, $dryRun = false, $timeout = 60);
35 | 
36 |     public function output();
37 | 
38 |     public function write($messages, $newline = false, $type = self::OUTPUT_NORMAL);
39 | 
40 |     public function writeln($messages, $type = self::OUTPUT_NORMAL);
41 | 
42 |     public function sshClient();
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Idephix/Task/Parameter/UserDefined.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Task\Parameter;
 3 | 
 4 | class UserDefined implements ParameterInterface
 5 | {
 6 |     private $name;
 7 |     private $description;
 8 |     private $defaultValue;
 9 | 
10 |     private function __construct()
11 |     {
12 |     }
13 | 
14 |     public static function create($name, $description, $defaultValue = null)
15 |     {
16 |         $param = new static();
17 |         $param->name = $name;
18 |         $param->description = $description;
19 |         $param->defaultValue = $defaultValue;
20 | 
21 |         return $param;
22 |     }
23 | 
24 |     public function isFlagOption()
25 |     {
26 |         return $this->defaultValue === false;
27 |     }
28 | 
29 |     public function isOptional()
30 |     {
31 |         return !is_null($this->defaultValue);
32 |     }
33 | 
34 |     public function name()
35 |     {
36 |         return $this->name;
37 |     }
38 | 
39 |     public function description()
40 |     {
41 |         return $this->description;
42 |     }
43 | 
44 |     public function defaultValue()
45 |     {
46 |         return $this->defaultValue;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Idephix/bootstrap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix;
 4 | 
 5 | use Idephix\Exception\FailedCommandException;
 6 | use Idephix\Task\TaskCollection;
 7 | use Symfony\Component\Console\Input\ArgvInput;
 8 | 
 9 | function run()
10 | {
11 |     $input = new ArgvInput();
12 | 
13 |     $configFile = $input->getParameterOption(array('--config', '-c'), getcwd() . '/' .'idxrc.php');
14 |     $defaultIdxFile = getcwd() . '/' . 'idxfile.php';
15 |     $idxFile = $input->getParameterOption(array('--file', '-f'), $defaultIdxFile);
16 | 
17 |     if (!is_file($configFile)) {
18 |         $configFile = null;
19 |     }
20 | 
21 |     if (is_file($idxFile)) {
22 |         try {
23 |             $idx = Idephix::create(TaskCollection::parseFile($idxFile), Config::parseFile($configFile));
24 |             $idx->run();
25 | 
26 |             return 0;
27 |         } catch (FailedCommandException $e) {
28 |             return 1;
29 |         }
30 |     }
31 | 
32 |     if (false === strpos($idxFile, $defaultIdxFile)) {
33 |         echo "$idxFile file not exist!";
34 |         return 1;
35 |     }
36 | 
37 |     $idx = new Idephix(Config::dry());
38 |     return $idx->run();
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Idephix/Test/SSH/StubProxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\Test\SSH;
 4 | 
 5 | use Idephix\SSH\BaseProxy;
 6 | 
 7 | class StubProxy extends BaseProxy
 8 | {
 9 |     protected $lastOutput;
10 |     protected $lastError;
11 | 
12 |     public function __construct($fakeOutput = 'test out ', $fakeError = 'test err ')
13 |     {
14 |         $this->lastOutput = $fakeOutput;
15 |         $this->lastError = $fakeError;
16 |     }
17 | 
18 |     public function connect($host, $port)
19 |     {
20 |         if ('fail_connection' === $host) {
21 |             return false;
22 |         }
23 | 
24 |         return true;
25 |     }
26 | 
27 |     public function authByPassword($user, $pwd)
28 |     {
29 |         return true;
30 |     }
31 | 
32 |     public function authByPublicKey($user, $public_key_file, $private_key_file, $pwd)
33 |     {
34 |         return true;
35 |     }
36 | 
37 |     public function authByAgent($user)
38 |     {
39 |         return true;
40 |     }
41 | 
42 |     public function exec($cmd)
43 |     {
44 |         $this->lastOutput .= $cmd;
45 |         $this->lastError .= $cmd;
46 | 
47 |         return $cmd;
48 |     }
49 | 
50 |     public function isConnected()
51 |     {
52 |         return true;
53 |     }
54 | 
55 |     public function put($localPath, $remotePath)
56 |     {
57 |     }
58 | 
59 |     public function get($remotePath, $localPath)
60 |     {
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/versions.html:
--------------------------------------------------------------------------------
 1 | {% if READTHEDOCS %}
 2 | {# Add rst-badge after rst-versions for small badge style. #}
 3 |   <div class="rst-versions" data-toggle="rst-versions" role="note" aria-label="versions">
 4 |     <span class="rst-current-version" data-toggle="rst-current-version">
 5 |       <span class="fa fa-book"> Read the Docs</span>
 6 |       v: {{ current_version }}
 7 |       <span class="fa fa-caret-down"></span>
 8 |     </span>
 9 |     <div class="rst-other-versions">
10 |       <dl>
11 |         <dt>Versions</dt>
12 |         {% for slug, url in versions %}
13 |           <dd><a href="{{ url }}">{{ slug }}</a></dd>
14 |         {% endfor %}
15 |       </dl>
16 |       <dl>
17 |         <dt>Downloads</dt>
18 |         {% for type, url in downloads %}
19 |           <dd><a href="{{ url }}">{{ type }}</a></dd>
20 |         {% endfor %}
21 |       </dl>
22 |       <dl>
23 |         <dt>On Read the Docs</dt>
24 |           <dd>
25 |             <a href="//{{ PRODUCTION_DOMAIN }}/projects/{{ slug }}/?fromdocs={{ slug }}">Project Home</a>
26 |           </dd>
27 |           <dd>
28 |             <a href="//{{ PRODUCTION_DOMAIN }}/builds/{{ slug }}/?fromdocs={{ slug }}">Builds</a>
29 |           </dd>
30 |       </dl>
31 |       <hr/>
32 |       Free document hosting provided by <a href="http://www.readthedocs.org">Read the Docs</a>.
33 | 
34 |     </div>
35 |   </div>
36 | {% endif %}
37 | 
38 | 


--------------------------------------------------------------------------------
/src/Idephix/Task/CollectionIterator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Task;
 3 | 
 4 | abstract class CollectionIterator implements \Iterator, \OuterIterator, \ArrayAccess
 5 | {
 6 |     /** @var  \Iterator */
 7 |     private $innerIterator;
 8 | 
 9 |     protected function __construct(\Iterator $iterator)
10 |     {
11 |         $this->innerIterator = $iterator;
12 |     }
13 | 
14 |     public function getInnerIterator()
15 |     {
16 |         return $this->innerIterator;
17 |     }
18 | 
19 |     public static function dry()
20 |     {
21 |         return new static(new \ArrayIterator(array()));
22 |     }
23 | 
24 |     public function count()
25 |     {
26 |         return count($this->getInnerIterator());
27 |     }
28 | 
29 |     public function offsetExists($offset)
30 |     {
31 |         return $this->getInnerIterator()->offsetExists($offset);
32 |     }
33 | 
34 |     public function offsetGet($offset)
35 |     {
36 |         return $this->getInnerIterator()->offsetGet($offset);
37 |     }
38 | 
39 |     public function offsetUnset($offset)
40 |     {
41 |         $this->getInnerIterator()->offsetUnset($offset);
42 |     }
43 | 
44 |     public function current()
45 |     {
46 |         return $this->innerIterator->current();
47 |     }
48 | 
49 |     public function next()
50 |     {
51 |         $this->innerIterator->next();
52 |     }
53 | 
54 |     public function key()
55 |     {
56 |         return $this->innerIterator->key();
57 |     }
58 | 
59 |     public function valid()
60 |     {
61 |         return $this->innerIterator->valid();
62 |     }
63 | 
64 |     public function rewind()
65 |     {
66 |         $this->innerIterator->rewind();
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/docs/recipes/deploy.rst:
--------------------------------------------------------------------------------
 1 | Deploying with Idephix
 2 | ======================
 3 | 
 4 | Deploying a PHP application can be done in many ways, this recipe shows you
 5 | our best strategy for a generic PHP application, and it is composed of several
 6 | steps:
 7 | 
 8 | * Preparing the local project
 9 | * Preparing the remote server
10 | * Syncing the project to the server
11 | * Linking shared files across releases (configuration files, cache, logs, etc)
12 | * Switching the symlink for the new release, finalizing the deploy
13 | 
14 | The recipe organize your code on the server using a directory hierarchy borrowed from
15 | `Capistrano <http://capistranorb.com/documentation/getting-started/structure/>`_:
16 | 
17 | .. code-block:: bash
18 | 
19 |     ├── current -> /var/www/my_app_name/releases/20150120114500/
20 |     ├── releases
21 |     │   ├── 20150080072500
22 |     │   ├── 20150090083000
23 |     │   ├── 20150100093500
24 |     │   ├── 20150110104000
25 |     │   └── 20150120114500
26 |     └── shared
27 |         └── <linked_files and linked_dirs>
28 | 
29 | So you can keep multiple releases on the server and switch the current release just creating a symlink to the actual
30 | one you want to make current. This allows you to easily rollback from one release to another.
31 | 
32 | .. literalinclude:: ../Cookbook/Deploy/idxfile.php
33 |     :language: php
34 |     :caption: idxfile.php
35 |     :emphasize-lines: 3,29,44,59,67
36 |     :linenos:
37 | 
38 | 
39 | These tasks are based on several configuration options that you can define in your idxrc.php file:
40 | 
41 | .. literalinclude:: ../Cookbook/Deploy/idxrc.php
42 |     :language: php
43 |     :caption: idxrc.php
44 |     :emphasize-lines: 4-17,24-26
45 |     :linenos:
46 | 


--------------------------------------------------------------------------------
/src/Idephix/Extension/MethodCollection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Extension;
 3 | 
 4 | use Idephix\Exception\MissingMethodException;
 5 | use Idephix\Task\CollectionIterator;
 6 | 
 7 | class MethodCollection extends CollectionIterator
 8 | {
 9 |     public static function ofCallables($array)
10 |     {
11 |         return new static(
12 |             new \ArrayIterator(
13 |                 array_filter(
14 |                     $array,
15 |                     function ($method) {
16 |                         return $method instanceof Method;
17 |                     }
18 |                 )
19 |             )
20 |         );
21 |     }
22 | 
23 |     public function offsetSet($offset, $value)
24 |     {
25 |         if (!$value instanceof Method) {
26 |             throw new \DomainException('MethodCollection can only accept \Idephix\Extension\Method instances');
27 |         }
28 | 
29 |         $this->getInnerIterator()->offsetSet($offset, $value);
30 |     }
31 | 
32 |     public function merge(MethodCollection $collection)
33 |     {
34 |         return new static(
35 |             new \ArrayIterator(
36 |                 array_merge(
37 |                     iterator_to_array($this->getInnerIterator()),
38 |                     iterator_to_array($collection->getInnerIterator())
39 |                 )
40 |             )
41 |         );
42 |     }
43 | 
44 |     public function execute($methodName, $args = array())
45 |     {
46 |         foreach ($this->getInnerIterator() as $method) {
47 |             if ($method->name() == $methodName) {
48 |                 return call_user_func_array($method, $args);
49 |             }
50 |         }
51 | 
52 |         throw new MissingMethodException("Unable to find method named $methodName");
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Idephix/SSH/ProxyInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\SSH;
 4 | 
 5 | interface ProxyInterface
 6 | {
 7 |     /**
 8 |      * @param string $host
 9 |      * @param integer $port
10 |      */
11 |     public function connect($host, $port);
12 | 
13 |     /**
14 |      * @param string $user
15 |      * @param string $pwd
16 |      */
17 |     public function authByPassword($user, $pwd);
18 | 
19 |     /**
20 |      * @param string $user
21 |      * @param string $public_key_file
22 |      * @param string $private_key_file
23 |      * @param string $pwd
24 |      */
25 |     public function authByPublicKey($user, $public_key_file, $private_key_file, $pwd);
26 | 
27 |     /**
28 |      * @param string $user
29 |      */
30 |     public function authByAgent($user);
31 | 
32 |     /**
33 |      * @param string $cmd the command to be execute
34 |      *
35 |      * @return boolean true in case of success, false otherwise
36 |      */
37 |     public function exec($cmd);
38 | 
39 |     /**
40 |      * Copy a file via scp from $localPath to $remotePath
41 |      *
42 |      * @param $localPath source local path
43 |      * @param $remotePath destination remote path
44 |      * @return boolean
45 |      */
46 |     public function put($localPath, $remotePath);
47 | 
48 |     /**
49 |      * Copy a file via scp from $remotePath to $localPath
50 |      *
51 |      * @param $remotePath source remote path
52 |      * @param $localPath destination local path
53 |      * @return boolean
54 |      */
55 |     public function get($remotePath, $localPath);
56 | 
57 |     /**
58 |      * @return string|null
59 |      */
60 |     public function getLastError();
61 | 
62 |     /**
63 |      * @return string|null
64 |      */
65 |     public function getLastOutput();
66 | }
67 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/search.html:
--------------------------------------------------------------------------------
 1 | {#
 2 |     basic/search.html
 3 |     ~~~~~~~~~~~~~~~~~
 4 | 
 5 |     Template for the search page.
 6 | 
 7 |     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
 8 |     :license: BSD, see LICENSE for details.
 9 | #}
10 | {%- extends "layout.html" %}
11 | {% set title = _('Search') %}
12 | {% set script_files = script_files + ['_static/searchtools.js'] %}
13 | {% block footer %}
14 |   <script type="text/javascript">
15 |     jQuery(function() { Search.loadIndex("{{ pathto('searchindex.js', 1) }}"); });
16 |   </script>
17 |   {# this is used when loading the search index using $.ajax fails,
18 |      such as on Chrome for documents on localhost #}
19 |   <script type="text/javascript" id="searchindexloader"></script>
20 |   {{ super() }}
21 | {% endblock %}
22 | {% block body %}
23 |   <noscript>
24 |   <div id="fallback" class="admonition warning">
25 |     <p class="last">
26 |       {% trans %}Please activate JavaScript to enable the search
27 |       functionality.{% endtrans %}
28 |     </p>
29 |   </div>
30 |   </noscript>
31 | 
32 |   {% if search_performed %}
33 |     <h2>{{ _('Search Results') }}</h2>
34 |     {% if not search_results %}
35 |       <p>{{ _('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.') }}</p>
36 |     {% endif %}
37 |   {% endif %}
38 |   <div id="search-results">
39 |   {% if search_results %}
40 |     <ul>
41 |     {% for href, caption, context in search_results %}
42 |       <li>
43 |         <a href="{{ pathto(item.href) }}">{{ caption }}</a>
44 |         <p class="context">{{ context|e }}</p>
45 |       </li>
46 |     {% endfor %}
47 |     </ul>
48 |   {% endif %}
49 |   </div>
50 | {% endblock %}
51 | 


--------------------------------------------------------------------------------
/docs/getting_started.rst:
--------------------------------------------------------------------------------
 1 | ===============
 2 | Getting Started
 3 | ===============
 4 | 
 5 | Installing
 6 | **********
 7 | 
 8 | You can install Idephix in several ways:
 9 | 
10 | As a phar (Recommended)
11 | -----------------------
12 | 
13 | You can download the phar directly from getidephix.com
14 | 
15 | .. code-block:: bash
16 | 
17 |     $ curl -LSs http://getidephix.com/idephix.phar > idephix.phar
18 |     $ chmod a+x idephix.phar
19 | 
20 | We recommend you to download the phar and put it under version control with your project, so you can have the best
21 | control over used version and you'll be sure to avoid dependencies conflicts with your project.
22 | 
23 | As a composer dependency
24 | ------------------------
25 | 
26 | .. code-block:: bash
27 | 
28 |     $ composer require ideato/idephix --dev
29 | 
30 | Globally using homebrew
31 | -----------------------
32 | 
33 | .. code-block:: bash
34 | 
35 |     $ brew tap ideatosrl/php
36 |     $ brew install idephix
37 | 
38 | 
39 | Basic Usage
40 | ***********
41 | 
42 | Idephix is a tool for running tasks. As a developer your main focus
43 | will be on writing tasks (as php functions) inside a file called ``idxfile.php``.
44 | You will also need to specify some configurations inside a file called ``idxrc.php``.
45 | 
46 | Fortunately you won't need to create those files manually, Idephix can generate
47 | them for you.
48 | 
49 | .. code-block:: bash
50 | 
51 |     $ idx initFile
52 | 
53 | This will generate an ``idxfile.php`` and a ``idxrc.php`` file that you can
54 | use as a boiler plate for your automated tasks.
55 | 
56 | Basically Idephix is a tool for running tasks either remote or local. Remote tasks
57 | can be run against a chosen environment connecting
58 | to it through ssh (see :ref:`idx_config` for more information on ssh connection and environments).
59 | 
60 | Local tasks are run on the local host without any need to establish an ssh connection.


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/footer.html:
--------------------------------------------------------------------------------
 1 | <footer>
 2 |   {% if next or prev %}
 3 |     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
 4 |       {% if next %}
 5 |         <a href="{{ next.link|e }}" class="btn btn-neutral float-right" title="{{ next.title|striptags|e }}" accesskey="n">Next <span class="fa fa-arrow-circle-right"></span></a>
 6 |       {% endif %}
 7 |       {% if prev %}
 8 |         <a href="{{ prev.link|e }}" class="btn btn-neutral" title="{{ prev.title|striptags|e }}" accesskey="p"><span class="fa fa-arrow-circle-left"></span> Previous</a>
 9 |       {% endif %}
10 |     </div>
11 |   {% endif %}
12 | 
13 |   <hr/>
14 | 
15 |   <div role="contentinfo">
16 |     <p>
17 |     {%- if show_copyright %}
18 |       {%- if hasdoc('copyright') %}
19 |         {% trans path=pathto('copyright'), copyright=copyright|e %}&copy; <a href="{{ path }}">Copyright</a> {{ copyright }}.{% endtrans %}
20 |       {%- else %}
21 |         {% trans copyright=copyright|e %}&copy; Copyright {{ copyright }}.{% endtrans %}
22 |       {%- endif %}
23 |     {%- endif %}
24 | 
25 |     {%- if build_id and build_url %}
26 |       {% trans build_url=build_url, build_id=build_id %}
27 |         <span class="build">
28 |           Build
29 |           <a href="{{ build_url }}">{{ build_id }}</a>.
30 |         </span>
31 |       {% endtrans %}
32 |     {%- elif commit %}
33 |       {% trans commit=commit %}
34 |         <span class="commit">
35 |           Revision <code>{{ commit }}</code>.
36 |         </span>
37 |       {% endtrans %}
38 |     {%- elif last_updated %}
39 |       {% trans last_updated=last_updated|e %}Last updated on {{ last_updated }}.{% endtrans %}
40 |     {%- endif %}
41 | 
42 |     </p>
43 |   </div>
44 | 
45 |   {%- if show_sphinx %}
46 |   {% trans %}Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>{% endtrans %}.
47 |   {%- endif %}
48 | 
49 |   {%- block extrafooter %} {% endblock %}
50 | 
51 | </footer>
52 | 
53 | 


--------------------------------------------------------------------------------
/src/Idephix/Test/DummyExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\Test;
 4 | 
 5 | use Idephix\Extension;
 6 | use Idephix\Extension\IdephixAwareInterface;
 7 | use Idephix\Idephix;
 8 | use Idephix\Task\Parameter\Collection;
 9 | use Idephix\Task\CallableTask;
10 | use Idephix\Task\TaskCollection;
11 | 
12 | class DummyExtension implements IdephixAwareInterface, Extension
13 | {
14 |     private $tester;
15 |     private $name;
16 | 
17 |     public function __construct(\PHPUnit_Framework_TestCase $tester, $name)
18 |     {
19 |         $this->tester = $tester;
20 |         $this->name = $name;
21 |     }
22 | 
23 |     public function setIdephix(Idephix $idx)
24 |     {
25 |         $this->tester->assertTrue(true, 'Set Idephix');
26 |     }
27 | 
28 |     public function test($return)
29 |     {
30 |         return $this->doTest($return);
31 |     }
32 | 
33 |     public function update($what)
34 |     {
35 |         return $this->doTest($what);
36 |     }
37 | 
38 |     /**
39 |      * @param $return
40 |      * @return mixed
41 |      */
42 |     private function doTest($return)
43 |     {
44 |         return $return;
45 |     }
46 | 
47 |     public function name()
48 |     {
49 |         return $this->name;
50 |     }
51 | 
52 |     public function unregisteredMethod($return)
53 |     {
54 |         return $return;
55 |     }
56 | 
57 |     /** @return TaskCollection */
58 |     public function tasks()
59 |     {
60 |         $collection = TaskCollection::dry();
61 |         $collection[] = new CallableTask(
62 |             'update', 'An exposed task by DummyExtension',
63 |             array($this, 'update'),
64 |             Collection::createFromArray(array('return' => array('description' => 'what do you want back')))
65 |         );
66 | 
67 |         return $collection;
68 |     }
69 | 
70 |     /** @return array of callable */
71 |     public function methods()
72 |     {
73 |         return Extension\MethodCollection::ofCallables(
74 |             array(
75 |                 new Extension\CallableMethod('test', array($this, 'test'))
76 |             )
77 |         );
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/docs/configuration.rst:
--------------------------------------------------------------------------------
 1 | .. _idx_config:
 2 | 
 3 | =============
 4 | Configuration
 5 | =============
 6 | 
 7 | All Idephix configurations are defined within the ``idxrc.php`` file.
 8 | By default Idephix will look for a file named ``idxrc.php`` in the root
 9 | directory of your project, but you can store it wherever you want and
10 | name it whatever you want. If you want to use a custom configuration file
11 | you need to specify id by using ``-c`` option with Idephix CLI.
12 | 
13 | The file **must** return an array of configurations. Idephix uses 3 main configuration elements:
14 | 
15 | - environments
16 | - ssh_client
17 | - extensions
18 | 
19 | None of them are mandatory, you'll need environments (at least one) and ssh_client only to execute remote
20 | tasks and extensions only if you want to register some extension.
21 | 
22 | This example of ``idxrc.php`` file will give you and idea of how define environments, ssh clients
23 | and extensions:
24 | 
25 | ::
26 | 
27 |     <?php
28 | 
29 |     $environments = array(
30 |         'prod' => array(
31 |             'hosts' => array('127.0.0.1', '33.33.33.10'),
32 |             'ssh_params' => array(
33 |                 'user' => 'ideato'
34 |             ),
35 |         ),
36 |         'stage' => array(
37 |             'hosts' => array('192.168.169.170'),
38 |             'ssh_params' => array(
39 |                 'user' => 'ideato'
40 |             ),
41 |         ),
42 |         'test' => array(
43 |             'hosts' => array('127.0.0.1'),
44 |             'ssh_params' => array('user' => 'kea'),
45 |         ),
46 |     );
47 | 
48 |     return array(
49 |         'envs' => $environments,
50 |         'ssh_client' => new \Idephix\SSH\SshClient(),
51 |         'extensions' => array(),
52 |     );
53 | 
54 | Idephix use ssh-agent to authenticate to remote computers without password.
55 | Otherwise you can specify the password in your script or use ``CLISshProxy``
56 | (instead of the default ``PeclSsh2Proxy``) that ask you the password.
57 | 
58 | Once you have defined several environments you can specify which one you want to run
59 | your remote task against, using ``--env`` CLI option.


--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
 1 | .. Idephix documentation master file, created by
 2 |    sphinx-quickstart on Thu Jun 30 23:03:52 2016.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | .. highlight:: php
 7 |    :linenothreshold: 3
 8 | 
 9 | .. toctree::
10 |    :hidden:
11 |    :maxdepth: 2
12 | 
13 |    Getting Started <getting_started>
14 |    Configuration <configuration>
15 |    Writing tasks <writing_tasks>
16 |    Extending Idephix <writing_extensions>
17 |    Cookbook <cookbook>
18 |    Migrating your idxfile <migrating_idx_file>
19 | 
20 | Welcome to Idephix's documentation!
21 | ===================================
22 | 
23 | Idephix is a PHP automation tool useful to perform **remote** and **local** tasks.
24 | It can be used to deploy applications, rotate logs, synchronize data repository
25 | across server or create a build system. The choice is up to you. Idephix is
26 | still in alpha, so things will change. You can report issues and submit PRs
27 | (greatly appreciated :-)) on the `github repo <https://github.com/ideatosrl/Idephix>`_
28 | 
29 | Basically what you're going to do is define a bunch of function in a php file and execute them from the command line.
30 | 
31 | ::
32 | 
33 |    <?php
34 |    /**
35 |    * This command will yell at you
36 |    *
37 |    * @param string $what What you want to yell
38 |    */
39 |    function yell(\Idephix\Context $context, $what = 'foo')
40 |    {
41 |       $context->writeln(strtoupper($what));
42 |    }
43 | 
44 | .. code-block:: bash
45 | 
46 |    $ bin/idx yell "say my name"
47 |    SAY MY NAME
48 | 
49 | Requirements
50 | ============
51 | 
52 | PHP 5.3.2 or above, at least 5.3.12 recommended
53 | 
54 | Authors
55 | =======
56 | 
57 | `Manuel 'Kea' Baldassarri <http://www.ideato.it/author/kea/>`_,
58 | `Michele 'Orso' Orselli <http://www.ideato.it/author/orso/>`_, `Filippo De Santis <https://github.com/p16>`_
59 | and `other contributors <https://github.com/ideatosrl/idephix/graphs/contributors>`_
60 | 
61 | License
62 | =======
63 | 
64 | Idephix is mantained by `ideato <http://www.ideato.it>`_, licensed under the MIT License.


--------------------------------------------------------------------------------
/src/Idephix/Task/Parsing/TaskCollector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Task\Parsing;
 3 | 
 4 | use Idephix\Task\Parameter\Collection;
 5 | use Idephix\Task\CallableTask;
 6 | use Idephix\Task\TaskCollection;
 7 | use PhpParser\Node;
 8 | use PhpParser\NodeVisitorAbstract;
 9 | use PhpParser\PrettyPrinter\Standard;
10 | 
11 | class TaskCollector extends NodeVisitorAbstract
12 | {
13 |     /**
14 |      * @var TaskCollection
15 |      */
16 |     private $collection;
17 | 
18 |     /**
19 |      * @var Standard
20 |      */
21 |     private $codePrinter;
22 | 
23 |     public function __construct(TaskCollection $collection)
24 |     {
25 |         $this->collection = $collection;
26 |         $this->codePrinter = new Standard();
27 |     }
28 | 
29 |     public function leaveNode(Node $node)
30 |     {
31 |         if ($node instanceof Node\Stmt\Function_) {
32 |             $closureName = 'task';
33 |             $closure = $this->convertFunctionToClosure($node, $closureName);
34 |             eval($this->codePrinter->prettyPrint(array($closure)));
35 | 
36 |             $this->collection[] = CallableTask::buildFromClosure($this->cleanupTaskName($node), ${$closureName});
37 |         }
38 |     }
39 | 
40 |     /**
41 |      * @param Node $node
42 |      * @return mixed
43 |      */
44 |     private function cleanupTaskName(Node $node)
45 |     {
46 |         return str_replace('_', '', $node->name);
47 |     }
48 | 
49 |     /**
50 |      * @param Node $functionNode
51 |      * @return Node\Expr\Assign
52 |      */
53 |     private function convertFunctionToClosure(Node $functionNode, $closureName)
54 |     {
55 |         $attributes = array();
56 |         if ($functionNode->getDocComment()) {
57 |             $attributes['comments'] = array($functionNode->getDocComment());
58 |         }
59 | 
60 |         $closure = new Node\Expr\Assign(
61 |             new Node\Expr\Variable($closureName),
62 |             new Node\Expr\Closure(
63 |                 array(
64 |                     'stmts' => $functionNode->stmts,
65 |                     'params' => $functionNode->params
66 |                 )
67 |             ),
68 |             $attributes
69 |         );
70 |         return $closure;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Idephix/Console/Application.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\Console;
 4 | 
 5 | use Symfony\Component\Console\Application as BaseApplication;
 6 | use Symfony\Component\Console\Input\InputOption;
 7 | use Symfony\Component\Console\Command\HelpCommand;
 8 | use Idephix\Console\Command\ListCommand;
 9 | 
10 | class Application extends BaseApplication
11 | {
12 |     private $logo = <<<'EOD'
13 | 
14 |   ___    _            _     _
15 |  |_ _|__| | ___ _ __ | |__ (_)_  __
16 |   | |/ _` |/ _ \  _ \|  _  | \ \/ /
17 |   | | (_| |  __/ |_) | | | | |>  <
18 |  |___\__,_|\___| .__/|_| |_|_/_/\_\
19 |                |_|
20 | 
21 | 
22 | EOD;
23 | 
24 |     private $releaseDate;
25 | 
26 |     public function __construct(
27 |       $name = 'UNKNOWN',
28 |       $version = 'UNKNOWN',
29 |       $releaseDate = 'UNKNOWN')
30 |     {
31 |         parent::__construct($name, $version);
32 | 
33 |         $this->releaseDate = $releaseDate;
34 | 
35 |         $this->setAutoExit(false);
36 | 
37 |         $this->getDefinition()->addOption(new InputOption('--config', 'c', InputOption::VALUE_OPTIONAL, 'idxrc file path', getcwd() . '/' .'idxrc.php'));
38 |         $this->getDefinition()->addOption(new InputOption('--file', 'f', InputOption::VALUE_OPTIONAL, 'idxrc file path', getcwd() . '/' . 'idxfile.php'));
39 |         $this->getDefinition()->addOption(new InputOption('--env', null, InputOption::VALUE_REQUIRED, 'Set remote environment.'));
40 |     }
41 | 
42 |     public function getHelp()
43 |     {
44 |         return $this->logo . parent::getHelp();
45 |     }
46 | 
47 |     public function getLongVersion()
48 |     {
49 |         if ('UNKNOWN' === $this->getName() ||
50 |             'UNKNOWN' === $this->getVersion()) {
51 |             return '<info>Console Tool</info>';
52 |         }
53 | 
54 |         $version = sprintf(
55 |             '<info>%s</info> version <comment>%s</comment> released %s',
56 |             $this->getName(),
57 |             $this->getVersion(),
58 |             $this->releaseDate
59 |         );
60 | 
61 |         return $version;
62 |     }
63 | 
64 |     protected function getDefaultCommands()
65 |     {
66 |         return array(new HelpCommand(), new ListCommand());
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/Idephix/Task/CallableTask.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Task;
 3 | 
 4 | use Idephix\Task\Parameter\Collection;
 5 | use Idephix\Task\Parameter\Context;
 6 | use Idephix\Task\Parameter\UserDefined;
 7 | use Idephix\Task\Parameter\UserDefinedCollection;
 8 | use Idephix\Util\DocBlockParser;
 9 | 
10 | class CallableTask implements Task
11 | {
12 |     private $name;
13 |     private $description;
14 |     private $parameters;
15 |     private $code;
16 | 
17 |     public function __construct($name, $description, $code, Collection $parameters)
18 |     {
19 |         $this->name = $name;
20 |         $this->description = $description;
21 |         $this->parameters = $parameters;
22 |         $this->code = $code;
23 |     }
24 | 
25 |     /**
26 |      * @return static
27 |      */
28 |     public static function buildFromClosure($name, \Closure $code)
29 |     {
30 |         $parameters = Collection::dry();
31 | 
32 |         $reflector = new \ReflectionFunction($code);
33 |         $parser = new DocBlockParser($reflector->getDocComment());
34 | 
35 |         foreach ($reflector->getParameters() as $parameter) {
36 |             if ($parameter->getClass() && $parameter->getClass()->getName() == 'Idephix\Context') {
37 |                 $parameters[] = Context::create();
38 |                 continue;
39 |             }
40 | 
41 |             $description = $parser->getParamDescription($parameter->getName());
42 |             $default = $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null;
43 |             $parameters[] = UserDefined::create($parameter->getName(), $description, $default);
44 |         }
45 | 
46 |         return new CallableTask(str_replace('_', '', $name), $parser->getDescription(), $code, $parameters);
47 |     }
48 | 
49 |     public function name()
50 |     {
51 |         return $this->name;
52 |     }
53 | 
54 |     public function description()
55 |     {
56 |         return $this->description;
57 |     }
58 | 
59 |     /**
60 |      * @return Collection
61 |      */
62 |     public function parameters()
63 |     {
64 |         return $this->parameters;
65 |     }
66 | 
67 |     public function userDefinedParameters()
68 |     {
69 |         return new UserDefinedCollection($this->parameters);
70 |     }
71 | 
72 |     public function code()
73 |     {
74 |         return $this->code;
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/Idephix/Dictionary.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Idephix;
 5 | 
 6 | class Dictionary implements DictionaryAccess
 7 | {
 8 |     private $data = array();
 9 | 
10 |     private function __construct($data)
11 |     {
12 |         $this->data = $data;
13 |     }
14 | 
15 |     public static function fromArray($data)
16 |     {
17 |         return new static($data);
18 |     }
19 | 
20 |     public static function dry()
21 |     {
22 |         return new static(array());
23 |     }
24 | 
25 |     public function offsetExists($offset)
26 |     {
27 |         return array_key_exists($offset, $this->data);
28 |     }
29 | 
30 |     public function offsetGet($offset)
31 |     {
32 |         if (array_key_exists($offset, $this->data)) {
33 |             return $this->resolveElement($this->data[$offset]);
34 |         }
35 | 
36 |         $name = explode('.', $offset);
37 | 
38 |         $element = $this->data;
39 | 
40 |         foreach ($name as $i => $part) {
41 |             if (!isset($element[$part])) {
42 |                 return null;
43 |             }
44 | 
45 |             $element = $element[$part];
46 |         }
47 | 
48 |         return $this->resolveElement($element);
49 |     }
50 | 
51 |     public function offsetSet($offset, $value)
52 |     {
53 |         if (isset($this->data[$offset])) {
54 |             $this->data[$offset] = $value;
55 |             return;
56 |         }
57 | 
58 |         $offset = array_reverse(explode('.', $offset));
59 | 
60 |         $result = $value;
61 | 
62 |         foreach ($offset as $part) {
63 |             $result = array($part => $result);
64 |         }
65 | 
66 |         $this->data = array_replace_recursive($this->data, $result);
67 |     }
68 | 
69 |     public function offsetUnset($offset)
70 |     {
71 |         unset($this->data[$offset]);
72 |     }
73 | 
74 |     public function get($offset, $default = null)
75 |     {
76 |         if (is_null($this->offsetGet($offset))) {
77 |             return $default;
78 |         }
79 | 
80 |         return $this->offsetGet($offset);
81 |     }
82 | 
83 |     public function set($key, $value)
84 |     {
85 |         $this->offsetSet($key, $value);
86 |     }
87 | 
88 |     private function resolveElement($element)
89 |     {
90 |         if ($element instanceof \Closure) {
91 |             $element = $element();
92 |         }
93 | 
94 |         return $element;
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/Idephix/Console/Descriptor/DescriptorHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\Console\Descriptor;
 4 | 
 5 | use Symfony\Component\Console\Output\OutputInterface;
 6 | use Symfony\Component\Console\Helper\Helper;
 7 | use Symfony\Component\Console\Descriptor\DescriptorInterface;
 8 | 
 9 | class DescriptorHelper extends Helper
10 | {
11 |     /**
12 |      * @var DescriptorInterface[]
13 |      */
14 |     private $descriptors = array();
15 | 
16 |     /**
17 |      * Constructor.
18 |      */
19 |     public function __construct()
20 |     {
21 |         $this
22 |             ->register('txt',  new TextDescriptor())
23 |             // ->register('xml',  new XmlDescriptor())
24 |             // ->register('json', new JsonDescriptor())
25 |             // ->register('md',   new MarkdownDescriptor())
26 |         ;
27 |     }
28 | 
29 |     /**
30 |      * Describes an object if supported.
31 |      *
32 |      * Available options are:
33 |      * * format: string, the output format name
34 |      * * raw_text: boolean, sets output type as raw
35 |      *
36 |      * @param OutputInterface $output
37 |      * @param object          $object
38 |      * @param array           $options
39 |      *
40 |      * @throws \InvalidArgumentException when the given format is not supported
41 |      */
42 |     public function describe(OutputInterface $output, $object, array $options = array())
43 |     {
44 |         $options = array_merge(array(
45 |             'raw_text'  => false,
46 |             'format'    => 'txt',
47 |         ), $options);
48 | 
49 |         if (!isset($this->descriptors[$options['format']])) {
50 |             throw new \InvalidArgumentException(sprintf('Unsupported format "%s".', $options['format']));
51 |         }
52 | 
53 |         $descriptor = $this->descriptors[$options['format']];
54 |         $descriptor->describe($output, $object, $options);
55 |     }
56 | 
57 |     /**
58 |      * Registers a descriptor.
59 |      *
60 |      * @param string              $format
61 |      * @param DescriptorInterface $descriptor
62 |      *
63 |      * @return DescriptorHelper
64 |      */
65 |     public function register($format, DescriptorInterface $descriptor)
66 |     {
67 |         $this->descriptors[$format] = $descriptor;
68 | 
69 |         return $this;
70 |     }
71 | 
72 |     /**
73 |      * {@inheritdoc}
74 |      */
75 |     public function getName()
76 |     {
77 |         return 'descriptor';
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/Idephix/Task/TaskCollection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Task;
 3 | 
 4 | use Idephix\Exception\InvalidIdxFileException;
 5 | use Idephix\Task\Parsing\TaskCollector;
 6 | use PhpParser\Lexer;
 7 | use PhpParser\NodeTraverser;
 8 | use PhpParser\NodeVisitor\NameResolver;
 9 | use PhpParser\Parser;
10 | 
11 | class TaskCollection extends CollectionIterator
12 | {
13 |     public static function ofTasks($array)
14 |     {
15 |         return new static(
16 |             new \ArrayIterator(
17 |                 array_filter(
18 |                     $array,
19 |                     function ($task) {
20 |                         return $task instanceof Task;
21 |                     }
22 |                 )
23 |             )
24 |         );
25 |     }
26 | 
27 |     public static function ofFunctions($idxFileContent)
28 |     {
29 |         $collection = static::dry();
30 | 
31 |         $parser = new Parser(new Lexer());
32 |         $traverser = new NodeTraverser();
33 |         $traverser->addVisitor(new NameResolver());
34 |         $traverser->addVisitor(new TaskCollector($collection));
35 |         $stmts = $parser->parse($idxFileContent);
36 |         $traverser->traverse($stmts);
37 | 
38 |         return $collection;
39 |     }
40 |     
41 |     public static function parseFile($idxFile)
42 |     {
43 |         try {
44 |             new \SplFileObject($idxFile);
45 |         } catch (\RuntimeException $e) {
46 |             throw new InvalidIdxFileException("$idxFile does not exists or is not readable");
47 |         }
48 | 
49 |         return static::ofFunctions(file_get_contents($idxFile));
50 |     }
51 | 
52 |     public function offsetSet($offset, $value)
53 |     {
54 |         if (!$value instanceof Task) {
55 |             throw new \DomainException('TaskCollection can only accept \Idephix\Task\Task object');
56 |         }
57 | 
58 |         $this->getInnerIterator()->offsetSet($offset, $value);
59 |     }
60 | 
61 |     public function has($taskName)
62 |     {
63 |         foreach ($this->getInnerIterator() as $task) {
64 |             if ($taskName === $task->name()) {
65 |                 return true;
66 |             }
67 |         }
68 | 
69 |         return false;
70 |     }
71 | 
72 |     public function get($taskName)
73 |     {
74 |         foreach ($this->getInnerIterator() as $task) {
75 |             if ($taskName === $task->name()) {
76 |                 return $task;
77 |             }
78 |         }
79 | 
80 |         throw new \RuntimeException('Non existing task ' . $taskName);
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/breadcrumbs.html:
--------------------------------------------------------------------------------
 1 | {# Support for Sphinx 1.3+ page_source_suffix, but don't break old builds. #}
 2 | 
 3 | {% if page_source_suffix %}
 4 | {% set suffix = page_source_suffix %}
 5 | {% else %}
 6 | {% set suffix = source_suffix %}
 7 | {% endif %}
 8 | 
 9 | {% if meta is defined and meta is not none %}
10 | {% set check_meta = True %}
11 | {% else %}
12 | {% set check_meta = False %}
13 | {% endif %}
14 | 
15 | {% if check_meta and 'github_url' in meta %}
16 | {% set display_github = True %}
17 | {% endif %}
18 | 
19 | {% if check_meta and 'bitbucket_url' in meta %}
20 | {% set display_bitbucket = True %}
21 | {% endif %}
22 | 
23 | <div role="navigation" aria-label="breadcrumbs navigation">
24 |   <ul class="wy-breadcrumbs">
25 |     {% block breadcrumbs %}
26 |       <li><a href="{{ pathto(master_doc) }}">Docs</a> &raquo;</li>
27 |         {% for doc in parents %}
28 |           <li><a href="{{ doc.link|e }}">{{ doc.title }}</a> &raquo;</li>
29 |         {% endfor %}
30 |       <li>{{ title }}</li>
31 |     {% endblock %}
32 |     {% block breadcrumbs_aside %}
33 |       <li class="wy-breadcrumbs-aside">
34 |         {% if pagename != "search" %}
35 |             {% if display_github %}
36 |             {% if check_meta and 'github_url' in meta %}
37 |               <!-- User defined GitHub URL -->
38 |               <a href="{{ meta['github_url'] }}" class="fa fa-github"> Edit on GitHub</a>
39 |             {% else %}
40 |               <a href="https://{{ github_host|default("github.com") }}/{{ github_user }}/{{ github_repo }}/blob/{{ github_version }}{{ conf_py_path }}{{ pagename }}{{ suffix }}" class="fa fa-github"> Edit on GitHub</a>
41 |             {% endif %}
42 |           {% elif display_bitbucket %}
43 |             {% if check_meta and 'bitbucket_url' in meta %}
44 |               <!-- User defined Bitbucket URL -->
45 |               <a href="{{ meta['bitbucket_url'] }}" class="fa fa-bitbucket"> Edit on Bitbucket</a>
46 |             {% else %}
47 |               <a href="https://bitbucket.org/{{ bitbucket_user }}/{{ bitbucket_repo }}/src/{{ bitbucket_version}}{{ conf_py_path }}{{ pagename }}{{ suffix }}" class="fa fa-bitbucket"> Edit on Bitbucket</a>
48 |             {% endif %}
49 |           {% elif show_source and source_url_prefix %}
50 |             <a href="{{ source_url_prefix }}{{ pagename }}{{ suffix }}">View page source</a>
51 |           {% elif show_source and has_source and sourcename %}
52 |             <a href="{{ pathto('_sources/' + sourcename, true)|e }}" rel="nofollow"> View page source</a>
53 |           {% endif %}
54 |         {% endif %}
55 |       </li>
56 |     {% endblock %}
57 |   </ul>
58 |   <hr/>
59 | </div>
60 | 


--------------------------------------------------------------------------------
/src/Idephix/Task/Builtin/SelfUpdate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\Task\Builtin;
 4 | 
 5 | use Idephix\Task\Parameter;
 6 | use Idephix\Idephix;
 7 | use Idephix\Extension\IdephixAwareInterface;
 8 | use Idephix\Task\Task;
 9 | 
10 | class SelfUpdate implements IdephixAwareInterface, Task
11 | {
12 |     private $idx;
13 | 
14 |     public function setIdephix(Idephix $idx)
15 |     {
16 |         $this->idx = $idx;
17 |     }
18 | 
19 |     public function name()
20 |     {
21 |         return 'selfupdate';
22 |     }
23 | 
24 |     public function description()
25 |     {
26 |         return 'Update Idephix to the latest version';
27 |     }
28 | 
29 |     public function code()
30 |     {
31 |         return array($this, 'update');
32 |     }
33 | 
34 |     public function parameters()
35 |     {
36 |         return Parameter\Collection::dry();
37 |     }
38 | 
39 |     public function userDefinedParameters()
40 |     {
41 |         return new Parameter\UserDefinedCollection($this->parameters());
42 |     }
43 | 
44 |     /**
45 |      * Based by composer self-update
46 |      */
47 |     public function update()
48 |     {
49 |         $baseUrl = 'http://getidephix.com/';
50 |         $latest = trim(file_get_contents($baseUrl.'version'));
51 | 
52 |         if (Idephix::VERSION !== $latest) {
53 |             $this->idx->output->writeln(sprintf('Updating to version <info>%s</info>.', $latest));
54 | 
55 |             $remoteFilename = $baseUrl.'idephix.phar';
56 |             $localFilename = $_SERVER['argv'][0];
57 |             $tempFilename = basename($localFilename, '.phar').'-temp.phar';
58 | 
59 |             file_put_contents($tempFilename, file_get_contents($remoteFilename));
60 | 
61 |             try {
62 |                 chmod($tempFilename, 0777 & ~umask());
63 |                 // test the phar validity
64 |                 $phar = new \Phar($tempFilename);
65 |                 // free the variable to unlock the file
66 |                 unset($phar);
67 |                 rename($tempFilename, $localFilename);
68 |             } catch (\Exception $e) {
69 |                 @unlink($tempFilename);
70 |                 if (!$e instanceof \UnexpectedValueException && !$e instanceof \PharException) {
71 |                     throw $e;
72 |                 }
73 |                 $this->idx->output->writeln('<error>The download is corrupted ('.$e->getMessage().').</error>');
74 |                 $this->idx->output->writeln('<error>Please re-run the self-update command to try again.</error>');
75 |             }
76 |         } else {
77 |             $this->idx->output->writeln('<info>You are using the latest idephix version.</info>');
78 |         }
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/src/Idephix/Console/Command/ListCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\Console\Command;
 4 | 
 5 | use Symfony\Component\Console\Input\InputArgument;
 6 | use Symfony\Component\Console\Input\InputOption;
 7 | use Symfony\Component\Console\Input\InputInterface;
 8 | use Symfony\Component\Console\Output\OutputInterface;
 9 | use Symfony\Component\Console\Input\InputDefinition;
10 | use Symfony\Component\Console\Command\Command;
11 | use Idephix\Console\Descriptor\DescriptorHelper;
12 | 
13 | class ListCommand extends Command
14 | {
15 |     /**
16 |      * {@inheritdoc}
17 |      */
18 |     protected function configure()
19 |     {
20 |         $this
21 |             ->setName('list')
22 |             ->setDefinition($this->createDefinition())
23 |             ->setDescription('Lists commands')
24 |             ->setHelp(<<<EOF
25 | The <info>%command.name%</info> command lists all commands:
26 | 
27 |   <info>php %command.full_name%</info>
28 | 
29 | You can also display the commands for a specific namespace:
30 | 
31 |   <info>php %command.full_name% test</info>
32 | 
33 | You can also output the information in other formats by using the <comment>--format</comment> option:
34 | 
35 |   <info>php %command.full_name% --format=xml</info>
36 | 
37 | It's also possible to get raw list of commands (useful for embedding command runner):
38 | 
39 |   <info>php %command.full_name% --raw</info>
40 | EOF
41 |             )
42 |         ;
43 |     }
44 | 
45 |     /**
46 |      * {@inheritdoc}
47 |      */
48 |     public function getNativeDefinition()
49 |     {
50 |         return $this->createDefinition();
51 |     }
52 | 
53 |     /**
54 |      * {@inheritdoc}
55 |      */
56 |     protected function execute(InputInterface $input, OutputInterface $output)
57 |     {
58 |         if ($input->getOption('xml')) {
59 |             $input->setOption('format', 'xml');
60 |         }
61 | 
62 |         $helper = new DescriptorHelper();
63 |         $helper->describe($output, $this->getApplication(), array(
64 |             'format'    => $input->getOption('format'),
65 |             'raw_text'  => $input->getOption('raw'),
66 |             'namespace' => $input->getArgument('namespace'),
67 |         ));
68 |     }
69 | 
70 |     /**
71 |      * {@inheritdoc}
72 |      */
73 |     private function createDefinition()
74 |     {
75 |         return new InputDefinition(array(
76 |             new InputArgument('namespace', InputArgument::OPTIONAL, 'The namespace name'),
77 |             new InputOption('xml', null, InputOption::VALUE_NONE, 'To output list as XML'),
78 |             new InputOption('raw', null, InputOption::VALUE_NONE, 'To output raw command list'),
79 |             new InputOption('format', null, InputOption::VALUE_REQUIRED, 'To output list in other formats', 'txt'),
80 |         ));
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/Idephix/SSH/PeclSsh2Proxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\SSH;
 4 | 
 5 | class PeclSsh2Proxy extends BaseProxy
 6 | {
 7 |     const RETURN_TOKEN = '__RETURNS__:';
 8 | 
 9 |     public function connect($host, $port = 22)
10 |     {
11 |         if (!empty($this->connection)) {
12 |             return $this->connection;
13 |         }
14 |         $this->connection = ssh2_connect($host, $port, null, array('disconnect', array($this, 'disconnect')));
15 | 
16 |         return $this->connection;
17 |     }
18 | 
19 |     public function authByPassword($user, $password)
20 |     {
21 |         return ssh2_auth_password($this->connection, $user, $password);
22 |     }
23 | 
24 |     public function authByPublicKey($user, $publicKeyFile, $privateKeyFile, $pwd)
25 |     {
26 |         return ssh2_auth_pubkey_file($this->connection, $user, $publicKeyFile, $privateKeyFile, $pwd);
27 |     }
28 | 
29 |     public function authByAgent($user)
30 |     {
31 |         if (!function_exists('ssh2_auth_agent')) {
32 |             throw new \Exception('ssh2_auth_agent does not exists');
33 |         }
34 | 
35 |         return ssh2_auth_agent($this->connection, $user);
36 |     }
37 | 
38 |     public function isSuccessful()
39 |     {
40 |         return 0 == $this->getExitCode();
41 |     }
42 | 
43 |     public function exec($cmd)
44 |     {
45 |         $stdout = ssh2_exec($this->connection, $cmd.'; echo "'.self::RETURN_TOKEN.'$?"', 'ansi');
46 |         $stderr = ssh2_fetch_stream($stdout, SSH2_STREAM_STDERR);
47 | 
48 |         stream_set_blocking($stderr, true);
49 |         $this->lastError = stream_get_contents($stderr);
50 | 
51 |         stream_set_blocking($stdout, true);
52 |         $this->lastOutput = stream_get_contents($stdout);
53 | 
54 |         $this->exitCode = -1;
55 | 
56 |         $pos = strpos($this->lastOutput, self::RETURN_TOKEN);
57 | 
58 |         if (false === $pos) {
59 |             return false;
60 |         }
61 | 
62 |         $this->exitCode = substr($this->lastOutput, $pos + strlen(self::RETURN_TOKEN));
63 |         $this->lastOutput = substr($this->lastOutput, 0, $pos);
64 | 
65 |         return $this->isSuccessful();
66 |     }
67 | 
68 |     public function disconnect()
69 |     {
70 |         if (null !== $this->connection) {
71 |             $this->exec('exit');
72 |             $this->connection = null;
73 |         }
74 |     }
75 | 
76 |     public function __destruct()
77 |     {
78 |         $this->disconnect();
79 |     }
80 | 
81 |     /**
82 |      * @inheritdoc
83 |      */
84 |     public function put($localPath, $remotePath)
85 |     {
86 |         return ssh2_scp_send($this->connection, $localPath, $remotePath);
87 |     }
88 | 
89 |     /**
90 |      * @inheritdoc
91 |      */
92 |     public function get($remotePath, $localPath)
93 |     {
94 |         return ssh2_scp_recv($this->connection, $remotePath, $localPath);
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/Idephix/Extension/Project/Rsync.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\Extension\Project;
 4 | 
 5 | use Idephix\Extension;
 6 | use Idephix\Extension\MethodCollection;
 7 | use Idephix\Extension\IdephixAwareInterface;
 8 | use Idephix\Idephix;
 9 | use Idephix\Task\TaskCollection;
10 | 
11 | /**
12 |  * Provide a basic rsync interface based on current Idephix context
13 |  */
14 | class Rsync implements IdephixAwareInterface, Extension
15 | {
16 |     /**
17 |      * @var \Idephix\Context
18 |      */
19 |     private $idx;
20 | 
21 |     public function setIdephix(Idephix $idx)
22 |     {
23 |         $this->idx = $idx;
24 |     }
25 | 
26 |     public function name()
27 |     {
28 |         return 'rsync';
29 |     }
30 | 
31 |     /** @return MethodCollection */
32 |     public function methods()
33 |     {
34 |         return MethodCollection::ofCallables(
35 |             array(
36 |                 new Extension\CallableMethod('rsyncProject', array($this, 'rsyncProject'))
37 |             )
38 |         );
39 |     }
40 | 
41 |     /** @return TaskCollection */
42 |     public function tasks()
43 |     {
44 |         return TaskCollection::dry();
45 |     }
46 | 
47 |     public function rsyncProject($remoteDir, $localDir = null, $exclude = null, $extraOpts = null)
48 |     {
49 |         if (substr($remoteDir, -1) != '/') {
50 |             $remoteDir .= '/';
51 |         }
52 | 
53 |         $context = $this->idx->getContext();
54 | 
55 |         if ($context->currentHost() === null) {
56 |             throw new \InvalidArgumentException('A host must be selected, invalid Context provided');
57 |         }
58 | 
59 | 
60 |         $port = $context->get('ssh_params.port');
61 | 
62 |         if (file_exists($exclude)) {
63 |             $extraOpts .= ' --exclude-from='.escapeshellarg($exclude);
64 |         } elseif (!empty($exclude)) {
65 |             $exclude = is_array($exclude) ? $exclude : array($exclude);
66 |             $extraOpts .= array_reduce($exclude, function ($carry, $item) {
67 |                 return $carry.' --exclude='.escapeshellarg($item);
68 |             });
69 |         }
70 | 
71 |         $sshCmd = 'ssh';
72 |         if ($port) {
73 |             $sshCmd .= ' -p ' . $port;
74 |         }
75 | 
76 |         $remoteConnection = $this->connectionString($context->currentHost(), $context->get('ssh_params.user'));
77 | 
78 |         $cmd = "rsync -rlDcz --force --delete --progress $extraOpts -e '$sshCmd' $localDir $remoteConnection:$remoteDir";
79 | 
80 |         return $this->idx->local($cmd);
81 |     }
82 | 
83 |     /**
84 |      * @param $host
85 |      * @param null $user
86 |      * @return string
87 |      */
88 |     private function connectionString($host, $user = null)
89 |     {
90 |         $remoteConnection = '';
91 |         $remoteConnection .= is_null($user) ? '' : "$user@";
92 |         $remoteConnection .= $host;
93 | 
94 |         return $remoteConnection;
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/Idephix/Extension/Slack/Slack.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Idephix\Extension\Slack;
  4 | 
  5 | use Idephix\Extension;
  6 | use Idephix\Extension\MethodCollection;
  7 | use Idephix\Idephix;
  8 | use Idephix\Extension\IdephixAwareInterface;
  9 | use Idephix\Task\TaskCollection;
 10 | 
 11 | /**
 12 |  * Description of Slack wrapper
 13 |  *
 14 |  * @author dymissy
 15 |  */
 16 | class Slack implements IdephixAwareInterface, Extension
 17 | {
 18 |     /**
 19 |      * @var \Idephix\Context
 20 |      */
 21 |     private $idx;
 22 | 
 23 |     private $settings;
 24 | 
 25 |     public function __construct($args = array())
 26 |     {
 27 |         $defaults = array(
 28 |             'url' => '',
 29 |             'channel' => '#general',
 30 |             'icon_url' => 'https://slack.com/img/icons/app-57.png',
 31 |             'username' => 'slackbot'
 32 |         );
 33 | 
 34 |         $this->settings = array_merge($defaults, $args);
 35 |     }
 36 | 
 37 |     /** @return TaskCollection */
 38 |     public function tasks()
 39 |     {
 40 |         return TaskCollection::dry();
 41 |     }
 42 | 
 43 |     public function name()
 44 |     {
 45 |         return 'slack';
 46 |     }
 47 | 
 48 |     public function sendToSlack($message, $attachments = array(), $channel = '', $icon_url = '', $username = '')
 49 |     {
 50 |         if (!$channel) {
 51 |             $channel = $this->settings['channel'];
 52 |         }
 53 | 
 54 |         if (!$icon_url) {
 55 |             $icon_url = $this->settings['icon_url'];
 56 |         }
 57 | 
 58 |         if (!$username) {
 59 |             $username = $this->settings['username'];
 60 |         }
 61 | 
 62 |         $data = 'payload=' . json_encode(array(
 63 |                 'channel' => $channel,
 64 |                 'text' => $message,
 65 |                 'icon_url' => $icon_url,
 66 |                 'unfurl_links' => true,
 67 |                 'username' => $username,
 68 |                 'attachments' => $attachments
 69 |             ));
 70 | 
 71 |         $url = $this->settings['url'];
 72 |         $response = $this->send($data, $url);
 73 | 
 74 |         if ($response != 'ok') {
 75 |             throw new \Exception('Unable to send the message to Slack. The error returned is: ' . $response);
 76 |         }
 77 | 
 78 |         $this->idx->local("echo 'Message sent to slack channel'");
 79 | 
 80 |         return $response;
 81 |     }
 82 | 
 83 |     protected function send($data, $url)
 84 |     {
 85 |         $ch = curl_init($url);
 86 |         curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
 87 |         curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
 88 |         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 89 |         $result = curl_exec($ch);
 90 |         curl_close($ch);
 91 | 
 92 |         return $result;
 93 |     }
 94 | 
 95 |     public function setIdephix(Idephix $idx)
 96 |     {
 97 |         $this->idx = $idx;
 98 |     }
 99 | 
100 |     /** @return MethodCollection */
101 |     public function methods()
102 |     {
103 |         return MethodCollection::dry();
104 |     }
105 | }
106 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/css/badge_only.css.map:
--------------------------------------------------------------------------------
1 | {
2 | "version": 3,
3 | "mappings": "CAyDA,SAAY,EACV,qBAAsB,EAAE,UAAW,EAqDrC,QAAS,EARP,IAAK,EAAE,AAAC,EACR,+BAAS,EAEP,MAAO,EAAE,IAAK,EACd,MAAO,EAAE,CAAE,EACb,cAAO,EACL,IAAK,EAAE,GAAI,EC1Gb,SAkBC,EAjBC,UAAW,ECFJ,UAAW,EDGlB,UAAW,EAHqC,KAAM,EAItD,SAAU,EAJsD,KAAM,EAapE,EAAG,EAAE,qCAAwB,EAC7B,EAAG,EAAE,0PAAyE,ECZpF,SAAU,EACR,MAAO,EAAE,WAAY,EACrB,UAAW,EAAE,UAAW,EACxB,SAAU,EAAE,KAAM,EAClB,UAAW,EAAE,KAAM,EACnB,UAAW,EAAE,AAAC,EACd,cAAe,EAAE,MAAO,EAG1B,IAAK,EACH,MAAO,EAAE,WAAY,EACrB,cAAe,EAAE,MAAO,EAIxB,KAAG,EACD,MAAO,EAAE,WAAY,EACvB,sCAAiB,EAGf,IAAK,EAAE,MAAY,EAEvB,KAAM,EACJ,cAAe,EAAE,GAAI,EACrB,UAAW,EAAE,EAAG,EAChB,UAAW,EAAE,KAAM,EAEjB,YAAG,EACD,IAAK,EAAE,IAAI,EACb,oDAAiB,EAGf,aAAc,EAAE,OAAQ,EAG9B,cAAe,EACb,MAAO,EAAE,EAAO,EAElB,gBAAiB,EACf,MAAO,EAAE,EAAO,EAElB,oBAAqB,EACnB,MAAO,EAAE,EAAO,EAElB,sBAAuB,EACrB,MAAO,EAAE,EAAO,EAElB,kBAAmB,EACjB,MAAO,EAAE,EAAO,EAElB,oBAAqB,EACnB,MAAO,EAAE,EAAO,EAElB,oBAAqB,EACnB,MAAO,EAAE,EAAO,EAElB,sBAAuB,EACrB,MAAO,EAAE,EAAO,EAElB,qBAAsB,EACpB,MAAO,EAAE,EAAO,EAElB,uBAAwB,EACtB,MAAO,EAAE,EAAO,ECnElB,YAAa,EACX,OAAQ,EAAE,IAAK,EACf,KAAM,EAAE,AAAC,EACT,GAAI,EAAE,AAAC,EACP,IAAK,EC6E+B,IAAK,ED5EzC,IAAK,EEoC+B,MAAyB,EFnC7D,SAAU,EAAE,MAAkC,EAC9C,SAAU,EAAE,iBAAiC,EAC7C,UAAW,EE+CyB,sDAAM,EF9C1C,MAAO,EC+E6B,EAAG,ED9EvC,cAAC,EACC,IAAK,EE+B6B,MAAK,EF9BvC,cAAe,EAAE,GAAI,EACvB,6BAAgB,EACd,MAAO,EAAE,GAAI,EACf,iCAAoB,EAClB,MAAO,EAAE,GAAqB,EAC9B,eAAgB,EAAE,MAAkC,EACpD,MAAO,EAAE,IAAK,EACd,SAAU,EAAE,IAAK,EACjB,QAAS,EAAE,EAAG,EACd,KAAM,EAAE,MAAO,EACf,IAAK,EEX6B,MAAM,EL4F1C,IAAK,EAAE,AAAC,EACR,iFAAS,EAEP,MAAO,EAAE,IAAK,EACd,MAAO,EAAE,CAAE,EACb,uCAAO,EACL,IAAK,EAAE,GAAI,EGrFX,qCAAG,EACD,IAAK,EEgB2B,MAAyB,EFf3D,0CAAQ,EACN,IAAK,EAAE,GAAI,EACb,4CAAU,EACR,IAAK,EAAE,GAAI,EACb,iDAAiB,EACf,eAAgB,ECQgB,MAAI,EDPpC,IAAK,EEI2B,GAAM,EFHxC,wDAAwB,EACtB,eAAgB,EEmBgB,MAAO,EFlBvC,IAAK,ECzB2B,GAAI,ED0BxC,yCAA8B,EAC5B,MAAO,EAAE,IAAK,EAChB,gCAAmB,EACjB,QAAS,EAAE,EAAG,EACd,MAAO,EAAE,GAAqB,EAC9B,IAAK,EEP6B,GAAY,EFQ9C,MAAO,EAAE,GAAI,EACb,mCAAE,EACA,MAAO,EAAE,IAAK,EACd,KAAM,EAAE,EAAG,EACX,KAAM,EAAE,AAAC,EACT,KAAM,EAAE,KAAM,EACd,MAAO,EAAE,AAAC,EACV,SAAU,EAAE,gBAA6C,EAC3D,mCAAE,EACA,MAAO,EAAE,WAAY,EACrB,KAAM,EAAE,AAAC,EACT,qCAAC,EACC,MAAO,EAAE,WAAY,EACrB,MAAO,EAAE,EAAqB,EAC9B,IAAK,EEfyB,MAAyB,EFgB7D,sBAAW,EACT,IAAK,EAAE,GAAI,EACX,KAAM,EAAE,GAAI,EACZ,IAAK,EAAE,GAAI,EACX,GAAI,EAAE,GAAI,EACV,KAAM,EAAE,GAAI,EACZ,QAAS,ECkByB,IAAK,EDjBvC,iCAAU,EACR,IAAK,EAAE,GAAI,EACb,+BAAQ,EACN,IAAK,EAAE,GAAI,EACb,oDAA+B,EAC7B,SAAU,EAAE,IAAK,EACjB,6DAAQ,EACN,IAAK,EAAE,GAAI,EACb,+DAAU,EACR,IAAK,EAAE,GAAI,EACf,2CAAoB,EAClB,IAAK,EAAE,GAAI,EACX,KAAM,EAAE,GAAI,EACZ,UAAW,EAAE,GAAI,EACjB,MAAO,EAAE,IAAuB,EAChC,MAAO,EAAE,IAAK,EACd,SAAU,EAAE,KAAM,EGhDpB,mCAAsB,EHmDxB,YAAa,EACX,IAAK,EAAE,EAAG,EACV,MAAO,EAAE,GAAI,EACb,kBAAO,EACL,MAAO,EAAE,IAAK,EAClB,EAAG,EACD,IAAK,EAAE,GAAI,EACX,KAAM,EAAE,GAAI",
4 | "sources": ["../../../bower_components/wyrm/sass/wyrm_core/_mixin.sass","../../../bower_components/bourbon/dist/css3/_font-face.scss","../../../sass/_theme_badge_fa.sass","../../../sass/_theme_badge.sass","../../../bower_components/wyrm/sass/wyrm_core/_wy_variables.sass","../../../sass/_theme_variables.sass","../../../bower_components/neat/app/assets/stylesheets/grid/_media.scss"],
5 | "names": [],
6 | "file": "badge_only.css"
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Idephix/Task/Builtin/InitIdxFile.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Idephix\Task\Builtin;
  3 | 
  4 | use Idephix\Extension\IdephixAwareInterface;
  5 | use Idephix\Idephix;
  6 | use Idephix\Task\Task;
  7 | use Idephix\Task\Parameter\Collection;
  8 | use Idephix\Task\Parameter\UserDefinedCollection;
  9 | 
 10 | class InitIdxFile implements Task, IdephixAwareInterface
 11 | {
 12 |     private $idx;
 13 |     private $baseDir;
 14 |     private $idxFileTemplate;
 15 |     private $idxRcTemplate;
 16 | 
 17 |     public function __construct($writeTo = '.', $idxFileTemplate, $idxRcTemplate)
 18 |     {
 19 |         $this->baseDir = $writeTo;
 20 |         $this->idxFileTemplate = $idxFileTemplate;
 21 |         $this->idxRcTemplate = $idxRcTemplate;
 22 |     }
 23 | 
 24 |     /**
 25 |      * @param string $writeTo
 26 |      * @return static
 27 |      */
 28 |     public static function fromDeployRecipe($writeTo = '.')
 29 |     {
 30 |         return new static(
 31 |             $writeTo,
 32 |             __DIR__ . '/../../Cookbook/Deploy/idxfile.php',
 33 |             __DIR__ . '/../../Cookbook/Deploy/idxrc.php'
 34 |         );
 35 |     }
 36 | 
 37 |     public function name()
 38 |     {
 39 |         return 'initFile';
 40 |     }
 41 | 
 42 |     public function description()
 43 |     {
 44 |         return 'Init idx configurations and tasks file';
 45 |     }
 46 | 
 47 |     public function parameters()
 48 |     {
 49 |         return Collection::dry();
 50 |     }
 51 | 
 52 |     public function userDefinedParameters()
 53 |     {
 54 |         return new UserDefinedCollection($this->parameters());
 55 |     }
 56 | 
 57 |     public function code()
 58 |     {
 59 |         return array($this, 'initFile');
 60 |     }
 61 | 
 62 |     /**
 63 |      * Based by composer self-update
 64 |      */
 65 |     public function initFile()
 66 |     {
 67 |         $this->initIdxFile();
 68 |         $this->initIdxRc();
 69 |     }
 70 | 
 71 |     private function initIdxRc()
 72 |     {
 73 |         $data = file_get_contents($this->idxRcTemplate);
 74 |         $this->writeFile('idxrc.php', $data);
 75 |     }
 76 | 
 77 |     private function initIdxFile()
 78 |     {
 79 |         $data = file_get_contents($this->idxFileTemplate);
 80 |         $this->writeFile('idxfile.php', $data);
 81 |     }
 82 | 
 83 |     private function writeFile($filename, $data)
 84 |     {
 85 |         $idxFile = $this->baseDir . DIRECTORY_SEPARATOR . $filename;
 86 |         if (file_exists($idxFile)) {
 87 |             $this->idx->output->writeln("<error>An {$filename} already exists, generation skipped.</error>");
 88 | 
 89 |             return;
 90 |         }
 91 | 
 92 |         $this->idx->output->writeln("Creating basic {$filename} file...");
 93 | 
 94 |         if (!is_writable($this->baseDir) || false === file_put_contents($idxFile, $data)) {
 95 |             throw new \Exception("Cannot write {$filename}, check your permission configuration.");
 96 |         }
 97 | 
 98 |         $this->idx->output->writeln("{$filename} file created.");
 99 |     }
100 | 
101 |     /**
102 |      * @param Idephix $idx
103 |      */
104 |     public function setIdephix(Idephix $idx)
105 |     {
106 |         $this->idx = $idx;
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/docs/Cookbook/Deploy/idxfile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | function deploy(Idephix\Context $context, $go = false)
 4 | {
 5 |     $sharedFiles = $context->get('deploy.shared_files', array());
 6 |     $sharedFolders = $context->get('deploy.shared_folders', array());
 7 |     $remoteBaseDir = $context->get('deploy.remote_base_dir');
 8 |     $rsyncExclude = $context->get('deploy.rsync_exclude');
 9 |     $repository = $context->get('deploy.repository');
10 |     $deployBranch = $context->get('deploy.branch');
11 |     $nextRelease = "$remoteBaseDir/releases/" . time();
12 |     $linkedRelease = "$remoteBaseDir/current";
13 |     $localArtifact = '.deploy';
14 |     $context->prepareArtifact($localArtifact, $repository, $deployBranch, $go);
15 |     $context->prepareSharedFilesAndFolders($remoteBaseDir, $sharedFolders, $sharedFiles, $go);
16 |     try {
17 |         $context->remote("cd $remoteBaseDir && cp -pPR `readlink {$linkedRelease}` $nextRelease");
18 |     } catch (\Exception $e) {
19 |         $context->output()->writeln('<info>First deploy, sending the whole project</info>');
20 |     }
21 |     $dryRun = $go ? '' : '--dry-run';
22 |     $context->rsyncProject($nextRelease, $localArtifact . '/', $rsyncExclude, $dryRun, $go);
23 |     $context->linkSharedFilesAndFolders($sharedFiles, $sharedFolders, $nextRelease, $remoteBaseDir, $go);
24 |     $context->switchToNextRelease($remoteBaseDir, $nextRelease, $go);
25 | }
26 | 
27 | function prepareArtifact(Idephix\Context $context, $localArtifact, $repository, $deployBranch, $go = false)
28 | {
29 |     $context->local(
30 |         "
31 |         rm -Rf {$localArtifact} && \\
32 |         git clone {$repository} {$localArtifact} && \\
33 |         cd {$localArtifact} && \\
34 |         git fetch && \\
35 |         git checkout --force {$deployBranch} && \\
36 |         composer install --no-dev --prefer-dist --no-progress --optimize-autoloader --no-interaction
37 |         ",
38 |         !$go
39 |     );
40 | }
41 | 
42 | function prepareSharedFilesAndFolders(Idephix\Context $context, $remoteBaseDir, $sharedFolders, $sharedFiles, $go = false)
43 | {
44 |     $context->remote(
45 |         "mkdir -p {$remoteBaseDir}/releases && \\
46 |          mkdir -p {$remoteBaseDir}/shared",
47 |         !$go
48 |     );
49 |     foreach ($sharedFolders as $folder) {
50 |         $context->remote("mkdir -p {$remoteBaseDir}/shared/{$folder}", !$go);
51 |     }
52 |     foreach ($sharedFiles as $file) {
53 |         $sharedFile = "{$remoteBaseDir}/shared/{$file}";
54 |         $context->remote("mkdir -p `dirname '{$sharedFile}'` && touch \"$sharedFile\"", !$go);
55 |     }
56 | }
57 | function linkSharedFilesAndFolders(Idephix\Context $context, $sharedFiles, $sharedFolders, $nextRelease, $remoteBaseDir, $go = false)
58 | {
59 |     foreach (array_merge($sharedFiles, $sharedFolders) as $item) {
60 |         $context->remote("rm -r $nextRelease/$item", !$go);
61 |         $context->remote("ln -nfs $remoteBaseDir/shared/$item $nextRelease/$item", !$go);
62 |     }
63 | }
64 | 
65 | function switchToNextRelease(Idephix\Context $context, $remoteBaseDir, $nextRelease, $go = false)
66 | {
67 |     $context->remote(
68 |         "
69 |         cd $remoteBaseDir && \\
70 |         ln -nfs $nextRelease current",
71 |         !$go
72 |     );
73 | }
74 | 


--------------------------------------------------------------------------------
/src/Idephix/Cookbook/Deploy/idxfile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | function deploy(Idephix\Context $context, $go = false)
 4 | {
 5 |     $sharedFiles = $context->get('deploy.shared_files', array());
 6 |     $sharedFolders = $context->get('deploy.shared_folders', array());
 7 |     $remoteBaseDir = $context->get('deploy.remote_base_dir');
 8 |     $rsyncExclude = $context->get('deploy.rsync_exclude');
 9 |     $repository = $context->get('deploy.repository');
10 |     $deployBranch = $context->get('deploy.branch');
11 |     $nextRelease = "$remoteBaseDir/releases/" . time();
12 |     $linkedRelease = "$remoteBaseDir/current";
13 |     $localArtifact = '.deploy';
14 |     $context->prepareArtifact($localArtifact, $repository, $deployBranch, $go);
15 |     $context->prepareSharedFilesAndFolders($remoteBaseDir, $sharedFolders, $sharedFiles, $go);
16 |     try {
17 |         $context->remote("cd $remoteBaseDir && cp -pPR `readlink {$linkedRelease}` $nextRelease");
18 |     } catch (\Exception $e) {
19 |         $context->output()->writeln('<info>First deploy, sending the whole project</info>');
20 |     }
21 |     $dryRun = $go ? '' : '--dry-run';
22 |     $context->rsyncProject($nextRelease, $localArtifact . '/', $rsyncExclude, $dryRun, $go);
23 |     $context->linkSharedFilesAndFolders($sharedFiles, $sharedFolders, $nextRelease, $remoteBaseDir, $go);
24 |     $context->switchToNextRelease($remoteBaseDir, $nextRelease, $go);
25 | }
26 | 
27 | function prepareArtifact(Idephix\Context $context, $localArtifact, $repository, $deployBranch, $go = false)
28 | {
29 |     $context->local(
30 |         "
31 |         rm -Rf {$localArtifact} && \\
32 |         git clone {$repository} {$localArtifact} && \\
33 |         cd {$localArtifact} && \\
34 |         git fetch && \\
35 |         git checkout --force {$deployBranch} && \\
36 |         composer install --no-dev --prefer-dist --no-progress --optimize-autoloader --no-interaction
37 |         ",
38 |         !$go
39 |     );
40 | }
41 | 
42 | function prepareSharedFilesAndFolders(Idephix\Context $context, $remoteBaseDir, $sharedFolders, $sharedFiles, $go = false)
43 | {
44 |     $context->remote(
45 |         "mkdir -p {$remoteBaseDir}/releases && \\
46 |          mkdir -p {$remoteBaseDir}/shared",
47 |         !$go
48 |     );
49 |     foreach ($sharedFolders as $folder) {
50 |         $context->remote("mkdir -p {$remoteBaseDir}/shared/{$folder}", !$go);
51 |     }
52 |     foreach ($sharedFiles as $file) {
53 |         $sharedFile = "{$remoteBaseDir}/shared/{$file}";
54 |         $context->remote("mkdir -p `dirname '{$sharedFile}'` && touch \"$sharedFile\"", !$go);
55 |     }
56 | }
57 | function linkSharedFilesAndFolders(Idephix\Context $context, $sharedFiles, $sharedFolders, $nextRelease, $remoteBaseDir, $go = false)
58 | {
59 |     foreach (array_merge($sharedFiles, $sharedFolders) as $item) {
60 |         $context->remote("rm -r $nextRelease/$item", !$go);
61 |         $context->remote("ln -nfs $remoteBaseDir/shared/$item $nextRelease/$item", !$go);
62 |     }
63 | }
64 | 
65 | function switchToNextRelease(Idephix\Context $context, $remoteBaseDir, $nextRelease, $go = false)
66 | {
67 |     $context->remote(
68 |         "
69 |         cd $remoteBaseDir && \\
70 |         ln -nfs $nextRelease current",
71 |         !$go
72 |     );
73 | }
74 | 


--------------------------------------------------------------------------------
/src/Idephix/Console/Command.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Idephix\Console;
 3 | 
 4 | use Idephix\TaskExecutor;
 5 | use Idephix\Task\Parameter;
 6 | use Idephix\Task\Task;
 7 | use Symfony\Component\Console\Command\Command as SymfonyCommand;
 8 | use Symfony\Component\Console\Input\InputArgument;
 9 | use Symfony\Component\Console\Input\InputInterface;
10 | use Symfony\Component\Console\Input\InputOption;
11 | use Symfony\Component\Console\Output\OutputInterface;
12 | 
13 | class Command extends SymfonyCommand
14 | {
15 |     private $idxTaskCode;
16 |     /** @var  TaskExecutor */
17 |     private $idx;
18 |     /** @var  Task */
19 |     private $task;
20 | 
21 |     /**
22 |      * @param Task $task
23 |      * @param TaskExecutor $idx
24 |      * @return Command
25 |      */
26 |     public static function fromTask(Task $task, TaskExecutor $idx)
27 |     {
28 |         $command = new static($task->name());
29 |         $command->task = $task;
30 |         $command->idx = $idx;
31 | 
32 |         $command->setDescription($task->description());
33 | 
34 |         /** @var Parameter\UserDefined $parameter */
35 |         foreach ($task->userDefinedParameters() as $parameter) {
36 |             if (!$parameter->isOptional()) {
37 |                 $command->addArgument($parameter->name(), InputArgument::REQUIRED, $parameter->description());
38 |                 continue;
39 |             }
40 | 
41 |             if ($parameter->isFlagOption()) {
42 |                 $command->addOption($parameter->name(), null, InputOption::VALUE_NONE, $parameter->description());
43 |                 continue;
44 |             }
45 | 
46 |             $command->addArgument(
47 |                 $parameter->name(),
48 |                 InputArgument::OPTIONAL,
49 |                 $parameter->description(),
50 |                 $parameter->defaultValue()
51 |             );
52 |         }
53 | 
54 |         $command->idxTaskCode = $task->code();
55 | 
56 |         return $command;
57 |     }
58 | 
59 |     protected function execute(InputInterface $input, OutputInterface $output)
60 |     {
61 |         return call_user_func_array($this->idxTaskCode, $this->extractArgumentsFrom($input));
62 |     }
63 | 
64 |     /**
65 |      * Create an array of arguments to call the defined task
66 |      *
67 |      * We remove all the arguments and the options defined
68 |      * for the command and we use the rest for the closure. This
69 |      * will remove all default args/options defined within command
70 |      * definition.
71 |      *
72 |      * @param InputInterface $input
73 |      * @return array
74 |      */
75 |     protected function extractArgumentsFrom(InputInterface $input)
76 |     {
77 |         $args = array();
78 |         /** @var Parameter\UserDefined $parameter */
79 |         foreach ($this->task->parameters() as $parameter) {
80 |             if ($parameter instanceof Parameter\Context) {
81 |                 $args[] = $this->idx->getContext();
82 |                 continue;
83 |             }
84 | 
85 |             if (false === $parameter->defaultValue()) {
86 |                 $args[] = $input->getOption($parameter->name());
87 |                 continue;
88 |             }
89 | 
90 |             $args[] = $input->getArgument($parameter->name());
91 |         }
92 | 
93 |         return $args;
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/css/badge_only.css:
--------------------------------------------------------------------------------
1 | .fa:before{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:before,.clearfix:after{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-weight:normal;font-style:normal;src:url("../font/fontawesome_webfont.eot");src:url("../font/fontawesome_webfont.eot?#iefix") format("embedded-opentype"),url("../font/fontawesome_webfont.woff") format("woff"),url("../font/fontawesome_webfont.ttf") format("truetype"),url("../font/fontawesome_webfont.svg#FontAwesome") format("svg")}.fa:before{display:inline-block;font-family:FontAwesome;font-style:normal;font-weight:normal;line-height:1;text-decoration:inherit}a .fa{display:inline-block;text-decoration:inherit}li .fa{display:inline-block}li .fa-large:before,li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-0.8em}ul.fas li .fa{width:0.8em}ul.fas li .fa-large:before,ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before{content:""}.icon-book:before{content:""}.fa-caret-down:before{content:""}.icon-caret-down:before{content:""}.fa-caret-up:before{content:""}.icon-caret-up:before{content:""}.fa-caret-left:before{content:""}.icon-caret-left:before{content:""}.fa-caret-right:before{content:""}.icon-caret-right:before{content:""}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;border-top:solid 10px #343131;font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;z-index:400}.rst-versions a{color:#2980B9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27AE60;*zoom:1}.rst-versions .rst-current-version:before,.rst-versions .rst-current-version:after{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book{float:left}.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#E74C3C;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#F1C40F;color:#000}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:gray;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:solid 1px #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px}.rst-versions.rst-badge .icon-book{float:none}.rst-versions.rst-badge .fa-book{float:none}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book{float:left}.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge .rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width: 768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}img{width:100%;height:auto}}
2 | /*# sourceMappingURL=badge_only.css.map */
3 | 


--------------------------------------------------------------------------------
/src/Idephix/Util/DocBlockParser.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Idephix\Util;
  4 | 
  5 | /**
  6 |  * Parse a docblock comment finding global description
  7 |  * and parameters description
  8 |  */
  9 | class DocBlockParser
 10 | {
 11 |     private $description;
 12 |     private $params;
 13 | 
 14 |     /**
 15 |      * @param string $comment the docBlock to parse
 16 |      */
 17 |     public function __construct($comment)
 18 |     {
 19 |         $this->parse($comment);
 20 |     }
 21 | 
 22 |     /**
 23 |      * Parse the string looking for description and parameters
 24 |      *
 25 |      * @param string $comment the docBlock to parse
 26 |      */
 27 |     private function parse($comment)
 28 |     {
 29 |         $rows = explode("\n", preg_replace('!(^\s*/\*\*\s*)|(\s*\*/\s*$)!', '', $comment));
 30 |         $this->description = $this->parseDescription($rows);
 31 |         $this->params = $this->parseParams($rows);
 32 |     }
 33 | 
 34 |     /**
 35 |      * Parse an array of string looking for parameters
 36 |      *
 37 |      * @param array $rows the docBlock to parse
 38 |      *
 39 |      * @return array parameters name, type and description
 40 |      */
 41 |     private function parseParams($rows)
 42 |     {
 43 |         $params = array();
 44 | 
 45 |         foreach ($rows as $row) {
 46 |             if (preg_match_all('/^\s*\*\s*@param\s*(?<type>[^\s]*)(?:\s*\$(?<name>[^\s]*))(?:\s*(?<description>.*))?$/us',
 47 |                 $row,
 48 |                 $matches
 49 |             )) {
 50 |                 $name = $matches['name'][0];
 51 |                 $params[$name] = array(
 52 |                     'name' => $name,
 53 |                     'type' => $matches['type'][0],
 54 |                     'description' => $matches['description'][0],
 55 |                 );
 56 |             }
 57 |         }
 58 | 
 59 |         return $params;
 60 |     }
 61 | 
 62 |     /**
 63 |      * Parse an array of string looking for global description
 64 |      *
 65 |      * @param array $rows the docBlock to parse
 66 |      *
 67 |      * @return string global description
 68 |      */
 69 |     private function parseDescription($rows)
 70 |     {
 71 |         $description = array();
 72 |         $row = '';
 73 |         while ((list(, $row) = each($rows)) && (false === strpos($row, '@'))) {
 74 |             $parts = trim($row, ' *');
 75 |             if (!empty($parts)) {
 76 |                 $description[] = $parts;
 77 |             }
 78 |         }
 79 | 
 80 |         return implode(' ', $description);
 81 |     }
 82 | 
 83 |     /**
 84 |      * If available, returns the param type, name and description
 85 |      *
 86 |      * @param string $name the param name
 87 |      *
 88 |      * @return array|null the param type, name and description
 89 |      */
 90 |     public function getParam($name)
 91 |     {
 92 |         return $this->hasParam($name) ? $this->params[$name] : null;
 93 |     }
 94 | 
 95 |     /**
 96 |      * @param string $name
 97 |      */
 98 |     public function hasParam($name)
 99 |     {
100 |         return isset($this->params[$name]);
101 |     }
102 | 
103 |     public function getParams()
104 |     {
105 |         return $this->params;
106 |     }
107 | 
108 |     public function getDescription()
109 |     {
110 |         return $this->description;
111 |     }
112 | 
113 |     /**
114 |      * @param string $name
115 |      * @return string
116 |      */
117 |     public function getParamDescription($name)
118 |     {
119 |         return $this->hasParam($name) ? $this->params[$name]['description'] : '';
120 |     }
121 | }
122 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Stories in Ready](https://badge.waffle.io/ideatosrl/Idephix.png?label=backlog&title=Get%20Involved)](https://waffle.io/ideatosrl/Idephix)
 2 | [![Gitter](https://badges.gitter.im/ideatosrl/Idephix.svg)](https://gitter.im/ideatosrl/Idephix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 3 | [![Build Status](https://travis-ci.org/ideatosrl/Idephix.svg)](https://travis-ci.org/ideatosrl/Idephix)
 4 | [![Read the docs](https://img.shields.io/badge/docs-latest-brightgreen.svg?style=flat)](http://idephix.readthedocs.io/en/latest/)
 5 | [![SensioLabsInsight](https://insight.sensiolabs.com/projects/47596bd6-4ac9-4314-b79a-1f2e50292c1f/mini.png)](https://insight.sensiolabs.com/projects/47596bd6-4ac9-4314-b79a-1f2e50292c1f)
 6 | [![Latest Stable Version](https://poser.pugx.org/ideato/idephix/version)](https://packagist.org/packages/ideato/idephix)
 7 | [![Total Downloads](https://poser.pugx.org/ideato/idephix/downloads)](https://packagist.org/packages/ideato/idephix)
 8 | [![Monthly Downloads](https://poser.pugx.org/ideato/idephix/d/monthly)](https://packagist.org/packages/ideato/idephix)
 9 | [![License](https://poser.pugx.org/ideato/idephix/license)](https://packagist.org/packages/ideato/idephix)
10 | 
11 | Idephix - Automation and Deploy tool
12 | ====================================
13 | 
14 | Idephix is a PHP automation tool useful to perform remote and local tasks. It can be used to deploy applications, rotate logs, synchronize data repository across server or create a build system. If you want to learn more about how to use it
15 | [read the docs][rd].
16 | 
17 | Installation / Usage
18 | --------------------
19 | 
20 | 1. Download the [`idephix.phar`](http://getidephix.com/idephix.phar) executable and init your idxfile.
21 | 
22 |     ``` sh
23 |     $ curl -LSs http://getidephix.com/idephix.phar > idephix.phar
24 |     $ chmod a+x idephix.phar
25 |     $ idx initFile
26 |     ```
27 | 
28 | 2. Now you can define tasks just defining php functions in your `idxfile.php`
29 | 
30 |     ```php
31 |     <?php
32 |     
33 |     /**
34 |      * Execute the touch of a file specified in input
35 |      * @param string $name the name of the file to be touch-ed
36 |      * @param bool   $go   if not specified the script execute a dry-run
37 |      */
38 |     function testParams(\Idephix\Context $context, $name, $go = false)
39 |     {
40 |          $context->local('touch /tmp/'.$name);
41 |          $context->remote('touch /tmp/'.$name.'_remote');
42 |     }
43 | 
44 |     ```
45 |     
46 | For more information about how to define tasks, configuration for multiple environments and much more [read the docs][rd].
47 | Global installation of Idephix
48 | 
49 | Deploying with Idephix
50 | ----------------------
51 | 
52 | Idephix is good for many different jobs, but we like to use it especially for application deployment. In fact 
53 | out of the box your `idxfile.php` will be initialized using our recipe for [PHP application deployment][idx-deploy] 
54 | that you can use as a starting point for your projects.
55 | 
56 | Requirements
57 | ------------
58 | 
59 | PHP 5.3.2 or above, >=5.3.12 recommended
60 | 
61 | Authors
62 | -------
63 | 
64 | * Manuel 'Kea' Baldassarri <mb@ideato.it>
65 | * Michele 'Orso' Orselli <mo@ideato.it>
66 | * Filippo De Santis <fd@ideato.it>
67 | * [other contributors](https://github.com/ideatosrl/idephix/graphs/contributors)
68 | 
69 | License
70 | -------
71 | 
72 | Idephix is licensed under the MIT License - see the LICENSE file for details
73 | 
74 | [rd]: http://idephix.readthedocs.io/en/latest/
75 | [idx-deploy]: http://idephix.readthedocs.io/en/latest/recipes/deploy.html
76 | 


--------------------------------------------------------------------------------
/src/Idephix/Console/Descriptor/TextDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Idephix\Console\Descriptor;
 4 | 
 5 | use Symfony\Component\Console\Application as SymfonyApp;
 6 | use Symfony\Component\Console\Descriptor\TextDescriptor as SymfonyTextDescriptior;
 7 | use Symfony\Component\Console\Descriptor\ApplicationDescription;
 8 | 
 9 | class TextDescriptor extends SymfonyTextDescriptior
10 | {
11 |     /**
12 |      * {@inheritdoc}
13 |      */
14 |     protected function describeApplication(SymfonyApp $application, array $options = array())
15 |     {
16 |         $describedNamespace = isset($options['namespace']) ? $options['namespace'] : null;
17 |         $description = new ApplicationDescription($application, $describedNamespace);
18 | 
19 |         if (isset($options['raw_text']) && $options['raw_text']) {
20 |             $width = $this->getColumnWidth($description->getCommands());
21 | 
22 |             foreach ($description->getCommands() as $command) {
23 |                 $this->writeText(sprintf("%-${width}s %s", $command->getName(), $command->getDescription()), $options);
24 |                 $this->writeText("\n");
25 |             }
26 |         } else {
27 |             $width = $this->getColumnWidth($description->getCommands());
28 | 
29 |             $this->writeText($application->getHelp(), $options);
30 |             $this->writeText("\n\n");
31 | 
32 |             if ($describedNamespace) {
33 |                 $this->writeText(sprintf('<comment>Available commands for the "%s" namespace:</comment>', $describedNamespace), $options);
34 |             } else {
35 |                 $this->writeText('<comment>Available commands:</comment>', $options);
36 |             }
37 | 
38 |             $default_cmds = array();
39 |             $user_cmds = array();
40 | 
41 |             // add commands by namespace
42 |             foreach ($description->getNamespaces() as $namespace) {
43 |                 foreach ($namespace['commands'] as $name) {
44 |                     if (in_array($name, array('help', 'list', 'initFile', 'selfupdate'))) {
45 |                         $default_cmds[] = $name;
46 |                     } else {
47 |                         $user_cmds[] = $name;
48 |                     }
49 |                 }
50 |             }
51 | 
52 |             $this->writeText("\n");
53 | 
54 |             foreach ($default_cmds as $name) {
55 |                 $this->writeText(sprintf("  <info>%-${width}s</info> %s", $name, $description->getCommand($name)->getDescription()), $options);
56 |                 $this->writeText("\n");
57 |             }
58 | 
59 |             $this->writeText("\n");
60 |             $this->writeText('<comment>User tasks:</comment>', $options);
61 |             $this->writeText("\n");
62 | 
63 |             foreach ($user_cmds as $name) {
64 |                 $this->writeText(sprintf("  <info>%-${width}s</info> %s", $name, $description->getCommand($name)->getDescription()), $options);
65 |                 $this->writeText("\n");
66 |             }
67 |         }
68 |     }
69 | 
70 |     /**
71 |      * {@inheritdoc}
72 |      */
73 |     private function writeText($content, array $options = array())
74 |     {
75 |         $this->write(
76 |             isset($options['raw_text']) && $options['raw_text'] ? strip_tags($content) : $content,
77 |             isset($options['raw_output']) ? !$options['raw_output'] : true
78 |         );
79 |     }
80 | 
81 |     /**
82 |      * @param Command[] $commands
83 |      *
84 |      * @return int
85 |      */
86 |     private function getColumnWidth(array $commands)
87 |     {
88 |         $width = 0;
89 |         foreach ($commands as $command) {
90 |             $width = strlen($command->getName()) > $width ? strlen($command->getName()) : $width;
91 |         }
92 | 
93 |         return $width + 2;
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/src/Idephix/Test/Console/IdephixCommandTester.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Idephix\Test\Console;
  4 | 
  5 | use Symfony\Component\Console\Command\Command;
  6 | use Symfony\Component\Console\Input\ArrayInput;
  7 | use Symfony\Component\Console\Input\InputInterface;
  8 | use Symfony\Component\Console\Output\OutputInterface;
  9 | 
 10 | class IdephixCommandTester
 11 | {
 12 |     private $command;
 13 |     private $input;
 14 |     private $output;
 15 |     private $statusCode;
 16 | 
 17 |     /**
 18 |      * Constructor.
 19 |      *
 20 |      * @param Command $command A Command instance to test.
 21 |      */
 22 |     public function __construct(Command $command, OutputInterface $output)
 23 |     {
 24 |         $this->command = $command;
 25 |         $this->output = $output;
 26 |     }
 27 | 
 28 |     /**
 29 |      * Executes the command.
 30 |      *
 31 |      * Available options:
 32 |      *
 33 |      *  * interactive: Sets the input interactive flag
 34 |      *  * decorated:   Sets the output decorated flag
 35 |      *  * verbosity:   Sets the output verbosity flag
 36 |      *
 37 |      * @param array $input An array of arguments and options
 38 |      * @param array $options An array of options
 39 |      *
 40 |      * @return int     The command exit code
 41 |      */
 42 |     public function execute(array $input, array $options = array())
 43 |     {
 44 |         // set the command name automatically if the application requires
 45 |         // this argument and no command name was passed
 46 |         if (!isset($input['command'])
 47 |             && (null !== $application = $this->command->getApplication())
 48 |             && $application->getDefinition()->hasArgument('command')
 49 |         ) {
 50 |             $input['command'] = $this->command->getName();
 51 |         }
 52 | 
 53 |         $this->input = new ArrayInput($input);
 54 |         if (isset($options['interactive'])) {
 55 |             $this->input->setInteractive($options['interactive']);
 56 |         }
 57 | 
 58 |         if (isset($options['decorated'])) {
 59 |             $this->output->setDecorated($options['decorated']);
 60 |         }
 61 |         if (isset($options['verbosity'])) {
 62 |             $this->output->setVerbosity($options['verbosity']);
 63 |         }
 64 | 
 65 |         return $this->statusCode = $this->command->run($this->input, $this->output);
 66 |     }
 67 | 
 68 |     /**
 69 |      * Gets the display returned by the last execution of the command.
 70 |      *
 71 |      * @param bool $normalize Whether to normalize end of lines to \n or not
 72 |      *
 73 |      * @return string The display
 74 |      */
 75 |     public function getDisplay($normalize = false)
 76 |     {
 77 |         rewind($this->output->getStream());
 78 | 
 79 |         $display = stream_get_contents($this->output->getStream());
 80 | 
 81 |         if ($normalize) {
 82 |             $display = str_replace(PHP_EOL, "\n", $display);
 83 |         }
 84 | 
 85 |         return $display;
 86 |     }
 87 | 
 88 |     /**
 89 |      * Gets the input instance used by the last execution of the command.
 90 |      *
 91 |      * @return InputInterface The current input instance
 92 |      */
 93 |     public function getInput()
 94 |     {
 95 |         return $this->input;
 96 |     }
 97 | 
 98 |     /**
 99 |      * Gets the output instance used by the last execution of the command.
100 |      *
101 |      * @return OutputInterface The current output instance
102 |      */
103 |     public function getOutput()
104 |     {
105 |         return $this->output;
106 |     }
107 | 
108 |     /**
109 |      * Gets the status code returned by the last execution of the application.
110 |      *
111 |      * @return int     The status code
112 |      */
113 |     public function getStatusCode()
114 |     {
115 |         return $this->statusCode;
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
  1 | # How to contribute
  2 | 
  3 | You can contribute to idephix in many ways: sending PR, requesting new functionality, fixing bugs. 
  4 | We want to make our development workflow public and to ease third party contributions like yours, 
  5 | so we created a public [kanban board for the project][waffle].
  6 | 
  7 | Feel free to use what you're more comfortable with, either the kanban board or github issues.
  8 | 
  9 | ## Sending PR
 10 | 
 11 | Fork, then clone the repo:
 12 | 
 13 |     git clone git@github.com:your-username/Idephix.git
 14 |     
 15 | Make sure the tests pass:
 16 | 
 17 |     bin/idephix.phar build
 18 |     
 19 | This will install all vendors and run all the tests.
 20 | Push to your fork and [submit a pull request][pr].
 21 | 
 22 | We will get back to you as soon as possible to discuss your PR
 23 | and decide if accept it. 
 24 | 
 25 | Some things that will increase the chance that your pull request is accepted:
 26 | 
 27 | * Write tests for your code (no test no party)
 28 | * Follow PSR2 coding style guide
 29 | * Document any new features you add
 30 | 
 31 | ## Coding Style Guide
 32 | 
 33 | idephix follows PSR2 coding standard, and you must respect that too if you 
 34 | want your contribution to be accepted. We don't want you to waste time fixing 
 35 | formatting though, you should add php-cs-fixer for that instead. 
 36 | 
 37 |     bin/php-cs-fixer fix {$fileName} --level=psr2 --fixers=long_array_syntax,single_quote,unused_use
 38 |     
 39 | You could also add a [pre-commit hook][hook] to ensure all committed files respect our 
 40 | coding standard
 41 | 
 42 | ```php
 43 | #!/usr/bin/php
 44 | <?php
 45 | /**
 46 |  * .git/hooks/pre-commit
 47 |  *
 48 |  * This pre-commit hooks will check for PHP error (lint), and make sure the code
 49 |  * is PSR compliant.
 50 |  *
 51 |  * Dependecy: PHP-CS-Fixer (https://github.com/fabpot/PHP-CS-Fixer)
 52 |  *
 53 |  * @author  Mardix  http://github.com/mardix
 54 |  * @since   Sept 4 2012
 55 |  *
 56 |  */
 57 | 
 58 | /**
 59 |  * collect all files which have been added, copied or
 60 |  * modified and store them in an array called output
 61 |  */
 62 | exec('git diff --cached --name-only --diff-filter=ACM', $output);
 63 | 
 64 | foreach ($output as $file) {
 65 | 
 66 |     $fileName = trim($file);
 67 | 
 68 |     if (pathinfo($fileName,PATHINFO_EXTENSION) == "php") {
 69 | 
 70 |         $lint_output = array();
 71 |         exec("php -l " . escapeshellarg($fileName), $lint_output, $return);
 72 | 
 73 |         if ($return == 0) {
 74 | 
 75 |           exec("bin/php-cs-fixer fix {$fileName} --level=psr2 --fixers=long_array_syntax,single_quote,unused_use");
 76 |           exec("git add {$fileName}");
 77 | 
 78 |         } else {
 79 |            echo implode("\n", $lint_output), "\n";
 80 |            exit(1);
 81 | 
 82 |         }
 83 | 
 84 |     }
 85 | 
 86 | }
 87 | 
 88 | exit(0);
 89 | ```
 90 | 
 91 | ## Writing documentation
 92 | 
 93 | We use [read the docs][rtd] to document features, and we really encourage you to write documentation
 94 | for any new feature you want to submit. Read the docs is based on sphinx, so in order to be able to generate 
 95 | documentation locally you'll need to [install some deps][rtd-getting-started]. Once you have all up and running 
 96 | you can generate the docs using idephix 
 97 | 
 98 |     bin/idephix.phar buildDoc
 99 |     
100 | and then open `docs/_build/html/index.html` with your preferred browser.
101 | 
102 | ## Dogfooding
103 | 
104 | We use idephix as the build tool for idephix itself. Our [continuous integration][ci] uses `bin/idephix.phar`
105 | to build the project. As a developer is your responsibility to update the phar when needed. Lucky enough the is
106 | a task for that
107 | 
108 |     bin/idephix.phar updatePhar
109 |     
110 | [waffle]: https://waffle.io/ideatosrl/Idephix
111 | [pr]: https://waffle.io/ideatosrl/Idephix
112 | [hook]: https://git-scm.com/book/it/v2/Customizing-Git-Git-Hooks
113 | [rtd]: http://idephix.readthedocs.io/
114 | [rtd-getting-started]: http://read-the-docs.readthedocs.io/en/latest/getting_started.html
115 | [ci]: https://travis-ci.org/ideatosrl/Idephix
116 | 


--------------------------------------------------------------------------------
/docs/writing_extensions.rst:
--------------------------------------------------------------------------------
  1 | ==========
  2 | Extensions
  3 | ==========
  4 | 
  5 | Extensions are meant to wrap reusable code into a class that you can wire to your next Idephix project. If you find
  6 | yourself writing the same task over and over again you may want to put it into an Extension so you can easily reuse it
  7 | in every projects.
  8 | 
  9 | .. hint::
 10 | 
 11 |     Extensions should be used wisely, for most cases a bunch of tasks that you copy and paste across projects is
 12 |     the best solution. We in the first place dropped the Deploy solution to a standard recipe that we include in
 13 |     out idxfile for each project. This ease the readability and the hackability of the procedure. An Extension will
 14 |     allow you to define reusable code, but it will hide it a little bit, so take this in consideration before
 15 |     implementing one
 16 | 
 17 | An Extension is identified by a name, and is capable of:
 18 | 
 19 | - registering new Tasks, so they will be directly available from CLI
 20 | - registering methods that will be hooked into the Idephix instance so you can use them within other tasks
 21 | 
 22 | Writing Extensions
 23 | ------------------
 24 | 
 25 | An Extension is simply a class implementing `\Idephix\Extension` interface. This will require you do define a name
 26 | and, TasksCollection and a MethodCollection. If your extension don't need to register new tasks or methods, you can
 27 | simply return an empty collection (`\Idephix\Task\TaskCollection::dry()` or `\Idephix\Extension\MethodCollection::dry()`).
 28 | 
 29 | If you need an instance of the current `\Idephix\Context` within your extension, simply implement also
 30 | the `\Idephix\Extension\IdephixAwareInterface` and you'll get one at runtime.
 31 | 
 32 | Only method registered by `::methods()` will be plugged into Idephix and will be available for other tasks to use:
 33 | 
 34 | ::
 35 | 
 36 |     <?php
 37 |     class DummyExtension implements Extension
 38 |     {
 39 | 
 40 |         public function doStuff(IdephixInterface $idx, $foo, $go=false)
 41 |         {
 42 |             //do some stuff
 43 |         }
 44 | 
 45 |         /** @return array of callable */
 46 |         public function methods()
 47 |         {
 48 |             return Extension\MethodCollection::ofCallables(
 49 |                 array(
 50 |                     new Extension\CallableMethod('doStuff', array($this, 'doStuff'))
 51 |                 )
 52 |             );
 53 |         }
 54 | 
 55 |     //cut
 56 |     }
 57 | 
 58 | ::
 59 | 
 60 |     <?php
 61 |     //your idxfile.php
 62 | 
 63 |     function deploy(IdephixInterface $idx, $go = false)
 64 |     {
 65 |         //your deploy business logic here
 66 |         $idx->doStuff($foo, $go)
 67 |     }
 68 | 
 69 | 
 70 | If you want to expose some of your methods as CLI commands you need to define them as a task:
 71 | 
 72 | ::
 73 | 
 74 |     <?php
 75 | 
 76 |     class DummyExtension implements Extension
 77 |     {
 78 | 
 79 |         /** @return TaskCollection */
 80 |         public function tasks()
 81 |         {
 82 |             return TaskCollection::ofTasks(array(
 83 |                 new Task(
 84 |                 'doStuff',
 85 |                 'DummyExtension helps you doing stuff',
 86 |                 array($this, 'doStuff'),
 87 |                 Collection::createFromArray(array(
 88 |                     'foo' => array('description' => 'A nice description of foo')
 89 |                 )),
 90 |             ));
 91 |         }
 92 | 
 93 |     //cut
 94 |     }
 95 | 
 96 | And the you'll also get to execute it directly from cli:
 97 | 
 98 | .. code-block:: bash
 99 | 
100 |     $ idx doStuff bar
101 | 
102 | 
103 | .. hint::
104 | 
105 |     Check out our `available extensions <https://github.com/ideatosrl/Idephix/tree/master/src/Idephix/Extension>`_
106 |     to see more complex examples ..
107 | 
108 | Execution priority
109 | ------------------
110 | 
111 | Idephix will always try to execute code from the idxfile first, so if some function within the idxfile conflicts
112 | with some registered method or task, the code from the idxfile will be executed and the extension code will be ignored.
113 | 


--------------------------------------------------------------------------------
/idxfile.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Deploys a phar on github pages
  4 |  */
  5 | function deployPhar(\Idephix\Context $idx)
  6 | {
  7 |     $idx->output()->writeln('Releasing new phar version...');
  8 | 
  9 |     if (!file_exists('./idephix.phar')) {
 10 |         $idx->output()->writeln('Idephix phar does not exists');
 11 |         exit(-1);
 12 |     }
 13 | 
 14 |     try {
 15 |         $newTag = trim($idx->local('git describe --exact-match --tags'));
 16 |     } catch (\Exception $e) {
 17 |         $commit_msg = trim($idx->local('git log -1 --pretty=%B'));
 18 |         $idx->output()->writeln("skipping, commit '$commit_msg' is not tagged");
 19 |         exit(0);
 20 |     }
 21 | 
 22 |     $currentTag = file_get_contents(
 23 |         'https://raw.githubusercontent.com/ideatosrl/getidephix.com/gh-pages/version'
 24 |     );
 25 | 
 26 |     if ($newTag == $currentTag) {
 27 |         $idx->output()->writeln("version $newTag already deployed");
 28 |         exit(0);
 29 |     }
 30 | 
 31 |     $idx->output()->writeln('setting up ssh key');
 32 |     $idx->local('mkdir -p ~/.ssh');
 33 |     $idx->local('chmod 600 ~/.ssh/id_rsa');
 34 | 
 35 |     $idx->output()->writeln('cloning getidephix website');
 36 |     $idx->local('rm -rf ~/docs');
 37 |     $idx->local('cd ~ && git clone --branch gh-pages git@github.com:ideatosrl/getidephix.com.git docs');
 38 |     $idx->local('cd ~/docs && git config user.name "ideatobot"');
 39 |     $idx->local('cd ~/docs && git config user.email "info@ideato.it"');
 40 | 
 41 |     $idx->output()->writeln('committing new phar');
 42 |     $idx->local('cp -f idephix.phar ~/docs');
 43 |     $idx->local('mkdir -p ~/docs/archive');
 44 |     $idx->local("cp -f idephix.phar ~/docs/archive/idephix-{$newTag}.phar");
 45 |     $idx->local("echo $newTag > ~/docs/version");
 46 |     $idx->local('cd ~/docs && git status');
 47 | 
 48 |     $idx->local('cd ~/docs && git add -A .');
 49 |     $idx->local("cd ~/docs && git commit -m 'deploy phar version $newTag'");
 50 |     $idx->local('cd ~/docs && git push -q origin gh-pages');
 51 | };
 52 | 
 53 | /**
 54 |  * Creates a new phar
 55 |  */
 56 | function createPhar(\Idephix\Context $idx)
 57 | {
 58 |     $idx->output()->writeln('Creating phar...');
 59 | 
 60 |     $idx->local('rm -rf /tmp/Idephix && mkdir -p /tmp/Idephix');
 61 |     $idx->local('cp -R . /tmp/Idephix');
 62 |     $idx->local('cd /tmp/Idephix && rm -rf vendor');
 63 |     $idx->local('cd /tmp/Idephix && git checkout -- .');
 64 |     $idx->local('cd /tmp/Idephix && composer install --prefer-source --no-dev -o');
 65 |     $idx->local('bin/box build -c /tmp/Idephix/box.json ');
 66 | 
 67 |     $idx->output()->writeln('Smoke testing...');
 68 | 
 69 |     $out = $idx->local('php idephix.phar');
 70 | 
 71 |     if (false === strpos($out, 'Idephix version')) {
 72 |         echo "Error!\n";
 73 |         exit(-1);
 74 |     }
 75 | 
 76 |     $idx->output()->writeln('All good!');
 77 | };
 78 | 
 79 | /**
 80 |  * Updates the idephix phar in this project.
 81 |  */
 82 | function updatePhar(\Idephix\Context $idx)
 83 | {
 84 |     $idx->createPhar();
 85 |     $idx->local('cp ./idephix.phar bin/');
 86 | }
 87 | 
 88 | /**
 89 |  * Build for continuous integration
 90 |  */
 91 | function buildTravis(\Idephix\Context $idx)
 92 | {
 93 |     try {
 94 |         $idx->local('composer install');
 95 |         $idx->local('bin/phpunit -c tests --coverage-clover=clover.xml', false, 240);
 96 |         $idx->execute('createPhar');
 97 |     } catch (\Exception $e) {
 98 |         $idx->output()->writeln(sprintf("<error>Exception: \n%s</error>", $e->getMessage()));
 99 |         exit(1);
100 |     }
101 | };
102 | 
103 | /**
104 |  * Build for local development
105 |  */
106 | function build(\Idephix\Context $idx)
107 | {
108 |     $idx->local('composer install --prefer-source');
109 |     $idx->local('bin/phpunit -c tests');
110 | };
111 | 
112 | /**
113 |  * Runs php-cs-fixer for coding standard fixes
114 |  */
115 | function fixCs(\Idephix\Context $idx)
116 | {
117 |     try {
118 |         $idx->local('bin/php-cs-fixer fix');
119 |     } catch (\Exception $e) {
120 |     }
121 | };
122 | 
123 | /**
124 |  * Rebuilds project documentation
125 |  */
126 | function buildDoc(\Idephix\Context $idx, $open = false)
127 | {
128 |     $idx->local('cp -r src/Idephix/Cookbook docs/');
129 |     $idx->local('make  -C ./docs html');
130 | 
131 |     if ($open) {
132 |         $idx->execute('openDoc');
133 |     }
134 | }
135 | 
136 | /**
137 |  * Opens documentaion in browser
138 |  */
139 | function openDoc(\Idephix\Context $idx)
140 | {
141 |     $idx->local('open docs/_build/html/index.html');
142 | }
143 | 
144 | /**
145 |  * This command will yell at you
146 |  *
147 |  * @param string $what What you want to yell
148 |  */
149 | function yell(\Idephix\Context $context, $what = 'foo')
150 | {
151 |     $context->writeln(strtoupper($what));
152 | }
153 | 


--------------------------------------------------------------------------------
/src/Idephix/Config.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Idephix;
  3 | 
  4 | use Idephix\Exception\InvalidConfigurationException;
  5 | use Idephix\SSH\SshClient;
  6 | use Symfony\Component\OptionsResolver\Exception\InvalidOptionsException;
  7 | use Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException;
  8 | use Symfony\Component\OptionsResolver\OptionsResolver;
  9 | 
 10 | class Config implements DictionaryAccess
 11 | {
 12 |     const ENVS = 'envs';
 13 |     const SSHCLIENT = 'ssh_client';
 14 |     const EXTENSIONS = 'extensions';
 15 | 
 16 |     private $dictionary;
 17 | 
 18 |     private function __construct(Dictionary $dictionary)
 19 |     {
 20 |         $this->dictionary = $dictionary;
 21 |     }
 22 | 
 23 |     public static function fromArray($data)
 24 |     {
 25 |         $resolver = new OptionsResolver();
 26 |         $resolver->setDefaults(array(
 27 |             self::ENVS => array(),
 28 |             self::EXTENSIONS => array(),
 29 |             self::SSHCLIENT => new SshClient(),
 30 |         ));
 31 | 
 32 |         $resolver->setAllowedTypes(self::SSHCLIENT, '\Idephix\SSH\SshClient');
 33 |         $resolver->setAllowedTypes(self::ENVS, 'array');
 34 |         $resolver->setAllowedTypes(self::EXTENSIONS, 'array');
 35 | 
 36 |         try {
 37 |             $resolvedConfig = $resolver->resolve($data);
 38 |         } catch (UndefinedOptionsException $e) {
 39 |             throw new InvalidConfigurationException($e->getMessage());
 40 |         } catch (InvalidOptionsException $e) {
 41 |             throw new InvalidConfigurationException($e->getMessage());
 42 |         }
 43 | 
 44 |         $resolvedConfig['envs'] = array_map(
 45 |             function ($envData) {
 46 |                 if (!is_array($envData)) {
 47 |                     throw new InvalidConfigurationException("Each env must be an array \"$envData\" given'");
 48 |                 }
 49 | 
 50 |                 $envData['hosts'] = empty($envData['hosts']) ? array(null) : $envData['hosts'];
 51 | 
 52 |                 $sshParamsResolver = new OptionsResolver();
 53 |                 $sshParamsResolver->setDefaults(
 54 |                     array(
 55 |                         'user' => '',
 56 |                         'password' => '',
 57 |                         'public_key_file' => '',
 58 |                         'private_key_file' => '',
 59 |                         'private_key_file_pwd' => '',
 60 |                         'ssh_port' => '22'
 61 |                     )
 62 |                 );
 63 |                 
 64 |                 $envData['ssh_params'] = $sshParamsResolver->resolve(
 65 |                     empty($envData['ssh_params']) ? array() : $envData['ssh_params']
 66 |                 );
 67 | 
 68 |                 return $envData;
 69 |             },
 70 | 
 71 |             $resolvedConfig['envs']
 72 |         );
 73 | 
 74 |         return new static(Dictionary::fromArray($resolvedConfig));
 75 |     }
 76 | 
 77 |     public static function dry()
 78 |     {
 79 |         return self::fromArray(array());
 80 |     }
 81 | 
 82 |     public static function parseFile($configFile)
 83 |     {
 84 |         if (is_null($configFile)) {
 85 |             return static::dry();
 86 |         }
 87 |         
 88 |         try {
 89 |             new \SplFileObject($configFile);
 90 |         } catch (\RuntimeException $e) {
 91 |             throw new InvalidConfigurationException('The config file does not exists or is not readable');
 92 |         }
 93 | 
 94 |         /** @var Config $config */
 95 |         $config = require_once $configFile;
 96 | 
 97 |         if (!is_array($config)) {
 98 |             throw new InvalidConfigurationException('The config file must return an array');
 99 |         }
100 | 
101 |         return static::fromArray($config);
102 |     }
103 | 
104 |     public function environments()
105 |     {
106 |         return is_null($this[self::ENVS]) ? array() : $this[self::ENVS];
107 |     }
108 | 
109 |     public function extensions()
110 |     {
111 |         return $this->get(self::EXTENSIONS, array());
112 |     }
113 | 
114 |     public function offsetExists($offset)
115 |     {
116 |         return $this->dictionary->offsetExists($offset);
117 |     }
118 | 
119 |     public function offsetGet($offset)
120 |     {
121 |         return $this->dictionary->offsetGet($offset);
122 |     }
123 | 
124 |     public function offsetSet($offset, $value)
125 |     {
126 |         $this->dictionary->offsetSet($offset, $value);
127 |     }
128 | 
129 |     public function offsetUnset($offset)
130 |     {
131 |         $this->dictionary->offsetUnset($offset);
132 |     }
133 | 
134 |     public function get($offset, $default = null)
135 |     {
136 |         return $this->dictionary->get($offset, $default);
137 |     }
138 | 
139 |     public function set($key, $value)
140 |     {
141 |         $this->dictionary->set($key, $value);
142 |     }
143 | }
144 | 


--------------------------------------------------------------------------------
/src/Idephix/SSH/SshClient.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Idephix\SSH;
  4 | 
  5 | class SshClient
  6 | {
  7 |     private $proxy;
  8 |     private $params;
  9 |     private $host;
 10 |     private $connected = false;
 11 | 
 12 |     /**
 13 |      * Constructor
 14 |      *
 15 |      * @param ProxyInterface $proxy
 16 |      */
 17 |     public function __construct(ProxyInterface $proxy = null)
 18 |     {
 19 |         if (null === $proxy) {
 20 |             $proxy = function_exists('ssh2_auth_agent') ? new PeclSsh2Proxy() : new CLISshProxy();
 21 |         }
 22 | 
 23 |         $this->proxy = $proxy;
 24 |     }
 25 | 
 26 |     /**
 27 |      * @param array $params array('user', 'password', 'public_key_file', 'private_key_file', 'private_key_file_pwd', 'ssh_port')
 28 |      */
 29 |     public function setParameters($params)
 30 |     {
 31 |         $this->connected = false;
 32 |         $this->params = array_merge(
 33 |             array(
 34 |                 'user'                 => '',
 35 |                 'password'             => '',
 36 |                 'public_key_file'      => '',
 37 |                 'private_key_file'     => '',
 38 |                 'private_key_file_pwd' => '',
 39 |                 'ssh_port'             => '22'),
 40 |             $params
 41 |         );
 42 |     }
 43 | 
 44 |     /**
 45 |      * @throws \Exception
 46 |      */
 47 |     public function connect()
 48 |     {
 49 |         if (null === $this->host) {
 50 |             throw new \Exception('You must set the host');
 51 |         }
 52 |         if (!$this->proxy->connect($this->host, $this->params['ssh_port'])) {
 53 |             throw new \Exception('Unable to connect');
 54 |         }
 55 | 
 56 |         if (!empty($this->params['password']) && !$this->proxy->authByPassword($this->params['user'], $this->params['password'])) {
 57 |             throw new \Exception('Unable to authenticate via password');
 58 |         }
 59 | 
 60 |         if (!empty($this->params['public_key_file']) && !$this->proxy->authByPublicKey($this->params['user'], $this->params['public_key_file'], $this->params['private_key_file'], $this->params['private_key_file_pwd'])) {
 61 |             throw new \Exception('Unable to authenticate via public/private keys');
 62 |         }
 63 | 
 64 |         if (empty($this->params['password']) && empty($this->params['public_key_file']) && !$this->proxy->authByAgent($this->params['user'])) {
 65 |             throw new \Exception('Unable to authenticate via agent');
 66 |         }
 67 | 
 68 |         $this->connected = true;
 69 | 
 70 |         return true;
 71 |     }
 72 | 
 73 |     public function disconnect()
 74 |     {
 75 |         $this->proxy->disconnect();
 76 |         $this->connected = false;
 77 |     }
 78 | 
 79 |     public function isConnected()
 80 |     {
 81 |         return $this->connected;
 82 |     }
 83 | 
 84 |     /**
 85 |      * @param string $cmd
 86 |      * @return bool
 87 |      */
 88 |     public function exec($cmd)
 89 |     {
 90 |         return $this->proxy->exec($cmd);
 91 |     }
 92 | 
 93 |     public function getLastOutput()
 94 |     {
 95 |         return $this->proxy->getLastOutput();
 96 |     }
 97 | 
 98 |     public function getLastError()
 99 |     {
100 |         return $this->proxy->getLastError();
101 |     }
102 | 
103 |     public function isSuccessful()
104 |     {
105 |         return $this->proxy->isSuccessful();
106 |     }
107 | 
108 |     public function getUser()
109 |     {
110 |         return $this->params['user'];
111 |     }
112 | 
113 |     public function getPort()
114 |     {
115 |         return $this->params['ssh_port'];
116 |     }
117 | 
118 |     public function setHost($host)
119 |     {
120 |         $this->host = $host;
121 |     }
122 | 
123 |     public function getHost()
124 |     {
125 |         return $this->host;
126 |     }
127 | 
128 |     /**
129 |      * Copy a file via scp from $localPath to $remotePath
130 |      *
131 |      * @param $localPath source local path
132 |      * @param $remotePath destination remote path
133 |      * @throws \Exception
134 |      * @return bool
135 |      */
136 |     public function put($localPath, $remotePath)
137 |     {
138 |         if (!$this->isConnected()) {
139 |             throw new \Exception('SSH Client is not connected');
140 |         }
141 | 
142 |         return $this->proxy->put($localPath, $remotePath);
143 |     }
144 | 
145 |     /**
146 |      * Copy a file via scp from $remotePath to $localPath
147 |      *
148 |      * @param $remotePath source remote path
149 |      * @param $localPath destination local path
150 |      * @throws \Exception
151 |      * @return bool
152 |      */
153 |     public function get($remotePath, $localPath)
154 |     {
155 |         if (!$this->isConnected()) {
156 |             throw new \Exception('SSH Client is not connected');
157 |         }
158 | 
159 |         return $this->proxy->get($remotePath, $localPath);
160 |     }
161 | }
162 | 


--------------------------------------------------------------------------------
/src/Idephix/SSH/CLISshProxy.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Idephix\SSH;
  4 | 
  5 | use Symfony\Component\Process\Process;
  6 | 
  7 | class CLISshProxy extends BaseProxy
  8 | {
  9 |     protected $executable = 'ssh';
 10 |     protected $host;
 11 |     protected $port = 22;
 12 |     protected $user = '';
 13 |     protected $password = '';
 14 |     protected $privateKeyFile = null;
 15 |     protected $timeout = 600;
 16 | 
 17 |     private function canConnect()
 18 |     {
 19 |         if ($this->exec('echo "connected"') &&
 20 |             false !== strpos($this->lastOutput, 'connected')) {
 21 |             return true;
 22 |         }
 23 | 
 24 |         return false;
 25 |     }
 26 | 
 27 |     private function assertConnected()
 28 |     {
 29 |         if (empty($this->host)) {
 30 |             throw new \Exception('You first need to connect');
 31 |         }
 32 |     }
 33 | 
 34 |     /**
 35 |      * Set executable full path
 36 |      *
 37 |      * @param $executable
 38 |      */
 39 |     public function setExecutable($executable)
 40 |     {
 41 |         $this->executable = $executable;
 42 |     }
 43 | 
 44 |     /**
 45 |      * Connect
 46 |      *
 47 |      * @param $host
 48 |      * @param int $port
 49 |      * @return bool
 50 |      */
 51 |     public function connect($host, $port = 22)
 52 |     {
 53 |         $this->host = $host;
 54 |         $this->port = $port;
 55 | 
 56 |         return true;
 57 |     }
 58 | 
 59 |     /**
 60 |      * @param $user
 61 |      * @param $pwd
 62 |      * @throws \Exception
 63 |      */
 64 |     public function authByPassword($user, $pwd)
 65 |     {
 66 |         throw new \Exception('Not implemented');
 67 |     }
 68 | 
 69 |     /**
 70 |      * @param $user
 71 |      * @return bool
 72 |      * @throws \Exception
 73 |      */
 74 |     public function authByAgent($user)
 75 |     {
 76 |         $this->assertConnected();
 77 |         $this->user = $user;
 78 | 
 79 |         return $this->canConnect();
 80 |     }
 81 | 
 82 |     /**
 83 |      * @param $user
 84 |      * @param $public_key_file
 85 |      * @param $privateKeyFile
 86 |      * @param $pwd
 87 |      * @return bool
 88 |      * @throws \Exception
 89 |      */
 90 |     public function authByPublicKey($user, $public_key_file, $privateKeyFile, $pwd)
 91 |     {
 92 |         $this->assertConnected();
 93 |         $this->user = $user;
 94 |         $this->privateKeyFile = $privateKeyFile;
 95 | 
 96 |         return $this->canConnect();
 97 |     }
 98 | 
 99 |     /**
100 |      * @inheritdoc
101 |      */
102 |     public function exec($cmd)
103 |     {
104 |         $preparedCmd = $this->prepareCommand($cmd);
105 | 
106 |         return $this->doExec($preparedCmd);
107 |     }
108 | 
109 |     /**
110 |      * @param string $preparedCmd
111 |      * @return bool
112 |      */
113 |     private function doExec($preparedCmd)
114 |     {
115 |         $process = new Process($preparedCmd, null, null, null, $this->timeout);
116 |         $process->run();
117 |         $this->lastOutput = $process->getOutput();
118 |         $this->lastError = $process->getErrorOutput();
119 |         $this->exitCode = $process->getExitCode();
120 | 
121 |         return $process->isSuccessful();
122 |     }
123 | 
124 |     /**
125 |      * @inheritdoc
126 |      */
127 |     public function put($localPath, $remotePath)
128 |     {
129 |         $user = $this->user ? $this->user.'@' : '';
130 |         $keyFile = $this->privateKeyFile ? '-i '.$this->privateKeyFile : '';
131 | 
132 |         $preparedCmd = sprintf(
133 |             'scp -pP %s %s %s %s%s:%s',
134 |             $this->port,
135 |             $keyFile,
136 |             escapeshellarg($localPath),
137 |             $user,
138 |             $this->host,
139 |             strtr(escapeshellarg($remotePath), array(' ' => '\\ '))
140 |         );
141 | 
142 |         return $this->doExec($preparedCmd);
143 |     }
144 | 
145 |     /**
146 |      * @inheritdoc
147 |      */
148 |     public function get($remotePath, $localPath)
149 |     {
150 |         $user = $this->user ? $this->user.'@' : '';
151 |         $keyFile = $this->privateKeyFile ? '-i '.$this->privateKeyFile : '';
152 | 
153 |         $preparedCmd = sprintf(
154 |             'scp -pP %s %s %s%s:%s %s',
155 |             $this->port,
156 |             $keyFile,
157 |             $user,
158 |             $this->host,
159 |             strtr(escapeshellarg($remotePath), array(' ' => '\\ ')),
160 |             escapeshellarg($localPath)
161 |         );
162 | 
163 |         return $this->doExec($preparedCmd);
164 |     }
165 | 
166 |     /**
167 |      * @param string $cmd
168 |      * @return string
169 |      */
170 |     private function prepareCommand($cmd)
171 |     {
172 |         $user = $this->user ? '-l '.$this->user : '';
173 |         $keyFile = $this->privateKeyFile ? '-i '.$this->privateKeyFile : '';
174 | 
175 |         return sprintf(
176 |             '%s -p %s %s %s %s %s',
177 |             $this->executable,
178 |             $this->port,
179 |             $keyFile,
180 |             $user,
181 |             $this->host,
182 |             escapeshellarg($cmd)
183 |         );
184 |     }
185 | }
186 | 


--------------------------------------------------------------------------------
/src/Idephix/Context.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Idephix;
  3 | 
  4 | class Context implements DictionaryAccess, TaskExecutor, \Iterator
  5 | {
  6 |     private $idx;
  7 |     private $data;
  8 | 
  9 |     public function __construct(Dictionary $data, TaskExecutor $idx)
 10 |     {
 11 |         $this->data = $data;
 12 |         $this->idx = $idx;
 13 |     }
 14 | 
 15 |     public static function dry(TaskExecutor $idx)
 16 |     {
 17 |         return new static(Dictionary::dry(), $idx);
 18 |     }
 19 | 
 20 |     public function env($name, Dictionary $contextData)
 21 |     {
 22 |         $context = clone $this;
 23 |         $contextData['env'] = array('name' => $name);
 24 |         $context->data = $contextData;
 25 | 
 26 |         return $context;
 27 |     }
 28 | 
 29 |     public function currentEnvName()
 30 |     {
 31 |         return $this->data['env.name'];
 32 |     }
 33 | 
 34 |     public function currentHost()
 35 |     {
 36 |         return $this->data['env.host'];
 37 |     }
 38 | 
 39 |     /**
 40 |      * Add trailing slash to the path if it is omitted
 41 |      *
 42 |      * @param string $name
 43 |      * @param string $default
 44 |      * @return string fixed path
 45 |      */
 46 |     public function getAsPath($name, $default = '')
 47 |     {
 48 |         return rtrim($this->get($name, $default), '/').'/';
 49 |     }
 50 | 
 51 |     public function offsetExists($offset)
 52 |     {
 53 |         return $this->data->offsetExists($offset);
 54 |     }
 55 | 
 56 |     public function offsetGet($offset)
 57 |     {
 58 |         return $this->data->offsetGet($offset);
 59 |     }
 60 | 
 61 |     public function offsetSet($offset, $value)
 62 |     {
 63 |         $this->data->offsetSet($offset, $value);
 64 |     }
 65 | 
 66 |     public function offsetUnset($offset)
 67 |     {
 68 |         $this->data->offsetUnset($offset);
 69 |     }
 70 | 
 71 |     public function get($offset, $default = null)
 72 |     {
 73 |         return $this->data->get($offset, $default);
 74 |     }
 75 | 
 76 |     public function set($key, $value)
 77 |     {
 78 |         $this->data->offsetSet($key, $value);
 79 |     }
 80 | 
 81 |     /**
 82 |      * @param $name
 83 |      * @return integer 0 success, 1 fail
 84 |      */
 85 |     public function execute($name)
 86 |     {
 87 |         call_user_func_array(array($this->idx, 'execute'), func_get_args());
 88 |     }
 89 | 
 90 |     /**
 91 |      * @param $name
 92 |      * @return integer 0 success, 1 fail
 93 |      */
 94 |     public function executeOnce($name)
 95 |     {
 96 |         call_user_func_array(array($this->idx, 'executeOnce'), func_get_args());
 97 |     }
 98 | 
 99 |     /**
100 |      * Execute remote command.
101 |      *
102 |      * @param string $cmd command
103 |      * @param boolean $dryRun
104 |      * @return void
105 |      */
106 |     public function remote($cmd, $dryRun = false)
107 |     {
108 |         $this->idx->remote($cmd, $dryRun);
109 |     }
110 | 
111 |     /**
112 |      * Execute local command.
113 |      *
114 |      * @param string $cmd Command
115 |      * @param boolean $dryRun
116 |      * @param integer $timeout
117 |      *
118 |      * @return string the command output
119 |      */
120 |     public function local($cmd, $dryRun = false, $timeout = 60)
121 |     {
122 |         return $this->idx->local($cmd, $dryRun, $timeout);
123 |     }
124 | 
125 |     public function output()
126 |     {
127 |         return $this->idx->output();
128 |     }
129 | 
130 |     public function write($messages, $newline = false, $type = self::OUTPUT_NORMAL)
131 |     {
132 |         $this->idx->write($messages, $newline, $type);
133 |     }
134 | 
135 |     public function writeln($messages, $type = self::OUTPUT_NORMAL)
136 |     {
137 |         $this->idx->writeln($messages, $type);
138 |     }
139 | 
140 |     public function sshClient()
141 |     {
142 |         return $this->idx->sshClient();
143 |     }
144 | 
145 |     public function __call($name, $arguments)
146 |     {
147 |         return call_user_func_array(array($this->idx, $name), $arguments);
148 |     }
149 | 
150 |     /**
151 |      * Return the current element
152 |      * @link http://php.net/manual/en/iterator.current.php
153 |      * @return mixed Can return any type.
154 |      * @since 5.0.0
155 |      */
156 |     public function current()
157 |     {
158 |         $newContextData = clone $this->data;
159 |         $newContextData['env'] = array(
160 |             'name' => $this->currentEnvName(),
161 |             'host' => current($this->hosts)
162 |         );
163 | 
164 |         $newContext = new static($newContextData, $this->idx);
165 | 
166 |         return $newContext;
167 |     }
168 | 
169 |     /**
170 |      * Move forward to next element
171 |      * @link http://php.net/manual/en/iterator.next.php
172 |      * @return void Any returned value is ignored.
173 |      * @since 5.0.0
174 |      */
175 |     public function next()
176 |     {
177 |         next($this->hosts);
178 |     }
179 | 
180 |     /**
181 |      * Return the key of the current element
182 |      * @link http://php.net/manual/en/iterator.key.php
183 |      * @return mixed scalar on success, or null on failure.
184 |      * @since 5.0.0
185 |      */
186 |     public function key()
187 |     {
188 |         return key($this->hosts);
189 |     }
190 | 
191 |     /**
192 |      * Checks if current position is valid
193 |      * @link http://php.net/manual/en/iterator.valid.php
194 |      * @return boolean The return value will be casted to boolean and then evaluated.
195 |      * Returns true on success or false on failure.
196 |      * @since 5.0.0
197 |      */
198 |     public function valid()
199 |     {
200 |         return $this->key() !== null;
201 |     }
202 | 
203 |     /**
204 |      * Rewind the Iterator to the first element
205 |      * @link http://php.net/manual/en/iterator.rewind.php
206 |      * @return void Any returned value is ignored.
207 |      * @since 5.0.0
208 |      */
209 |     public function rewind()
210 |     {
211 |         $this->hosts = $this->data->get('hosts', array(null));
212 |         reset($this->hosts);
213 |     }
214 | }
215 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/static/js/theme.js:
--------------------------------------------------------------------------------
  1 | require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"sphinx-rtd-theme":[function(require,module,exports){
  2 | var jQuery = (typeof(window) != 'undefined') ? window.jQuery : require('jquery');
  3 | 
  4 | // Sphinx theme nav state
  5 | function ThemeNav () {
  6 | 
  7 |     var nav = {
  8 |         navBar: null,
  9 |         win: null,
 10 |         winScroll: false,
 11 |         winResize: false,
 12 |         linkScroll: false,
 13 |         winPosition: 0,
 14 |         winHeight: null,
 15 |         docHeight: null,
 16 |         isRunning: false
 17 |     };
 18 | 
 19 |     nav.enable = function () {
 20 |         var self = this;
 21 | 
 22 |         if (!self.isRunning) {
 23 |             self.isRunning = true;
 24 |             jQuery(function ($) {
 25 |                 self.init($);
 26 | 
 27 |                 self.reset();
 28 |                 self.win.on('hashchange', self.reset);
 29 | 
 30 |                 // Set scroll monitor
 31 |                 self.win.on('scroll', function () {
 32 |                     if (!self.linkScroll) {
 33 |                         self.winScroll = true;
 34 |                     }
 35 |                 });
 36 |                 setInterval(function () { if (self.winScroll) self.onScroll(); }, 25);
 37 | 
 38 |                 // Set resize monitor
 39 |                 self.win.on('resize', function () {
 40 |                     self.winResize = true;
 41 |                 });
 42 |                 setInterval(function () { if (self.winResize) self.onResize(); }, 25);
 43 |                 self.onResize();
 44 |             });
 45 |         };
 46 |     };
 47 | 
 48 |     nav.init = function ($) {
 49 |         var doc = $(document),
 50 |             self = this;
 51 | 
 52 |         this.navBar = $('div.wy-side-scroll:first');
 53 |         this.win = $(window);
 54 | 
 55 |         // Set up javascript UX bits
 56 |         $(document)
 57 |             // Shift nav in mobile when clicking the menu.
 58 |             .on('click', "[data-toggle='wy-nav-top']", function() {
 59 |                 $("[data-toggle='wy-nav-shift']").toggleClass("shift");
 60 |                 $("[data-toggle='rst-versions']").toggleClass("shift");
 61 |             })
 62 | 
 63 |             // Nav menu link click operations
 64 |             .on('click', ".wy-menu-vertical .current ul li a", function() {
 65 |                 var target = $(this);
 66 |                 // Close menu when you click a link.
 67 |                 $("[data-toggle='wy-nav-shift']").removeClass("shift");
 68 |                 $("[data-toggle='rst-versions']").toggleClass("shift");
 69 |                 // Handle dynamic display of l3 and l4 nav lists
 70 |                 self.toggleCurrent(target);
 71 |                 self.hashChange();
 72 |             })
 73 |             .on('click', "[data-toggle='rst-current-version']", function() {
 74 |                 $("[data-toggle='rst-versions']").toggleClass("shift-up");
 75 |             })
 76 | 
 77 |         // Make tables responsive
 78 |         $("table.docutils:not(.field-list)")
 79 |             .wrap("<div class='wy-table-responsive'></div>");
 80 | 
 81 |         // Add expand links to all parents of nested ul
 82 |         $('.wy-menu-vertical ul').not('.simple').siblings('a').each(function () {
 83 |             var link = $(this);
 84 |                 expand = $('<span class="toctree-expand"></span>');
 85 |             expand.on('click', function (ev) {
 86 |                 self.toggleCurrent(link);
 87 |                 ev.stopPropagation();
 88 |                 return false;
 89 |             });
 90 |             link.prepend(expand);
 91 |         });
 92 |     };
 93 | 
 94 |     nav.reset = function () {
 95 |         // Get anchor from URL and open up nested nav
 96 |         var anchor = encodeURI(window.location.hash);
 97 |         if (anchor) {
 98 |             try {
 99 |                 var link = $('.wy-menu-vertical')
100 |                     .find('[href="' + anchor + '"]');
101 |                 $('.wy-menu-vertical li.toctree-l1 li.current')
102 |                     .removeClass('current');
103 |                 link.closest('li.toctree-l2').addClass('current');
104 |                 link.closest('li.toctree-l3').addClass('current');
105 |                 link.closest('li.toctree-l4').addClass('current');
106 |             }
107 |             catch (err) {
108 |                 console.log("Error expanding nav for anchor", err);
109 |             }
110 |         }
111 |     };
112 | 
113 |     nav.onScroll = function () {
114 |         this.winScroll = false;
115 |         var newWinPosition = this.win.scrollTop(),
116 |             winBottom = newWinPosition + this.winHeight,
117 |             navPosition = this.navBar.scrollTop(),
118 |             newNavPosition = navPosition + (newWinPosition - this.winPosition);
119 |         if (newWinPosition < 0 || winBottom > this.docHeight) {
120 |             return;
121 |         }
122 |         this.navBar.scrollTop(newNavPosition);
123 |         this.winPosition = newWinPosition;
124 |     };
125 | 
126 |     nav.onResize = function () {
127 |         this.winResize = false;
128 |         this.winHeight = this.win.height();
129 |         this.docHeight = $(document).height();
130 |     };
131 | 
132 |     nav.hashChange = function () {
133 |         this.linkScroll = true;
134 |         this.win.one('hashchange', function () {
135 |             this.linkScroll = false;
136 |         });
137 |     };
138 | 
139 |     nav.toggleCurrent = function (elem) {
140 |         var parent_li = elem.closest('li');
141 |         parent_li.siblings('li.current').removeClass('current');
142 |         parent_li.siblings().find('li.current').removeClass('current');
143 |         parent_li.find('> ul li.current').removeClass('current');
144 |         parent_li.toggleClass('current');
145 |     }
146 | 
147 |     return nav;
148 | };
149 | 
150 | module.exports.ThemeNav = ThemeNav();
151 | 
152 | if (typeof(window) != 'undefined') {
153 |     window.SphinxRtdTheme = { StickyNav: module.exports.ThemeNav };
154 | }
155 | 
156 | },{"jquery":"jquery"}]},{},["sphinx-rtd-theme"]);
157 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/layout.html:
--------------------------------------------------------------------------------
  1 | {# TEMPLATE VAR SETTINGS #}
  2 | {%- set url_root = pathto('', 1) %}
  3 | {%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
  4 | {%- if not embedded and docstitle %}
  5 |   {%- set titlesuffix = " &mdash; "|safe + docstitle|e %}
  6 | {%- else %}
  7 |   {%- set titlesuffix = "" %}
  8 | {%- endif %}
  9 | 
 10 | <!DOCTYPE html>
 11 | <!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
 12 | <!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
 13 | <head>
 14 |   <meta charset="utf-8">
 15 |   {{ metatags }}
 16 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 17 |   {% block htmltitle %}
 18 |   <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
 19 |   {% endblock %}
 20 | 
 21 |   {# FAVICON #}
 22 |   {% if favicon %}
 23 |     <link rel="shortcut icon" href="{{ pathto('_static/' + favicon, 1) }}"/>
 24 |   {% endif %}
 25 | 
 26 |   {# CSS #}
 27 | 
 28 |   {# OPENSEARCH #}
 29 |   {% if not embedded %}
 30 |     {% if use_opensearch %}
 31 |       <link rel="search" type="application/opensearchdescription+xml" title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}" href="{{ pathto('_static/opensearch.xml', 1) }}"/>
 32 |     {% endif %}
 33 | 
 34 |   {% endif %}
 35 | 
 36 |   {# RTD hosts this file, so just load on non RTD builds #}
 37 |   {% if not READTHEDOCS %}
 38 |     <link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
 39 |   {% endif %}
 40 | 
 41 |   {% for cssfile in css_files %}
 42 |     <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
 43 |   {% endfor %}
 44 | 
 45 |   {% for cssfile in extra_css_files %}
 46 |     <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
 47 |   {% endfor %}
 48 | 
 49 |   {%- block linktags %}
 50 |     {%- if hasdoc('about') %}
 51 |         <link rel="author" title="{{ _('About these documents') }}"
 52 |               href="{{ pathto('about') }}"/>
 53 |     {%- endif %}
 54 |     {%- if hasdoc('genindex') %}
 55 |         <link rel="index" title="{{ _('Index') }}"
 56 |               href="{{ pathto('genindex') }}"/>
 57 |     {%- endif %}
 58 |     {%- if hasdoc('search') %}
 59 |         <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}"/>
 60 |     {%- endif %}
 61 |     {%- if hasdoc('copyright') %}
 62 |         <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}"/>
 63 |     {%- endif %}
 64 |     <link rel="top" title="{{ docstitle|e }}" href="{{ pathto('index') }}"/>
 65 |     {%- if parents %}
 66 |         <link rel="up" title="{{ parents[-1].title|striptags|e }}" href="{{ parents[-1].link|e }}"/>
 67 |     {%- endif %}
 68 |     {%- if next %}
 69 |         <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}"/>
 70 |     {%- endif %}
 71 |     {%- if prev %}
 72 |         <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}"/>
 73 |     {%- endif %}
 74 |   {%- endblock %}
 75 |   {%- block extrahead %} {% endblock %}
 76 | 
 77 |   {# Keep modernizr in head - http://modernizr.com/docs/#installing #}
 78 |   <script src="{{ pathto('_static/js/modernizr.min.js', 1) }}"></script>
 79 | 
 80 | </head>
 81 | 
 82 | <body class="wy-body-for-nav" role="document">
 83 | 
 84 |   {% block extrabody %} {% endblock %}
 85 |   <div class="wy-grid-for-nav">
 86 | 
 87 |     {# SIDE NAV, TOGGLES ON MOBILE #}
 88 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
 89 |       <div class="wy-side-scroll">
 90 |         <div class="wy-side-nav-search">
 91 |           {% block sidebartitle %}
 92 | 
 93 |           {% if logo and theme_logo_only %}
 94 |             <a href="{{ pathto(master_doc) }}">
 95 |           {% else %}
 96 |             <a href="{{ pathto(master_doc) }}" class="icon icon-home"> {{ project }}
 97 |           {% endif %}
 98 | 
 99 |           {% if logo %}
100 |             {# Not strictly valid HTML, but it's the only way to display/scale it properly, without weird scripting or heaps of work #}
101 |             <img src="{{ pathto('_static/' + logo, 1) }}" class="logo" />
102 |           {% endif %}
103 |           </a>
104 | 
105 |           {% if theme_display_version %}
106 |             {%- set nav_version = version %}
107 |             {% if READTHEDOCS and current_version %}
108 |               {%- set nav_version = current_version %}
109 |             {% endif %}
110 |             {% if nav_version %}
111 |               <div class="version">
112 |                 {{ nav_version }}
113 |               </div>
114 |             {% endif %}
115 |           {% endif %}
116 | 
117 |           {% include "searchbox.html" %}
118 | 
119 |           {% endblock %}
120 |         </div>
121 | 
122 |         <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
123 |           {% block menu %}
124 |             {% set toctree = toctree(maxdepth=theme_navigation_depth, collapse=theme_collapse_navigation, includehidden=True) %}
125 |             {% if toctree %}
126 |                 {{ toctree }}
127 |             {% else %}
128 |                 <!-- Local TOC -->
129 |                 <div class="local-toc">{{ toc }}</div>
130 |             {% endif %}
131 |           {% endblock %}
132 |         </div>
133 |       </div>
134 |     </nav>
135 | 
136 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
137 | 
138 |       {# MOBILE NAV, TRIGGLES SIDE NAV ON TOGGLE #}
139 |       <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
140 |         {% block mobile_nav %}
141 |           <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
142 |           <a href="{{ pathto(master_doc) }}">{{ project }}</a>
143 |         {% endblock %}
144 |       </nav>
145 | 
146 | 
147 |       {# PAGE CONTENT #}
148 |       <div class="wy-nav-content">
149 |         <div class="rst-content">
150 |           {% include "breadcrumbs.html" %}
151 |           <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
152 |            <div itemprop="articleBody">
153 |             {% block body %}{% endblock %}
154 |            </div>
155 |           </div>
156 |           {% include "footer.html" %}
157 |         </div>
158 |       </div>
159 | 
160 |     </section>
161 | 
162 |   </div>
163 |   {% include "versions.html" %}
164 | 
165 |   {% if not embedded %}
166 | 
167 |     <script type="text/javascript">
168 |         var DOCUMENTATION_OPTIONS = {
169 |             URL_ROOT:'{{ url_root }}',
170 |             VERSION:'{{ release|e }}',
171 |             COLLAPSE_INDEX:false,
172 |             FILE_SUFFIX:'{{ '' if no_search_suffix else file_suffix }}',
173 |             HAS_SOURCE:  {{ has_source|lower }}
174 |         };
175 |     </script>
176 |     {%- for scriptfile in script_files %}
177 |       <script type="text/javascript" src="{{ pathto(scriptfile, 1) }}"></script>
178 |     {%- endfor %}
179 | 
180 |   {% endif %}
181 | 
182 |   {# RTD hosts this file, so just load on non RTD builds #}
183 |   {% if not READTHEDOCS %}
184 |     <script type="text/javascript" src="{{ pathto('_static/js/theme.js', 1) }}"></script>
185 |   {% endif %}
186 | 
187 |   {# STICKY NAVIGATION #}
188 |   {% if theme_sticky_navigation %}
189 |   <script type="text/javascript">
190 |       jQuery(function () {
191 |           SphinxRtdTheme.StickyNav.enable();
192 |       });
193 |   </script>
194 |   {% endif %}
195 | 
196 |   {%- block footer %} {% endblock %}
197 | 
198 | </body>
199 | </html>
200 | 


--------------------------------------------------------------------------------
/docs/_themes/sphinx_rtd_theme/layout_old.html:
--------------------------------------------------------------------------------
  1 | {#
  2 |     basic/layout.html
  3 |     ~~~~~~~~~~~~~~~~~
  4 | 
  5 |     Master layout template for Sphinx themes.
  6 | 
  7 |     :copyright: Copyright 2007-2013 by the Sphinx team, see AUTHORS.
  8 |     :license: BSD, see LICENSE for details.
  9 | #}
 10 | {%- block doctype -%}
 11 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 12 |   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 13 | {%- endblock %}
 14 | {%- set reldelim1 = reldelim1 is not defined and ' &raquo;' or reldelim1 %}
 15 | {%- set reldelim2 = reldelim2 is not defined and ' |' or reldelim2 %}
 16 | {%- set render_sidebar = (not embedded) and (not theme_nosidebar|tobool) and
 17 |                          (sidebars != []) %}
 18 | {%- set url_root = pathto('', 1) %}
 19 | {# XXX necessary? #}
 20 | {%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
 21 | {%- if not embedded and docstitle %}
 22 |   {%- set titlesuffix = " &mdash; "|safe + docstitle|e %}
 23 | {%- else %}
 24 |   {%- set titlesuffix = "" %}
 25 | {%- endif %}
 26 | 
 27 | {%- macro relbar() %}
 28 |     <div class="related">
 29 |       <h3>{{ _('Navigation') }}</h3>
 30 |       <ul>
 31 |         {%- for rellink in rellinks %}
 32 |         <li class="right" {% if loop.first %}style="margin-right: 10px"{% endif %}>
 33 |           <a href="{{ pathto(rellink[0]) }}" title="{{ rellink[1]|striptags|e }}"
 34 |              {{ accesskey(rellink[2]) }}>{{ rellink[3] }}</a>
 35 |           {%- if not loop.first %}{{ reldelim2 }}{% endif %}</li>
 36 |         {%- endfor %}
 37 |         {%- block rootrellink %}
 38 |         <li><a href="{{ pathto(master_doc) }}">{{ shorttitle|e }}</a>{{ reldelim1 }}</li>
 39 |         {%- endblock %}
 40 |         {%- for parent in parents %}
 41 |           <li><a href="{{ parent.link|e }}" {% if loop.last %}{{ accesskey("U") }}{% endif %}>{{ parent.title }}</a>{{ reldelim1 }}</li>
 42 |         {%- endfor %}
 43 |         {%- block relbaritems %} {% endblock %}
 44 |       </ul>
 45 |     </div>
 46 | {%- endmacro %}
 47 | 
 48 | {%- macro sidebar() %}
 49 |       {%- if render_sidebar %}
 50 |       <div class="sphinxsidebar">
 51 |         <div class="sphinxsidebarwrapper">
 52 |           {%- block sidebarlogo %}
 53 |           {%- if logo %}
 54 |             <p class="logo"><a href="{{ pathto(master_doc) }}">
 55 |               <img class="logo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
 56 |             </a></p>
 57 |           {%- endif %}
 58 |           {%- endblock %}
 59 |           {%- if sidebars != None %}
 60 |             {#- new style sidebar: explicitly include/exclude templates #}
 61 |             {%- for sidebartemplate in sidebars %}
 62 |             {%- include sidebartemplate %}
 63 |             {%- endfor %}
 64 |           {%- else %}
 65 |             {#- old style sidebars: using blocks -- should be deprecated #}
 66 |             {%- block sidebartoc %}
 67 |             {%- include "localtoc.html" %}
 68 |             {%- endblock %}
 69 |             {%- block sidebarrel %}
 70 |             {%- include "relations.html" %}
 71 |             {%- endblock %}
 72 |             {%- block sidebarsourcelink %}
 73 |             {%- include "sourcelink.html" %}
 74 |             {%- endblock %}
 75 |             {%- if customsidebar %}
 76 |             {%- include customsidebar %}
 77 |             {%- endif %}
 78 |             {%- block sidebarsearch %}
 79 |             {%- include "searchbox.html" %}
 80 |             {%- endblock %}
 81 |           {%- endif %}
 82 |         </div>
 83 |       </div>
 84 |       {%- endif %}
 85 | {%- endmacro %}
 86 | 
 87 | {%- macro script() %}
 88 |     <script type="text/javascript">
 89 |       var DOCUMENTATION_OPTIONS = {
 90 |         URL_ROOT:    '{{ url_root }}',
 91 |         VERSION:     '{{ release|e }}',
 92 |         COLLAPSE_INDEX: false,
 93 |         FILE_SUFFIX: '{{ '' if no_search_suffix else file_suffix }}',
 94 |         HAS_SOURCE:  {{ has_source|lower }}
 95 |       };
 96 |     </script>
 97 |     {%- for scriptfile in script_files %}
 98 |     <script type="text/javascript" src="{{ pathto(scriptfile, 1) }}"></script>
 99 |     {%- endfor %}
100 | {%- endmacro %}
101 | 
102 | {%- macro css() %}
103 |     <link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
104 |     <link rel="stylesheet" href="{{ pathto('_static/pygments.css', 1) }}" type="text/css" />
105 |     {%- for cssfile in css_files %}
106 |     <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
107 |     {%- endfor %}
108 | {%- endmacro %}
109 | 
110 | <html xmlns="http://www.w3.org/1999/xhtml">
111 |   <head>
112 |     <meta http-equiv="Content-Type" content="text/html; charset={{ encoding }}" />
113 |     {{ metatags }}
114 |     {%- block htmltitle %}
115 |     <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
116 |     {%- endblock %}
117 |     {{ css() }}
118 |     {%- if not embedded %}
119 |     {{ script() }}
120 |     {%- if use_opensearch %}
121 |     <link rel="search" type="application/opensearchdescription+xml"
122 |           title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}"
123 |           href="{{ pathto('_static/opensearch.xml', 1) }}"/>
124 |     {%- endif %}
125 |     {%- if favicon %}
126 |     <link rel="shortcut icon" href="{{ pathto('_static/' + favicon, 1) }}"/>
127 |     {%- endif %}
128 |     {%- endif %}
129 | {%- block linktags %}
130 |     {%- if hasdoc('about') %}
131 |     <link rel="author" title="{{ _('About these documents') }}" href="{{ pathto('about') }}" />
132 |     {%- endif %}
133 |     {%- if hasdoc('genindex') %}
134 |     <link rel="index" title="{{ _('Index') }}" href="{{ pathto('genindex') }}" />
135 |     {%- endif %}
136 |     {%- if hasdoc('search') %}
137 |     <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}" />
138 |     {%- endif %}
139 |     {%- if hasdoc('copyright') %}
140 |     <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}" />
141 |     {%- endif %}
142 |     <link rel="top" title="{{ docstitle|e }}" href="{{ pathto('index') }}" />
143 |     {%- if parents %}
144 |     <link rel="up" title="{{ parents[-1].title|striptags|e }}" href="{{ parents[-1].link|e }}" />
145 |     {%- endif %}
146 |     {%- if next %}
147 |     <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}" />
148 |     {%- endif %}
149 |     {%- if prev %}
150 |     <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}" />
151 |     {%- endif %}
152 | {%- endblock %}
153 | {%- block extrahead %} {% endblock %}
154 |   </head>
155 |   <body>
156 | {%- block header %}{% endblock %}
157 | 
158 | {%- block relbar1 %}{{ relbar() }}{% endblock %}
159 | 
160 | {%- block content %}
161 |   {%- block sidebar1 %} {# possible location for sidebar #} {% endblock %}
162 | 
163 |     <div class="document">
164 |   {%- block document %}
165 |       <div class="documentwrapper">
166 |       {%- if render_sidebar %}
167 |         <div class="bodywrapper">
168 |       {%- endif %}
169 |           <div class="body">
170 |             {% block body %} {% endblock %}
171 |           </div>
172 |       {%- if render_sidebar %}
173 |         </div>
174 |       {%- endif %}
175 |       </div>
176 |   {%- endblock %}
177 | 
178 |   {%- block sidebar2 %}{{ sidebar() }}{% endblock %}
179 |       <div class="clearer"></div>
180 |     </div>
181 | {%- endblock %}
182 | 
183 | {%- block relbar2 %}{{ relbar() }}{% endblock %}
184 | 
185 | {%- block footer %}
186 |     <div class="footer">
187 |     {%- if show_copyright %}
188 |       {%- if hasdoc('copyright') %}
189 |         {% trans path=pathto('copyright'), copyright=copyright|e %}&copy; <a href="{{ path }}">Copyright</a> {{ copyright }}.{% endtrans %}
190 |       {%- else %}
191 |         {% trans copyright=copyright|e %}&copy; Copyright {{ copyright }}.{% endtrans %}
192 |       {%- endif %}
193 |     {%- endif %}
194 |     {%- if last_updated %}
195 |       {% trans last_updated=last_updated|e %}Last updated on {{ last_updated }}.{% endtrans %}
196 |     {%- endif %}
197 |     {%- if show_sphinx %}
198 |       {% trans sphinx_version=sphinx_version|e %}Created using <a href="http://sphinx-doc.org/">Sphinx</a> {{ sphinx_version }}.{% endtrans %}
199 |     {%- endif %}
200 |     </div>
201 |     <p>asdf asdf asdf asdf 22</p>
202 | {%- endblock %}
203 |   </body>
204 | </html>
205 | 
206 | 


--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
  1 | # Makefile for Sphinx documentation
  2 | #
  3 | 
  4 | # You can set these variables from the command line.
  5 | SPHINXOPTS    =
  6 | SPHINXBUILD   = sphinx-build
  7 | PAPER         =
  8 | BUILDDIR      = _build
  9 | 
 10 | # Internal variables.
 11 | PAPEROPT_a4     = -D latex_paper_size=a4
 12 | PAPEROPT_letter = -D latex_paper_size=letter
 13 | ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
 14 | # the i18n builder cannot share the environment and doctrees with the others
 15 | I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
 16 | 
 17 | .PHONY: help
 18 | help:
 19 | 	@echo "Please use \`make <target>' where <target> is one of"
 20 | 	@echo "  html       to make standalone HTML files"
 21 | 	@echo "  dirhtml    to make HTML files named index.html in directories"
 22 | 	@echo "  singlehtml to make a single large HTML file"
 23 | 	@echo "  pickle     to make pickle files"
 24 | 	@echo "  json       to make JSON files"
 25 | 	@echo "  htmlhelp   to make HTML files and a HTML help project"
 26 | 	@echo "  qthelp     to make HTML files and a qthelp project"
 27 | 	@echo "  applehelp  to make an Apple Help Book"
 28 | 	@echo "  devhelp    to make HTML files and a Devhelp project"
 29 | 	@echo "  epub       to make an epub"
 30 | 	@echo "  epub3      to make an epub3"
 31 | 	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
 32 | 	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
 33 | 	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
 34 | 	@echo "  text       to make text files"
 35 | 	@echo "  man        to make manual pages"
 36 | 	@echo "  texinfo    to make Texinfo files"
 37 | 	@echo "  info       to make Texinfo files and run them through makeinfo"
 38 | 	@echo "  gettext    to make PO message catalogs"
 39 | 	@echo "  changes    to make an overview of all changed/added/deprecated items"
 40 | 	@echo "  xml        to make Docutils-native XML files"
 41 | 	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
 42 | 	@echo "  linkcheck  to check all external links for integrity"
 43 | 	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
 44 | 	@echo "  coverage   to run coverage check of the documentation (if enabled)"
 45 | 	@echo "  dummy      to check syntax errors of document sources"
 46 | 
 47 | .PHONY: clean
 48 | clean:
 49 | 	rm -rf $(BUILDDIR)/*
 50 | 
 51 | .PHONY: html
 52 | html:
 53 | 	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
 54 | 	@echo
 55 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
 56 | 
 57 | .PHONY: dirhtml
 58 | dirhtml:
 59 | 	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
 60 | 	@echo
 61 | 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
 62 | 
 63 | .PHONY: singlehtml
 64 | singlehtml:
 65 | 	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
 66 | 	@echo
 67 | 	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
 68 | 
 69 | .PHONY: pickle
 70 | pickle:
 71 | 	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
 72 | 	@echo
 73 | 	@echo "Build finished; now you can process the pickle files."
 74 | 
 75 | .PHONY: json
 76 | json:
 77 | 	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
 78 | 	@echo
 79 | 	@echo "Build finished; now you can process the JSON files."
 80 | 
 81 | .PHONY: htmlhelp
 82 | htmlhelp:
 83 | 	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
 84 | 	@echo
 85 | 	@echo "Build finished; now you can run HTML Help Workshop with the" \
 86 | 	      ".hhp project file in $(BUILDDIR)/htmlhelp."
 87 | 
 88 | .PHONY: qthelp
 89 | qthelp:
 90 | 	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
 91 | 	@echo
 92 | 	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
 93 | 	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
 94 | 	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Idephix.qhcp"
 95 | 	@echo "To view the help file:"
 96 | 	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Idephix.qhc"
 97 | 
 98 | .PHONY: applehelp
 99 | applehelp:
100 | 	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
101 | 	@echo
102 | 	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
103 | 	@echo "N.B. You won't be able to view it unless you put it in" \
104 | 	      "~/Library/Documentation/Help or install it in your application" \
105 | 	      "bundle."
106 | 
107 | .PHONY: devhelp
108 | devhelp:
109 | 	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
110 | 	@echo
111 | 	@echo "Build finished."
112 | 	@echo "To view the help file:"
113 | 	@echo "# mkdir -p $$HOME/.local/share/devhelp/Idephix"
114 | 	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Idephix"
115 | 	@echo "# devhelp"
116 | 
117 | .PHONY: epub
118 | epub:
119 | 	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
120 | 	@echo
121 | 	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
122 | 
123 | .PHONY: epub3
124 | epub3:
125 | 	$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
126 | 	@echo
127 | 	@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
128 | 
129 | .PHONY: latex
130 | latex:
131 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
132 | 	@echo
133 | 	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
134 | 	@echo "Run \`make' in that directory to run these through (pdf)latex" \
135 | 	      "(use \`make latexpdf' here to do that automatically)."
136 | 
137 | .PHONY: latexpdf
138 | latexpdf:
139 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
140 | 	@echo "Running LaTeX files through pdflatex..."
141 | 	$(MAKE) -C $(BUILDDIR)/latex all-pdf
142 | 	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
143 | 
144 | .PHONY: latexpdfja
145 | latexpdfja:
146 | 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
147 | 	@echo "Running LaTeX files through platex and dvipdfmx..."
148 | 	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
149 | 	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
150 | 
151 | .PHONY: text
152 | text:
153 | 	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
154 | 	@echo
155 | 	@echo "Build finished. The text files are in $(BUILDDIR)/text."
156 | 
157 | .PHONY: man
158 | man:
159 | 	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
160 | 	@echo
161 | 	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
162 | 
163 | .PHONY: texinfo
164 | texinfo:
165 | 	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
166 | 	@echo
167 | 	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
168 | 	@echo "Run \`make' in that directory to run these through makeinfo" \
169 | 	      "(use \`make info' here to do that automatically)."
170 | 
171 | .PHONY: info
172 | info:
173 | 	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
174 | 	@echo "Running Texinfo files through makeinfo..."
175 | 	make -C $(BUILDDIR)/texinfo info
176 | 	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
177 | 
178 | .PHONY: gettext
179 | gettext:
180 | 	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
181 | 	@echo
182 | 	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
183 | 
184 | .PHONY: changes
185 | changes:
186 | 	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
187 | 	@echo
188 | 	@echo "The overview file is in $(BUILDDIR)/changes."
189 | 
190 | .PHONY: linkcheck
191 | linkcheck:
192 | 	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
193 | 	@echo
194 | 	@echo "Link check complete; look for any errors in the above output " \
195 | 	      "or in $(BUILDDIR)/linkcheck/output.txt."
196 | 
197 | .PHONY: doctest
198 | doctest:
199 | 	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
200 | 	@echo "Testing of doctests in the sources finished, look at the " \
201 | 	      "results in $(BUILDDIR)/doctest/output.txt."
202 | 
203 | .PHONY: coverage
204 | coverage:
205 | 	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
206 | 	@echo "Testing of coverage in the sources finished, look at the " \
207 | 	      "results in $(BUILDDIR)/coverage/python.txt."
208 | 
209 | .PHONY: xml
210 | xml:
211 | 	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
212 | 	@echo
213 | 	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
214 | 
215 | .PHONY: pseudoxml
216 | pseudoxml:
217 | 	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
218 | 	@echo
219 | 	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
220 | 
221 | .PHONY: dummy
222 | dummy:
223 | 	$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
224 | 	@echo
225 | 	@echo "Build finished. Dummy builder generates no files."
226 | 


--------------------------------------------------------------------------------
/docs/make.bat:
--------------------------------------------------------------------------------
  1 | @ECHO OFF
  2 | 
  3 | REM Command file for Sphinx documentation
  4 | 
  5 | if "%SPHINXBUILD%" == "" (
  6 | 	set SPHINXBUILD=sphinx-build
  7 | )
  8 | set BUILDDIR=_build
  9 | set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% .
 10 | set I18NSPHINXOPTS=%SPHINXOPTS% .
 11 | if NOT "%PAPER%" == "" (
 12 | 	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
 13 | 	set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS%
 14 | )
 15 | 
 16 | if "%1" == "" goto help
 17 | 
 18 | if "%1" == "help" (
 19 | 	:help
 20 | 	echo.Please use `make ^<target^>` where ^<target^> is one of
 21 | 	echo.  html       to make standalone HTML files
 22 | 	echo.  dirhtml    to make HTML files named index.html in directories
 23 | 	echo.  singlehtml to make a single large HTML file
 24 | 	echo.  pickle     to make pickle files
 25 | 	echo.  json       to make JSON files
 26 | 	echo.  htmlhelp   to make HTML files and a HTML help project
 27 | 	echo.  qthelp     to make HTML files and a qthelp project
 28 | 	echo.  devhelp    to make HTML files and a Devhelp project
 29 | 	echo.  epub       to make an epub
 30 | 	echo.  epub3      to make an epub3
 31 | 	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
 32 | 	echo.  text       to make text files
 33 | 	echo.  man        to make manual pages
 34 | 	echo.  texinfo    to make Texinfo files
 35 | 	echo.  gettext    to make PO message catalogs
 36 | 	echo.  changes    to make an overview over all changed/added/deprecated items
 37 | 	echo.  xml        to make Docutils-native XML files
 38 | 	echo.  pseudoxml  to make pseudoxml-XML files for display purposes
 39 | 	echo.  linkcheck  to check all external links for integrity
 40 | 	echo.  doctest    to run all doctests embedded in the documentation if enabled
 41 | 	echo.  coverage   to run coverage check of the documentation if enabled
 42 | 	echo.  dummy      to check syntax errors of document sources
 43 | 	goto end
 44 | )
 45 | 
 46 | if "%1" == "clean" (
 47 | 	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
 48 | 	del /q /s %BUILDDIR%\*
 49 | 	goto end
 50 | )
 51 | 
 52 | 
 53 | REM Check if sphinx-build is available and fallback to Python version if any
 54 | %SPHINXBUILD% 1>NUL 2>NUL
 55 | if errorlevel 9009 goto sphinx_python
 56 | goto sphinx_ok
 57 | 
 58 | :sphinx_python
 59 | 
 60 | set SPHINXBUILD=python -m sphinx.__init__
 61 | %SPHINXBUILD% 2> nul
 62 | if errorlevel 9009 (
 63 | 	echo.
 64 | 	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
 65 | 	echo.installed, then set the SPHINXBUILD environment variable to point
 66 | 	echo.to the full path of the 'sphinx-build' executable. Alternatively you
 67 | 	echo.may add the Sphinx directory to PATH.
 68 | 	echo.
 69 | 	echo.If you don't have Sphinx installed, grab it from
 70 | 	echo.http://sphinx-doc.org/
 71 | 	exit /b 1
 72 | )
 73 | 
 74 | :sphinx_ok
 75 | 
 76 | 
 77 | if "%1" == "html" (
 78 | 	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
 79 | 	if errorlevel 1 exit /b 1
 80 | 	echo.
 81 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
 82 | 	goto end
 83 | )
 84 | 
 85 | if "%1" == "dirhtml" (
 86 | 	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
 87 | 	if errorlevel 1 exit /b 1
 88 | 	echo.
 89 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
 90 | 	goto end
 91 | )
 92 | 
 93 | if "%1" == "singlehtml" (
 94 | 	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
 95 | 	if errorlevel 1 exit /b 1
 96 | 	echo.
 97 | 	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
 98 | 	goto end
 99 | )
100 | 
101 | if "%1" == "pickle" (
102 | 	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
103 | 	if errorlevel 1 exit /b 1
104 | 	echo.
105 | 	echo.Build finished; now you can process the pickle files.
106 | 	goto end
107 | )
108 | 
109 | if "%1" == "json" (
110 | 	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
111 | 	if errorlevel 1 exit /b 1
112 | 	echo.
113 | 	echo.Build finished; now you can process the JSON files.
114 | 	goto end
115 | )
116 | 
117 | if "%1" == "htmlhelp" (
118 | 	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
119 | 	if errorlevel 1 exit /b 1
120 | 	echo.
121 | 	echo.Build finished; now you can run HTML Help Workshop with the ^
122 | .hhp project file in %BUILDDIR%/htmlhelp.
123 | 	goto end
124 | )
125 | 
126 | if "%1" == "qthelp" (
127 | 	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
128 | 	if errorlevel 1 exit /b 1
129 | 	echo.
130 | 	echo.Build finished; now you can run "qcollectiongenerator" with the ^
131 | .qhcp project file in %BUILDDIR%/qthelp, like this:
132 | 	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Idephix.qhcp
133 | 	echo.To view the help file:
134 | 	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Idephix.ghc
135 | 	goto end
136 | )
137 | 
138 | if "%1" == "devhelp" (
139 | 	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
140 | 	if errorlevel 1 exit /b 1
141 | 	echo.
142 | 	echo.Build finished.
143 | 	goto end
144 | )
145 | 
146 | if "%1" == "epub" (
147 | 	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
148 | 	if errorlevel 1 exit /b 1
149 | 	echo.
150 | 	echo.Build finished. The epub file is in %BUILDDIR%/epub.
151 | 	goto end
152 | )
153 | 
154 | if "%1" == "epub3" (
155 | 	%SPHINXBUILD% -b epub3 %ALLSPHINXOPTS% %BUILDDIR%/epub3
156 | 	if errorlevel 1 exit /b 1
157 | 	echo.
158 | 	echo.Build finished. The epub3 file is in %BUILDDIR%/epub3.
159 | 	goto end
160 | )
161 | 
162 | if "%1" == "latex" (
163 | 	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
164 | 	if errorlevel 1 exit /b 1
165 | 	echo.
166 | 	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
167 | 	goto end
168 | )
169 | 
170 | if "%1" == "latexpdf" (
171 | 	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
172 | 	cd %BUILDDIR%/latex
173 | 	make all-pdf
174 | 	cd %~dp0
175 | 	echo.
176 | 	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
177 | 	goto end
178 | )
179 | 
180 | if "%1" == "latexpdfja" (
181 | 	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
182 | 	cd %BUILDDIR%/latex
183 | 	make all-pdf-ja
184 | 	cd %~dp0
185 | 	echo.
186 | 	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
187 | 	goto end
188 | )
189 | 
190 | if "%1" == "text" (
191 | 	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
192 | 	if errorlevel 1 exit /b 1
193 | 	echo.
194 | 	echo.Build finished. The text files are in %BUILDDIR%/text.
195 | 	goto end
196 | )
197 | 
198 | if "%1" == "man" (
199 | 	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
200 | 	if errorlevel 1 exit /b 1
201 | 	echo.
202 | 	echo.Build finished. The manual pages are in %BUILDDIR%/man.
203 | 	goto end
204 | )
205 | 
206 | if "%1" == "texinfo" (
207 | 	%SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo
208 | 	if errorlevel 1 exit /b 1
209 | 	echo.
210 | 	echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo.
211 | 	goto end
212 | )
213 | 
214 | if "%1" == "gettext" (
215 | 	%SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale
216 | 	if errorlevel 1 exit /b 1
217 | 	echo.
218 | 	echo.Build finished. The message catalogs are in %BUILDDIR%/locale.
219 | 	goto end
220 | )
221 | 
222 | if "%1" == "changes" (
223 | 	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
224 | 	if errorlevel 1 exit /b 1
225 | 	echo.
226 | 	echo.The overview file is in %BUILDDIR%/changes.
227 | 	goto end
228 | )
229 | 
230 | if "%1" == "linkcheck" (
231 | 	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
232 | 	if errorlevel 1 exit /b 1
233 | 	echo.
234 | 	echo.Link check complete; look for any errors in the above output ^
235 | or in %BUILDDIR%/linkcheck/output.txt.
236 | 	goto end
237 | )
238 | 
239 | if "%1" == "doctest" (
240 | 	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
241 | 	if errorlevel 1 exit /b 1
242 | 	echo.
243 | 	echo.Testing of doctests in the sources finished, look at the ^
244 | results in %BUILDDIR%/doctest/output.txt.
245 | 	goto end
246 | )
247 | 
248 | if "%1" == "coverage" (
249 | 	%SPHINXBUILD% -b coverage %ALLSPHINXOPTS% %BUILDDIR%/coverage
250 | 	if errorlevel 1 exit /b 1
251 | 	echo.
252 | 	echo.Testing of coverage in the sources finished, look at the ^
253 | results in %BUILDDIR%/coverage/python.txt.
254 | 	goto end
255 | )
256 | 
257 | if "%1" == "xml" (
258 | 	%SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml
259 | 	if errorlevel 1 exit /b 1
260 | 	echo.
261 | 	echo.Build finished. The XML files are in %BUILDDIR%/xml.
262 | 	goto end
263 | )
264 | 
265 | if "%1" == "pseudoxml" (
266 | 	%SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml
267 | 	if errorlevel 1 exit /b 1
268 | 	echo.
269 | 	echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml.
270 | 	goto end
271 | )
272 | 
273 | if "%1" == "dummy" (
274 | 	%SPHINXBUILD% -b dummy %ALLSPHINXOPTS% %BUILDDIR%/dummy
275 | 	if errorlevel 1 exit /b 1
276 | 	echo.
277 | 	echo.Build finished. Dummy builder generates no files.
278 | 	goto end
279 | )
280 | 
281 | :end
282 | 


--------------------------------------------------------------------------------
/docs/conf.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | #
  3 | # Idephix documentation build configuration file, created by
  4 | # sphinx-quickstart on Thu Jun 30 23:03:52 2016.
  5 | #
  6 | # This file is execfile()d with the current directory set to its
  7 | # containing dir.
  8 | #
  9 | # Note that not all possible configuration values are present in this
 10 | # autogenerated file.
 11 | #
 12 | # All configuration values have a default; values that are commented out
 13 | # serve to show the default.
 14 | 
 15 | # If extensions (or modules to document with autodoc) are in another directory,
 16 | # add these directories to sys.path here. If the directory is relative to the
 17 | # documentation root, use os.path.abspath to make it absolute, like shown here.
 18 | #
 19 | # import os
 20 | # import sys
 21 | # sys.path.insert(0, os.path.abspath('.'))
 22 | 
 23 | # -- General configuration ------------------------------------------------
 24 | 
 25 | # If your documentation needs a minimal Sphinx version, state it here.
 26 | #
 27 | # needs_sphinx = '1.0'
 28 | 
 29 | # Add any Sphinx extension module names here, as strings. They can be
 30 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 31 | # ones.
 32 | extensions = []
 33 | 
 34 | # Add any paths that contain templates here, relative to this directory.
 35 | templates_path = ['_templates']
 36 | 
 37 | # The suffix(es) of source filenames.
 38 | # You can specify multiple suffix as a list of string:
 39 | #
 40 | # source_suffix = ['.rst', '.md']
 41 | source_suffix = '.rst'
 42 | 
 43 | # The encoding of source files.
 44 | #
 45 | # source_encoding = 'utf-8-sig'
 46 | 
 47 | # The master toctree document.
 48 | master_doc = 'index'
 49 | 
 50 | # General information about the project.
 51 | project = u'Idephix'
 52 | copyright = u'2016, Manuel Baldassarri'
 53 | author = u'Manuel Baldassarri'
 54 | 
 55 | # The version info for the project you're documenting, acts as replacement for
 56 | # |version| and |release|, also used in various other places throughout the
 57 | # built documents.
 58 | #
 59 | # The short X.Y version.
 60 | version = u'0.3'
 61 | # The full version, including alpha/beta/rc tags.
 62 | release = u'0.3.0'
 63 | 
 64 | # The language for content autogenerated by Sphinx. Refer to documentation
 65 | # for a list of supported languages.
 66 | #
 67 | # This is also used if you do content translation via gettext catalogs.
 68 | # Usually you set "language" from the command line for these cases.
 69 | language = None
 70 | 
 71 | # There are two options for replacing |today|: either, you set today to some
 72 | # non-false value, then it is used:
 73 | #
 74 | # today = ''
 75 | #
 76 | # Else, today_fmt is used as the format for a strftime call.
 77 | #
 78 | # today_fmt = '%B %d, %Y'
 79 | 
 80 | # List of patterns, relative to source directory, that match files and
 81 | # directories to ignore when looking for source files.
 82 | # This patterns also effect to html_static_path and html_extra_path
 83 | exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
 84 | 
 85 | # The reST default role (used for this markup: `text`) to use for all
 86 | # documents.
 87 | #
 88 | # default_role = None
 89 | 
 90 | # If true, '()' will be appended to :func: etc. cross-reference text.
 91 | #
 92 | # add_function_parentheses = True
 93 | 
 94 | # If true, the current module name will be prepended to all description
 95 | # unit titles (such as .. function::).
 96 | #
 97 | # add_module_names = True
 98 | 
 99 | # If true, sectionauthor and moduleauthor directives will be shown in the
100 | # output. They are ignored by default.
101 | #
102 | # show_authors = False
103 | 
104 | # The name of the Pygments (syntax highlighting) style to use.
105 | pygments_style = 'sphinx'
106 | 
107 | # A list of ignored prefixes for module index sorting.
108 | # modindex_common_prefix = []
109 | 
110 | # If true, keep warnings as "system message" paragraphs in the built documents.
111 | # keep_warnings = False
112 | 
113 | # If true, `todo` and `todoList` produce output, else they produce nothing.
114 | todo_include_todos = False
115 | 
116 | 
117 | # -- Options for HTML output ----------------------------------------------
118 | 
119 | # The theme to use for HTML and HTML Help pages.  See the documentation for
120 | # a list of builtin themes.
121 | #
122 | html_theme = 'sphinx_rtd_theme'
123 | 
124 | # Theme options are theme-specific and customize the look and feel of a theme
125 | # further.  For a list of options available for each theme, see the
126 | # documentation.
127 | #
128 | html_theme_options = {
129 |     'collapse_navigation': False,
130 |     'display_version': False,
131 |     'navigation_depth': 3
132 |  }
133 | 
134 | # Add any paths that contain custom themes here, relative to this directory.
135 | 
136 | html_theme_path = ["_themes"]
137 | 
138 | # The name for this set of Sphinx documents.
139 | # "<project> v<release> documentation" by default.
140 | #
141 | # html_title = u'Idephix v0.3.0'
142 | 
143 | # A shorter title for the navigation bar.  Default is the same as html_title.
144 | #
145 | # html_short_title = None
146 | 
147 | # The name of an image file (relative to this directory) to place at the top
148 | # of the sidebar.
149 | #
150 | # html_logo = None
151 | 
152 | # The name of an image file (relative to this directory) to use as a favicon of
153 | # the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
154 | # pixels large.
155 | #
156 | # html_favicon = None
157 | 
158 | # Add any paths that contain custom static files (such as style sheets) here,
159 | # relative to this directory. They are copied after the builtin static files,
160 | # so a file named "default.css" will overwrite the builtin "default.css".
161 | html_static_path = ['_static']
162 | 
163 | # Add any extra paths that contain custom files (such as robots.txt or
164 | # .htaccess) here, relative to this directory. These files are copied
165 | # directly to the root of the documentation.
166 | #
167 | # html_extra_path = []
168 | 
169 | # If not None, a 'Last updated on:' timestamp is inserted at every page
170 | # bottom, using the given strftime format.
171 | # The empty string is equivalent to '%b %d, %Y'.
172 | #
173 | # html_last_updated_fmt = None
174 | 
175 | # If true, SmartyPants will be used to convert quotes and dashes to
176 | # typographically correct entities.
177 | #
178 | # html_use_smartypants = True
179 | 
180 | # Custom sidebar templates, maps document names to template names.
181 | #
182 | # html_sidebars = {}
183 | 
184 | # Additional templates that should be rendered to pages, maps page names to
185 | # template names.
186 | #
187 | # html_additional_pages = {}
188 | 
189 | # If false, no module index is generated.
190 | #
191 | # html_domain_indices = True
192 | 
193 | # If false, no index is generated.
194 | #
195 | # html_use_index = True
196 | 
197 | # If true, the index is split into individual pages for each letter.
198 | #
199 | # html_split_index = False
200 | 
201 | # If true, links to the reST sources are added to the pages.
202 | #
203 | # html_show_sourcelink = True
204 | 
205 | # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
206 | #
207 | # html_show_sphinx = True
208 | 
209 | # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
210 | #
211 | # html_show_copyright = True
212 | 
213 | # If true, an OpenSearch description file will be output, and all pages will
214 | # contain a <link> tag referring to it.  The value of this option must be the
215 | # base URL from which the finished HTML is served.
216 | #
217 | # html_use_opensearch = ''
218 | 
219 | # This is the file name suffix for HTML files (e.g. ".xhtml").
220 | # html_file_suffix = None
221 | 
222 | # Language to be used for generating the HTML full-text search index.
223 | # Sphinx supports the following languages:
224 | #   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
225 | #   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh'
226 | #
227 | # html_search_language = 'en'
228 | 
229 | # A dictionary with options for the search language support, empty by default.
230 | # 'ja' uses this config value.
231 | # 'zh' user can custom change `jieba` dictionary path.
232 | #
233 | # html_search_options = {'type': 'default'}
234 | 
235 | # The name of a javascript file (relative to the configuration directory) that
236 | # implements a search results scorer. If empty, the default will be used.
237 | #
238 | # html_search_scorer = 'scorer.js'
239 | 
240 | # Output file base name for HTML help builder.
241 | htmlhelp_basename = 'Idephixdoc'
242 | 
243 | # -- Options for LaTeX output ---------------------------------------------
244 | 
245 | latex_elements = {
246 |      # The paper size ('letterpaper' or 'a4paper').
247 |      #
248 |      # 'papersize': 'letterpaper',
249 | 
250 |      # The font size ('10pt', '11pt' or '12pt').
251 |      #
252 |      # 'pointsize': '10pt',
253 | 
254 |      # Additional stuff for the LaTeX preamble.
255 |      #
256 |      # 'preamble': '',
257 | 
258 |      # Latex figure (float) alignment
259 |      #
260 |      # 'figure_align': 'htbp',
261 | }
262 | 
263 | # Grouping the document tree into LaTeX files. List of tuples
264 | # (source start file, target name, title,
265 | #  author, documentclass [howto, manual, or own class]).
266 | latex_documents = [
267 |     (master_doc, 'Idephix.tex', u'Idephix Documentation',
268 |      u'Manuel Baldassarri', 'manual'),
269 | ]
270 | 
271 | # The name of an image file (relative to this directory) to place at the top of
272 | # the title page.
273 | #
274 | # latex_logo = None
275 | 
276 | # For "manual" documents, if this is true, then toplevel headings are parts,
277 | # not chapters.
278 | #
279 | # latex_use_parts = False
280 | 
281 | # If true, show page references after internal links.
282 | #
283 | # latex_show_pagerefs = False
284 | 
285 | # If true, show URL addresses after external links.
286 | #
287 | # latex_show_urls = False
288 | 
289 | # Documents to append as an appendix to all manuals.
290 | #
291 | # latex_appendices = []
292 | 
293 | # If false, no module index is generated.
294 | #
295 | # latex_domain_indices = True
296 | 
297 | 
298 | # -- Options for manual page output ---------------------------------------
299 | 
300 | # One entry per manual page. List of tuples
301 | # (source start file, name, description, authors, manual section).
302 | man_pages = [
303 |     (master_doc, 'idephix', u'Idephix Documentation',
304 |      [author], 1)
305 | ]
306 | 
307 | # If true, show URL addresses after external links.
308 | #
309 | # man_show_urls = False
310 | 
311 | 
312 | # -- Options for Texinfo output -------------------------------------------
313 | 
314 | # Grouping the document tree into Texinfo files. List of tuples
315 | # (source start file, target name, title, author,
316 | #  dir menu entry, description, category)
317 | texinfo_documents = [
318 |     (master_doc, 'Idephix', u'Idephix Documentation',
319 |      author, 'Idephix', 'One line description of project.',
320 |      'Miscellaneous'),
321 | ]
322 | 
323 | # Documents to append as an appendix to all manuals.
324 | #
325 | # texinfo_appendices = []
326 | 
327 | # If false, no module index is generated.
328 | #
329 | # texinfo_domain_indices = True
330 | 
331 | # How to display URL addresses: 'footnote', 'no', or 'inline'.
332 | #
333 | # texinfo_show_urls = 'footnote'
334 | 
335 | # If true, do not generate a @detailmenu in the "Top" node's menu.
336 | #
337 | # texinfo_no_detailmenu = False
338 | 


--------------------------------------------------------------------------------
/docs/writing_tasks.rst:
--------------------------------------------------------------------------------
  1 | .. _writing_tasks:
  2 | 
  3 | .. highlight:: php
  4 |    :linenothreshold: 3
  5 | 
  6 | ==============
  7 | Defining Tasks
  8 | ==============
  9 | 
 10 | To define a new task you just need to define a function within the ``idxfile.php`` and
 11 | it will be automatically mounted as an Idephix command.
 12 | 
 13 | ::
 14 | 
 15 |     <?php
 16 | 
 17 |     function myNewTask()
 18 |     {
 19 |         echo 'I am a brand new task' . PHP_EOL;
 20 |     }
 21 | 
 22 | Now running idx you'll get
 23 | 
 24 | .. code-block:: bash
 25 | 
 26 |     $ bin/idx
 27 | 
 28 |     $ Available commands:
 29 |     $ help            Displays help for a command
 30 |     $ initFile        Init idx configurations and tasks file
 31 |     $ list            Lists commands
 32 |     $ myNewTask
 33 | 
 34 | And you can execute it with:
 35 | 
 36 | .. code-block:: bash
 37 | 
 38 |     $ bin/idx myNewTask
 39 |     I am a brand new task
 40 | 
 41 | You can even execute a task within another task:
 42 | 
 43 | ::
 44 | 
 45 |     <?php
 46 | 
 47 |     function anotherTask()
 48 |     {
 49 |     }
 50 | 
 51 |     function myNewTask(\Idephix\Context $context)
 52 |     {
 53 |         $context->anotherTask();
 54 |     }
 55 | 
 56 | .. hint::
 57 | 
 58 |     Every task can define a special arguments: ``$context``. If you define an argument and type hint it as
 59 |     ``\Idephix\Context`` an instance of the context object will be injected at runtime. The context object allows
 60 |     you to execute tasks and access configuration parameters. For more info about ``Context`` check
 61 |     out `Scripting with Idephix`_ section
 62 | 
 63 | Adding task arguments
 64 | =====================
 65 | 
 66 | Function parameters will be used as the task arguments.
 67 | 
 68 | ::
 69 | 
 70 |     <?php
 71 | 
 72 |     function yell($what)
 73 |     {
 74 |         echo $what . PHP_EOL;
 75 |     }
 76 | 
 77 | Mandatory Arguments
 78 | -------------------
 79 | The parameter $name will be a mandatory option to be specified in the command execution.
 80 | 
 81 | .. code-block:: bash
 82 | 
 83 |     $ bin/idx help yell
 84 |     Usage:
 85 |         yell what
 86 | 
 87 |     Arguments:
 88 |         what
 89 | 
 90 | You can add as many arguments as you need, just adding function parameters.
 91 | 
 92 | Optional Arguments
 93 | ------------------
 94 | 
 95 | If you want to add optional arguments, just define a default value for the
 96 | parameter, as:
 97 | 
 98 | ::
 99 | 
100 |     <?php
101 | 
102 |     function yell($what = 'foo')
103 |     {
104 |         echo $what . PHP_EOL;
105 |     }
106 | 
107 | Optional arguments as task flags
108 | --------------------------------
109 | 
110 | A flag is a special parameter with default value false.
111 | Using flags should be useful to implement a dry-run approach in your script
112 | 
113 | ::
114 | 
115 |     <?php
116 | 
117 |     function deploy($go = false){
118 |          if ($go) {
119 |              //bla bla bla
120 |          return;
121 |      }
122 |  }
123 | 
124 | Documenting tasks
125 | =================
126 | 
127 | Tasks and arguments can have a description. You can define descriptions using
128 | simple and well known phpdoc block.
129 | 
130 | ::
131 | 
132 |     <?php
133 | 
134 |     /**
135 |      * This command will yell at you
136 |      *
137 |      *
138 |      * @param string $what What you want to yell
139 |      */
140 |     function yell($what = 'foo')
141 |     {
142 |         echo $what . PHP_EOL;
143 |     }
144 | 
145 | Configure a task like
146 | 
147 | .. code-block:: bash
148 | 
149 |     $ bin/idx help yell
150 |     Usage:
151 |         yell [what]
152 | 
153 |     Arguments:
154 |         what    What you want to yell (default: "foo")
155 | 
156 | Scripting with Idephix
157 | ======================
158 | 
159 | With Idephix you compose your script basically:
160 | 
161 | * executing local commands
162 | * executing remote commands
163 | * executing other tasks you have already defined
164 | * sending some output to the console
165 | 
166 | In order to perform such operations you will need an instance of the ``Idephix\\Context`` object. Idephix will inject it
167 | at runtime in each tasks that defines an argument type hinted as ``Idephix\\Context``. A ``Context`` implements
168 | ``\Idephix\TaskExecutor`` and ``\Idephix\DictionaryAccess`` allowing you to execute commands and to access the configuration
169 | data related to the choosen ``env``.
170 | 
171 | Executing local commands
172 | ------------------------
173 | 
174 | ``\Idephix\TaskExecutor::local`` allows you to execute local commands. A local command will be executing without any
175 | need for a SSH connection, on your local machine.
176 | 
177 | .. code-block:: php
178 |     :linenos:
179 |     :emphasize-lines: 3,4
180 | 
181 |     <?php
182 | 
183 |     function buildDoc(\Idephix\Context $context, $open = false)
184 |     {
185 |         $context->local('cp -r src/Idephix/Cookbook docs/');
186 |         $context->local('make  -C ./docs html');
187 | 
188 |         if ($open) {
189 |             $context->openDoc();
190 |         }
191 |     }
192 | 
193 | If you need so you can execute the command in dry run mode
194 | 
195 | .. code-block:: php
196 |     :linenos:
197 |     :emphasize-lines: 3
198 | 
199 |     <?php
200 | 
201 |     function buildDoc(\Idephix\Context $context, $open = false)
202 |     {
203 |         $context->local('cp -r src/Idephix/Cookbook docs/', true);
204 |     }
205 | 
206 | In dry run mode the command will just be echoed to the console. This can be useful while debugging your idxfile to check
207 | the actual command that would be executed.
208 | 
209 | For local commands you can also specify a timeout:
210 | 
211 | .. code-block:: php
212 |     :linenos:
213 |     :emphasize-lines: 5
214 | 
215 |     <?php
216 | 
217 |     function buildTravis(\Idephix\Context $context)
218 |     {
219 |         try {
220 |             $context->local('composer install');
221 |             $context->local('bin/phpunit -c tests --coverage-clover=clover.xml', false, 240);
222 |             $context->runTask('createPhar');
223 |         } catch (\Exception $e) {
224 |             $context->output()->writeln(sprintf("<error>Exception: \n%s</error>", $e->getMessage()));
225 |             exit(1);
226 |         }
227 |     };
228 | 
229 | Executing remote commands
230 | -------------------------
231 | 
232 | Running remote commands is almost the same as running local commands. You can do that using
233 | ``\Idephix\TaskExecutor::remote`` method. Dry run mode works quite the same as for local commands, but mind that
234 | `at the moment is not possible to specify a timeout for remote commands`.
235 | 
236 | ::
237 | 
238 |     <?php
239 | 
240 |     function switchToNextRelease(Idephix\Context $context, $remoteBaseDir, $nextRelease, $go = false)
241 |     {
242 |         $context->remote(
243 |             "
244 |             cd $remoteBaseDir && \\
245 |             ln -nfs $nextRelease current",
246 |             !$go
247 |         );
248 |     }
249 | 
250 | In order to execute a remote command you must specify an environment using ``--env`` option. If you fail to
251 | specify a valid env name you will get an error and the command will not be executed.
252 | 
253 | Executing user defined tasks
254 | ----------------------------
255 | 
256 | Every task that you define will be accessible as a method of the ``Idephix\Context`` object.
257 | Mind that you don't have to manually inject the ``Context`` object, Idephix will do that for you at runtime.
258 | 
259 | .. code-block:: php
260 |     :linenos:
261 |     :emphasize-lines: 7,11
262 | 
263 |     <?php
264 | 
265 |     function buildDoc(\Idephix\Context $context, $open = false)
266 |     {
267 |         $context->local('cp -r src/Idephix/Cookbook docs/');
268 |         $context->local('make  -C ./docs html');
269 | 
270 |         if ($open) {
271 |             $context->openDoc();
272 |         }
273 |     }
274 | 
275 |     function openDoc(\Idephix\Context $context)
276 |     {
277 |         $context->local('open docs/_build/html/index.html');
278 |     }
279 | 
280 | Accessing configuration from tasks
281 | ----------------------------------
282 | 
283 | ``Idephix\Context`` object gives you also access to every configuration defined for the current environment.
284 | Imagine you have defined this configuration:
285 | 
286 | ::
287 | 
288 |     <?php
289 | 
290 |     $environments = array(
291 |         'prod' => array(
292 |             'hosts' => array('127.0.0.1'),
293 |             'ssh_params' => array(
294 |                 'user' => 'ideato'
295 |             ),
296 |             'deploy' => array(
297 |                 'repository' => './',
298 |                 'branch' => 'origin/master',
299 |                 'shared_files' => array('app/config/parameters.yml'),
300 |                 'shared_folders' => array('app/cache', 'app/logs'),
301 |                 'remote_base_dir' => '/var/www/testidx',
302 |                 'rsync_exclude' => './rsync_exclude.txt',
303 |             )
304 |         ),
305 |         'test' => array(//blablabla),
306 |     );
307 | 
308 | While executing a command using ``--env=prod`` option your tasks will receive a ``Context`` filled up with prod data, so
309 | you can access to it. ``Context`` allows you to access configuration data implementing php ``\ArrayAccess`` interface or
310 | through get ``\Idephix\DictionaryAccess::get`` method.
311 | 
312 | ::
313 | 
314 |     <?php
315 | 
316 |     function deploy(Idephix\Context $context, $go = false)
317 |     {
318 |         $sharedFiles = $context->get('deploy.shared_files', array());
319 |         $repository = $context['deploy.repository'];
320 |         //cut
321 | 
322 | 
323 | Writing output to the console
324 | -----------------------------
325 | 
326 | Idephix is based on Symfony console component so you can send output to the user using the
327 | ``\Symfony\Component\Console\Style\SymfonyStyle``. You can get the full ``SymfonyStyle`` component
328 | through the ``\Idephix\TaskExecutor::output`` method or you can use the shortcut methods:
329 | ``\Idephix\TaskExecutor::write`` and ``\Idephix\TaskExecutor::writeln``.
330 | 
331 | Here is an example of you you can send some output to the console.
332 | 
333 | ::
334 | 
335 |     <?php
336 |     
337 |     /**
338 |      * This command will yell at you
339 |      *
340 |      * @param string $what What you want to yell
341 |      */
342 |     function yell(\Idephix\Context $context, $what = 'foo')
343 |     {
344 |         $context->writeln(strtoupper($what));
345 |         $context->write(strtoupper($what) . PHP_EOL);
346 | 
347 |         $output = $idx->output();
348 | 
349 |         // common output elements
350 |         $output->title($what);
351 |         $output->section($what);
352 |         $output->text($what);
353 |         $output->comment($what);
354 |         $output->note($what);
355 |         $output->caution($what);
356 |         $output->listing([$what, $what, $what]);
357 |         $output->success($what);
358 |         $output->error($what);
359 |         $output->warning($what);
360 | 
361 |         //table
362 |         $headers = ['Parameter', 'Value', 'Value 3'];
363 |         $rows = [
364 |           ['Param1', 'Value1', 'Value 3'],
365 |           ['Param2', 'Value2', 'Value 3']
366 |         ];
367 |         $output->table($headers, $rows);
368 |     }
369 | 
370 | .. hint::
371 | 
372 |     For more information about ``SymfonyStyle`` read the official
373 |     component `documentation <http://symfony.com/blog/new-in-symfony-2-8-console-style-guide>`_
374 | 


--------------------------------------------------------------------------------
/composer.lock:
--------------------------------------------------------------------------------
  1 | {
  2 |     "_readme": [
  3 |         "This file locks the dependencies of your project to a known state",
  4 |         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file",
  5 |         "This file is @generated automatically"
  6 |     ],
  7 |     "hash": "8bc07d4227bc1594b73cbfeaadc1f958",
  8 |     "content-hash": "b44fe27be8c92196036031544b4669d0",
  9 |     "packages": [
 10 |         {
 11 |             "name": "nikic/php-parser",
 12 |             "version": "v1.4.1",
 13 |             "source": {
 14 |                 "type": "git",
 15 |                 "url": "https://github.com/nikic/PHP-Parser.git",
 16 |                 "reference": "f78af2c9c86107aa1a34cd1dbb5bbe9eeb0d9f51"
 17 |             },
 18 |             "dist": {
 19 |                 "type": "zip",
 20 |                 "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/f78af2c9c86107aa1a34cd1dbb5bbe9eeb0d9f51",
 21 |                 "reference": "f78af2c9c86107aa1a34cd1dbb5bbe9eeb0d9f51",
 22 |                 "shasum": ""
 23 |             },
 24 |             "require": {
 25 |                 "ext-tokenizer": "*",
 26 |                 "php": ">=5.3"
 27 |             },
 28 |             "type": "library",
 29 |             "extra": {
 30 |                 "branch-alias": {
 31 |                     "dev-master": "1.4-dev"
 32 |                 }
 33 |             },
 34 |             "autoload": {
 35 |                 "files": [
 36 |                     "lib/bootstrap.php"
 37 |                 ]
 38 |             },
 39 |             "notification-url": "https://packagist.org/downloads/",
 40 |             "license": [
 41 |                 "BSD-3-Clause"
 42 |             ],
 43 |             "authors": [
 44 |                 {
 45 |                     "name": "Nikita Popov"
 46 |                 }
 47 |             ],
 48 |             "description": "A PHP parser written in PHP",
 49 |             "keywords": [
 50 |                 "parser",
 51 |                 "php"
 52 |             ],
 53 |             "time": "2015-09-19 14:15:08"
 54 |         },
 55 |         {
 56 |             "name": "symfony/console",
 57 |             "version": "v2.8.9",
 58 |             "source": {
 59 |                 "type": "git",
 60 |                 "url": "https://github.com/symfony/console.git",
 61 |                 "reference": "36e62335caca8a6e909c5c5bac4a8128149911c9"
 62 |             },
 63 |             "dist": {
 64 |                 "type": "zip",
 65 |                 "url": "https://api.github.com/repos/symfony/console/zipball/36e62335caca8a6e909c5c5bac4a8128149911c9",
 66 |                 "reference": "36e62335caca8a6e909c5c5bac4a8128149911c9",
 67 |                 "shasum": ""
 68 |             },
 69 |             "require": {
 70 |                 "php": ">=5.3.9",
 71 |                 "symfony/polyfill-mbstring": "~1.0"
 72 |             },
 73 |             "require-dev": {
 74 |                 "psr/log": "~1.0",
 75 |                 "symfony/event-dispatcher": "~2.1|~3.0.0",
 76 |                 "symfony/process": "~2.1|~3.0.0"
 77 |             },
 78 |             "suggest": {
 79 |                 "psr/log": "For using the console logger",
 80 |                 "symfony/event-dispatcher": "",
 81 |                 "symfony/process": ""
 82 |             },
 83 |             "type": "library",
 84 |             "extra": {
 85 |                 "branch-alias": {
 86 |                     "dev-master": "2.8-dev"
 87 |                 }
 88 |             },
 89 |             "autoload": {
 90 |                 "psr-4": {
 91 |                     "Symfony\\Component\\Console\\": ""
 92 |                 },
 93 |                 "exclude-from-classmap": [
 94 |                     "/Tests/"
 95 |                 ]
 96 |             },
 97 |             "notification-url": "https://packagist.org/downloads/",
 98 |             "license": [
 99 |                 "MIT"
100 |             ],
101 |             "authors": [
102 |                 {
103 |                     "name": "Fabien Potencier",
104 |                     "email": "fabien@symfony.com"
105 |                 },
106 |                 {
107 |                     "name": "Symfony Community",
108 |                     "homepage": "https://symfony.com/contributors"
109 |                 }
110 |             ],
111 |             "description": "Symfony Console Component",
112 |             "homepage": "https://symfony.com",
113 |             "time": "2016-07-30 07:20:35"
114 |         },
115 |         {
116 |             "name": "symfony/options-resolver",
117 |             "version": "v2.8.9",
118 |             "source": {
119 |                 "type": "git",
120 |                 "url": "https://github.com/symfony/options-resolver.git",
121 |                 "reference": "b6f982782a0624d37b5416c2c96fb99ce5ab74d5"
122 |             },
123 |             "dist": {
124 |                 "type": "zip",
125 |                 "url": "https://api.github.com/repos/symfony/options-resolver/zipball/b6f982782a0624d37b5416c2c96fb99ce5ab74d5",
126 |                 "reference": "b6f982782a0624d37b5416c2c96fb99ce5ab74d5",
127 |                 "shasum": ""
128 |             },
129 |             "require": {
130 |                 "php": ">=5.3.9"
131 |             },
132 |             "type": "library",
133 |             "extra": {
134 |                 "branch-alias": {
135 |                     "dev-master": "2.8-dev"
136 |                 }
137 |             },
138 |             "autoload": {
139 |                 "psr-4": {
140 |                     "Symfony\\Component\\OptionsResolver\\": ""
141 |                 },
142 |                 "exclude-from-classmap": [
143 |                     "/Tests/"
144 |                 ]
145 |             },
146 |             "notification-url": "https://packagist.org/downloads/",
147 |             "license": [
148 |                 "MIT"
149 |             ],
150 |             "authors": [
151 |                 {
152 |                     "name": "Fabien Potencier",
153 |                     "email": "fabien@symfony.com"
154 |                 },
155 |                 {
156 |                     "name": "Symfony Community",
157 |                     "homepage": "https://symfony.com/contributors"
158 |                 }
159 |             ],
160 |             "description": "Symfony OptionsResolver Component",
161 |             "homepage": "https://symfony.com",
162 |             "keywords": [
163 |                 "config",
164 |                 "configuration",
165 |                 "options"
166 |             ],
167 |             "time": "2016-06-29 05:29:29"
168 |         },
169 |         {
170 |             "name": "symfony/polyfill-mbstring",
171 |             "version": "v1.2.0",
172 |             "source": {
173 |                 "type": "git",
174 |                 "url": "https://github.com/symfony/polyfill-mbstring.git",
175 |                 "reference": "dff51f72b0706335131b00a7f49606168c582594"
176 |             },
177 |             "dist": {
178 |                 "type": "zip",
179 |                 "url": "https://api.github.com/repos/symfony/polyfill-mbstring/zipball/dff51f72b0706335131b00a7f49606168c582594",
180 |                 "reference": "dff51f72b0706335131b00a7f49606168c582594",
181 |                 "shasum": ""
182 |             },
183 |             "require": {
184 |                 "php": ">=5.3.3"
185 |             },
186 |             "suggest": {
187 |                 "ext-mbstring": "For best performance"
188 |             },
189 |             "type": "library",
190 |             "extra": {
191 |                 "branch-alias": {
192 |                     "dev-master": "1.2-dev"
193 |                 }
194 |             },
195 |             "autoload": {
196 |                 "psr-4": {
197 |                     "Symfony\\Polyfill\\Mbstring\\": ""
198 |                 },
199 |                 "files": [
200 |                     "bootstrap.php"
201 |                 ]
202 |             },
203 |             "notification-url": "https://packagist.org/downloads/",
204 |             "license": [
205 |                 "MIT"
206 |             ],
207 |             "authors": [
208 |                 {
209 |                     "name": "Nicolas Grekas",
210 |                     "email": "p@tchwork.com"
211 |                 },
212 |                 {
213 |                     "name": "Symfony Community",
214 |                     "homepage": "https://symfony.com/contributors"
215 |                 }
216 |             ],
217 |             "description": "Symfony polyfill for the Mbstring extension",
218 |             "homepage": "https://symfony.com",
219 |             "keywords": [
220 |                 "compatibility",
221 |                 "mbstring",
222 |                 "polyfill",
223 |                 "portable",
224 |                 "shim"
225 |             ],
226 |             "time": "2016-05-18 14:26:46"
227 |         },
228 |         {
229 |             "name": "symfony/process",
230 |             "version": "v2.8.9",
231 |             "source": {
232 |                 "type": "git",
233 |                 "url": "https://github.com/symfony/process.git",
234 |                 "reference": "d20332e43e8774ff8870b394f3dd6020cc7f8e0c"
235 |             },
236 |             "dist": {
237 |                 "type": "zip",
238 |                 "url": "https://api.github.com/repos/symfony/process/zipball/d20332e43e8774ff8870b394f3dd6020cc7f8e0c",
239 |                 "reference": "d20332e43e8774ff8870b394f3dd6020cc7f8e0c",
240 |                 "shasum": ""
241 |             },
242 |             "require": {
243 |                 "php": ">=5.3.9"
244 |             },
245 |             "type": "library",
246 |             "extra": {
247 |                 "branch-alias": {
248 |                     "dev-master": "2.8-dev"
249 |                 }
250 |             },
251 |             "autoload": {
252 |                 "psr-4": {
253 |                     "Symfony\\Component\\Process\\": ""
254 |                 },
255 |                 "exclude-from-classmap": [
256 |                     "/Tests/"
257 |                 ]
258 |             },
259 |             "notification-url": "https://packagist.org/downloads/",
260 |             "license": [
261 |                 "MIT"
262 |             ],
263 |             "authors": [
264 |                 {
265 |                     "name": "Fabien Potencier",
266 |                     "email": "fabien@symfony.com"
267 |                 },
268 |                 {
269 |                     "name": "Symfony Community",
270 |                     "homepage": "https://symfony.com/contributors"
271 |                 }
272 |             ],
273 |             "description": "Symfony Process Component",
274 |             "homepage": "https://symfony.com",
275 |             "time": "2016-07-28 11:13:19"
276 |         }
277 |     ],
278 |     "packages-dev": [
279 |         {
280 |             "name": "mikey179/vfsStream",
281 |             "version": "v1.3.0",
282 |             "source": {
283 |                 "type": "git",
284 |                 "url": "https://github.com/mikey179/vfsStream.git",
285 |                 "reference": "8571f349567e02af1b7efc0fc4e3a4a1c98e664e"
286 |             },
287 |             "dist": {
288 |                 "type": "zip",
289 |                 "url": "https://api.github.com/repos/mikey179/vfsStream/zipball/8571f349567e02af1b7efc0fc4e3a4a1c98e664e",
290 |                 "reference": "8571f349567e02af1b7efc0fc4e3a4a1c98e664e",
291 |                 "shasum": ""
292 |             },
293 |             "require": {
294 |                 "php": ">=5.3.0"
295 |             },
296 |             "require-dev": {
297 |                 "phpunit/phpunit": "~4.1"
298 |             },
299 |             "type": "library",
300 |             "extra": {
301 |                 "branch-alias": {
302 |                     "dev-master": "1.3.x-dev"
303 |                 }
304 |             },
305 |             "autoload": {
306 |                 "psr-0": {
307 |                     "org\\bovigo\\vfs\\": "src/main/php"
308 |                 }
309 |             },
310 |             "notification-url": "https://packagist.org/downloads/",
311 |             "license": [
312 |                 "BSD"
313 |             ],
314 |             "homepage": "http://vfs.bovigo.org/",
315 |             "time": "2014-07-21 20:15:54"
316 |         }
317 |     ],
318 |     "aliases": [],
319 |     "minimum-stability": "stable",
320 |     "stability-flags": {
321 |         "mikey179/vfsstream": 20
322 |     },
323 |     "prefer-stable": false,
324 |     "prefer-lowest": false,
325 |     "platform": {
326 |         "php": ">=5.3.9"
327 |     },
328 |     "platform-dev": []
329 | }
330 | 


--------------------------------------------------------------------------------