Actualización

vendor/alchemy/binary-driver/.gitignore

@@ -0,0 +1,2 @@
+/vendor/
+composer.lock

vendor/alchemy/binary-driver/.travis.yml

@@ -0,0 +1,16 @@
+language: php
+
+sudo: false
+
+matrix:
+  fast_finish: true
+
+before_script:
+  - composer self-update
+  - composer install --prefer-source
+
+php:
+  - 5.5
+  - 5.6
+  - 7.0
+  - hhvm

vendor/alchemy/binary-driver/CHANGELOG.md

@@ -0,0 +1,64 @@
+CHANGELOG
+---------
+* 1.6.0 (2015-03-02)
+  * BC Break: bump minimum PHP versions 
+  * Allow use of evenement v2.0 (thanks @patkar for the P/R)
+
+* 1.5.0 (2013-06-21)
+
+  * BC Break : ConfigurationInterface::get does not throw exceptions anymore
+    in case the key does not exist. Second argument is a default value to return
+    in case the key does not exist.
+
+* 1.4.1 (2013-05-23)
+
+  * Add third parameter to BinaryInterface::command method to pass a listener or
+    an array of listener that will be registered just the time of the command.
+
+* 1.4.0 (2013-05-11)
+
+  * Extract process run management to ProcessRunner.
+  * Add support for process listeners.
+  * Provides bundled DebugListener.
+  * Add BinaryInterface::command method.
+  * BC break : ProcessRunnerInterface::run now takes an SplObjectStorage containing
+    listeners as second argument.
+  * BC break : BinaryInterface no longer implements LoggerAwareInterface
+    as it is now supported by ProcessRunner.
+
+* 1.3.4 (2013-04-26)
+
+  * Add BinaryDriver::run method.
+
+* 1.3.3 (2013-04-26)
+
+  * Add BinaryDriver::createProcessMock method.
+
+* 1.3.2 (2013-04-26)
+
+  * Add BinaryDriverTestCase for testing BinaryDriver implementations.
+
+* 1.3.1 (2013-04-24)
+
+  * Add timeouts handling
+
+* 1.3.0 (2013-04-24)
+
+  * Add BinaryInterface and AbstractBinary
+
+* 1.2.1 (2013-04-24)
+
+  * Add ConfigurationAwareInterface
+  * Add ProcessBuilderAwareInterface
+
+* 1.2.0 (2013-04-24)
+
+  * Add BinaryDriver\Configuration
+
+* 1.1.0 (2013-04-24)
+
+  * Add support for timeouts via `setTimeout` method
+
+* 1.0.0 (2013-04-23)
+
+  * First stable version.

vendor/alchemy/binary-driver/LICENSE

@@ -0,0 +1,21 @@
+BinaryDriver is released with MIT License :
+
+Copyright (c) 2013 Alchemy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

vendor/alchemy/binary-driver/README.md

@@ -0,0 +1,190 @@
+# Binary Driver
+
+Binary-Driver is a set of PHP tools to build binary drivers.
+
+[![Build Status](https://travis-ci.org/alchemy-fr/BinaryDriver.png?branch=master)](https://travis-ci.org/alchemy-fr/BinaryDriver)
+
+## Why ?
+
+You may wonder *Why building a library while I can use `exec` or
+[symfony/process](https://github.com/symfony/Process) ?*.
+
+Here is a simple answer :
+
+ - If you use `exec`, `passthru`, `system`, `proc_open` or any low level process
+   handling in PHP, you should have a look to [symfony/process](https://github.com/symfony/Process)
+   component that will provide an OO portable, testable and secure interface to
+   deal with this. It seems easy at first approach, but if you look at this
+   component [unit tests](https://github.com/symfony/Process/tree/master/Tests),
+   you will see that handling process in a simple interface can easily become a
+   nightmare.
+
+ - If you already use symfony/process, and want to build binary drivers, you
+   will always have the same common set of methods and objects to configure, log,
+   debug, and generate processes.
+   This library is a base to implement any binary driver with this common set of
+   needs.
+
+## AbstractBinary
+
+`AbstractBinary` provides an abstract class to build a binary driver. It implements
+`BinaryInterface`.
+
+Implementation example :
+
+```php
+use Alchemy\BinaryDriver\AbstractBinary;
+
+class LsDriver extends AbstractBinary
+{
+    public function getName()
+    {
+        return 'ls driver';
+    }
+}
+
+$parser = new LsParser();
+
+$driver = Driver::load('ls');
+// will return the output of `ls -a -l`
+$parser->parse($driver->command(array('-a', '-l')));
+```
+
+### Binary detection troubleshooting
+
+If you are using Nginx with PHP-fpm, executable detection may not work because of an empty `$_ENV['path']`. 
+To avoid having an empty `PATH` environment variable, add the following line to your `fastcgi_params` 
+config file (replace `/your/current/path/` with the output of `printenv PATH`) :
+
+```
+fastcgi_param    PATH    /your/current/path
+```
+
+## Logging
+
+You can log events with a `Psr\Log\LoggerInterface` by passing it in the load
+method as second argument :
+
+```php
+$logger = new Monolog\Logger('driver');
+$driver = Driver::load('ls', $logger);
+```
+
+## Listeners
+
+You can add custom listeners on processes.
+Listeners are built on top of [Evenement](https://github.com/igorw/evenement)
+and must implement `Alchemy\BinaryDriver\ListenerInterface`.
+
+```php
+use Symfony\Component\Process\Process;
+
+class DebugListener extends EventEmitter implements ListenerInterface
+{
+    public function handle($type, $data)
+    {
+        foreach (explode(PHP_EOL, $data) as $line) {
+            $this->emit($type === Process::ERR ? 'error' : 'out', array($line));
+        }
+    }
+
+    public function forwardedEvents()
+    {
+        // forward 'error' events to the BinaryInterface
+        return array('error');
+    }
+}
+
+$listener = new DebugListener();
+
+$driver = CustomImplementation::load('php');
+
+// adds listener
+$driver->listen($listener);
+
+$driver->on('error', function ($line) {
+    echo '[ERROR] ' . $line . PHP_EOL;
+});
+
+// removes listener
+$driver->unlisten($listener);
+```
+
+### Bundled listeners
+
+The debug listener is a simple listener to catch `stderr` and `stdout` outputs ;
+read the implementation for customization.
+
+```php
+use Alchemy\BinaryDriver\Listeners\DebugListener;
+
+$driver = CustomImplementation::load('php');
+$driver->listen(new DebugListener());
+
+$driver->on('debug', function ($line) {
+    echo $line;
+});
+```
+
+## ProcessBuilderFactory
+
+ProcessBuilderFactory ease spawning processes by generating Symfony [Process]
+(http://symfony.com/doc/master/components/process.html) objects.
+
+```php
+use Alchemy\BinaryDriver\ProcessBuilderFactory;
+
+$factory = new ProcessBuilderFactory('/usr/bin/php');
+
+// return a Symfony\Component\Process\Process
+$process = $factory->create('-v');
+
+// echoes '/usr/bin/php' '-v'
+echo $process->getCommandLine();
+
+$process = $factory->create(array('-r', 'echo "Hello !";'));
+
+// echoes '/usr/bin/php' '-r' 'echo "Hello !";'
+echo $process->getCommandLine();
+```
+
+## Configuration
+
+A simple configuration object, providing an `ArrayAccess` and `IteratorAggregate`
+interface.
+
+```php
+use Alchemy\BinaryDriver\Configuration;
+
+$conf = new Configuration(array('timeout' => 0));
+
+echo $conf->get('timeout');
+
+if ($conf->has('param')) {
+    $conf->remove('param');
+}
+
+$conf->set('timeout', 20);
+
+$conf->all();
+```
+
+Same example using the `ArrayAccess` interface :
+
+```php
+use Alchemy\BinaryDriver\Configuration;
+
+$conf = new Configuration(array('timeout' => 0));
+
+echo $conf['timeout'];
+
+if (isset($conf['param'])) {
+    unset($conf['param']);
+}
+
+$conf['timeout'] = 20;
+```
+
+## License
+
+This project is released under the MIT license.

vendor/alchemy/binary-driver/composer.json

@@ -0,0 +1,38 @@
+{
+    "name": "alchemy/binary-driver",
+    "type": "library",
+    "description": "A set of tools to build binary drivers",
+    "keywords": ["binary", "driver"],
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Nicolas Le Goff",
+            "email": "legoff.n@gmail.com"
+        },
+        {
+            "name": "Romain Neutron",
+            "email": "imprec@gmail.com",
+            "homepage": "http://www.lickmychip.com/"
+        },
+        {
+            "name": "Phraseanet Team",
+            "email": "info@alchemy.fr",
+            "homepage": "http://www.phraseanet.com/"
+        }
+    ],
+    "require": {
+        "php"                 : ">=5.5",
+        "evenement/evenement" : "^2.0|^1.0",
+        "monolog/monolog"     : "^1.3",
+        "psr/log"             : "^1.0",
+        "symfony/process"     : "^2.0|^3.0"
+    },
+    "require-dev": {
+        "phpunit/phpunit"     : "^4.0|^5.0"
+    },
+    "autoload": {
+        "psr-0": {
+            "Alchemy": "src"
+        }
+    }
+}

vendor/alchemy/binary-driver/phpunit.xml.dist

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit backupGlobals="false"
+         backupStaticAttributes="false"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnFailure="false"
+         syntaxCheck="true"
+         verbose="false"
+         bootstrap="tests/bootstrap.php"
+>
+    <php>
+      <ini name="display_errors" value="on"/>
+    </php>
+
+    <testsuites>
+        <testsuite>
+            <directory>tests</directory>
+        </testsuite>
+    </testsuites>
+    <filter>
+      <blacklist>
+        <directory>vendor</directory>
+        <directory>tests</directory>
+      </blacklist>
+    </filter>
+
+</phpunit>
+

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/AbstractBinary.php

@@ -0,0 +1,220 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+use Alchemy\BinaryDriver\Exception\ExecutableNotFoundException;
+use Alchemy\BinaryDriver\Exception\ExecutionFailureException;
+use Alchemy\BinaryDriver\Listeners\Listeners;
+use Alchemy\BinaryDriver\Listeners\ListenerInterface;
+use Evenement\EventEmitter;
+use Monolog\Logger;
+use Monolog\Handler\NullHandler;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Process\ExecutableFinder;
+use Symfony\Component\Process\Process;
+
+abstract class AbstractBinary extends EventEmitter implements BinaryInterface
+{
+    /** @var ConfigurationInterface */
+    protected $configuration;
+
+    /** @var ProcessBuilderFactoryInterface */
+    protected $factory;
+
+    /** @var ProcessRunner */
+    private $processRunner;
+
+    /** @var Listeners */
+    private $listenersManager;
+
+    public function __construct(ProcessBuilderFactoryInterface $factory, LoggerInterface $logger, ConfigurationInterface $configuration)
+    {
+        $this->factory = $factory;
+        $this->configuration = $configuration;
+        $this->processRunner = new ProcessRunner($logger, $this->getName());
+        $this->listenersManager = new Listeners();
+        $this->applyProcessConfiguration();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function listen(ListenerInterface $listener)
+    {
+        $this->listenersManager->register($listener, $this);
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function unlisten(ListenerInterface $listener)
+    {
+        $this->listenersManager->unregister($listener, $this);
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getConfiguration()
+    {
+        return $this->configuration;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return BinaryInterface
+     */
+    public function setConfiguration(ConfigurationInterface $configuration)
+    {
+        $this->configuration = $configuration;
+        $this->applyProcessConfiguration();
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getProcessBuilderFactory()
+    {
+        return $this->factory;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return BinaryInterface
+     */
+    public function setProcessBuilderFactory(ProcessBuilderFactoryInterface $factory)
+    {
+        $this->factory = $factory;
+        $this->applyProcessConfiguration();
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getProcessRunner()
+    {
+        return $this->processRunner;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setProcessRunner(ProcessRunnerInterface $runner)
+    {
+        $this->processRunner = $runner;
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function command($command, $bypassErrors = false, $listeners = null)
+    {
+        if (!is_array($command)) {
+            $command = array($command);
+        }
+
+        return $this->run($this->factory->create($command), $bypassErrors, $listeners);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function load($binaries, LoggerInterface $logger = null, $configuration = array())
+    {
+        $finder = new ExecutableFinder();
+        $binary = null;
+        $binaries = is_array($binaries) ? $binaries : array($binaries);
+
+        foreach ($binaries as $candidate) {
+            if (file_exists($candidate) && is_executable($candidate)) {
+                $binary = $candidate;
+                break;
+            }
+            if (null !== $binary = $finder->find($candidate)) {
+                break;
+            }
+        }
+
+        if (null === $binary) {
+            throw new ExecutableNotFoundException(sprintf(
+                'Executable not found, proposed : %s', implode(', ', $binaries)
+            ));
+        }
+
+        if (null === $logger) {
+            $logger = new Logger(__NAMESPACE__ . ' logger');
+            $logger->pushHandler(new NullHandler());
+        }
+
+        $configuration = $configuration instanceof ConfigurationInterface ? $configuration : new Configuration($configuration);
+
+        return new static(new ProcessBuilderFactory($binary), $logger, $configuration);
+    }
+
+    /**
+     * Returns the name of the driver
+     *
+     * @return string
+     */
+    abstract public function getName();
+
+    /**
+     * Executes a process, logs events
+     *
+     * @param Process                 $process
+     * @param Boolean                 $bypassErrors Set to true to disable throwing ExecutionFailureExceptions
+     * @param ListenerInterface|array $listeners    A listener or an array of listener to register for this unique run
+     *
+     * @return string The Process output
+     *
+     * @throws ExecutionFailureException in case of process failure.
+     */
+    protected function run(Process $process, $bypassErrors = false, $listeners = null)
+    {
+        if (null !== $listeners) {
+            if (!is_array($listeners)) {
+                $listeners = array($listeners);
+            }
+
+            $listenersManager = clone $this->listenersManager;
+
+            foreach ($listeners as $listener) {
+                $listenersManager->register($listener, $this);
+            }
+        } else {
+            $listenersManager = $this->listenersManager;
+        }
+
+        return $this->processRunner->run($process, $listenersManager->storage, $bypassErrors);
+    }
+
+    private function applyProcessConfiguration()
+    {
+        if ($this->configuration->has('timeout')) {
+            $this->factory->setTimeout($this->configuration->get('timeout'));
+        }
+
+        return $this;
+    }
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/BinaryDriverTestCase.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace Alchemy\BinaryDriver;
+
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Process\Process;
+
+/**
+ * Convenient PHPUnit methods for testing BinaryDriverInterface implementations.
+ */
+class BinaryDriverTestCase extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @return ProcessBuilderFactoryInterface
+     */
+    public function createProcessBuilderFactoryMock()
+    {
+        return $this->getMock('Alchemy\BinaryDriver\ProcessBuilderFactoryInterface');
+    }
+
+    /**
+     * @param integer $runs        The number of runs expected
+     * @param Boolean $success     True if the process expects to be successfull
+     * @param string  $commandLine The commandline executed
+     * @param string  $output      The process output
+     * @param string  $error       The process error output
+     *
+     * @return Process
+     */
+    public function createProcessMock($runs = 1, $success = true, $commandLine = null, $output = null, $error = null, $callback = false)
+    {
+        $process = $this->getMockBuilder('Symfony\Component\Process\Process')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $builder = $process->expects($this->exactly($runs))
+            ->method('run');
+
+        if (true === $callback) {
+            $builder->with($this->isInstanceOf('Closure'));
+        }
+
+        $process->expects($this->any())
+            ->method('isSuccessful')
+            ->will($this->returnValue($success));
+
+        foreach (array(
+            'getOutput' => $output,
+            'getErrorOutput' => $error,
+            'getCommandLine' => $commandLine,
+        ) as $command => $value) {
+            $process
+                ->expects($this->any())
+                ->method($command)
+                ->will($this->returnValue($value));
+        }
+
+        return $process;
+    }
+
+    /**
+     * @return LoggerInterface
+     */
+    public function createLoggerMock()
+    {
+        return $this->getMock('Psr\Log\LoggerInterface');
+    }
+
+    /**
+     * @return ConfigurationInterface
+     */
+    public function createConfigurationMock()
+    {
+        return $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface');
+    }
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/BinaryInterface.php

@@ -0,0 +1,67 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+use Alchemy\BinaryDriver\Exception\ExecutableNotFoundException;
+use Alchemy\BinaryDriver\Exception\ExecutionFailureException;
+use Alchemy\BinaryDriver\Listeners\ListenerInterface;
+use Psr\Log\LoggerInterface;
+use Evenement\EventEmitterInterface;
+
+interface BinaryInterface extends ConfigurationAwareInterface, ProcessBuilderFactoryAwareInterface, ProcessRunnerAwareInterface, EventEmitterInterface
+{
+    /**
+     * Adds a listener to the binary driver
+     *
+     * @param ListenerInterface $listener
+     *
+     * @return BinaryInterface
+     */
+    public function listen(ListenerInterface $listener);
+
+    /**
+     * Removes a listener from the binary driver
+     *
+     * @param ListenerInterface $listener
+     *
+     * @return BinaryInterface
+     */
+    public function unlisten(ListenerInterface $listener);
+
+    /**
+     * Runs a command against the driver.
+     *
+     * Calling this method on a `ls` driver with the command `-a` would run `ls -a`.
+     *
+     * @param array|string            $command      A command or an array of command
+     * @param Boolean                 $bypassErrors If set to true, an erronous process will not throw an exception
+     * @param ListenerInterface|array $listeners    A listener or an array of listeners to register for this unique run
+     *
+     * @return string The command output
+     *
+     * @throws ExecutionFailureException in case of process failure.
+     */
+    public function command($command, $bypassErrors = false, $listeners = null);
+
+    /**
+     * Loads a binary
+     *
+     * @param string|array                 $binaries      A binary name or an array of binary names
+     * @param null|LoggerInterface        $logger        A Logger
+     * @param array|ConfigurationInterface $configuration The configuration
+     *
+     * @throws ExecutableNotFoundException In case none of the binaries were found
+     *
+     * @return BinaryInterface
+     */
+    public static function load($binaries, LoggerInterface $logger = null, $configuration = array());
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Configuration.php

@@ -0,0 +1,107 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+class Configuration implements ConfigurationInterface
+{
+    private $data;
+
+    public function __construct(array $data = array())
+    {
+        $this->data = $data;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->data);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key, $default = null)
+    {
+        return isset($this->data[$key]) ? $this->data[$key] : $default;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($key, $value)
+    {
+        $this->data[$key] = $value;
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function has($key)
+    {
+        return array_key_exists($key, $this->data);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function remove($key)
+    {
+        $value = $this->get($key);
+        unset($this->data[$key]);
+
+        return $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function all()
+    {
+        return $this->data;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function offsetExists($offset)
+    {
+        return $this->has($offset);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function offsetGet($offset)
+    {
+        return $this->get($offset);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function offsetSet($offset, $value)
+    {
+        $this->set($offset, $value);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function offsetUnset($offset)
+    {
+        $this->remove($offset);
+    }
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ConfigurationAwareInterface.php

@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+interface ConfigurationAwareInterface
+{
+    /**
+     * Returns the configuration
+     *
+     * @return ConfigurationInterface
+     */
+    public function getConfiguration();
+
+    /**
+     * Set the configuration
+     *
+     * @param ConfigurationInterface $configuration
+     */
+    public function setConfiguration(ConfigurationInterface $configuration);
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ConfigurationInterface.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+interface ConfigurationInterface extends \ArrayAccess, \IteratorAggregate
+{
+    /**
+     * Returns the value given a key from configuration
+     *
+     * @param string $key
+     * @param mixed  $default The default value in case the key does not exist
+     *
+     * @return mixed
+     */
+    public function get($key, $default = null);
+
+    /**
+     * Set a value to configuration
+     *
+     * @param string $key   The key
+     * @param mixed  $value The value corresponding to the key
+     */
+    public function set($key, $value);
+
+    /**
+     * Tells if Configuration contains `$key`
+     *
+     * @param string $key
+     *
+     * @return Boolean
+     */
+    public function has($key);
+
+    /**
+     * Removes a value given a key
+     *
+     * @param string $key
+     *
+     * @return mixed The previous value
+     */
+    public function remove($key);
+
+    /**
+     * Returns all values set in the configuration
+     *
+     * @return array
+     */
+    public function all();
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Exception/ExceptionInterface.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver\Exception;
+
+interface ExceptionInterface
+{
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Exception/ExecutableNotFoundException.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver\Exception;
+
+class ExecutableNotFoundException extends \RuntimeException implements ExceptionInterface
+{
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Exception/ExecutionFailureException.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver\Exception;
+
+class ExecutionFailureException extends \RuntimeException implements ExceptionInterface
+{
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Exception/InvalidArgumentException.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver\Exception;
+
+class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
+{
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Listeners/DebugListener.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver\Listeners;
+
+use Evenement\EventEmitter;
+use Symfony\Component\Process\Process;
+
+class DebugListener extends EventEmitter implements ListenerInterface
+{
+    private $prefixOut;
+    private $prefixErr;
+    private $eventOut;
+    private $eventErr;
+
+    public function __construct($prefixOut = '[OUT] ', $prefixErr = '[ERROR] ', $eventOut = 'debug', $eventErr = 'debug')
+    {
+        $this->prefixOut = $prefixOut;
+        $this->prefixErr = $prefixErr;
+        $this->eventOut = $eventOut;
+        $this->eventErr = $eventErr;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function handle($type, $data)
+    {
+        if (Process::ERR === $type) {
+            $this->emitLines($this->eventErr, $this->prefixErr, $data);
+        } elseif (Process::OUT === $type) {
+            $this->emitLines($this->eventOut, $this->prefixOut, $data);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function forwardedEvents()
+    {
+        return array_unique(array($this->eventErr, $this->eventOut));
+    }
+
+    private function emitLines($event, $prefix, $lines)
+    {
+        foreach (explode("\n", $lines) as $line) {
+            $this->emit($event, array($prefix . $line));
+        }
+    }
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Listeners/ListenerInterface.php

@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver\Listeners;
+
+use Evenement\EventEmitterInterface;
+
+interface ListenerInterface extends EventEmitterInterface
+{
+    /**
+     * Handle the output of a ProcessRunner
+     *
+     * @param string $type The data type, one of Process::ERR, Process::OUT constants
+     * @param string $data The output
+     */
+    public function handle($type, $data);
+
+    /**
+     * An array of events that should be forwarded to BinaryInterface
+     *
+     * @return array
+     */
+    public function forwardedEvents();
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Listeners/Listeners.php

@@ -0,0 +1,88 @@
+<?php
+
+namespace Alchemy\BinaryDriver\Listeners;
+
+use SplObjectStorage;
+use Evenement\EventEmitter;
+
+class Listeners extends EventEmitter
+{
+    /** @var SplObjectStorage */
+    public $storage;
+
+    public function __construct()
+    {
+        $this->storage = new SplObjectStorage();
+    }
+
+    public function __clone()
+    {
+        $storage = $this->storage;
+        $this->storage = new SplObjectStorage();
+        $this->storage->addAll($storage);
+    }
+
+    /**
+     * Registers a listener, pass the listener events to the target.
+     *
+     * @param ListenerInterface $listener
+     * @param null|EventEmitter $target
+     *
+     * @return ListenersInterface
+     */
+    public function register(ListenerInterface $listener, EventEmitter $target = null)
+    {
+        $EElisteners = array();
+
+        if (null !== $target) {
+            $EElisteners = $this->forwardEvents($listener, $target, $listener->forwardedEvents());
+        }
+
+        $this->storage->attach($listener, $EElisteners);
+
+        return $this;
+    }
+
+    /**
+     * Unregisters a listener, removes the listener events from the target.
+     *
+     * @param ListenerInterface $listener
+     *
+     * @return ListenersInterface
+     *
+     * @throws InvalidArgumentException In case the listener is not registered
+     */
+    public function unregister(ListenerInterface $listener)
+    {
+        if (!isset($this->storage[$listener])) {
+            throw new InvalidArgumentException('Listener is not registered.');
+        }
+
+        foreach ($this->storage[$listener] as $event => $EElistener) {
+            $listener->removeListener($event, $EElistener);
+        }
+
+        $this->storage->detach($listener);
+
+        return $this;
+    }
+
+    private function forwardEvents($source, $target, array $events)
+    {
+        $EElisteners = array();
+
+        foreach ($events as $event) {
+            $listener = $this->createListener($event, $target);
+            $source->on($event, $EElisteners[$event] = $listener);
+        }
+
+        return $EElisteners;
+    }
+
+    private function createListener($event, $target)
+    {
+        return function () use ($event, $target) {
+            $target->emit($event, func_get_args());
+        };
+    }
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ProcessBuilderFactory.php

@@ -0,0 +1,177 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+use Alchemy\BinaryDriver\Exception\InvalidArgumentException;
+use Symfony\Component\Process\ProcessBuilder;
+
+class ProcessBuilderFactory implements ProcessBuilderFactoryInterface
+{
+    /**
+     * The binary path
+     *
+     * @var String
+     */
+    protected $binary;
+
+    /**
+     * The timeout for the generated processes
+     *
+     * @var integer|float
+     */
+    private $timeout;
+
+    /**
+     * An internal ProcessBuilder.
+     *
+     * Note that this one is used only if Symfony ProcessBuilder has method
+     * setPrefix (2.3)
+     *
+     * @var ProcessBuilder
+     */
+    private $builder;
+
+    /**
+     * Tells whether Symfony LTS ProcessBuilder should be emulated or not.
+     *
+     * This symfony version provided a brand new ::setPrefix method.
+     *
+     * @var Boolean
+     */
+    public static $emulateSfLTS;
+
+    /**
+     * Constructor
+     *
+     * @param String $binary The path to the binary
+     *
+     * @throws InvalidArgumentException In case binary path is invalid
+     */
+    public function __construct($binary)
+    {
+        $this->detectEmulation();
+
+        if (!self::$emulateSfLTS) {
+            $this->builder = new ProcessBuilder();
+        }
+
+        $this->useBinary($binary);
+    }
+
+    /**
+     * Covenient method for unit testing
+     *
+     * @return type
+     */
+    public function getBuilder()
+    {
+        return $this->builder;
+    }
+
+    /**
+     * Covenient method for unit testing
+     *
+     * @param  ProcessBuilder        $builder
+     * @return ProcessBuilderFactory
+     */
+    public function setBuilder(ProcessBuilder $builder)
+    {
+        $this->builder = $builder;
+
+        return $this;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function getBinary()
+    {
+        return $this->binary;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function useBinary($binary)
+    {
+        if (!is_executable($binary)) {
+            throw new InvalidArgumentException(sprintf('`%s` is not an executable binary', $binary));
+        }
+
+        $this->binary = $binary;
+
+        if (!static::$emulateSfLTS) {
+            $this->builder->setPrefix($binary);
+        }
+
+        return $this;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function setTimeout($timeout)
+    {
+        $this->timeout = $timeout;
+
+        if (!static::$emulateSfLTS) {
+            $this->builder->setTimeout($this->timeout);
+        }
+
+        return $this;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function getTimeout()
+    {
+        return $this->timeout;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function create($arguments = array())
+    {
+        if (null === $this->binary) {
+            throw new InvalidArgumentException('No binary set');
+        }
+
+        if (!is_array($arguments)) {
+            $arguments = array($arguments);
+        }
+
+        if (static::$emulateSfLTS) {
+            array_unshift($arguments, $this->binary);
+
+            return ProcessBuilder::create($arguments)
+                ->setTimeout($this->timeout)
+                ->getProcess();
+        } else {
+            return $this->builder
+                ->setArguments($arguments)
+                ->getProcess();
+        }
+    }
+
+    private function detectEmulation()
+    {
+        if (null !== static::$emulateSfLTS) {
+            return $this;
+        }
+
+        static::$emulateSfLTS = !method_exists('Symfony\Component\Process\ProcessBuilder', 'setPrefix');
+
+        return $this;
+    }
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ProcessBuilderFactoryAwareInterface.php

@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+interface ProcessBuilderFactoryAwareInterface
+{
+    /**
+     * Returns the current process builder factory
+     *
+     * @return ProcessBuilderFactoryInterface
+     */
+    public function getProcessBuilderFactory();
+
+    /**
+     * Set a process builder factory
+     *
+     * @param ProcessBuilderFactoryInterface $factory
+     */
+    public function setProcessBuilderFactory(ProcessBuilderFactoryInterface $factory);
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ProcessBuilderFactoryInterface.php

@@ -0,0 +1,65 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+use Alchemy\BinaryDriver\Exception\InvalidArgumentException;
+use Symfony\Component\Process\Process;
+
+interface ProcessBuilderFactoryInterface
+{
+    /**
+     * Returns a new instance of Symfony Process
+     *
+     * @param string|array $arguments An argument or an array of arguments
+     *
+     * @return Process
+     *
+     * @throws InvalidArgumentException
+     */
+    public function create($arguments = array());
+
+    /**
+     * Returns the path to the binary that is used
+     *
+     * @return String
+     */
+    public function getBinary();
+
+    /**
+     * Sets the path to the binary
+     *
+     * @param String $binary A path to a binary
+     *
+     * @return ProcessBuilderFactoryInterface
+     *
+     * @throws InvalidArgumentException In case binary is not executable
+     */
+    public function useBinary($binary);
+
+    /**
+     * Set the default timeout to apply on created processes.
+     *
+     * @param integer|float $timeout
+     *
+     * @return ProcessBuilderFactoryInterface
+     *
+     * @throws InvalidArgumentException In case the timeout is not valid
+     */
+    public function setTimeout($timeout);
+
+    /**
+     * Returns the current timeout applied to the created processes.
+     *
+     * @return integer|float
+     */
+    public function getTimeout();
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ProcessRunner.php

@@ -0,0 +1,104 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+use Alchemy\BinaryDriver\Exception\ExecutionFailureException;
+use Psr\Log\LoggerInterface;
+use SplObjectStorage;
+use Symfony\Component\Process\Exception\RuntimeException;
+use Symfony\Component\Process\Process;
+
+class ProcessRunner implements ProcessRunnerInterface
+{
+    /** @var LoggerInterface */
+    private $logger;
+
+    /** @var string */
+    private $name;
+
+    public function __construct(LoggerInterface $logger, $name)
+    {
+        $this->logger = $logger;
+        $this->name = $name;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return ProcessRunner
+     */
+    public function setLogger(LoggerInterface $logger)
+    {
+        $this->logger = $logger;
+
+        return $this;
+    }
+
+    /**
+     * @return LoggerInterface
+     */
+    public function getLogger()
+    {
+        return $this->logger;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function run(Process $process, SplObjectStorage $listeners, $bypassErrors)
+    {
+        $this->logger->info(sprintf(
+            '%s running command %s', $this->name, $process->getCommandLine()
+        ));
+
+        try {
+            $process->run($this->buildCallback($listeners));
+        } catch (RuntimeException $e) {
+            if (!$bypassErrors) {
+                $this->doExecutionFailure($process->getCommandLine(), $e);
+            }
+        }
+
+        if (!$bypassErrors && !$process->isSuccessful()) {
+            $this->doExecutionFailure($process->getCommandLine());
+        } elseif (!$process->isSuccessful()) {
+            $this->logger->error(sprintf(
+                '%s failed to execute command %s', $this->name, $process->getCommandLine()
+            ));
+
+            return;
+        } else {
+            $this->logger->info(sprintf('%s executed command successfully', $this->name));
+
+            return $process->getOutput();
+        }
+    }
+
+    private function buildCallback(SplObjectStorage $listeners)
+    {
+        return function ($type, $data) use ($listeners) {
+            foreach ($listeners as $listener) {
+                $listener->handle($type, $data);
+            }
+        };
+    }
+
+    private function doExecutionFailure($command, \Exception $e = null)
+    {
+        $this->logger->error(sprintf(
+            '%s failed to execute command %s', $this->name, $command
+        ));
+        throw new ExecutionFailureException(sprintf(
+            '%s failed to execute command %s', $this->name, $command
+        ), $e ? $e->getCode() : null, $e ?: null);
+    }
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ProcessRunnerAwareInterface.php

@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+interface ProcessRunnerAwareInterface
+{
+    /**
+     * Returns the current process runner
+     *
+     * @return ProcessRunnerInterface
+     */
+    public function getProcessRunner();
+
+    /**
+     * Sets a process runner
+     *
+     * @param ProcessRunnerInterface $runner
+     */
+    public function setProcessRunner(ProcessRunnerInterface $runner);
+}

vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ProcessRunnerInterface.php

@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\BinaryDriver;
+
+use Alchemy\BinaryDriver\Exception\ExecutionFailureException;
+use Psr\Log\LoggerAwareInterface;
+use SplObjectStorage;
+use Symfony\Component\Process\Process;
+
+interface ProcessRunnerInterface extends LoggerAwareInterface
+{
+    /**
+     * Executes a process, logs events
+     *
+     * @param Process          $process
+     * @param SplObjectStorage $listeners    Some listeners
+     * @param Boolean          $bypassErrors Set to true to disable throwing ExecutionFailureExceptions
+     *
+     * @return string The Process output
+     *
+     * @throws ExecutionFailureException in case of process failure.
+     */
+    public function run(Process $process, SplObjectStorage $listeners, $bypassErrors);
+}

vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/AbstractBinaryTest.php

@@ -0,0 +1,300 @@
+<?php
+
+namespace Alchemy\Tests\BinaryDriver;
+
+use Alchemy\BinaryDriver\AbstractBinary;
+use Alchemy\BinaryDriver\BinaryDriverTestCase;
+use Alchemy\BinaryDriver\Configuration;
+use Alchemy\BinaryDriver\Exception\ExecutableNotFoundException;
+use Alchemy\BinaryDriver\Listeners\ListenerInterface;
+use Symfony\Component\Process\ExecutableFinder;
+
+class AbstractBinaryTest extends BinaryDriverTestCase
+{
+    protected function getPhpBinary()
+    {
+        $finder = new ExecutableFinder();
+        $php = $finder->find('php');
+
+        if (null === $php) {
+            $this->markTestSkipped('Unable to find a php binary');
+        }
+
+        return $php;
+    }
+
+    public function testSimpleLoadWithBinaryPath()
+    {
+        $php = $this->getPhpBinary();
+        $imp = Implementation::load($php);
+        $this->assertInstanceOf('Alchemy\Tests\BinaryDriver\Implementation', $imp);
+
+        $this->assertEquals($php, $imp->getProcessBuilderFactory()->getBinary());
+    }
+
+    public function testMultipleLoadWithBinaryPath()
+    {
+        $php = $this->getPhpBinary();
+        $imp = Implementation::load(array('/zz/path/to/unexisting/command', $php));
+        $this->assertInstanceOf('Alchemy\Tests\BinaryDriver\Implementation', $imp);
+
+        $this->assertEquals($php, $imp->getProcessBuilderFactory()->getBinary());
+    }
+
+    public function testSimpleLoadWithBinaryName()
+    {
+        $php = $this->getPhpBinary();
+        $imp = Implementation::load('php');
+        $this->assertInstanceOf('Alchemy\Tests\BinaryDriver\Implementation', $imp);
+
+        $this->assertEquals($php, $imp->getProcessBuilderFactory()->getBinary());
+    }
+
+    public function testMultipleLoadWithBinaryName()
+    {
+        $php = $this->getPhpBinary();
+        $imp = Implementation::load(array('bachibouzouk', 'php'));
+        $this->assertInstanceOf('Alchemy\Tests\BinaryDriver\Implementation', $imp);
+
+        $this->assertEquals($php, $imp->getProcessBuilderFactory()->getBinary());
+    }
+
+    public function testLoadWithMultiplePathExpectingAFailure()
+    {
+        $this->setExpectedException(ExecutableNotFoundException::class);
+
+        Implementation::load(array('bachibouzouk', 'moribon'));
+    }
+
+    public function testLoadWithUniquePathExpectingAFailure()
+    {
+        $this->setExpectedException(ExecutableNotFoundException::class);
+
+        Implementation::load('bachibouzouk');
+    }
+
+    public function testLoadWithCustomLogger()
+    {
+        $logger = $this->getMock('Psr\Log\LoggerInterface');
+        $imp = Implementation::load('php', $logger);
+
+        $this->assertEquals($logger, $imp->getProcessRunner()->getLogger());
+    }
+
+    public function testLoadWithCustomConfigurationAsArray()
+    {
+        $conf = array('timeout' => 200);
+        $imp = Implementation::load('php', null, $conf);
+
+        $this->assertEquals($conf, $imp->getConfiguration()->all());
+    }
+
+    public function testLoadWithCustomConfigurationAsObject()
+    {
+        $conf = $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface');
+        $imp = Implementation::load('php', null, $conf);
+
+        $this->assertEquals($conf, $imp->getConfiguration());
+    }
+
+    public function testProcessBuilderFactoryGetterAndSetters()
+    {
+        $imp = Implementation::load('php');
+        $factory = $this->getMock('Alchemy\BinaryDriver\ProcessBuilderFactoryInterface');
+
+        $imp->setProcessBuilderFactory($factory);
+        $this->assertEquals($factory, $imp->getProcessBuilderFactory());
+    }
+
+    public function testConfigurationGetterAndSetters()
+    {
+        $imp = Implementation::load('php');
+        $conf = $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface');
+
+        $imp->setConfiguration($conf);
+        $this->assertEquals($conf, $imp->getConfiguration());
+    }
+
+    public function testTimeoutIsSetOnConstruction()
+    {
+        $imp = Implementation::load('php', null, array('timeout' => 42));
+        $this->assertEquals(42, $imp->getProcessBuilderFactory()->getTimeout());
+    }
+
+    public function testTimeoutIsSetOnConfigurationSetting()
+    {
+        $imp = Implementation::load('php', null);
+        $imp->setConfiguration(new Configuration(array('timeout' => 42)));
+        $this->assertEquals(42, $imp->getProcessBuilderFactory()->getTimeout());
+    }
+
+    public function testTimeoutIsSetOnProcessBuilderSetting()
+    {
+        $imp = Implementation::load('php', null, array('timeout' => 42));
+
+        $factory = $this->getMock('Alchemy\BinaryDriver\ProcessBuilderFactoryInterface');
+        $factory->expects($this->once())
+            ->method('setTimeout')
+            ->with(42);
+
+        $imp->setProcessBuilderFactory($factory);
+    }
+
+    public function testListenRegistersAListener()
+    {
+        $imp = Implementation::load('php');
+
+        $listeners = $this->getMockBuilder('Alchemy\BinaryDriver\Listeners\Listeners')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $listener = $this->getMock('Alchemy\BinaryDriver\Listeners\ListenerInterface');
+
+        $listeners->expects($this->once())
+            ->method('register')
+            ->with($this->equalTo($listener), $this->equalTo($imp));
+
+        $reflexion = new \ReflectionClass('Alchemy\BinaryDriver\AbstractBinary');
+        $prop = $reflexion->getProperty('listenersManager');
+        $prop->setAccessible(true);
+        $prop->setValue($imp, $listeners);
+
+        $imp->listen($listener);
+    }
+
+    /**
+     * @dataProvider provideCommandParameters
+     */
+    public function testCommandRunsAProcess($parameters, $bypassErrors, $expectedParameters, $output)
+    {
+        $imp = Implementation::load('php');
+        $factory = $this->getMock('Alchemy\BinaryDriver\ProcessBuilderFactoryInterface');
+        $processRunner = $this->getMock('Alchemy\BinaryDriver\ProcessRunnerInterface');
+
+        $process = $this->getMockBuilder('Symfony\Component\Process\Process')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $processRunner->expects($this->once())
+            ->method('run')
+            ->with($this->equalTo($process), $this->isInstanceOf('SplObjectStorage'), $this->equalTo($bypassErrors))
+            ->will($this->returnValue($output));
+
+        $factory->expects($this->once())
+            ->method('create')
+            ->with($expectedParameters)
+            ->will($this->returnValue($process));
+
+        $imp->setProcessBuilderFactory($factory);
+        $imp->setProcessRunner($processRunner);
+
+        $this->assertEquals($output, $imp->command($parameters, $bypassErrors));
+    }
+
+    /**
+     * @dataProvider provideCommandWithListenersParameters
+     */
+    public function testCommandWithTemporaryListeners($parameters, $bypassErrors, $expectedParameters, $output, $count, $listeners)
+    {
+        $imp = Implementation::load('php');
+        $factory = $this->getMock('Alchemy\BinaryDriver\ProcessBuilderFactoryInterface');
+        $processRunner = $this->getMock('Alchemy\BinaryDriver\ProcessRunnerInterface');
+
+        $process = $this->getMockBuilder('Symfony\Component\Process\Process')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $firstStorage = $secondStorage = null;
+
+        $processRunner->expects($this->exactly(2))
+            ->method('run')
+            ->with($this->equalTo($process), $this->isInstanceOf('SplObjectStorage'), $this->equalTo($bypassErrors))
+            ->will($this->returnCallback(function ($process, $storage, $errors) use ($output, &$firstStorage, &$secondStorage) {
+                if (null === $firstStorage) {
+                    $firstStorage = $storage;
+                } else {
+                    $secondStorage = $storage;
+                }
+
+                return $output;
+            }));
+
+        $factory->expects($this->exactly(2))
+            ->method('create')
+            ->with($expectedParameters)
+            ->will($this->returnValue($process));
+
+        $imp->setProcessBuilderFactory($factory);
+        $imp->setProcessRunner($processRunner);
+
+        $this->assertEquals($output, $imp->command($parameters, $bypassErrors, $listeners));
+        $this->assertCount($count, $firstStorage);
+        $this->assertEquals($output, $imp->command($parameters, $bypassErrors));
+        $this->assertCount(0, $secondStorage);
+    }
+
+    public function provideCommandWithListenersParameters()
+    {
+        return array(
+            array('-a', false, array('-a'), 'loubda', 2, array($this->getMockListener(), $this->getMockListener())),
+            array('-a', false, array('-a'), 'loubda', 1, array($this->getMockListener())),
+            array('-a', false, array('-a'), 'loubda', 1, $this->getMockListener()),
+            array('-a', false, array('-a'), 'loubda', 0, array()),
+        );
+    }
+
+    public function provideCommandParameters()
+    {
+        return array(
+            array('-a', false, array('-a'), 'loubda'),
+            array('-a', true, array('-a'), 'loubda'),
+            array('-a -b', false, array('-a -b'), 'loubda'),
+            array(array('-a'), false, array('-a'), 'loubda'),
+            array(array('-a'), true, array('-a'), 'loubda'),
+            array(array('-a', '-b'), false, array('-a', '-b'), 'loubda'),
+        );
+    }
+
+    public function testUnlistenUnregistersAListener()
+    {
+        $imp = Implementation::load('php');
+
+        $listeners = $this->getMockBuilder('Alchemy\BinaryDriver\Listeners\Listeners')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $listener = $this->getMock('Alchemy\BinaryDriver\Listeners\ListenerInterface');
+
+        $listeners->expects($this->once())
+            ->method('unregister')
+            ->with($this->equalTo($listener), $this->equalTo($imp));
+
+        $reflexion = new \ReflectionClass('Alchemy\BinaryDriver\AbstractBinary');
+        $prop = $reflexion->getProperty('listenersManager');
+        $prop->setAccessible(true);
+        $prop->setValue($imp, $listeners);
+
+        $imp->unlisten($listener);
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject
+     */
+    private function getMockListener()
+    {
+        $listener = $this->getMock(ListenerInterface::class);
+        $listener->expects($this->any())
+            ->method('forwardedEvents')
+            ->willReturn(array());
+
+        return $listener;
+    }
+}
+
+class Implementation extends AbstractBinary
+{
+    public function getName()
+    {
+        return 'Implementation';
+    }
+}

vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/AbstractProcessBuilderFactoryTest.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace Alchemy\Tests\BinaryDriver;
+
+use Symfony\Component\Process\ExecutableFinder;
+use Alchemy\BinaryDriver\ProcessBuilderFactory;
+
+abstract class AbstractProcessBuilderFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    public static $phpBinary;
+
+    private $original;
+    /**
+     * @return ProcessBuilderFactory
+     */
+    abstract protected function getProcessBuilderFactory($binary);
+
+    public function setUp()
+    {
+        ProcessBuilderFactory::$emulateSfLTS = null;
+        if (null === static::$phpBinary) {
+            $this->markTestSkipped('Unable to detect php binary, skipping');
+        }
+    }
+
+    public static function setUpBeforeClass()
+    {
+        $finder = new ExecutableFinder();
+        static::$phpBinary = $finder->find('php');
+    }
+
+    public function testThatBinaryIsSetOnConstruction()
+    {
+        $factory = $this->getProcessBuilderFactory(static::$phpBinary);
+        $this->assertEquals(static::$phpBinary, $factory->getBinary());
+    }
+
+    public function testGetSetBinary()
+    {
+        $finder = new ExecutableFinder();
+        $phpUnit = $finder->find('phpunit');
+
+        if (null === $phpUnit) {
+            $this->markTestSkipped('Unable to detect phpunit binary, skipping');
+        }
+
+        $factory = $this->getProcessBuilderFactory(static::$phpBinary);
+        $factory->useBinary($phpUnit);
+        $this->assertEquals($phpUnit, $factory->getBinary());
+    }
+
+    /**
+     * @expectedException Alchemy\BinaryDriver\Exception\InvalidArgumentException
+     */
+    public function testUseNonExistantBinary()
+    {
+        $factory = $this->getProcessBuilderFactory(static::$phpBinary);
+        $factory->useBinary('itissureitdoesnotexist');
+    }
+
+    public function testCreateShouldReturnAProcess()
+    {
+        $factory = $this->getProcessBuilderFactory(static::$phpBinary);
+        $process = $factory->create();
+
+        $this->assertInstanceOf('Symfony\Component\Process\Process', $process);
+        $this->assertEquals("'".static::$phpBinary."'", $process->getCommandLine());
+    }
+
+    public function testCreateWithStringArgument()
+    {
+        $factory = $this->getProcessBuilderFactory(static::$phpBinary);
+        $process = $factory->create('-v');
+
+        $this->assertInstanceOf('Symfony\Component\Process\Process', $process);
+        $this->assertEquals("'".static::$phpBinary."' '-v'", $process->getCommandLine());
+    }
+
+    public function testCreateWithArrayArgument()
+    {
+        $factory = $this->getProcessBuilderFactory(static::$phpBinary);
+        $process = $factory->create(array('-r', 'echo "Hello !";'));
+
+        $this->assertInstanceOf('Symfony\Component\Process\Process', $process);
+        $this->assertEquals("'".static::$phpBinary."' '-r' 'echo \"Hello !\";'", $process->getCommandLine());
+    }
+
+    public function testCreateWithTimeout()
+    {
+        $factory = $this->getProcessBuilderFactory(static::$phpBinary);
+        $factory->setTimeout(200);
+        $process = $factory->create(array('-i'));
+
+        $this->assertInstanceOf('Symfony\Component\Process\Process', $process);
+        $this->assertEquals(200, $process->getTimeout());
+    }
+}

vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/ConfigurationTest.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace Alchemy\Tests\BinaryDriver;
+
+use Alchemy\BinaryDriver\Configuration;
+
+class ConfigurationTest extends \PHPUnit_Framework_TestCase
+{
+    public function testArrayAccessImplementation()
+    {
+        $configuration = new Configuration(array('key' => 'value'));
+
+        $this->assertTrue(isset($configuration['key']));
+        $this->assertEquals('value', $configuration['key']);
+
+        $this->assertFalse(isset($configuration['key2']));
+        unset($configuration['key']);
+        $this->assertFalse(isset($configuration['key']));
+
+        $configuration['key2'] = 'value2';
+        $this->assertTrue(isset($configuration['key2']));
+        $this->assertEquals('value2', $configuration['key2']);
+    }
+
+    public function testGetOnNonExistentKeyShouldReturnDefaultValue()
+    {
+        $conf = new Configuration();
+        $this->assertEquals('booba', $conf->get('hooba', 'booba'));
+        $this->assertEquals(null, $conf->get('hooba'));
+    }
+
+    public function testSetHasGetRemove()
+    {
+        $configuration = new Configuration(array('key' => 'value'));
+
+        $this->assertTrue($configuration->has('key'));
+        $this->assertEquals('value', $configuration->get('key'));
+
+        $this->assertFalse($configuration->has('key2'));
+        $configuration->remove('key');
+        $this->assertFalse($configuration->has('key'));
+
+        $configuration->set('key2', 'value2');
+        $this->assertTrue($configuration->has('key2'));
+        $this->assertEquals('value2', $configuration->get('key2'));
+    }
+
+    public function testIterator()
+    {
+        $data = array(
+            'key1' => 'value1',
+            'key2' => 'value2',
+            'key3' => 'value3',
+        );
+
+        $captured = array();
+        $conf = new Configuration($data);
+
+        foreach ($conf as $key => $value) {
+            $captured[$key] = $value;
+        }
+
+        $this->assertEquals($data, $captured);
+    }
+
+    public function testAll()
+    {
+        $data = array(
+            'key1' => 'value1',
+            'key2' => 'value2',
+            'key3' => 'value3',
+        );
+
+        $conf = new Configuration($data);
+        $this->assertEquals($data, $conf->all());
+    }
+
+}

vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/LTSProcessBuilderFactoryTest.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace Alchemy\Tests\BinaryDriver;
+
+use Symfony\Component\Process\ProcessBuilder;
+use Alchemy\BinaryDriver\ProcessBuilderFactory;
+use Symfony\Component\Process\Process;
+
+class LTSProcessBuilderFactoryTest extends AbstractProcessBuilderFactoryTest
+{
+    protected function getProcessBuilderFactory($binary)
+    {
+        $factory = new ProcessBuilderFactory($binary);
+        $factory->setBuilder(new LTSProcessBuilder());
+        ProcessBuilderFactory::$emulateSfLTS = false;
+        $factory->useBinary($binary);
+
+        return $factory;
+    }
+}
+
+class LTSProcessBuilder extends ProcessBuilder
+{
+    private $arguments;
+    private $prefix;
+    private $timeout;
+
+    public function __construct(array $arguments = array())
+    {
+        $this->arguments = $arguments;
+        parent::__construct($arguments);
+    }
+
+    public function setArguments(array $arguments)
+    {
+        $this->arguments = $arguments;
+
+        return $this;
+    }
+
+    public function setPrefix($prefix)
+    {
+        $this->prefix = $prefix;
+
+        return $this;
+    }
+
+    public function setTimeout($timeout)
+    {
+        $this->timeout = $timeout;
+
+        return $this;
+    }
+
+    public function getProcess()
+    {
+        if (!$this->prefix && !count($this->arguments)) {
+            throw new LogicException('You must add() command arguments before calling getProcess().');
+        }
+
+        $args = $this->prefix ? array_merge(array($this->prefix), $this->arguments) : $this->arguments;
+        $script = implode(' ', array_map('escapeshellarg', $args));
+
+        return new Process($script, null, null, null, $this->timeout);
+    }
+}

vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/Listeners/DebugListenerTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Alchemy\Tests\BinaryDriver\Listeners;
+
+use Alchemy\BinaryDriver\Listeners\DebugListener;
+use Symfony\Component\Process\Process;
+
+class DebugListenerTest extends \PHPUnit_Framework_TestCase
+{
+    public function testHandle()
+    {
+        $listener = new DebugListener();
+
+        $lines = array();
+        $listener->on('debug', function ($line) use (&$lines) {
+            $lines[] = $line;
+        });
+        $listener->handle(Process::ERR, "first line\nsecond line");
+        $listener->handle(Process::OUT, "cool output");
+        $listener->handle('unknown', "lalala");
+        $listener->handle(Process::OUT, "another output\n");
+
+        $expected = array(
+            '[ERROR] first line',
+            '[ERROR] second line',
+            '[OUT] cool output',
+            '[OUT] another output',
+            '[OUT] ',
+        );
+
+        $this->assertEquals($expected, $lines);
+    }
+}

vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/Listeners/ListenersTest.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace Alchemy\Tests\BinaryDriver\Listeners;
+
+use Alchemy\BinaryDriver\Listeners\Listeners;
+use Evenement\EventEmitter;
+use Alchemy\BinaryDriver\Listeners\ListenerInterface;
+
+class ListenersTest extends \PHPUnit_Framework_TestCase
+{
+    public function testRegister()
+    {
+        $listener = new MockListener();
+
+        $listeners = new Listeners();
+        $listeners->register($listener);
+
+        $n = 0;
+        $listener->on('received', function ($type, $data) use (&$n, &$capturedType, &$capturedData) {
+            $n++;
+            $capturedData = $data;
+            $capturedType = $type;
+        });
+
+        $type = 'type';
+        $data = 'data';
+
+        $listener->handle($type, $data);
+        $listener->handle($type, $data);
+
+        $listeners->unregister($listener);
+
+        $listener->handle($type, $data);
+
+        $this->assertEquals(3, $n);
+        $this->assertEquals($type, $capturedType);
+        $this->assertEquals($data, $capturedData);
+    }
+
+    public function testRegisterAndForwardThenUnregister()
+    {
+        $listener = new MockListener();
+        $target = new EventEmitter();
+
+        $n = 0;
+        $target->on('received', function ($type, $data) use (&$n, &$capturedType, &$capturedData) {
+            $n++;
+            $capturedData = $data;
+            $capturedType = $type;
+        });
+
+        $m = 0;
+        $listener->on('received', function ($type, $data) use (&$m, &$capturedType2, &$capturedData2) {
+            $m++;
+            $capturedData2 = $data;
+            $capturedType2 = $type;
+        });
+
+        $listeners = new Listeners();
+        $listeners->register($listener, $target);
+
+        $type = 'type';
+        $data = 'data';
+
+        $listener->handle($type, $data);
+        $listener->handle($type, $data);
+
+        $listeners->unregister($listener, $target);
+
+        $listener->handle($type, $data);
+
+        $this->assertEquals(2, $n);
+        $this->assertEquals(3, $m);
+        $this->assertEquals($type, $capturedType);
+        $this->assertEquals($data, $capturedData);
+        $this->assertEquals($type, $capturedType2);
+        $this->assertEquals($data, $capturedData2);
+    }
+}
+
+class MockListener extends EventEmitter implements ListenerInterface
+{
+    public function handle($type, $data)
+    {
+        $this->emit('received', array($type, $data));
+    }
+
+    public function forwardedEvents()
+    {
+        return array('received');
+    }
+}

vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/NONLTSProcessBuilderFactoryTest.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Alchemy\Tests\BinaryDriver;
+
+use Alchemy\BinaryDriver\ProcessBuilderFactory;
+
+class NONLTSProcessBuilderFactoryTest extends AbstractProcessBuilderFactoryTest
+{
+    protected function getProcessBuilderFactory($binary)
+    {
+        ProcessBuilderFactory::$emulateSfLTS = true;
+
+        return new ProcessBuilderFactory($binary);
+    }
+}

vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/ProcessRunnerTest.php

@@ -0,0 +1,208 @@
+<?php
+
+/*
+ * This file is part of Alchemy\BinaryDriver.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Alchemy\Tests\BinaryDriver;
+
+use Alchemy\BinaryDriver\ProcessRunner;
+use Alchemy\BinaryDriver\BinaryDriverTestCase;
+use Alchemy\BinaryDriver\Exception\ExecutionFailureException;
+use Alchemy\BinaryDriver\Listeners\ListenerInterface;
+use Evenement\EventEmitter;
+use Symfony\Component\Process\Exception\RuntimeException as ProcessRuntimeException;
+
+class ProcessRunnerTest extends BinaryDriverTestCase
+{
+    public function getProcessRunner($logger)
+    {
+        return new ProcessRunner($logger, 'test-runner');
+    }
+
+    public function testRunSuccessFullProcess()
+    {
+        $logger = $this->createLoggerMock();
+        $runner = $this->getProcessRunner($logger);
+
+        $process = $this->createProcessMock(1, true, '--helloworld--', "Kikoo Romain", null, true);
+
+        $logger
+            ->expects($this->never())
+            ->method('error');
+        $logger
+            ->expects($this->exactly(2))
+            ->method('info');
+
+        $this->assertEquals('Kikoo Romain', $runner->run($process, new \SplObjectStorage(), false));
+    }
+
+    public function testRunSuccessFullProcessBypassingErrors()
+    {
+        $logger = $this->createLoggerMock();
+        $runner = $this->getProcessRunner($logger);
+
+        $process = $this->createProcessMock(1, true, '--helloworld--', "Kikoo Romain", null, true);
+
+        $logger
+            ->expects($this->never())
+            ->method('error');
+        $logger
+            ->expects($this->exactly(2))
+            ->method('info');
+
+        $this->assertEquals('Kikoo Romain', $runner->run($process, new \SplObjectStorage(), true));
+    }
+
+    public function testRunFailingProcess()
+    {
+        $logger = $this->createLoggerMock();
+        $runner = $this->getProcessRunner($logger);
+
+        $process = $this->createProcessMock(1, false, '--helloworld--', null, null, true);
+
+        $logger
+            ->expects($this->once())
+            ->method('error');
+        $logger
+            ->expects($this->once())
+            ->method('info');
+
+        try {
+            $runner->run($process, new \SplObjectStorage(), false);
+            $this->fail('An exception should have been raised');
+        } catch (ExecutionFailureException $e) {
+
+        }
+    }
+
+    public function testRunFailingProcessWithException()
+    {
+        $logger = $this->createLoggerMock();
+        $runner = $this->getProcessRunner($logger);
+
+        $exception = new ProcessRuntimeException('Process Failed');
+        $process = $this->getMockBuilder('Symfony\Component\Process\Process')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $process->expects($this->once())
+            ->method('run')
+            ->will($this->throwException($exception));
+
+        $logger
+            ->expects($this->once())
+            ->method('error');
+        $logger
+            ->expects($this->once())
+            ->method('info');
+
+        try {
+            $runner->run($process, new \SplObjectStorage(), false);
+            $this->fail('An exception should have been raised');
+        } catch (ExecutionFailureException $e) {
+            $this->assertEquals($exception, $e->getPrevious());
+        }
+    }
+
+    public function testRunfailingProcessBypassingErrors()
+    {
+        $logger = $this->createLoggerMock();
+        $runner = $this->getProcessRunner($logger);
+
+        $process = $this->createProcessMock(1, false, '--helloworld--', 'Hello output', null, true);
+
+        $logger
+            ->expects($this->once())
+            ->method('error');
+        $logger
+            ->expects($this->once())
+            ->method('info');
+
+        $this->assertNull($runner->run($process, new \SplObjectStorage(), true));
+    }
+
+    public function testRunFailingProcessWithExceptionBypassingErrors()
+    {
+        $logger = $this->createLoggerMock();
+        $runner = $this->getProcessRunner($logger);
+
+        $exception = new ProcessRuntimeException('Process Failed');
+        $process = $this->getMockBuilder('Symfony\Component\Process\Process')
+            ->disableOriginalConstructor()
+            ->getMock();
+        $process->expects($this->once())
+            ->method('run')
+            ->will($this->throwException($exception));
+
+        $logger
+            ->expects($this->once())
+            ->method('error');
+        $logger
+            ->expects($this->once())
+            ->method('info');
+
+        $this->assertNull($runner->run($process, new \SplObjectStorage(), true));
+    }
+
+    public function testRunSuccessFullProcessWithHandlers()
+    {
+        $logger = $this->createLoggerMock();
+        $runner = $this->getProcessRunner($logger);
+
+        $capturedCallback = null;
+
+        $process = $this->createProcessMock(1, true, '--helloworld--', "Kikoo Romain", null, true);
+        $process->expects($this->once())
+            ->method('run')
+            ->with($this->isInstanceOf('Closure'))
+            ->will($this->returnCallback(function ($callback) use (&$capturedCallback) {
+                $capturedCallback = $callback;
+            }));
+
+        $logger
+            ->expects($this->never())
+            ->method('error');
+        $logger
+            ->expects($this->exactly(2))
+            ->method('info');
+
+        $listener = new TestListener();
+        $storage = new \SplObjectStorage();
+        $storage->attach($listener);
+
+        $capturedType = $capturedData = null;
+
+        $listener->on('received', function ($type, $data) use (&$capturedType, &$capturedData) {
+            $capturedData = $data;
+            $capturedType = $type;
+        });
+
+        $this->assertEquals('Kikoo Romain', $runner->run($process, $storage, false));
+
+        $type = 'err';
+        $data = 'data';
+
+        $capturedCallback($type, $data);
+
+        $this->assertEquals($data, $capturedData);
+        $this->assertEquals($type, $capturedType);
+    }
+}
+
+class TestListener extends EventEmitter implements ListenerInterface
+{
+    public function handle($type, $data)
+    {
+        return $this->emit('received', array($type, $data));
+    }
+
+    public function forwardedEvents()
+    {
+        return array();
+    }
+}

vendor/alchemy/binary-driver/tests/bootstrap.php

@@ -0,0 +1,4 @@
+<?php
+
+$loader = require __DIR__.'/../vendor/autoload.php';
+$loader->add('Alchemy\Tests', __DIR__);

vendor/alchemy/ghostscript/.gitignore

@@ -0,0 +1 @@
+/vendor/

vendor/alchemy/ghostscript/.travis.yml

@@ -0,0 +1,14 @@
+language: php
+
+before_script:
+  - sudo apt-get install -y ghostscript
+  - composer install --dev --prefer-source
+
+php:
+  - 5.3.3
+  - 5.3
+  - 5.4
+  - 5.5
+
+script:
+  - phpunit

vendor/alchemy/ghostscript/CHANGELOG.md

@@ -0,0 +1,22 @@
+CHANGELOG
+---------
+
+* 0.4.0 (06-25-2013)
+
+  * BC Break : Transcoder::create arguments have been inverted.
+  * BC Break : Service provider configuration has been updated.
+
+* 0.3.0 (04-24-2013)
+
+  * Use Alchemy\BinaryDriver as driver base.
+  * BC Break : remove methods `open` and `close`. Methods `toImage` and `toPDF`
+    now take the input file as first argument.
+  * Code cleanup
+
+* 0.2.0 (02-01-2013)
+
+  * Update API, BC break : rename PDFTranscoder to Transcoder
+
+* 0.1.1 (11-27-2012)
+
+  * First stable version.

vendor/alchemy/ghostscript/LICENSE

@@ -0,0 +1,21 @@
+Ghostscript-PHP is released with MIT License :
+
+Copyright (c) 2012 Alchemy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

vendor/alchemy/ghostscript/README.md

@@ -0,0 +1,65 @@
+# Ghostscript PHP driver
+
+[![Build Status](https://secure.travis-ci.org/alchemy-fr/Ghostscript-PHP.png)](http://travis-ci.org/alchemy-fr/Ghostscript-PHP)
+
+# API usage
+
+To instantiate Ghostscript driver, the easiest way is :
+
+```php
+$transcoder = Ghostscript\Transcoder::create();
+```
+
+You can customize your driver by passing a `Psr\Log\LoggerInterface` or
+configuration options.
+
+Available options are :
+
+ - `gs.binaries` : the path (or an array of potential paths) to the ghostscript binary.
+ - `timeout` : the timeout for the underlying process.
+
+```php
+$transcoder = Ghostscript\Transcoder::create(array(
+    'timeout' => 42,
+    'gs.binaries' => '/opt/local/gs/bin/gs',
+), $logger);
+```
+
+To process a file to PDF format, use the `toPDF` method :
+
+Third and fourth arguments are respectively the first page and the number of
+page to transcode.
+
+```php
+$transcoder->toPDF('document.pdf', 'first-page.pdf', 1, 1);
+```
+
+To render a file to Image, use the `toImage` method :
+
+```php
+$transcoder->toImage('document.pdf', 'output.jpg');
+```
+
+## Silex service provider :
+
+A [Silex](silex.sensiolabs.org) Service Provider is available, all parameters
+are optionals :
+
+```php
+$app = new Silex\Application();
+$app->register(new Ghostscript\GhostscriptServiceProvider(), array(
+    'ghostscript.configuration' => array(
+        'gs.binaries' => '/usr/bin/gs',
+        'timeout'     => 42,
+    )
+    'ghostscript.logger' => $app->share(function () {
+        return $app['monolog']; // use Monolog service provider
+    }),
+));
+
+$app['ghostscript.pdf-transcoder']->toImage('document.pdf', 'image.jpg');
+```
+
+# License
+
+Released under the MIT License

vendor/alchemy/ghostscript/composer.json

@@ -0,0 +1,33 @@
+{
+    "name": "alchemy/ghostscript",
+    "type": "library",
+    "description": "Ghostscript PDF, a library to handle PDF through ghostscript",
+    "keywords": ["ghostscript", "pdf"],
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Romain Neutron",
+            "email": "imprec@gmail.com",
+            "homepage": "http://www.lickmychip.com/"
+        },
+        {
+            "name": "Phraseanet Team",
+            "email": "info@alchemy.fr",
+            "homepage": "http://www.phraseanet.com/"
+        }
+    ],
+    "require": {
+        "php"                   : ">=5.3.3",
+        "alchemy/binary-driver" : "~1.5"
+    },
+    "require-dev": {
+        "phpunit/phpunit"       : "~3.7",
+        "sami/sami"             : "~1.0",
+        "silex/silex"           : "~1.0"
+    },
+    "autoload": {
+        "psr-0": {
+            "Ghostscript"       : "src"
+        }
+    }
+}

vendor/alchemy/ghostscript/phpunit.xml.dist

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit backupGlobals="false"
+         backupStaticAttributes="false"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnFailure="false"
+         syntaxCheck="true"
+         verbose="false"
+         bootstrap="tests/bootstrap.php"
+>
+    <php>
+      <ini name="display_errors" value="on"/>
+    </php>
+
+    <testsuites>
+        <testsuite name="Ghostscript Tests Suite">
+            <directory>tests</directory>
+        </testsuite>
+    </testsuites>
+    <filter>
+      <blacklist>
+        <directory>vendor</directory>
+        <directory>tests</directory>
+      </blacklist>
+    </filter>
+
+</phpunit>
+

vendor/alchemy/ghostscript/src/Ghostscript/Exception/ExceptionInterface.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of Ghostscript-PHP.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Ghostscript\Exception;
+
+interface ExceptionInterface
+{
+}

vendor/alchemy/ghostscript/src/Ghostscript/Exception/RuntimeException.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of Ghostscript-PHP.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Ghostscript\Exception;
+
+class RuntimeException extends \RuntimeException implements ExceptionInterface
+{
+}

vendor/alchemy/ghostscript/src/Ghostscript/GhostscriptServiceProvider.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of Ghostscript-PHP.
+ *
+ * (c) Alchemy <info@alchemy.fr>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Ghostscript;
+
+use Silex\ServiceProviderInterface;
+use Silex\Application;
+
+class GhostscriptServiceProvider implements ServiceProviderInterface
+{
+    public function register(Application $app)
+    {
+        $app['ghostscript.default.configuration'] = array(
+            'gs.binaries' => array('gs'),
+            'timeout'     => 60,
+        );
+        $app['ghostscript.configuration'] = array();
+        $app['ghostscript.logger'] = null;
+
+        $app['ghostscript.transcoder'] = $app->share(function(Application $app) {
+            $app['ghostscript.configuration'] = array_replace(
+                $app['ghostscript.default.configuration'], $app['ghostscript.configuration']
+            );
+
+            return Transcoder::create($app['ghostscript.configuration'], $app['ghostscript.logger']);
+        });
+    }
+
+    public function boot(Application $app)
+    {
+    }
+}

vendor/alchemy/ghostscript/src/Ghostscript/Transcoder.php

@@ -0,0 +1,108 @@
+<?php
+
+namespace Ghostscript;
+
+use Alchemy\BinaryDriver\AbstractBinary;
+use Psr\Log\LoggerInterface;
+use Ghostscript\Exception\RuntimeException;
+use Alchemy\BinaryDriver\Configuration;
+use Alchemy\BinaryDriver\ConfigurationInterface;
+use Alchemy\BinaryDriver\Exception\ExecutionFailureException;
+
+class Transcoder extends AbstractBinary
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        return 'ghostscript-transcoder';
+    }
+
+    /**
+     * Transcode a PDF to an image.
+     *
+     * @param string $input          The path to the input file.
+     * @param string $destinationThe path to the output file.
+     *
+     * @return Transcoder
+     *
+     * @throws RuntimeException In case of failure
+     */
+    public function toImage($input, $destination)
+    {
+        try {
+            $this->command(array(
+                '-sDEVICE=jpeg',
+                '-dNOPAUSE',
+                '-dBATCH',
+                '-dSAFER',
+                '-sOutputFile=' . $destination,
+                $input,
+            ));
+        } catch (ExecutionFailureException $e) {
+            throw new RuntimeException('Ghostscript was unable to transcode to Image', $e->getCode(), $e);
+        }
+
+        if (!file_exists($destination)) {
+            throw new RuntimeException('Ghostscript was unable to transcode to Image');
+        }
+
+        return $this;
+    }
+
+    /**
+     * Transcode a PDF to another PDF
+     *
+     * @param string  $input        The path to the input file.
+     * @param string  $destination  The path to the output file.
+     * @param integer $pageStart    The number of the first page.
+     * @param integer $pageQuantity The number of page to include.
+     *
+     * @return Transcoder
+     *
+     * @throws RuntimeException In case of failure
+     */
+    public function toPDF($input, $destination, $pageStart, $pageQuantity)
+    {
+        try {
+            $this->command(array(
+                '-sDEVICE=pdfwrite',
+                '-dNOPAUSE',
+                '-dBATCH',
+                '-dSAFER',
+                sprintf('-dFirstPage=%d', $pageStart),
+                sprintf('-dLastPage=%d', ($pageStart + $pageQuantity - 1)),
+                '-sOutputFile=' . $destination,
+                $input,
+            ));
+        } catch (ExecutionFailureException $e) {
+            throw new RuntimeException('Ghostscript was unable to transcode to PDF', $e->getCode(), $e);
+        }
+
+        if (!file_exists($destination)) {
+            throw new RuntimeException('Ghostscript was unable to transcode to PDF');
+        }
+
+        return $this;
+    }
+
+    /**
+     * Creates a Transcoder.
+     *
+     * @param array|ConfigurationInterface $configuration
+     * @param LoggerInterface              $logger
+     *
+     * @return Transcoder
+     */
+    public static function create($configuration = array(), LoggerInterface $logger = null)
+    {
+        if (!$configuration instanceof ConfigurationInterface) {
+            $configuration = new Configuration($configuration);
+        }
+
+        $binaries = $configuration->get('gs.binaries', array('gs'));
+
+        return static::load($binaries, $logger, $configuration);
+    }
+}

vendor/alchemy/ghostscript/tests/Ghostscript/Tests/GhostscriptServiceProviderTest.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace Ghostscript\Tests;
+
+use Ghostscript\GhostscriptServiceProvider;
+use Silex\Application;
+use Symfony\Component\Process\ExecutableFinder;
+
+class GhostscriptServiceProviderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testRegister()
+    {
+        $app = new Application;
+        $app->register(new GhostscriptServiceProvider());
+
+        $this->assertInstanceOf('\\Ghostscript\\Transcoder', $app['ghostscript.transcoder']);
+    }
+
+    public function testRegisterWithCustomTimeout()
+    {
+        $app = new Application;
+        $app->register(new GhostscriptServiceProvider(), array(
+            'ghostscript.configuration' => array(
+                'timeout' => 42
+            ),
+        ));
+
+        $this->assertEquals(42, $app['ghostscript.transcoder']->getProcessBuilderfactory()->getTimeout());
+    }
+
+    public function testRegisterWithCustomBinary()
+    {
+        $finder = new ExecutableFinder();
+        $MP4Box = $finder->find('MP4Box');
+
+        if (null === $MP4Box) {
+            $this->markTestSkipped('Unable to detect MP4Box, required for this test');
+        }
+
+        $app = new Application;
+        $app->register(new GhostscriptServiceProvider(), array(
+            'ghostscript.configuration' => array(
+                'gs.binaries' => $MP4Box
+            ),
+        ));
+
+        $this->assertEquals($MP4Box, $app['ghostscript.transcoder']->getProcessBuilderfactory()->getBinary());
+    }
+
+    public function testRegisterWithCustomLogger()
+    {
+        $logger = $this->getMock('Psr\Log\LoggerInterface');
+
+        $app = new Application;
+        $app->register(new GhostscriptServiceProvider(), array(
+            'ghostscript.logger' => $logger,
+        ));
+
+        $this->assertEquals($logger, $app['ghostscript.transcoder']->getProcessRunner()->getLogger());
+    }
+}

vendor/alchemy/ghostscript/tests/Ghostscript/Tests/TranscoderTest.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Ghostscript\Tests;
+
+use Ghostscript\Transcoder;
+
+class TranscoderTest extends \PHPUnit_Framework_TestCase
+{
+    protected $object;
+
+    protected function setUp()
+    {
+        $this->object = Transcoder::create();
+    }
+
+    public function testTranscodeToPdf()
+    {
+        $dest = tempnam(sys_get_temp_dir(), 'gs_temp') . '.pdf';
+        $this->object->toPDF(__DIR__ . '/../../files/test.pdf', $dest, 1, 1);
+
+        $this->assertTrue(file_exists($dest));
+        $this->assertGreaterThan(0, filesize($dest));
+
+        unlink($dest);
+    }
+
+    public function testTranscodeAIToImage()
+    {
+        $dest = tempnam(sys_get_temp_dir(), 'gs_temp') . '.jpg';
+        $this->object->toImage(__DIR__ . '/../../files/test.pdf', $dest);
+
+        $this->assertTrue(file_exists($dest));
+        $this->assertGreaterThan(0, filesize($dest));
+
+        unlink($dest);
+    }
+}

vendor/alchemy/ghostscript/tests/bootstrap.php

@@ -0,0 +1,4 @@
+<?php
+
+$loader = require __DIR__.'/../vendor/autoload.php';
+$loader->add('Ghostscript\Tests', __DIR__);

vendor/alchemy/mediavorus/.gitignore

@@ -0,0 +1,4 @@
+/nbproject
+/vendor
+/docs/_build
+composer.phar

vendor/alchemy/mediavorus/.travis.yml

@@ -0,0 +1,19 @@
+language: php
+
+sudo: required
+
+before_install:
+  - composer self-update --rollback
+  - sudo apt-get update
+  - sudo apt-get install ffmpeg
+  - phpenv config-rm xdebug.ini
+install:
+  - composer update --prefer-source
+
+php:
+  - 5.6
+  - 7.0
+  - 7.1
+
+matrix:
+  fast_finish: true

vendor/alchemy/mediavorus/CHANGELOG.md

@@ -0,0 +1,60 @@
+CHANGELOG
+---------
+
+* 0.4.4 (08-26-2014)
+
+  * Fix width and height video extraction (@nlegoff).
+  
+* 0.4.3 (01-06-2014)
+
+  * Fix video audio sample rate cast.
+
+* 0.4.2 (11-28-2013)
+
+  * Add support for video orientation.
+
+* 0.4.1 (10-21-2013)
+
+  * Add compatibility with PHP-FFMpeg 0.4.
+  * Fix temporary files management.
+
+* 0.4.0 (07-04-2013)
+
+  * Add compatibility with PHP-FFMpeg 0.3.
+  * BC Break : Implementation must now explicitely registered MediaVorus
+    mimetype guessers as they are not automatically registered anymore.
+  * Ensure FFProbe dependency is optional.
+
+* 0.3.2 (04-16-2013)
+
+  * Cleanup JMS Serializer / exiftool / PHPExiftool version dependencies
+
+* 0.3.1 (01-31-2013)
+
+  * Merge with 0.1.2
+  * Register FileBinaryMimeTypeGuesser prior to FileInfoMimetypeGuesser
+
+* 0.3.0 (01-14-2013)
+
+  * Add support for media serialization via JMS serializer.
+
+* 0.2.1 (12-21-2012)
+
+  * Support of the latest PHPExiftool API.
+
+* 0.2.0 (12-14-2012)
+
+  * Update API.
+  * Add support of videos Width/Height via FFProbe.
+
+* 0.1.2 (02-07-2013)
+
+  * Add more mime types to match the document format.
+
+* 0.1.1 (12-14-2012)
+
+  * Support for Video Width / Height extraction via FFProbe.
+
+* 0.1.0 (11-26-2012)
+
+  * First stable version.

vendor/alchemy/mediavorus/LICENSE

@@ -0,0 +1,18 @@
+This project is released under MIT License
+
+Copyright (c) 2012 Romain Neutron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

vendor/alchemy/mediavorus/README.md

@@ -0,0 +1,27 @@
+MediaVorus
+==========
+
+[![Build Status](https://secure.travis-ci.org/romainneutron/MediaVorus.png?branch=master)](http://travis-ci.org/romainneutron/MediaVorus)
+
+A lib to get every technical informations about your files
+
+#Exemple
+
+```php
+use MediaVorus\MediaVorus;
+use MediaVorus\Media\Image;
+
+$mediavorus = MediaVorus::create();
+
+$image = $mediavorus->guess('RawCanon.cr2');
+
+echo sprintf("Photo as been taken with a %s Shutter Speed", $Image->getShutterSpeed());
+```
+
+#Documentation
+
+Documentation is hosted on Read The Docs http://mediavorus.readthedocs.org/
+
+#License
+
+MediaVorus is released under the [MIT license](http://opensource.org/licenses/MIT)

vendor/alchemy/mediavorus/composer.json

@@ -0,0 +1,45 @@
+{
+    "name": "alchemy/mediavorus",
+    "type": "library",
+    "description": "MediaVorus",
+    "keywords": ["metadata"],
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Romain Neutron",
+            "email": "imprec@gmail.com",
+            "homepage": "http://www.lickmychip.com/"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.0",
+        "alchemy/phpexiftool"     : "~0.1",
+        "doctrine/collections"    : "~1.0",
+        "symfony/http-foundation" : "~2.0",
+        "php-ffmpeg/php-ffmpeg"   : "~0.3",
+        "monolog/monolog"         : "~1.0"
+    },
+    "suggest": {
+        "jms/serializer"          : "To serialize Medias",
+        "symfony/yaml"            : "To serialize Medias in Yaml format"
+    },
+    "require-dev": {
+        "silex/silex"             : "~1.0",
+        "symfony/yaml"            : "~2.0",
+        "jms/serializer"          : "~0.12.0",
+        "phpunit/phpunit"         : "^4.0|^5.0"
+    },
+    "replace": {
+        "mediavorus/mediavorus": "<=0.4.4"
+    },
+    "autoload": {
+        "psr-0": {
+            "MediaVorus": "src"
+        }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "0.4.x-dev"
+        }
+    }
+}

vendor/alchemy/mediavorus/docs/API.rst

@@ -0,0 +1,6 @@
+API
+===
+
+
+.. toctree::
+   :maxdepth: 2

vendor/alchemy/mediavorus/docs/Makefile

@@ -0,0 +1,153 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = _build
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+
+clean:
+	-rm -rf $(BUILDDIR)/*
+
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/MediaVorus.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/MediaVorus.qhc"
+
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/MediaVorus"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/MediaVorus"
+	@echo "# devhelp"
+
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+texinfo:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+info:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+gettext:
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."

vendor/alchemy/mediavorus/docs/UseCases.rst

@@ -0,0 +1,7 @@
+Use Cases
+=========
+
+
+.. toctree::
+   :maxdepth: 2
+

vendor/alchemy/mediavorus/docs/_static/js/plugins.js

@@ -0,0 +1,11 @@
+// usage: log('inside coolFunc', this, arguments);
+// paulirish.com/2009/log-a-lightweight-wrapper-for-consolelog/
+window.log = function f(){ log.history = log.history || []; log.history.push(arguments); if(this.console) { var args = arguments, newarr; try { args.callee = f.caller } catch(e) {}; newarr = [].slice.call(args); if (typeof console.log === 'object') log.apply.call(console.log, console, newarr); else console.log.apply(console, newarr);}};
+
+// make it safe to use console.log always
+(function(a){function b(){}for(var c="assert,count,debug,dir,dirxml,error,exception,group,groupCollapsed,groupEnd,info,log,markTimeline,profile,profileEnd,time,timeEnd,trace,warn".split(","),d;!!(d=c.pop());){a[d]=a[d]||b;}})
+(function(){try{console.log();return window.console;}catch(a){return (window.console={});}}());
+
+
+// place any jQuery/helper plugins in here, instead of separate, slower script files.
+

vendor/alchemy/mediavorus/docs/_static/js/script.js

@@ -0,0 +1,8 @@
+/* Author:
+
+*/
+
+
+
+
+

vendor/alchemy/mediavorus/docs/_static/less/accordion.less

@@ -0,0 +1,28 @@
+// ACCORDION
+// ---------
+
+
+// Parent container
+.accordion {
+  margin-bottom: @baseLineHeight;
+}
+
+// Group == heading + body
+.accordion-group {
+  margin-bottom: 2px;
+  border: 1px solid #e5e5e5;
+  .border-radius(4px);
+}
+.accordion-heading {
+  border-bottom: 0;
+}
+.accordion-heading .accordion-toggle {
+  display: block;
+  padding: 8px 15px;
+}
+
+// Inner needs the styles because you can't animate properly with any styles on the element
+.accordion-inner {
+  padding: 9px 15px;
+  border-top: 1px solid #e5e5e5;
+}

vendor/alchemy/mediavorus/docs/_static/less/alerts.less

@@ -0,0 +1,58 @@
+// ALERT STYLES
+// ------------
+
+// Base alert styles
+.alert {
+  padding: 8px 35px 8px 14px;
+  margin-bottom: @baseLineHeight;
+  text-shadow: 0 1px 0 rgba(255,255,255,.5);
+  background-color: @warningBackground;
+  border: 1px solid @warningBorder;
+  .border-radius(4px);
+  color: @warningText;
+}
+.alert-heading {
+  color: inherit;
+}
+
+// Adjust close link position
+.alert .close {
+  position: relative;
+  top: -2px;
+  right: -21px;
+  line-height: 18px;
+}
+
+// Alternate styles
+// ----------------
+
+.alert-success {
+  background-color: @successBackground;
+  border-color: @successBorder;  
+  color: @successText;
+}
+.alert-danger,
+.alert-error {
+  background-color: @errorBackground;
+  border-color: @errorBorder;
+  color: @errorText;
+}
+.alert-info {
+  background-color: @infoBackground;
+  border-color: @infoBorder;
+  color: @infoText;
+}
+
+// Block alerts
+// ------------------------
+.alert-block {
+  padding-top: 14px;
+  padding-bottom: 14px;
+}
+.alert-block > p,
+.alert-block > ul {
+  margin-bottom: 0;
+}
+.alert-block p + p {
+  margin-top: 5px;
+}

vendor/alchemy/mediavorus/docs/_static/less/badges.less

@@ -0,0 +1,36 @@
+// BADGES
+// ------
+
+// Base
+.badge {
+  padding: 1px 9px 2px;
+  font-size: @baseFontSize * .925;
+  font-weight: bold;
+  white-space: nowrap;
+  color: @white;
+  background-color: @grayLight;
+  .border-radius(9px);
+}
+
+// Hover state
+.badge:hover {
+  color: @white;
+  text-decoration: none;
+  cursor: pointer;
+}
+
+// Colors
+.badge-error            { background-color: @errorText; }
+.badge-error:hover      { background-color: darken(@errorText, 10%); }
+
+.badge-warning          { background-color: @orange; }
+.badge-warning:hover    { background-color: darken(@orange, 10%); }
+
+.badge-success          { background-color: @successText; }
+.badge-success:hover    { background-color: darken(@successText, 10%); }
+
+.badge-info             { background-color: @infoText; }
+.badge-info:hover       { background-color: darken(@infoText, 10%); }
+
+.badge-inverse          { background-color: @grayDark; }
+.badge-inverse:hover    { background-color: darken(@grayDark, 10%); }

vendor/alchemy/mediavorus/docs/_static/less/bootstrap.less

@@ -0,0 +1,63 @@
+/*!
+ * Bootstrap v2.0.2
+ *
+ * Copyright 2012 Twitter, Inc
+ * Licensed under the Apache License v2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Designed and built with all the love in the world @twitter by @mdo and @fat.
+ */
+
+// CSS Reset
+@import "reset.less";
+
+// Core variables and mixins
+@import "variables.less"; // Modify this for custom colors, font-sizes, etc
+@import "mixins.less";
+
+// Grid system and page structure
+@import "scaffolding.less";
+@import "grid.less";
+@import "layouts.less";
+
+// Base CSS
+@import "type.less";
+@import "code.less";
+@import "forms.less";
+@import "tables.less";
+
+// Components: common
+@import "sprites.less";
+@import "dropdowns.less";
+@import "wells.less";
+@import "component-animations.less";
+@import "close.less";
+
+// Components: Buttons & Alerts
+@import "buttons.less";
+@import "button-groups.less";
+@import "alerts.less"; // Note: alerts share common CSS with buttons and thus have styles in buttons.less
+
+// Components: Nav
+@import "navs.less";
+@import "navbar.less";
+@import "breadcrumbs.less";
+@import "pagination.less";
+@import "pager.less";
+
+// Components: Popovers
+@import "modals.less";
+@import "tooltip.less";
+@import "popovers.less";
+
+// Components: Misc
+@import "thumbnails.less";
+@import "labels.less";
+@import "badges.less";
+@import "progress-bars.less";
+@import "accordion.less";
+@import "carousel.less";
+@import "hero-unit.less";
+
+// Utility classes
+@import "utilities.less"; // Has to be last to override when necessary

vendor/alchemy/mediavorus/docs/_static/less/breadcrumbs.less

@@ -0,0 +1,24 @@
+// BREADCRUMBS
+// -----------
+
+.breadcrumb {
+  padding: 7px 14px;
+  margin: 0 0 @baseLineHeight;
+  list-style: none;
+  #gradient > .vertical(@white, #f5f5f5);
+  border: 1px solid #ddd;
+  .border-radius(3px);
+  .box-shadow(inset 0 1px 0 @white);
+  li {
+    display: inline-block;
+    .ie7-inline-block();
+    text-shadow: 0 1px 0 @white;
+  }
+  .divider {
+    padding: 0 5px;
+    color: @grayLight;
+  }
+  .active a {
+    color: @grayDark;
+  }
+}

vendor/alchemy/mediavorus/docs/_static/less/button-groups.less

@@ -0,0 +1,172 @@
+// BUTTON GROUPS
+// -------------
+
+
+// Make the div behave like a button
+.btn-group {
+  position: relative;
+  .clearfix(); // clears the floated buttons
+  .ie7-restore-left-whitespace();
+}
+
+// Space out series of button groups
+.btn-group + .btn-group {
+  margin-left: 5px;
+}
+
+// Optional: Group multiple button groups together for a toolbar
+.btn-toolbar {
+  margin-top: @baseLineHeight / 2;
+  margin-bottom: @baseLineHeight / 2;
+  .btn-group {
+    display: inline-block;
+    .ie7-inline-block();
+  }
+}
+
+// Float them, remove border radius, then re-add to first and last elements
+.btn-group .btn {
+  position: relative;
+  float: left;
+  margin-left: -1px;
+  .border-radius(0);
+}
+// Set corners individual because sometimes a single button can be in a .btn-group and we need :first-child and :last-child to both match
+.btn-group .btn:first-child {
+  margin-left: 0;
+     -webkit-border-top-left-radius: 4px;
+         -moz-border-radius-topleft: 4px;
+             border-top-left-radius: 4px;
+  -webkit-border-bottom-left-radius: 4px;
+      -moz-border-radius-bottomleft: 4px;
+          border-bottom-left-radius: 4px;
+}
+.btn-group .btn:last-child,
+.btn-group .dropdown-toggle {
+     -webkit-border-top-right-radius: 4px;
+         -moz-border-radius-topright: 4px;
+             border-top-right-radius: 4px;
+  -webkit-border-bottom-right-radius: 4px;
+      -moz-border-radius-bottomright: 4px;
+          border-bottom-right-radius: 4px;
+}
+// Reset corners for large buttons
+.btn-group .btn.large:first-child {
+  margin-left: 0;
+     -webkit-border-top-left-radius: 6px;
+         -moz-border-radius-topleft: 6px;
+             border-top-left-radius: 6px;
+  -webkit-border-bottom-left-radius: 6px;
+      -moz-border-radius-bottomleft: 6px;
+          border-bottom-left-radius: 6px;
+}
+.btn-group .btn.large:last-child,
+.btn-group .large.dropdown-toggle {
+     -webkit-border-top-right-radius: 6px;
+         -moz-border-radius-topright: 6px;
+             border-top-right-radius: 6px;
+  -webkit-border-bottom-right-radius: 6px;
+      -moz-border-radius-bottomright: 6px;
+          border-bottom-right-radius: 6px;
+}
+
+// On hover/focus/active, bring the proper btn to front
+.btn-group .btn:hover,
+.btn-group .btn:focus,
+.btn-group .btn:active,
+.btn-group .btn.active {
+  z-index: 2;
+}
+
+// On active and open, don't show outline
+.btn-group .dropdown-toggle:active,
+.btn-group.open .dropdown-toggle {
+  outline: 0;
+}
+
+
+
+// Split button dropdowns
+// ----------------------
+
+// Give the line between buttons some depth
+.btn-group .dropdown-toggle {
+  padding-left: 8px;
+  padding-right: 8px;
+  @shadow: inset 1px 0 0 rgba(255,255,255,.125), inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+  .box-shadow(@shadow);
+  *padding-top: 3px;
+  *padding-bottom: 3px;
+}
+.btn-group .btn-mini.dropdown-toggle {
+  padding-left: 5px;
+  padding-right: 5px;
+  *padding-top: 1px;
+  *padding-bottom: 1px;
+}
+.btn-group .btn-small.dropdown-toggle {
+  *padding-top: 4px;
+  *padding-bottom: 4px;
+}
+.btn-group .btn-large.dropdown-toggle {
+  padding-left: 12px;
+  padding-right: 12px;
+}
+
+.btn-group.open {
+  // IE7's z-index only goes to the nearest positioned ancestor, which would
+  // make the menu appear below buttons that appeared later on the page
+  *z-index: @zindexDropdown;
+
+  // Reposition menu on open and round all corners
+  .dropdown-menu {
+    display: block;
+    margin-top: 1px;
+    .border-radius(5px);
+  }
+
+  .dropdown-toggle {
+    background-image: none;
+    @shadow: inset 0 1px 6px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);
+    .box-shadow(@shadow);
+  }
+}
+
+// Reposition the caret
+.btn .caret {
+  margin-top: 7px;
+  margin-left: 0;
+}
+.btn:hover .caret,
+.open.btn-group .caret {
+  .opacity(100);
+}
+// Carets in other button sizes
+.btn-mini .caret {
+  margin-top: 5px;
+}
+.btn-small .caret {
+  margin-top: 6px;
+}
+.btn-large .caret {
+  margin-top: 6px;
+  border-left:  5px solid transparent;
+  border-right: 5px solid transparent;
+  border-top:   5px solid @black;
+}
+
+
+// Account for other colors
+.btn-primary,
+.btn-warning,
+.btn-danger,
+.btn-info,
+.btn-success,
+.btn-inverse {
+  .caret {
+    border-top-color: @white;
+    border-bottom-color: @white;
+    .opacity(75);
+  }
+}
+

vendor/alchemy/mediavorus/docs/_static/less/buttons.less

@@ -0,0 +1,187 @@
+// BUTTON STYLES
+// -------------
+
+
+// Base styles
+// --------------------------------------------------
+
+// Core
+.btn {
+  display: inline-block;
+  .ie7-inline-block();
+  padding: 4px 10px 4px;
+  margin-bottom: 0; // For input.btn
+  font-size: @baseFontSize;
+  line-height: @baseLineHeight;
+  color: @grayDark;
+  text-align: center;
+  text-shadow: 0 1px 1px rgba(255,255,255,.75);
+  vertical-align: middle;
+  .buttonBackground(@btnBackground, @btnBackgroundHighlight);
+  border: 1px solid @btnBorder;
+  border-bottom-color: darken(@btnBorder, 10%);
+  .border-radius(4px);
+  @shadow: inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+  .box-shadow(@shadow);
+  cursor: pointer;
+
+  // Give IE7 some love
+  .ie7-restore-left-whitespace();
+}
+
+// Hover state
+.btn:hover {
+  color: @grayDark;
+  text-decoration: none;
+  background-color: darken(@white, 10%);
+  background-position: 0 -15px;
+
+  // transition is only when going to hover, otherwise the background
+  // behind the gradient (there for IE<=9 fallback) gets mismatched
+  .transition(background-position .1s linear);
+}
+
+// Focus state for keyboard and accessibility
+.btn:focus {
+  .tab-focus();
+}
+
+// Active state
+.btn.active,
+.btn:active {
+  background-image: none;
+  @shadow: inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);
+  .box-shadow(@shadow);
+  background-color: darken(@white, 10%);
+  background-color: darken(@white, 15%) e("\9");
+  outline: 0;
+}
+
+// Disabled state
+.btn.disabled,
+.btn[disabled] {
+  cursor: default;
+  background-image: none;
+  background-color: darken(@white, 10%);
+  .opacity(65);
+  .box-shadow(none);
+}
+
+
+// Button Sizes
+// --------------------------------------------------
+
+// Large
+.btn-large {
+  padding: 9px 14px;
+  font-size: @baseFontSize + 2px;
+  line-height: normal;
+  .border-radius(5px);
+}
+.btn-large [class^="icon-"] {
+  margin-top: 1px;
+}
+
+// Small
+.btn-small {
+  padding: 5px 9px;
+  font-size: @baseFontSize - 2px;
+  line-height: @baseLineHeight - 2px;
+}
+.btn-small [class^="icon-"] {
+  margin-top: -1px;
+}
+
+// Mini
+.btn-mini {
+  padding: 2px 6px;
+  font-size: @baseFontSize - 2px;
+  line-height: @baseLineHeight - 4px;
+}
+
+
+// Alternate buttons
+// --------------------------------------------------
+
+// Set text color
+// -------------------------
+.btn-primary,
+.btn-primary:hover,
+.btn-warning,
+.btn-warning:hover,
+.btn-danger,
+.btn-danger:hover,
+.btn-success,
+.btn-success:hover,
+.btn-info,
+.btn-info:hover,
+.btn-inverse,
+.btn-inverse:hover {
+  text-shadow: 0 -1px 0 rgba(0,0,0,.25);
+  color: @white;
+}
+// Provide *some* extra contrast for those who can get it
+.btn-primary.active,
+.btn-warning.active,
+.btn-danger.active,
+.btn-success.active,
+.btn-info.active,
+.btn-inverse.active {
+  color: rgba(255,255,255,.75);
+}
+
+// Set the backgrounds
+// -------------------------
+.btn-primary {
+  .buttonBackground(@btnPrimaryBackground, @btnPrimaryBackgroundHighlight);
+}
+// Warning appears are orange
+.btn-warning {
+  .buttonBackground(@btnWarningBackground, @btnWarningBackgroundHighlight);
+}
+// Danger and error appear as red
+.btn-danger {
+  .buttonBackground(@btnDangerBackground, @btnDangerBackgroundHighlight);
+}
+// Success appears as green
+.btn-success {
+  .buttonBackground(@btnSuccessBackground, @btnSuccessBackgroundHighlight);
+}
+// Info appears as a neutral blue
+.btn-info {
+  .buttonBackground(@btnInfoBackground, @btnInfoBackgroundHighlight);
+}
+// Inverse appears as dark gray
+.btn-inverse {
+  .buttonBackground(@btnInverseBackground, @btnInverseBackgroundHighlight);
+}
+
+
+// Cross-browser Jank
+// --------------------------------------------------
+
+button.btn,
+input[type="submit"].btn {
+
+  // Firefox 3.6 only I believe
+  &::-moz-focus-inner {
+    padding: 0;
+    border: 0;
+  }
+
+  // IE7 has some default padding on button controls
+  *padding-top: 2px;
+  *padding-bottom: 2px;
+  &.btn-large {
+    *padding-top: 7px;
+    *padding-bottom: 7px;
+  }
+  &.btn-small {
+    *padding-top: 3px;
+    *padding-bottom: 3px;
+  }
+  &.btn-mini {
+    *padding-top: 1px;
+    *padding-bottom: 1px;
+  }
+}

vendor/alchemy/mediavorus/docs/_static/less/carousel.less

@@ -0,0 +1,121 @@
+// CAROUSEL
+// --------
+
+.carousel {
+  position: relative;
+  margin-bottom: @baseLineHeight;
+  line-height: 1;
+}
+
+.carousel-inner {
+  overflow: hidden;
+  width: 100%;
+  position: relative;
+}
+
+.carousel {
+
+  .item {
+    display: none;
+    position: relative;
+    .transition(.6s ease-in-out left);
+  }
+
+  // Account for jankitude on images
+  .item > img {
+    display: block;
+    line-height: 1;
+  }
+
+  .active,
+  .next,
+  .prev { display: block; }
+
+  .active {
+    left: 0;
+  }
+
+  .next,
+  .prev {
+    position: absolute;
+    top: 0;
+    width: 100%;
+  }
+
+  .next {
+    left: 100%;
+  }
+  .prev {
+    left: -100%;
+  }
+  .next.left,
+  .prev.right {
+    left: 0;
+  }
+
+  .active.left {
+    left: -100%;
+  }
+  .active.right {
+    left: 100%;
+  }
+
+}
+
+// Left/right controls for nav
+// ---------------------------
+
+.carousel-control {
+  position: absolute;
+  top: 40%;
+  left: 15px;
+  width: 40px;
+  height: 40px;
+  margin-top: -20px;
+  font-size: 60px;
+  font-weight: 100;
+  line-height: 30px;
+  color: @white;
+  text-align: center;
+  background: @grayDarker;
+  border: 3px solid @white;
+  .border-radius(23px);
+  .opacity(50);
+
+  // we can't have this transition here
+  // because webkit cancels the carousel
+  // animation if you trip this while
+  // in the middle of another animation
+  // ;_;
+  // .transition(opacity .2s linear);
+
+  // Reposition the right one
+  &.right {
+    left: auto;
+    right: 15px;
+  }
+
+  // Hover state
+  &:hover {
+    color: @white;
+    text-decoration: none;
+    .opacity(90);
+  }
+}
+
+// Caption for text below images
+// -----------------------------
+
+.carousel-caption {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  padding: 10px 15px 5px;
+  background: @grayDark;
+  background: rgba(0,0,0,.75);
+}
+.carousel-caption h4,
+.carousel-caption p {
+  color: @white;
+}

vendor/alchemy/mediavorus/docs/_static/less/close.less

@@ -0,0 +1,18 @@
+// CLOSE ICONS
+// -----------
+
+.close {
+  float: right;
+  font-size: 20px;
+  font-weight: bold;
+  line-height: @baseLineHeight;
+  color: @black;
+  text-shadow: 0 1px 0 rgba(255,255,255,1);
+  .opacity(20);
+  &:hover {
+    color: @black;
+    text-decoration: none;
+    .opacity(40);
+    cursor: pointer;
+  }
+}

vendor/alchemy/mediavorus/docs/_static/less/code.less

@@ -0,0 +1,57 @@
+// Code.less
+// Code typography styles for the <code> and <pre> elements
+// --------------------------------------------------------
+
+// Inline and block code styles
+code,
+pre {
+  padding: 0 3px 2px;
+  #font > #family > .monospace;
+  font-size: @baseFontSize - 1;
+  color: @grayDark;
+  .border-radius(3px);
+}
+
+// Inline code
+code {
+  padding: 2px 4px;
+  color: #d14;
+  background-color: #f7f7f9;
+  border: 1px solid #e1e1e8;
+}
+
+// Blocks of code
+pre {
+  display: block;
+  padding: (@baseLineHeight - 1) / 2;
+  margin: 0 0 @baseLineHeight / 2;
+  font-size: @baseFontSize * .925; // 13px to 12px
+  line-height: @baseLineHeight;
+  background-color: #f5f5f5;
+  border: 1px solid #ccc; // fallback for IE7-8
+  border: 1px solid rgba(0,0,0,.15);
+  .border-radius(4px);
+  white-space: pre;
+  white-space: pre-wrap;
+  word-break: break-all;
+  word-wrap: break-word;
+
+  // Make prettyprint styles more spaced out for readability
+  &.prettyprint {
+    margin-bottom: @baseLineHeight;
+  }
+
+  // Account for some code outputs that place code tags in pre tags
+  code {
+    padding: 0;
+    color: inherit;
+    background-color: transparent;
+    border: 0;
+  }
+}
+
+// Enable scrollable blocks of code
+.pre-scrollable {
+  max-height: 340px;
+  overflow-y: scroll;
+}

vendor/alchemy/mediavorus/docs/_static/less/component-animations.less

@@ -0,0 +1,20 @@
+// COMPONENT ANIMATIONS
+// --------------------
+
+.fade {
+  .transition(opacity .15s linear);
+  opacity: 0;
+  &.in {
+    opacity: 1;
+  }
+}
+
+.collapse {
+  .transition(height .35s ease);
+  position:relative;
+  overflow:hidden;
+  height: 0;
+  &.in {
+    height: auto;
+  }
+}

vendor/alchemy/mediavorus/docs/_static/less/dropdowns.less

@@ -0,0 +1,148 @@
+// DROPDOWN MENUS
+// --------------
+
+// Use the .menu class on any <li> element within the topbar or ul.tabs and you'll get some superfancy dropdowns
+.dropdown {
+  position: relative;
+}
+.dropdown-toggle {
+  // The caret makes the toggle a bit too tall in IE7
+  *margin-bottom: -3px;
+}
+.dropdown-toggle:active,
+.open .dropdown-toggle {
+  outline: 0;
+}
+
+// Dropdown arrow/caret
+// --------------------
+.caret {
+  display: inline-block;
+  width: 0;
+  height: 0;
+  vertical-align: top;
+  border-left:  4px solid transparent;
+  border-right: 4px solid transparent;
+  border-top:   4px solid @black;
+  .opacity(30);
+  content: "";
+}
+
+// Place the caret
+.dropdown .caret {
+  margin-top: 8px;
+  margin-left: 2px;
+}
+.dropdown:hover .caret,
+.open.dropdown .caret {
+  .opacity(100);
+}
+
+// The dropdown menu (ul)
+// ----------------------
+.dropdown-menu {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  z-index: @zindexDropdown;
+  float: left;
+  display: none; // none by default, but block on "open" of the menu
+  min-width: 160px;
+  padding: 4px 0;
+  margin: 0; // override default ul
+  list-style: none;
+  background-color: @dropdownBackground;
+  border-color: #ccc;
+  border-color: rgba(0,0,0,.2);
+  border-style: solid;
+  border-width: 1px;
+  .border-radius(0 0 5px 5px);
+  .box-shadow(0 5px 10px rgba(0,0,0,.2));
+  -webkit-background-clip: padding-box;
+     -moz-background-clip: padding;
+          background-clip: padding-box;
+  *border-right-width: 2px;
+  *border-bottom-width: 2px;
+
+  // Aligns the dropdown menu to right
+  &.pull-right {
+    right: 0;
+    left: auto;
+  }
+
+  // Dividers (basically an hr) within the dropdown
+  .divider {
+    .nav-divider();
+  }
+
+  // Links within the dropdown menu
+  a {
+    display: block;
+    padding: 3px 15px;
+    clear: both;
+    font-weight: normal;
+    line-height: @baseLineHeight;
+    color: @dropdownLinkColor;
+    white-space: nowrap;
+  }
+}
+
+// Hover state
+// -----------
+.dropdown-menu li > a:hover,
+.dropdown-menu .active > a,
+.dropdown-menu .active > a:hover {
+  color: @dropdownLinkColorHover;
+  text-decoration: none;
+  background-color: @dropdownLinkBackgroundHover;
+}
+
+// Open state for the dropdown
+// ---------------------------
+.dropdown.open {
+  // IE7's z-index only goes to the nearest positioned ancestor, which would
+  // make the menu appear below buttons that appeared later on the page
+  *z-index: @zindexDropdown;
+
+  .dropdown-toggle {
+    color: @white;
+    background: #ccc;
+    background: rgba(0,0,0,.3);
+  }
+  .dropdown-menu {
+    display: block;
+  }
+}
+
+// Right aligned dropdowns
+.pull-right .dropdown-menu {
+  left: auto;
+  right: 0;
+}
+
+// Allow for dropdowns to go bottom up (aka, dropup-menu)
+// ------------------------------------------------------
+// Just add .dropup after the standard .dropdown class and you're set, bro.
+// TODO: abstract this so that the navbar fixed styles are not placed here?
+.dropup,
+.navbar-fixed-bottom .dropdown {
+  // Reverse the caret
+  .caret {
+    border-top: 0;
+    border-bottom: 4px solid @black;
+    content: "\2191";
+  }
+  // Different positioning for bottom up menu
+  .dropdown-menu {
+    top: auto;
+    bottom: 100%;
+    margin-bottom: 1px;
+  }
+}
+
+// Typeahead
+// ---------
+.typeahead {
+  margin-top: 2px; // give it some space to breathe
+  .border-radius(4px);
+}

vendor/alchemy/mediavorus/docs/_static/less/forms.less

@@ -0,0 +1,555 @@
+// Forms.less
+// Base styles for various input types, form layouts, and states
+// -------------------------------------------------------------
+
+
+// GENERAL STYLES
+// --------------
+
+// Make all forms have space below them
+form {
+  margin: 0 0 @baseLineHeight;
+}
+
+fieldset {
+  padding: 0;
+  margin: 0;
+  border: 0;
+}
+
+// Groups of fields with labels on top (legends)
+legend {
+  display: block;
+  width: 100%;
+  padding: 0;
+  margin-bottom: @baseLineHeight * 1.5;
+  font-size: @baseFontSize * 1.5;
+  line-height: @baseLineHeight * 2;
+  color: @grayDark;
+  border: 0;
+  border-bottom: 1px solid #eee;
+
+  // Small
+  small {
+    font-size: @baseLineHeight * .75;
+    color: @grayLight;
+  }
+}
+
+// Set font for forms
+label,
+input,
+button,
+select,
+textarea {
+  #font > .shorthand(@baseFontSize,normal,@baseLineHeight); // Set size, weight, line-height here
+}
+input,
+button,
+select,
+textarea {
+  font-family: @baseFontFamily; // And only set font-family here for those that need it (note the missing label element)
+}
+
+// Identify controls by their labels
+label {
+  display: block;
+  margin-bottom: 5px;
+  color: @grayDark;
+}
+
+// Inputs, Textareas, Selects
+input,
+textarea,
+select,
+.uneditable-input {
+  display: inline-block;
+  width: 210px;
+  height: @baseLineHeight;
+  padding: 4px;
+  margin-bottom: 9px;
+  font-size: @baseFontSize;
+  line-height: @baseLineHeight;
+  color: @gray;
+  border: 1px solid @inputBorder;
+  .border-radius(3px);
+}
+.uneditable-textarea {
+  width: auto;
+  height: auto;
+}
+
+// Inputs within a label
+label input,
+label textarea,
+label select {
+  display: block;
+}
+
+// Mini reset for unique input types
+input[type="image"],
+input[type="checkbox"],
+input[type="radio"] {
+  width: auto;
+  height: auto;
+  padding: 0;
+  margin: 3px 0;
+  *margin-top: 0; /* IE7 */
+  line-height: normal;
+  cursor: pointer;
+  .border-radius(0);
+  border: 0 \9; /* IE9 and down */
+}
+input[type="image"] {
+  border: 0;
+}
+
+// Reset the file input to browser defaults
+input[type="file"] {
+  width: auto;
+  padding: initial;
+  line-height: initial;
+  border: initial;
+  background-color: @inputBackground;
+  background-color: initial;
+  .box-shadow(none);
+}
+
+// Help out input buttons
+input[type="button"],
+input[type="reset"],
+input[type="submit"] {
+  width: auto;
+  height: auto;
+}
+
+// Set the height of select and file controls to match text inputs
+select,
+input[type="file"] {
+  height: 28px; /* In IE7, the height of the select element cannot be changed by height, only font-size */
+  *margin-top: 4px; /* For IE7, add top margin to align select with labels */
+  line-height: 28px;
+}
+
+// Reset line-height for IE
+input[type="file"] {
+  line-height: 18px \9;
+}
+
+// Chrome on Linux and Mobile Safari need background-color
+select {
+  width: 220px; // default input width + 10px of padding that doesn't get applied
+  background-color: @inputBackground;
+}
+
+// Make multiple select elements height not fixed
+select[multiple],
+select[size] {
+  height: auto;
+}
+
+// Remove shadow from image inputs
+input[type="image"] {
+  .box-shadow(none);
+}
+
+// Make textarea height behave
+textarea {
+  height: auto;
+}
+
+// Hidden inputs
+input[type="hidden"] {
+  display: none;
+}
+
+
+
+// CHECKBOXES & RADIOS
+// -------------------
+
+// Indent the labels to position radios/checkboxes as hanging
+.radio,
+.checkbox {
+  padding-left: 18px;
+}
+.radio input[type="radio"],
+.checkbox input[type="checkbox"] {
+  float: left;
+  margin-left: -18px;
+}
+
+// Move the options list down to align with labels
+.controls > .radio:first-child,
+.controls > .checkbox:first-child {
+  padding-top: 5px; // has to be padding because margin collaspes
+}
+
+// Radios and checkboxes on same line
+// TODO v3: Convert .inline to .control-inline
+.radio.inline,
+.checkbox.inline {
+  display: inline-block;
+  padding-top: 5px;
+  margin-bottom: 0;
+  vertical-align: middle;
+}
+.radio.inline + .radio.inline,
+.checkbox.inline + .checkbox.inline {
+  margin-left: 10px; // space out consecutive inline controls
+}
+
+
+
+// FOCUS STATE
+// -----------
+
+input,
+textarea {
+  .box-shadow(inset 0 1px 1px rgba(0,0,0,.075));
+  @transition: border linear .2s, box-shadow linear .2s;
+  .transition(@transition);
+}
+input:focus,
+textarea:focus {
+  border-color: rgba(82,168,236,.8);
+  @shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(82,168,236,.6);
+  .box-shadow(@shadow);
+  outline: 0;
+  outline: thin dotted \9; /* IE6-9 */
+}
+input[type="file"]:focus,
+input[type="radio"]:focus,
+input[type="checkbox"]:focus,
+select:focus {
+  .box-shadow(none); // override for file inputs
+  .tab-focus();
+}
+
+
+
+// INPUT SIZES
+// -----------
+
+// General classes for quick sizes
+.input-mini       { width: 60px; }
+.input-small      { width: 90px; }
+.input-medium     { width: 150px; }
+.input-large      { width: 210px; }
+.input-xlarge     { width: 270px; }
+.input-xxlarge    { width: 530px; }
+
+// Grid style input sizes
+input[class*="span"],
+select[class*="span"],
+textarea[class*="span"],
+.uneditable-input {
+  float: none;
+  margin-left: 0;
+}
+
+
+
+// GRID SIZING FOR INPUTS
+// ----------------------
+
+#grid > .input (@gridColumnWidth, @gridGutterWidth);
+
+
+
+
+// DISABLED STATE
+// --------------
+
+// Disabled and read-only inputs
+input[disabled],
+select[disabled],
+textarea[disabled],
+input[readonly],
+select[readonly],
+textarea[readonly] {
+  background-color: @inputDisabledBackground;
+  border-color: #ddd;
+  cursor: not-allowed;
+}
+
+
+
+
+// FORM FIELD FEEDBACK STATES
+// --------------------------
+
+// Warning
+.control-group.warning {
+  .formFieldState(@warningText, @warningText, @warningBackground);
+}
+// Error
+.control-group.error {
+  .formFieldState(@errorText, @errorText, @errorBackground);
+}
+// Success
+.control-group.success {
+  .formFieldState(@successText, @successText, @successBackground);
+}
+
+// HTML5 invalid states
+// Shares styles with the .control-group.error above
+input:focus:required:invalid,
+textarea:focus:required:invalid,
+select:focus:required:invalid {
+  color: #b94a48;
+  border-color: #ee5f5b;
+  &:focus {
+    border-color: darken(#ee5f5b, 10%);
+    .box-shadow(0 0 6px lighten(#ee5f5b, 20%));
+  }
+}
+
+
+
+// FORM ACTIONS
+// ------------
+
+.form-actions {
+  padding: (@baseLineHeight - 1) 20px @baseLineHeight;
+  margin-top: @baseLineHeight;
+  margin-bottom: @baseLineHeight;
+  background-color: @grayLighter;
+  border-top: 1px solid #ddd;
+  .clearfix(); // Adding clearfix to allow for .pull-right button containers
+}
+
+// For text that needs to appear as an input but should not be an input
+.uneditable-input {
+  display: block;
+  background-color: @inputBackground;
+  border-color: #eee;
+  .box-shadow(inset 0 1px 2px rgba(0,0,0,.025));
+  cursor: not-allowed;
+}
+
+// Placeholder text gets special styles; can't be bundled together though for some reason
+.placeholder(@grayLight);
+
+
+
+// HELP TEXT
+// ---------
+
+.help-block,
+.help-inline {
+  color: @gray; // lighten the text some for contrast
+}
+
+.help-block {
+  display: block; // account for any element using help-block
+  margin-bottom: @baseLineHeight / 2;
+}
+
+.help-inline {
+  display: inline-block;
+  .ie7-inline-block();
+  vertical-align: middle;
+  padding-left: 5px;
+}
+
+
+
+// INPUT GROUPS
+// ------------
+
+// Allow us to put symbols and text within the input field for a cleaner look
+.input-prepend,
+.input-append {
+  margin-bottom: 5px;
+  input,
+  select,
+  .uneditable-input {
+    *margin-left: 0;
+    .border-radius(0 3px 3px 0);
+    &:focus {
+      position: relative;
+      z-index: 2;
+    }
+  }
+  .uneditable-input {
+    border-left-color: #ccc;
+  }
+  .add-on {
+    display: inline-block;
+    width: auto;
+    min-width: 16px;
+    height: @baseLineHeight;
+    padding: 4px 5px;
+    font-weight: normal;
+    line-height: @baseLineHeight;
+    text-align: center;
+    text-shadow: 0 1px 0 @white;
+    vertical-align: middle;
+    background-color: @grayLighter;
+    border: 1px solid #ccc;
+  }
+  .add-on,
+  .btn {
+    .border-radius(3px 0 0 3px);
+  }
+  .active {
+    background-color: lighten(@green, 30);
+    border-color: @green;
+  }
+}
+.input-prepend {
+  .add-on,
+  .btn {
+    margin-right: -1px;
+  }
+}
+.input-append {
+  input,
+  select
+  .uneditable-input {
+    .border-radius(3px 0 0 3px);
+  }
+  .uneditable-input {
+    border-left-color: #eee;
+    border-right-color: #ccc;
+  }
+  .add-on,
+  .btn {
+    margin-left: -1px;
+    .border-radius(0 3px 3px 0);
+  }
+}
+// Remove all border-radius for inputs with both prepend and append
+.input-prepend.input-append {
+  input,
+  select,
+  .uneditable-input {
+    .border-radius(0);
+  }
+  .add-on:first-child,
+  .btn:first-child {
+    margin-right: -1px;
+    .border-radius(3px 0 0 3px);
+  }
+  .add-on:last-child,
+  .btn:last-child {
+    margin-left: -1px;
+    .border-radius(0 3px 3px 0);
+  }
+}
+
+
+
+// SEARCH FORM
+// -----------
+
+.search-query {
+  padding-left: 14px;
+  padding-right: 14px;
+  margin-bottom: 0; // remove the default margin on all inputs
+  .border-radius(14px);
+}
+
+
+
+// HORIZONTAL & VERTICAL FORMS
+// ---------------------------
+
+// Common properties
+// -----------------
+
+.form-search,
+.form-inline,
+.form-horizontal {
+  input,
+  textarea,
+  select,
+  .help-inline,
+  .uneditable-input,
+  .input-prepend,
+  .input-append {
+    display: inline-block;
+    margin-bottom: 0;
+  }
+  // Re-hide hidden elements due to specifity
+  .hide {
+    display: none;
+  }
+}
+.form-search label,
+.form-inline label {
+  display: inline-block;
+}
+// Remove margin for input-prepend/-append
+.form-search .input-append,
+.form-inline .input-append,
+.form-search .input-prepend,
+.form-inline .input-prepend {
+  margin-bottom: 0;
+}
+// Inline checkbox/radio labels (remove padding on left)
+.form-search .radio,
+.form-search .checkbox,
+.form-inline .radio,
+.form-inline .checkbox {
+  padding-left: 0;
+  margin-bottom: 0;
+  vertical-align: middle;
+}
+// Remove float and margin, set to inline-block
+.form-search .radio input[type="radio"],
+.form-search .checkbox input[type="checkbox"],
+.form-inline .radio input[type="radio"],
+.form-inline .checkbox input[type="checkbox"] {
+  float: left;
+  margin-left: 0;
+  margin-right: 3px;
+}
+
+
+// Margin to space out fieldsets
+.control-group {
+  margin-bottom: @baseLineHeight / 2;
+}
+
+// Legend collapses margin, so next element is responsible for spacing
+legend + .control-group {
+  margin-top: @baseLineHeight;
+  -webkit-margin-top-collapse: separate;
+}
+
+// Horizontal-specific styles
+// --------------------------
+
+.form-horizontal {
+  // Increase spacing between groups
+  .control-group {
+    margin-bottom: @baseLineHeight;
+    .clearfix();
+  }
+  // Float the labels left
+  .control-label {
+    float: left;
+    width: 140px;
+    padding-top: 5px;
+    text-align: right;
+  }
+  // Move over all input controls and content
+  .controls {
+    margin-left: 160px;
+    /* Super jank IE7 fix to ensure the inputs in .input-append and input-prepend don't inherit the margin of the parent, in this case .controls */
+    *display: inline-block;
+    *margin-left: 0;
+    *padding-left: 20px;
+  }
+  // Remove bottom margin on block level help text since that's accounted for on .control-group
+  .help-block {
+    margin-top: @baseLineHeight / 2;
+    margin-bottom: 0;
+  }
+  // Move over buttons in .form-actions to align with .controls
+  .form-actions {
+    padding-left: 160px;
+  }
+}

vendor/alchemy/mediavorus/docs/_static/less/grid.less

@@ -0,0 +1,5 @@
+// Fixed (940px)
+#grid > .core(@gridColumnWidth, @gridGutterWidth);
+
+// Fluid (940px)
+#grid > .fluid(@fluidGridColumnWidth, @fluidGridGutterWidth);

vendor/alchemy/mediavorus/docs/_static/less/hero-unit.less

@@ -0,0 +1,22 @@
+// HERO UNIT
+// ---------
+
+.hero-unit {
+  padding: 60px;
+  margin-bottom: 30px;
+  background-color: @heroUnitBackground;
+  .border-radius(6px);
+  h1 {
+    margin-bottom: 0;
+    font-size: 60px;
+    line-height: 1;
+    color: @heroUnitHeadingColor;
+    letter-spacing: -1px;
+  }
+  p {
+    font-size: 18px;
+    font-weight: 200;
+    line-height: @baseLineHeight * 1.5;
+    color: @heroUnitLeadColor;
+  }
+}

vendor/alchemy/mediavorus/docs/_static/less/labels.less

@@ -0,0 +1,38 @@
+// LABELS
+// ------
+
+// Base
+.label {
+  padding: 1px 4px 2px;
+  font-size: @baseFontSize * .846;
+  font-weight: bold;
+  line-height: 13px; // ensure proper line-height if floated
+  color: @white;
+  vertical-align: middle;
+  white-space: nowrap;
+  text-shadow: 0 -1px 0 rgba(0,0,0,.25);
+  background-color: @grayLight;
+  .border-radius(3px);
+}
+
+// Hover state
+.label:hover {
+  color: @white;
+  text-decoration: none;
+}
+
+// Colors
+.label-important        { background-color: @errorText; }
+.label-important:hover  { background-color: darken(@errorText, 10%); }
+
+.label-warning          { background-color: @orange; }
+.label-warning:hover    { background-color: darken(@orange, 10%); }
+
+.label-success          { background-color: @successText; }
+.label-success:hover    { background-color: darken(@successText, 10%); }
+
+.label-info             { background-color: @infoText; }
+.label-info:hover       { background-color: darken(@infoText, 10%); }
+
+.label-inverse             { background-color: @grayDark; }
+.label-inverse:hover       { background-color: darken(@grayDark, 10%); }

vendor/alchemy/mediavorus/docs/_static/less/layouts.less

@@ -0,0 +1,17 @@
+//
+// Layouts
+// Fixed-width and fluid (with sidebar) layouts
+// --------------------------------------------
+
+
+// Container (centered, fixed-width layouts)
+.container {
+  .container-fixed();
+}
+
+// Fluid layouts (left aligned, with sidebar, min- & max-width content)
+.container-fluid {
+  padding-left: @gridGutterWidth;
+  padding-right: @gridGutterWidth;
+  .clearfix();
+}

vendor/alchemy/mediavorus/docs/_static/less/mixins.less

@@ -0,0 +1,614 @@
+// Mixins.less
+// Snippets of reusable CSS to develop faster and keep code readable
+// -----------------------------------------------------------------
+
+
+// UTILITY MIXINS
+// --------------------------------------------------
+
+// Clearfix
+// --------
+// For clearing floats like a boss h5bp.com/q
+.clearfix {
+  *zoom: 1;
+  &:before,
+  &:after {
+    display: table;
+    content: "";
+  }
+  &:after {
+    clear: both;
+  }
+}
+
+// Webkit-style focus
+// ------------------
+.tab-focus() {
+  // Default
+  outline: thin dotted #333;
+  // Webkit
+  outline: 5px auto -webkit-focus-ring-color;
+  outline-offset: -2px;
+}
+
+// Center-align a block level element
+// ----------------------------------
+.center-block() {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+// IE7 inline-block
+// ----------------
+.ie7-inline-block() {
+  *display: inline; /* IE7 inline-block hack */
+  *zoom: 1;
+}
+
+// IE7 likes to collapse whitespace on either side of the inline-block elements.
+// Ems because we're attempting to match the width of a space character. Left
+// version is for form buttons, which typically come after other elements, and
+// right version is for icons, which come before. Applying both is ok, but it will
+// mean that space between those elements will be .6em (~2 space characters) in IE7,
+// instead of the 1 space in other browsers.
+.ie7-restore-left-whitespace() {
+  *margin-left: .3em;
+
+  &:first-child {
+    *margin-left: 0;
+  }
+}
+
+.ie7-restore-right-whitespace() {
+  *margin-right: .3em;
+
+  &:last-child {
+    *margin-left: 0;
+  }
+}
+
+// Sizing shortcuts
+// -------------------------
+.size(@height: 5px, @width: 5px) {
+  width: @width;
+  height: @height;
+}
+.square(@size: 5px) {
+  .size(@size, @size);
+}
+
+// Placeholder text
+// -------------------------
+.placeholder(@color: @placeholderText) {
+  :-moz-placeholder {
+    color: @color;
+  }
+  ::-webkit-input-placeholder {
+    color: @color;
+  }
+}
+
+// Text overflow
+// -------------------------
+// Requires inline-block or block for proper styling
+.text-overflow() {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+// New image replacement
+// -------------------------
+// Source: http://www.zeldman.com/2012/03/01/replacing-the-9999px-hack-new-image-replacement/
+.hide-text {
+  overflow: hidden;
+  text-indent: 100%;
+  white-space: nowrap;
+}
+
+
+// FONTS
+// --------------------------------------------------
+
+#font {
+  #family {
+    .serif() {
+      font-family: Georgia, "Times New Roman", Times, serif;
+    }
+    .sans-serif() {
+      font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    }
+    .monospace() {
+      font-family: Menlo, Monaco, "Courier New", monospace;
+    }
+  }
+  .shorthand(@size: @baseFontSize, @weight: normal, @lineHeight: @baseLineHeight) {
+    font-size: @size;
+    font-weight: @weight;
+    line-height: @lineHeight;
+  }
+  .serif(@size: @baseFontSize, @weight: normal, @lineHeight: @baseLineHeight) {
+    #font > #family > .serif;
+    #font > .shorthand(@size, @weight, @lineHeight);
+  }
+  .sans-serif(@size: @baseFontSize, @weight: normal, @lineHeight: @baseLineHeight) {
+    #font > #family > .sans-serif;
+    #font > .shorthand(@size, @weight, @lineHeight);
+  }
+  .monospace(@size: @baseFontSize, @weight: normal, @lineHeight: @baseLineHeight) {
+    #font > #family > .monospace;
+    #font > .shorthand(@size, @weight, @lineHeight);
+  }
+}
+
+
+// FORMS
+// --------------------------------------------------
+
+// Block level inputs
+.input-block-level {
+  display: block;
+  width: 100%;
+  min-height: 28px; /* Make inputs at least the height of their button counterpart */
+  /* Makes inputs behave like true block-level elements */
+  .box-sizing(border-box);
+}
+
+
+// Mixin for form field states
+.formFieldState(@textColor: #555, @borderColor: #ccc, @backgroundColor: #f5f5f5) {
+  // Set the text color
+  > label,
+  .help-block,
+  .help-inline {
+    color: @textColor;
+  }
+  // Style inputs accordingly
+  input,
+  select,
+  textarea {
+    color: @textColor;
+    border-color: @borderColor;
+    &:focus {
+      border-color: darken(@borderColor, 10%);
+      .box-shadow(0 0 6px lighten(@borderColor, 20%));
+    }
+  }
+  // Give a small background color for input-prepend/-append
+  .input-prepend .add-on,
+  .input-append .add-on {
+    color: @textColor;
+    background-color: @backgroundColor;
+    border-color: @textColor;
+  }
+}
+
+
+
+// CSS3 PROPERTIES
+// --------------------------------------------------
+
+// Border Radius
+.border-radius(@radius: 5px) {
+  -webkit-border-radius: @radius;
+     -moz-border-radius: @radius;
+          border-radius: @radius;
+}
+
+// Drop shadows
+.box-shadow(@shadow: 0 1px 3px rgba(0,0,0,.25)) {
+  -webkit-box-shadow: @shadow;
+     -moz-box-shadow: @shadow;
+          box-shadow: @shadow;
+}
+
+// Transitions
+.transition(@transition) {
+  -webkit-transition: @transition;
+     -moz-transition: @transition;
+      -ms-transition: @transition;
+       -o-transition: @transition;
+          transition: @transition;
+}
+
+// Transformations
+.rotate(@degrees) {
+  -webkit-transform: rotate(@degrees);
+     -moz-transform: rotate(@degrees);
+      -ms-transform: rotate(@degrees);
+       -o-transform: rotate(@degrees);
+          transform: rotate(@degrees);
+}
+.scale(@ratio) {
+  -webkit-transform: scale(@ratio);
+     -moz-transform: scale(@ratio);
+      -ms-transform: scale(@ratio);
+       -o-transform: scale(@ratio);
+          transform: scale(@ratio);
+}
+.translate(@x: 0, @y: 0) {
+  -webkit-transform: translate(@x, @y);
+     -moz-transform: translate(@x, @y);
+      -ms-transform: translate(@x, @y);
+       -o-transform: translate(@x, @y);
+          transform: translate(@x, @y);
+}
+.skew(@x: 0, @y: 0) {
+  -webkit-transform: skew(@x, @y);
+     -moz-transform: skew(@x, @y);
+      -ms-transform: skew(@x, @y);
+       -o-transform: skew(@x, @y);
+          transform: skew(@x, @y);
+}
+.translate3d(@x: 0, @y: 0, @z: 0) {
+  -webkit-transform: translate(@x, @y, @z);
+     -moz-transform: translate(@x, @y, @z);
+      -ms-transform: translate(@x, @y, @z);
+       -o-transform: translate(@x, @y, @z);
+          transform: translate(@x, @y, @z);
+}
+
+// Background clipping
+// Heads up: FF 3.6 and under need "padding" instead of "padding-box"
+.background-clip(@clip) {
+  -webkit-background-clip: @clip;
+     -moz-background-clip: @clip;
+          background-clip: @clip;
+}
+
+// Background sizing
+.background-size(@size){
+  -webkit-background-size: @size;
+     -moz-background-size: @size;
+       -o-background-size: @size;
+          background-size: @size;
+}
+
+
+// Box sizing
+.box-sizing(@boxmodel) {
+  -webkit-box-sizing: @boxmodel;
+     -moz-box-sizing: @boxmodel;
+      -ms-box-sizing: @boxmodel;
+          box-sizing: @boxmodel;
+}
+
+// User select
+// For selecting text on the page
+.user-select(@select) {
+  -webkit-user-select: @select;
+     -moz-user-select: @select;
+       -o-user-select: @select;
+          user-select: @select;
+}
+
+// Resize anything
+.resizable(@direction: both) {
+  resize: @direction; // Options: horizontal, vertical, both
+  overflow: auto; // Safari fix
+}
+
+// CSS3 Content Columns
+.content-columns(@columnCount, @columnGap: @gridColumnGutter) {
+  -webkit-column-count: @columnCount;
+     -moz-column-count: @columnCount;
+          column-count: @columnCount;
+  -webkit-column-gap: @columnGap;
+     -moz-column-gap: @columnGap;
+          column-gap: @columnGap;
+}
+
+// Opacity
+.opacity(@opacity: 100) {
+  opacity: @opacity / 100;
+   filter: ~"alpha(opacity=@{opacity})";
+}
+
+
+
+// BACKGROUNDS
+// --------------------------------------------------
+
+// Add an alphatransparency value to any background or border color (via Elyse Holladay)
+#translucent {
+  .background(@color: @white, @alpha: 1) {
+    background-color: hsla(hue(@color), saturation(@color), lightness(@color), @alpha);
+  }
+  .border(@color: @white, @alpha: 1) {
+    border-color: hsla(hue(@color), saturation(@color), lightness(@color), @alpha);
+    .background-clip(padding-box);
+  }
+}
+
+// Gradient Bar Colors for buttons and alerts
+.gradientBar(@primaryColor, @secondaryColor) {
+  #gradient > .vertical(@primaryColor, @secondaryColor);
+  border-color: @secondaryColor @secondaryColor darken(@secondaryColor, 15%);
+  border-color: rgba(0,0,0,.1) rgba(0,0,0,.1) fadein(rgba(0,0,0,.1), 15%);
+}
+
+// Gradients
+#gradient {
+  .horizontal(@startColor: #555, @endColor: #333) {
+    background-color: @endColor;
+    background-image: -moz-linear-gradient(left, @startColor, @endColor); // FF 3.6+
+    background-image: -ms-linear-gradient(left, @startColor, @endColor); // IE10
+    background-image: -webkit-gradient(linear, 0 0, 100% 0, from(@startColor), to(@endColor)); // Safari 4+, Chrome 2+
+    background-image: -webkit-linear-gradient(left, @startColor, @endColor); // Safari 5.1+, Chrome 10+
+    background-image: -o-linear-gradient(left, @startColor, @endColor); // Opera 11.10
+    background-image: linear-gradient(left, @startColor, @endColor); // Le standard
+    background-repeat: repeat-x;
+    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=1)",@startColor,@endColor)); // IE9 and down
+  }
+  .vertical(@startColor: #555, @endColor: #333) {
+    background-color: mix(@startColor, @endColor, 60%);
+    background-image: -moz-linear-gradient(top, @startColor, @endColor); // FF 3.6+
+    background-image: -ms-linear-gradient(top, @startColor, @endColor); // IE10
+    background-image: -webkit-gradient(linear, 0 0, 0 100%, from(@startColor), to(@endColor)); // Safari 4+, Chrome 2+
+    background-image: -webkit-linear-gradient(top, @startColor, @endColor); // Safari 5.1+, Chrome 10+
+    background-image: -o-linear-gradient(top, @startColor, @endColor); // Opera 11.10
+    background-image: linear-gradient(top, @startColor, @endColor); // The standard
+    background-repeat: repeat-x;
+    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=0)",@startColor,@endColor)); // IE9 and down
+  }
+  .directional(@startColor: #555, @endColor: #333, @deg: 45deg) {
+    background-color: @endColor;
+    background-repeat: repeat-x;
+    background-image: -moz-linear-gradient(@deg, @startColor, @endColor); // FF 3.6+
+    background-image: -ms-linear-gradient(@deg, @startColor, @endColor); // IE10
+    background-image: -webkit-linear-gradient(@deg, @startColor, @endColor); // Safari 5.1+, Chrome 10+
+    background-image: -o-linear-gradient(@deg, @startColor, @endColor); // Opera 11.10
+    background-image: linear-gradient(@deg, @startColor, @endColor); // The standard
+  }
+  .vertical-three-colors(@startColor: #00b3ee, @midColor: #7a43b6, @colorStop: 50%, @endColor: #c3325f) {
+    background-color: mix(@midColor, @endColor, 80%);
+    background-image: -webkit-gradient(linear, 0 0, 0 100%, from(@startColor), color-stop(@colorStop, @midColor), to(@endColor));
+    background-image: -webkit-linear-gradient(@startColor, @midColor @colorStop, @endColor);
+    background-image: -moz-linear-gradient(top, @startColor, @midColor @colorStop, @endColor);
+    background-image: -ms-linear-gradient(@startColor, @midColor @colorStop, @endColor);
+    background-image: -o-linear-gradient(@startColor, @midColor @colorStop, @endColor);
+    background-image: linear-gradient(@startColor, @midColor @colorStop, @endColor);
+    background-repeat: no-repeat;
+    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=0)",@startColor,@endColor)); // IE9 and down, gets no color-stop at all for proper fallback
+  }
+  .radial(@innerColor: #555, @outerColor: #333)  {
+    background-color: @outerColor;
+    background-image: -webkit-gradient(radial, center center, 0, center center, 460, from(@innerColor), to(@outerColor));
+    background-image: -webkit-radial-gradient(circle, @innerColor, @outerColor);
+    background-image: -moz-radial-gradient(circle, @innerColor, @outerColor);
+    background-image: -ms-radial-gradient(circle, @innerColor, @outerColor);
+    background-image: -o-radial-gradient(circle, @innerColor, @outerColor);
+    background-repeat: no-repeat;
+  }
+  .striped(@color, @angle: -45deg) {
+    background-color: @color;
+    background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(.25, rgba(255,255,255,.15)), color-stop(.25, transparent), color-stop(.5, transparent), color-stop(.5, rgba(255,255,255,.15)), color-stop(.75, rgba(255,255,255,.15)), color-stop(.75, transparent), to(transparent));
+    background-image: -webkit-linear-gradient(@angle, rgba(255,255,255,.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,.15) 50%, rgba(255,255,255,.15) 75%, transparent 75%, transparent);
+    background-image: -moz-linear-gradient(@angle, rgba(255,255,255,.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,.15) 50%, rgba(255,255,255,.15) 75%, transparent 75%, transparent);
+    background-image: -ms-linear-gradient(@angle, rgba(255,255,255,.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,.15) 50%, rgba(255,255,255,.15) 75%, transparent 75%, transparent);
+    background-image: -o-linear-gradient(@angle, rgba(255,255,255,.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,.15) 50%, rgba(255,255,255,.15) 75%, transparent 75%, transparent);
+    background-image: linear-gradient(@angle, rgba(255,255,255,.15) 25%, transparent 25%, transparent 50%, rgba(255,255,255,.15) 50%, rgba(255,255,255,.15) 75%, transparent 75%, transparent);
+  }
+}
+// Reset filters for IE
+.reset-filter() {
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
+
+
+
+// COMPONENT MIXINS
+// --------------------------------------------------
+
+// Horizontal dividers
+// -------------------------
+// Dividers (basically an hr) within dropdowns and nav lists
+.nav-divider() {
+  height: 1px;
+  margin: ((@baseLineHeight / 2) - 1) 1px; // 8px 1px
+  overflow: hidden;
+  background-color: #e5e5e5;
+  border-bottom: 1px solid @white;
+
+  // IE7 needs a set width since we gave a height. Restricting just
+  // to IE7 to keep the 1px left/right space in other browsers.
+  // It is unclear where IE is getting the extra space that we need
+  // to negative-margin away, but so it goes.
+  *width: 100%;
+  *margin: -5px 0 5px;
+}
+
+// Button backgrounds
+// ------------------
+.buttonBackground(@startColor, @endColor) {
+  // gradientBar will set the background to a pleasing blend of these, to support IE<=9
+  .gradientBar(@startColor, @endColor);
+  .reset-filter();
+
+  // in these cases the gradient won't cover the background, so we override
+  &:hover, &:active, &.active, &.disabled, &[disabled] {
+    background-color: @endColor;
+  }
+
+  // IE 7 + 8 can't handle box-shadow to show active, so we darken a bit ourselves
+  &:active,
+  &.active {
+    background-color: darken(@endColor, 10%) e("\9");
+  }
+}
+
+// Navbar vertical align
+// -------------------------
+// Vertically center elements in the navbar.
+// Example: an element has a height of 30px, so write out `.navbarVerticalAlign(30px);` to calculate the appropriate top margin.
+.navbarVerticalAlign(@elementHeight) {
+  margin-top: (@navbarHeight - @elementHeight) / 2;
+}
+
+// Popover arrows
+// -------------------------
+// For tipsies and popovers
+#popoverArrow {
+  .top(@arrowWidth: 5px, @color: @black) {
+    bottom: 0;
+    left: 50%;
+    margin-left: -@arrowWidth;
+    border-left: @arrowWidth solid transparent;
+    border-right: @arrowWidth solid transparent;
+    border-top: @arrowWidth solid @color;
+  }
+  .left(@arrowWidth: 5px, @color: @black) {
+    top: 50%;
+    right: 0;
+    margin-top: -@arrowWidth;
+    border-top: @arrowWidth solid transparent;
+    border-bottom: @arrowWidth solid transparent;
+    border-left: @arrowWidth solid @color;
+  }
+  .bottom(@arrowWidth: 5px, @color: @black) {
+    top: 0;
+    left: 50%;
+    margin-left: -@arrowWidth;
+    border-left: @arrowWidth solid transparent;
+    border-right: @arrowWidth solid transparent;
+    border-bottom: @arrowWidth solid @color;
+  }
+  .right(@arrowWidth: 5px, @color: @black) {
+    top: 50%;
+    left: 0;
+    margin-top: -@arrowWidth;
+    border-top: @arrowWidth solid transparent;
+    border-bottom: @arrowWidth solid transparent;
+    border-right: @arrowWidth solid @color;
+  }
+}
+
+// Grid System
+// -----------
+
+// Centered container element
+.container-fixed() {
+  margin-left: auto;
+  margin-right: auto;
+  .clearfix();
+}
+
+// Table columns
+.tableColumns(@columnSpan: 1) {
+  float: none; // undo default grid column styles
+  width: ((@gridColumnWidth) * @columnSpan) + (@gridGutterWidth * (@columnSpan - 1)) - 16; // 16 is total padding on left and right of table cells
+  margin-left: 0; // undo default grid column styles
+}
+
+// Make a Grid
+// Use .makeRow and .makeColumn to assign semantic layouts grid system behavior
+.makeRow() {
+  margin-left: @gridGutterWidth * -1;
+  .clearfix();
+}
+.makeColumn(@columns: 1) {
+  float: left;
+  margin-left: @gridGutterWidth;
+  width: (@gridColumnWidth * @columns) + (@gridGutterWidth * (@columns - 1));
+}
+
+// The Grid
+#grid {
+
+  .core (@gridColumnWidth, @gridGutterWidth) {
+
+    .spanX (@index) when (@index > 0) {
+      (~".span@{index}") { .span(@index); }
+      .spanX(@index - 1);
+    }
+    .spanX (0) {}
+
+    .offsetX (@index) when (@index > 0) {
+      (~".offset@{index}") { .offset(@index); }
+      .offsetX(@index - 1);
+    }
+    .offsetX (0) {}
+
+    .offset (@columns) {
+      margin-left: (@gridColumnWidth * @columns) + (@gridGutterWidth * (@columns - 1)) + (@gridGutterWidth * 2);
+    }
+
+    .span (@columns) {
+      width: (@gridColumnWidth * @columns) + (@gridGutterWidth * (@columns - 1));
+    }
+
+    .row {
+      margin-left: @gridGutterWidth * -1;
+      .clearfix();
+    }
+
+    [class*="span"] {
+      float: left;
+      margin-left: @gridGutterWidth;
+    }
+
+    // Set the container width, and override it for fixed navbars in media queries
+    .container,
+    .navbar-fixed-top .container,
+    .navbar-fixed-bottom .container { .span(@gridColumns); }
+
+    // generate .spanX and .offsetX
+    .spanX (@gridColumns);
+    .offsetX (@gridColumns);
+
+  }
+
+  .fluid (@fluidGridColumnWidth, @fluidGridGutterWidth) {
+
+    .spanX (@index) when (@index > 0) {
+      (~"> .span@{index}") { .span(@index); }
+      .spanX(@index - 1);
+    }
+    .spanX (0) {}
+
+    .span (@columns) {
+      width: (@fluidGridColumnWidth * @columns) + (@fluidGridGutterWidth * (@columns - 1));
+    }
+
+    .row-fluid {
+      width: 100%;
+      .clearfix();
+      > [class*="span"] {
+        float: left;
+        margin-left: @fluidGridGutterWidth;
+      }
+      > [class*="span"]:first-child {
+        margin-left: 0;
+      }
+
+      // generate .spanX
+      .spanX (@gridColumns);
+    }
+
+  }
+
+  .input(@gridColumnWidth, @gridGutterWidth) {
+
+    .spanX (@index) when (@index > 0) {
+      (~"input.span@{index}, textarea.span@{index}, .uneditable-input.span@{index}") { .span(@index); }
+      .spanX(@index - 1);
+    }
+    .spanX (0) {}
+
+    .span(@columns) {
+      width: ((@gridColumnWidth) * @columns) + (@gridGutterWidth * (@columns - 1)) - 10;
+    }
+
+    input,
+    textarea,
+    .uneditable-input {
+      margin-left: 0; // override margin-left from core grid system
+    }
+
+    // generate .spanX
+    .spanX (@gridColumns);
+
+  }
+
+}

vendor/alchemy/mediavorus/docs/_static/less/modals.less

@@ -0,0 +1,90 @@
+// MODALS
+// ------
+
+// Recalculate z-index where appropriate
+.modal-open {
+  .dropdown-menu {  z-index: @zindexDropdown + @zindexModal; }
+  .dropdown.open { *z-index: @zindexDropdown + @zindexModal; }
+  .popover       {  z-index: @zindexPopover  + @zindexModal; }
+  .tooltip       {  z-index: @zindexTooltip  + @zindexModal; }
+}
+
+// Background
+.modal-backdrop {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: @zindexModalBackdrop;
+  background-color: @black;
+  // Fade for backdrop
+  &.fade { opacity: 0; }
+}
+
+.modal-backdrop,
+.modal-backdrop.fade.in {
+  .opacity(80);
+}
+
+// Base modal
+.modal {
+  position: fixed;
+  top: 50%;
+  left: 50%;
+  z-index: @zindexModal;
+  overflow: auto;
+  width: 560px;
+  margin: -250px 0 0 -280px;
+  background-color: @white;
+  border: 1px solid #999;
+  border: 1px solid rgba(0,0,0,.3);
+  *border: 1px solid #999; /* IE6-7 */
+  .border-radius(6px);
+  .box-shadow(0 3px 7px rgba(0,0,0,0.3));
+  .background-clip(padding-box);
+  &.fade {
+    .transition(e('opacity .3s linear, top .3s ease-out'));
+    top: -25%;
+  }
+  &.fade.in { top: 50%; }
+}
+.modal-header {
+  padding: 9px 15px;
+  border-bottom: 1px solid #eee;
+  // Close icon
+  .close { margin-top: 2px; }
+}
+
+// Body (where all modal content resises)
+.modal-body {
+  overflow-y: auto;
+  max-height: 400px;
+  padding: 15px;
+}
+// Remove bottom margin if need be
+.modal-form {
+  margin-bottom: 0;
+}
+
+// Footer (for actions)
+.modal-footer {
+  padding: 14px 15px 15px;
+  margin-bottom: 0;
+  text-align: right; // right align buttons
+  background-color: #f5f5f5;
+  border-top: 1px solid #ddd;
+  .border-radius(0 0 6px 6px);
+  .box-shadow(inset 0 1px 0 @white);
+  .clearfix(); // clear it in case folks use .pull-* classes on buttons
+
+  // Properly space out buttons
+  .btn + .btn {
+    margin-left: 5px;
+    margin-bottom: 0; // account for input[type="submit"] which gets the bottom margin like all other inputs
+  }
+  // but override that for button groups
+  .btn-group .btn + .btn {
+    margin-left: -1px;
+  }
+}

vendor/alchemy/mediavorus/docs/_static/less/navbar.less

@@ -0,0 +1,341 @@
+// NAVBAR (FIXED AND STATIC)
+// -------------------------
+
+
+// COMMON STYLES
+// -------------
+
+.navbar {
+  // Fix for IE7's bad z-indexing so dropdowns don't appear below content that follows the navbar
+  *position: relative;
+  *z-index: 2;
+
+  overflow: visible;
+  margin-bottom: @baseLineHeight;
+}
+
+// Gradient is applied to it's own element because overflow visible is not honored by IE when filter is present
+.navbar-inner {
+  padding-left:  20px;
+  padding-right: 20px;
+  #gradient > .vertical(@navbarBackgroundHighlight, @navbarBackground);
+  .border-radius(4px);
+  @shadow: 0 1px 3px rgba(0,0,0,.25), inset 0 -1px 0 rgba(0,0,0,.1);
+  .box-shadow(@shadow);
+}
+
+// Set width to auto for default container
+// We then reset it for fixed navbars in the #gridSystem mixin
+.navbar .container {
+  width: auto;
+}
+
+// Navbar button for toggling navbar items in responsive layouts
+.btn-navbar {
+  display: none;
+  float: right;
+  padding: 7px 10px;
+  margin-left: 5px;
+  margin-right: 5px;
+  .buttonBackground(@navbarBackgroundHighlight, @navbarBackground);
+  @shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.075);
+  .box-shadow(@shadow);
+}
+.btn-navbar .icon-bar {
+  display: block;
+  width: 18px;
+  height: 2px;
+  background-color: #f5f5f5;
+  .border-radius(1px);
+  .box-shadow(0 1px 0 rgba(0,0,0,.25));
+}
+.btn-navbar .icon-bar + .icon-bar {
+  margin-top: 3px;
+}
+// Override the default collapsed state
+.nav-collapse.collapse {
+  height: auto;
+}
+
+
+// Brand, links, text, and buttons
+.navbar {
+  color: @navbarText;
+  // Hover and active states
+  .brand:hover {
+    text-decoration: none;
+  }
+  // Website or project name
+  .brand {
+    float: left;
+    display: block;
+    padding: 8px 20px 12px;
+    margin-left: -20px; // negative indent to left-align the text down the page
+    font-size: 20px;
+    font-weight: 200;
+    line-height: 1;
+    color: @white;
+  }
+  // Plain text in topbar
+  .navbar-text {
+    margin-bottom: 0;
+    line-height: @navbarHeight;
+  }
+  // Buttons in navbar
+  .btn,
+  .btn-group {
+    .navbarVerticalAlign(30px); // Vertically center in navbar
+  }
+  .btn-group .btn {
+    margin-top: 0; // then undo the margin here so we don't accidentally double it
+  }
+}
+
+// Navbar forms
+.navbar-form {
+  margin-bottom: 0; // remove default bottom margin
+  .clearfix();
+  input,
+  select,
+  .radio,
+  .checkbox {
+    .navbarVerticalAlign(30px); // Vertically center in navbar
+  }
+  input,
+  select {
+    display: inline-block;
+    margin-bottom: 0;
+  }
+  input[type="image"],
+  input[type="checkbox"],
+  input[type="radio"] {
+    margin-top: 3px;
+  }
+  .input-append,
+  .input-prepend {
+    margin-top: 6px;
+    white-space: nowrap; // preven two  items from separating within a .navbar-form that has .pull-left
+    input {
+      margin-top: 0; // remove the margin on top since it's on the parent
+    }
+  }
+}
+
+// Navbar search
+.navbar-search {
+  position: relative;
+  float: left;
+  .navbarVerticalAlign(28px); // Vertically center in navbar
+  margin-bottom: 0;
+  .search-query {
+    padding: 4px 9px;
+    #font > .sans-serif(13px, normal, 1);
+    color: @white;
+    background-color: @navbarSearchBackground;
+    border: 1px solid @navbarSearchBorder;
+    @shadow: inset 0 1px 2px rgba(0,0,0,.1), 0 1px 0px rgba(255,255,255,.15);
+    .box-shadow(@shadow);
+    .transition(none);
+
+    // Placeholder text gets special styles; can't be a grouped selector
+    &:-moz-placeholder {
+      color: @navbarSearchPlaceholderColor;
+    }
+    &::-webkit-input-placeholder {
+      color: @navbarSearchPlaceholderColor;
+    }
+
+    // Focus states (we use .focused since IE7-8 and down doesn't support :focus)
+    &:focus,
+    &.focused {
+      padding: 5px 10px;
+      color: @grayDark;
+      text-shadow: 0 1px 0 @white;
+      background-color: @navbarSearchBackgroundFocus;
+      border: 0;
+      .box-shadow(0 0 3px rgba(0,0,0,.15));
+      outline: 0;
+    }
+  }
+}
+
+
+
+// FIXED NAVBAR
+// ------------
+
+// Shared (top/bottom) styles
+.navbar-fixed-top,
+.navbar-fixed-bottom {
+  position: fixed;
+  right: 0;
+  left: 0;
+  z-index: @zindexFixedNavbar;
+  margin-bottom: 0; // remove 18px margin for static navbar
+}
+.navbar-fixed-top .navbar-inner,
+.navbar-fixed-bottom .navbar-inner {
+  padding-left:  0;
+  padding-right: 0;
+  .border-radius(0);
+}
+
+.navbar-fixed-top .container,
+.navbar-fixed-bottom .container {
+  #grid > .core > .span(@gridColumns);
+}
+
+// Fixed to top
+.navbar-fixed-top {
+  top: 0;
+}
+
+// Fixed to bottom
+.navbar-fixed-bottom {
+  bottom: 0;
+}
+
+
+
+// NAVIGATION
+// ----------
+
+.navbar .nav {
+  position: relative;
+  left: 0;
+  display: block;
+  float: left;
+  margin: 0 10px 0 0;
+}
+.navbar .nav.pull-right {
+  float: right; // redeclare due to specificity
+}
+.navbar .nav > li {
+  display: block;
+  float: left;
+}
+
+// Links
+.navbar .nav > li > a {
+  float: none;
+  padding: 10px 10px 11px;
+  line-height: 19px;
+  color: @navbarLinkColor;
+  text-decoration: none;
+  text-shadow: 0 -1px 0 rgba(0,0,0,.25);
+}
+// Hover
+.navbar .nav > li > a:hover {
+  background-color: @navbarLinkBackgroundHover; // "transparent" is default to differentiate :hover from .active
+  color: @navbarLinkColorHover;
+  text-decoration: none;
+}
+
+// Active nav items
+.navbar .nav .active > a,
+.navbar .nav .active > a:hover {
+  color: @navbarLinkColorActive;
+  text-decoration: none;
+  background-color: @navbarLinkBackgroundActive;
+}
+
+// Dividers (basically a vertical hr)
+.navbar .divider-vertical {
+  height: @navbarHeight;
+  width: 1px;
+  margin: 0 9px;
+  overflow: hidden;
+  background-color: @navbarBackground;
+  border-right: 1px solid @navbarBackgroundHighlight;
+}
+
+// Secondary (floated right) nav in topbar
+.navbar .nav.pull-right {
+  margin-left: 10px;
+  margin-right: 0;
+}
+
+
+
+// Dropdown menus
+// --------------
+
+// Menu position and menu carets
+.navbar .dropdown-menu {
+  margin-top: 1px;
+  .border-radius(4px);
+  &:before {
+    content: '';
+    display: inline-block;
+    border-left:   7px solid transparent;
+    border-right:  7px solid transparent;
+    border-bottom: 7px solid #ccc;
+    border-bottom-color: @dropdownBorder;
+    position: absolute;
+    top: -7px;
+    left: 9px;
+  }
+  &:after {
+    content: '';
+    display: inline-block;
+    border-left:   6px solid transparent;
+    border-right:  6px solid transparent;
+    border-bottom: 6px solid @dropdownBackground;
+    position: absolute;
+    top: -6px;
+    left: 10px;
+  }
+}
+// Menu position and menu caret support for dropups via extra dropup class
+.navbar-fixed-bottom .dropdown-menu {
+  &:before {
+    border-top: 7px solid #ccc;
+    border-top-color: @dropdownBorder;
+    border-bottom: 0;
+    bottom: -7px;
+    top: auto;
+  }
+  &:after {
+    border-top: 6px solid @dropdownBackground;
+    border-bottom: 0;
+    bottom: -6px;
+    top: auto;
+  }
+}
+// Dropdown toggle caret
+.navbar .nav .dropdown-toggle .caret,
+.navbar .nav .open.dropdown .caret {
+  border-top-color: @white;
+  border-bottom-color: @white;
+}
+.navbar .nav .active .caret {
+  .opacity(100);
+}
+
+// Remove background color from open dropdown
+.navbar .nav .open > .dropdown-toggle,
+.navbar .nav .active > .dropdown-toggle,
+.navbar .nav .open.active > .dropdown-toggle {
+  background-color: transparent;
+}
+
+// Dropdown link on hover
+.navbar .nav .active > .dropdown-toggle:hover {
+  color: @white;
+}
+
+// Right aligned menus need alt position
+// TODO: rejigger this at some point to simplify the selectors
+.navbar .nav.pull-right .dropdown-menu,
+.navbar .nav .dropdown-menu.pull-right {
+  left: auto;
+  right: 0;
+  &:before {
+    left: auto;
+    right: 12px;
+  }
+  &:after {
+    left: auto;
+    right: 13px;
+  }
+}

vendor/alchemy/mediavorus/docs/_static/less/navs.less

@@ -0,0 +1,363 @@
+// NAVIGATIONS
+// -----------
+
+
+
+// BASE CLASS
+// ----------
+
+.nav {
+  margin-left: 0;
+  margin-bottom: @baseLineHeight;
+  list-style: none;
+}
+
+// Make links block level
+.nav > li > a {
+  display: block;
+}
+.nav > li > a:hover {
+  text-decoration: none;
+  background-color: @grayLighter;
+}
+
+// Nav headers (for dropdowns and lists)
+.nav .nav-header {
+  display: block;
+  padding: 3px 15px;
+  font-size: 11px;
+  font-weight: bold;
+  line-height: @baseLineHeight;
+  color: @grayLight;
+  text-shadow: 0 1px 0 rgba(255,255,255,.5);
+  text-transform: uppercase;
+}
+// Space them out when they follow another list item (link)
+.nav li + .nav-header {
+  margin-top: 9px;
+}
+
+
+// NAV LIST
+// --------
+
+.nav-list {
+  padding-left: 15px;
+  padding-right: 15px;
+  margin-bottom: 0;
+}
+.nav-list > li > a,
+.nav-list .nav-header {
+  margin-left:  -15px;
+  margin-right: -15px;
+  text-shadow: 0 1px 0 rgba(255,255,255,.5);
+}
+.nav-list > li > a {
+  padding: 3px 15px;
+}
+.nav-list > .active > a,
+.nav-list > .active > a:hover {
+  color: @white;
+  text-shadow: 0 -1px 0 rgba(0,0,0,.2);
+  background-color: @linkColor;
+}
+.nav-list [class^="icon-"] {
+  margin-right: 2px;
+}
+// Dividers (basically an hr) within the dropdown
+.nav-list .divider {
+  .nav-divider();
+}
+
+
+
+// TABS AND PILLS
+// -------------
+
+// Common styles
+.nav-tabs,
+.nav-pills {
+  .clearfix();
+}
+.nav-tabs > li,
+.nav-pills > li {
+  float: left;
+}
+.nav-tabs > li > a,
+.nav-pills > li > a {
+  padding-right: 12px;
+  padding-left: 12px;
+  margin-right: 2px;
+  line-height: 14px; // keeps the overall height an even number
+}
+
+// TABS
+// ----
+
+// Give the tabs something to sit on
+.nav-tabs {
+  border-bottom: 1px solid #ddd;
+}
+
+// Make the list-items overlay the bottom border
+.nav-tabs > li {
+  margin-bottom: -1px;
+}
+
+// Actual tabs (as links)
+.nav-tabs > li > a {
+  padding-top: 8px;
+  padding-bottom: 8px;
+  line-height: @baseLineHeight;
+  border: 1px solid transparent;
+  .border-radius(4px 4px 0 0);
+  &:hover {
+    border-color: @grayLighter @grayLighter #ddd;
+  }
+}
+// Active state, and it's :hover to override normal :hover
+.nav-tabs > .active > a,
+.nav-tabs > .active > a:hover {
+  color: @gray;
+  background-color: @white;
+  border: 1px solid #ddd;
+  border-bottom-color: transparent;
+  cursor: default;
+}
+
+// PILLS
+// -----
+
+// Links rendered as pills
+.nav-pills > li > a {
+  padding-top: 8px;
+  padding-bottom: 8px;
+  margin-top: 2px;
+  margin-bottom: 2px;
+  .border-radius(5px);
+}
+
+// Active state
+.nav-pills > .active > a,
+.nav-pills > .active > a:hover {
+  color: @white;
+  background-color: @linkColor;
+}
+
+
+
+// STACKED NAV
+// -----------
+
+// Stacked tabs and pills
+.nav-stacked > li {
+  float: none;
+}
+.nav-stacked > li > a {
+  margin-right: 0; // no need for the gap between nav items
+}
+
+// Tabs
+.nav-tabs.nav-stacked {
+  border-bottom: 0;
+}
+.nav-tabs.nav-stacked > li > a {
+  border: 1px solid #ddd;
+  .border-radius(0);
+}
+.nav-tabs.nav-stacked > li:first-child > a {
+  .border-radius(4px 4px 0 0);
+}
+.nav-tabs.nav-stacked > li:last-child > a {
+  .border-radius(0 0 4px 4px);
+}
+.nav-tabs.nav-stacked > li > a:hover {
+  border-color: #ddd;
+  z-index: 2;
+}
+
+// Pills
+.nav-pills.nav-stacked > li > a {
+  margin-bottom: 3px;
+}
+.nav-pills.nav-stacked > li:last-child > a {
+  margin-bottom: 1px; // decrease margin to match sizing of stacked tabs
+}
+
+
+
+// DROPDOWNS
+// ---------
+
+// Position the menu
+.nav-tabs .dropdown-menu,
+.nav-pills .dropdown-menu {
+  margin-top: 1px;
+  border-width: 1px;
+}
+.nav-pills .dropdown-menu {
+  .border-radius(4px);
+}
+
+// Default dropdown links
+// -------------------------
+// Make carets use linkColor to start
+.nav-tabs .dropdown-toggle .caret,
+.nav-pills .dropdown-toggle .caret {
+  border-top-color: @linkColor;
+  border-bottom-color: @linkColor;
+  margin-top: 6px;
+}
+.nav-tabs .dropdown-toggle:hover .caret,
+.nav-pills .dropdown-toggle:hover .caret {
+  border-top-color: @linkColorHover;
+  border-bottom-color: @linkColorHover;
+}
+
+// Active dropdown links
+// -------------------------
+.nav-tabs .active .dropdown-toggle .caret,
+.nav-pills .active .dropdown-toggle .caret {
+  border-top-color: @grayDark;
+  border-bottom-color: @grayDark;
+}
+
+// Active:hover dropdown links
+// -------------------------
+.nav > .dropdown.active > a:hover {
+  color: @black;
+  cursor: pointer;
+}
+
+// Open dropdowns
+// -------------------------
+.nav-tabs .open .dropdown-toggle,
+.nav-pills .open .dropdown-toggle,
+.nav > .open.active > a:hover {
+  color: @white;
+  background-color: @grayLight;
+  border-color: @grayLight;
+}
+.nav .open .caret,
+.nav .open.active .caret,
+.nav .open a:hover .caret {
+  border-top-color: @white;
+  border-bottom-color: @white;
+  .opacity(100);
+}
+
+// Dropdowns in stacked tabs
+.tabs-stacked .open > a:hover {
+  border-color: @grayLight;
+}
+
+
+
+// TABBABLE
+// --------
+
+
+// COMMON STYLES
+// -------------
+
+// Clear any floats
+.tabbable {
+  .clearfix();
+}
+.tab-content {
+  display: table; // prevent content from running below tabs
+  width: 100%;
+}
+
+// Remove border on bottom, left, right
+.tabs-below .nav-tabs,
+.tabs-right .nav-tabs,
+.tabs-left .nav-tabs {
+  border-bottom: 0;
+}
+
+// Show/hide tabbable areas
+.tab-content > .tab-pane,
+.pill-content > .pill-pane {
+  display: none;
+}
+.tab-content > .active,
+.pill-content > .active {
+  display: block;
+}
+
+
+// BOTTOM
+// ------
+
+.tabs-below .nav-tabs {
+  border-top: 1px solid #ddd;
+}
+.tabs-below .nav-tabs > li {
+  margin-top: -1px;
+  margin-bottom: 0;
+}
+.tabs-below .nav-tabs > li > a {
+  .border-radius(0 0 4px 4px);
+  &:hover {
+    border-bottom-color: transparent;
+    border-top-color: #ddd;
+  }
+}
+.tabs-below .nav-tabs .active > a,
+.tabs-below .nav-tabs .active > a:hover {
+  border-color: transparent #ddd #ddd #ddd;
+}
+
+// LEFT & RIGHT
+// ------------
+
+// Common styles
+.tabs-left .nav-tabs > li,
+.tabs-right .nav-tabs > li {
+  float: none;
+}
+.tabs-left .nav-tabs > li > a,
+.tabs-right .nav-tabs > li > a {
+  min-width: 74px;
+  margin-right: 0;
+  margin-bottom: 3px;
+}
+
+// Tabs on the left
+.tabs-left .nav-tabs {
+  float: left;
+  margin-right: 19px;
+  border-right: 1px solid #ddd;
+}
+.tabs-left .nav-tabs > li > a {
+  margin-right: -1px;
+  .border-radius(4px 0 0 4px);
+}
+.tabs-left .nav-tabs > li > a:hover {
+  border-color: @grayLighter #ddd @grayLighter @grayLighter;
+}
+.tabs-left .nav-tabs .active > a,
+.tabs-left .nav-tabs .active > a:hover {
+  border-color: #ddd transparent #ddd #ddd;
+  *border-right-color: @white;
+}
+
+// Tabs on the right
+.tabs-right .nav-tabs {
+  float: right;
+  margin-left: 19px;
+  border-left: 1px solid #ddd;
+}
+.tabs-right .nav-tabs > li > a {
+  margin-left: -1px;
+  .border-radius(0 4px 4px 0);
+}
+.tabs-right .nav-tabs > li > a:hover {
+  border-color: @grayLighter @grayLighter @grayLighter #ddd;
+}
+.tabs-right .nav-tabs .active > a,
+.tabs-right .nav-tabs .active > a:hover {
+  border-color: #ddd #ddd #ddd transparent;
+  *border-left-color: @white;
+}

vendor/alchemy/mediavorus/docs/_static/less/pager.less

@@ -0,0 +1,36 @@
+// PAGER
+// -----
+
+.pager {
+  margin-left: 0;
+  margin-bottom: @baseLineHeight;
+  list-style: none;
+  text-align: center;
+  .clearfix();
+}
+.pager li {
+  display: inline;
+}
+.pager a {
+  display: inline-block;
+  padding: 5px 14px;
+  background-color: #fff;
+  border: 1px solid #ddd;
+  .border-radius(15px);
+}
+.pager a:hover {
+  text-decoration: none;
+  background-color: #f5f5f5;
+}
+.pager .next a {
+  float: right;
+}
+.pager .previous a {
+  float: left;
+}
+.pager .disabled a,
+.pager .disabled a:hover {
+  color: @grayLight;
+  background-color: #fff;
+  cursor: default;
+}

vendor/alchemy/mediavorus/docs/_static/less/pagination.less

@@ -0,0 +1,56 @@
+// PAGINATION
+// ----------
+
+.pagination {
+  height: @baseLineHeight * 2;
+  margin: @baseLineHeight 0;
+ }
+.pagination ul {
+  display: inline-block;
+  .ie7-inline-block();
+  margin-left: 0;
+  margin-bottom: 0;
+  .border-radius(3px);
+  .box-shadow(0 1px 2px rgba(0,0,0,.05));
+}
+.pagination li {
+    display: inline;
+  }
+.pagination a {
+  float: left;
+  padding: 0 14px;
+  line-height: (@baseLineHeight * 2) - 2;
+  text-decoration: none;
+  border: 1px solid #ddd;
+  border-left-width: 0;
+}
+.pagination a:hover,
+.pagination .active a {
+  background-color: #f5f5f5;
+}
+.pagination .active a {
+  color: @grayLight;
+  cursor: default;
+}
+.pagination .disabled span,
+.pagination .disabled a,
+.pagination .disabled a:hover {
+  color: @grayLight;
+  background-color: transparent;
+  cursor: default;
+}
+.pagination li:first-child a {
+  border-left-width: 1px;
+  .border-radius(3px 0 0 3px);
+}
+.pagination li:last-child a {
+  .border-radius(0 3px 3px 0);
+}
+
+// Centered
+.pagination-centered {
+  text-align: center;
+}
+.pagination-right {
+  text-align: right;
+}

vendor/alchemy/mediavorus/docs/_static/less/popovers.less

@@ -0,0 +1,49 @@
+// POPOVERS
+// --------
+
+.popover {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: @zindexPopover;
+  display: none;
+  padding: 5px;
+  &.top    { margin-top:  -5px; }
+  &.right  { margin-left:  5px; }
+  &.bottom { margin-top:   5px; }
+  &.left   { margin-left: -5px; }
+  &.top .arrow    { #popoverArrow > .top(); }
+  &.right .arrow  { #popoverArrow > .right(); }
+  &.bottom .arrow { #popoverArrow > .bottom(); }
+  &.left .arrow   { #popoverArrow > .left();  }
+  .arrow {
+    position: absolute;
+    width: 0;
+    height: 0;
+  }
+}
+.popover-inner {
+  padding: 3px;
+  width: 280px;
+  overflow: hidden;
+  background: @black; // has to be full background declaration for IE fallback
+  background: rgba(0,0,0,.8);
+  .border-radius(6px);
+  .box-shadow(0 3px 7px rgba(0,0,0,0.3));
+}
+.popover-title {
+  padding: 9px 15px;
+  line-height: 1;
+  background-color: #f5f5f5;
+  border-bottom:1px solid #eee;
+  .border-radius(3px 3px 0 0);
+}
+.popover-content {
+  padding: 14px;
+  background-color: @white;
+  .border-radius(0 0 3px 3px);
+  .background-clip(padding-box);
+  p, ul, ol {
+    margin-bottom: 0;
+  }
+}

vendor/alchemy/mediavorus/docs/_static/less/progress-bars.less

@@ -0,0 +1,109 @@
+// PROGRESS BARS
+// -------------
+
+
+// ANIMATIONS
+// ----------
+
+// Webkit
+@-webkit-keyframes progress-bar-stripes {
+  from  { background-position: 0 0; }
+  to    { background-position: 40px 0; }
+}
+
+// Firefox
+@-moz-keyframes progress-bar-stripes {
+  from  { background-position: 0 0; }
+  to    { background-position: 40px 0; }
+}
+
+// IE9
+@-ms-keyframes progress-bar-stripes {
+  from  { background-position: 0 0; }
+  to    { background-position: 40px 0; }
+}
+
+// Spec
+@keyframes progress-bar-stripes {
+  from  { background-position: 0 0; }
+  to    { background-position: 40px 0; }
+}
+
+
+
+// THE BARS
+// --------
+
+// Outer container
+.progress {
+  overflow: hidden;
+  height: 18px;
+  margin-bottom: 18px;
+  #gradient > .vertical(#f5f5f5, #f9f9f9);
+  .box-shadow(inset 0 1px 2px rgba(0,0,0,.1));
+  .border-radius(4px);
+}
+
+// Bar of progress
+.progress .bar {
+  width: 0%;
+  height: 18px;
+  color: @white;
+  font-size: 12px;
+  text-align: center;
+  text-shadow: 0 -1px 0 rgba(0,0,0,.25);
+  #gradient > .vertical(#149bdf, #0480be);
+  .box-shadow(inset 0 -1px 0 rgba(0,0,0,.15));
+  .box-sizing(border-box);
+  .transition(width .6s ease);
+}
+
+// Striped bars
+.progress-striped .bar {
+  #gradient > .striped(#149bdf);
+  .background-size(40px 40px);
+}
+
+// Call animation for the active one
+.progress.active .bar {
+  -webkit-animation: progress-bar-stripes 2s linear infinite;
+     -moz-animation: progress-bar-stripes 2s linear infinite;
+          animation: progress-bar-stripes 2s linear infinite;
+}
+
+
+
+// COLORS
+// ------
+
+// Danger (red)
+.progress-danger .bar {
+  #gradient > .vertical(#ee5f5b, #c43c35);
+}
+.progress-danger.progress-striped .bar {
+  #gradient > .striped(#ee5f5b);
+}
+
+// Success (green)
+.progress-success .bar {
+  #gradient > .vertical(#62c462, #57a957);
+}
+.progress-success.progress-striped .bar {
+  #gradient > .striped(#62c462);
+}
+
+// Info (teal)
+.progress-info .bar {
+  #gradient > .vertical(#5bc0de, #339bb9);
+}
+.progress-info.progress-striped .bar {
+  #gradient > .striped(#5bc0de);
+}
+
+// Warning (orange)
+.progress-warning .bar {
+  #gradient > .vertical(lighten(@orange, 15%), @orange);
+}
+.progress-warning.progress-striped .bar {
+  #gradient > .striped(lighten(@orange, 15%));
+}

vendor/alchemy/mediavorus/docs/_static/less/reset.less

@@ -0,0 +1,126 @@
+// Reset.less
+// Adapted from Normalize.css http://github.com/necolas/normalize.css
+// ------------------------------------------------------------------------
+
+// Display in IE6-9 and FF3
+// -------------------------
+
+article,
+aside,
+details,
+figcaption,
+figure,
+footer,
+header,
+hgroup,
+nav,
+section {
+  display: block;
+}
+
+// Display block in IE6-9 and FF3
+// -------------------------
+
+audio,
+canvas,
+video {
+  display: inline-block;
+  *display: inline;
+  *zoom: 1;
+}
+
+// Prevents modern browsers from displaying 'audio' without controls
+// -------------------------
+
+audio:not([controls]) {
+    display: none;
+}
+
+// Base settings
+// -------------------------
+
+html {
+  font-size: 100%;
+  -webkit-text-size-adjust: 100%;
+      -ms-text-size-adjust: 100%;
+}
+// Focus states
+a:focus {
+  .tab-focus();
+}
+// Hover & Active
+a:hover,
+a:active {
+  outline: 0;
+}
+
+// Prevents sub and sup affecting line-height in all browsers
+// -------------------------
+
+sub,
+sup {
+  position: relative;
+  font-size: 75%;
+  line-height: 0;
+  vertical-align: baseline;
+}
+sup {
+  top: -0.5em;
+}
+sub {
+  bottom: -0.25em;
+}
+
+// Img border in a's and image quality
+// -------------------------
+
+img {
+  height: auto;
+  border: 0;
+  -ms-interpolation-mode: bicubic;
+  vertical-align: middle;
+}
+
+// Forms
+// -------------------------
+
+// Font size in all browsers, margin changes, misc consistency
+button,
+input,
+select,
+textarea {
+  margin: 0;
+  font-size: 100%;
+  vertical-align: middle;
+}
+button,
+input {
+  *overflow: visible; // Inner spacing ie IE6/7
+  line-height: normal; // FF3/4 have !important on line-height in UA stylesheet
+}
+button::-moz-focus-inner,
+input::-moz-focus-inner { // Inner padding and border oddities in FF3/4
+  padding: 0;
+  border: 0;
+}
+button,
+input[type="button"],
+input[type="reset"],
+input[type="submit"] {
+  cursor: pointer; // Cursors on all buttons applied consistently
+  -webkit-appearance: button; // Style clickable inputs in iOS
+}
+input[type="search"] { // Appearance in Safari/Chrome
+  -webkit-appearance: textfield;
+  -webkit-box-sizing: content-box;
+     -moz-box-sizing: content-box;
+          box-sizing: content-box;
+}
+input[type="search"]::-webkit-search-decoration,
+input[type="search"]::-webkit-search-cancel-button {
+  -webkit-appearance: none; // Inner-padding issues in Chrome OSX, Safari 5
+}
+textarea {
+  overflow: auto; // Remove vertical scrollbar in IE6-9
+  vertical-align: top; // Readability and alignment cross-browser
+}

vendor/alchemy/mediavorus/docs/_static/less/responsive.less

@@ -0,0 +1,371 @@
+/*!
+ * Bootstrap Responsive v2.0.2
+ *
+ * Copyright 2012 Twitter, Inc
+ * Licensed under the Apache License v2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Designed and built with all the love in the world @twitter by @mdo and @fat.
+ */
+
+// Responsive.less
+// For phone and tablet devices
+// -------------------------------------------------------------
+
+
+// REPEAT VARIABLES & MIXINS
+// -------------------------
+// Required since we compile the responsive stuff separately
+
+@import "variables.less"; // Modify this for custom colors, font-sizes, etc
+@import "mixins.less";
+
+
+// RESPONSIVE CLASSES
+// ------------------
+
+// Hide from screenreaders and browsers
+// Credit: HTML5 Boilerplate
+.hidden {
+  display: none;
+  visibility: hidden;
+}
+
+// Visibility utilities
+
+// For desktops
+.visible-phone     { display: none; }
+.visible-tablet    { display: none; }
+.visible-desktop   { display: block; }
+.hidden-phone      { display: block; }
+.hidden-tablet     { display: block; }
+.hidden-desktop    { display: none; }
+
+// Phones only
+@media (max-width: 767px) {
+  // Show
+  .visible-phone     { display: block; }
+  // Hide
+  .hidden-phone      { display: none; }
+  // Hide everything else
+  .hidden-desktop    { display: block; }
+  .visible-desktop   { display: none; }
+}
+
+// Tablets & small desktops only
+@media (min-width: 768px) and (max-width: 979px) {
+  // Show
+  .visible-tablet    { display: block; }
+  // Hide
+  .hidden-tablet     { display: none; }
+  // Hide everything else
+  .hidden-desktop    { display: block; }
+  .visible-desktop   { display: none; }
+}
+
+
+// UP TO LANDSCAPE PHONE
+// ---------------------
+
+@media (max-width: 480px) {
+
+  // Smooth out the collapsing/expanding nav
+  .nav-collapse {
+    -webkit-transform: translate3d(0, 0, 0); // activate the GPU
+  }
+
+  // Block level the page header small tag for readability
+  .page-header h1 small {
+    display: block;
+    line-height: @baseLineHeight;
+  }
+
+  // Update checkboxes for iOS
+  input[type="checkbox"],
+  input[type="radio"] {
+    border: 1px solid #ccc;
+  }
+
+  // Remove the horizontal form styles
+  .form-horizontal .control-group > label {
+    float: none;
+    width: auto;
+    padding-top: 0;
+    text-align: left;
+  }
+  // Move over all input controls and content
+  .form-horizontal .controls {
+    margin-left: 0;
+  }
+  // Move the options list down to align with labels
+  .form-horizontal .control-list {
+    padding-top: 0; // has to be padding because margin collaspes
+  }
+  // Move over buttons in .form-actions to align with .controls
+  .form-horizontal .form-actions {
+    padding-left: 10px;
+    padding-right: 10px;
+  }
+
+  // Modals
+  .modal {
+    position: absolute;
+    top:   10px;
+    left:  10px;
+    right: 10px;
+    width: auto;
+    margin: 0;
+    &.fade.in { top: auto; }
+  }
+  .modal-header .close {
+    padding: 10px;
+    margin: -10px;
+  }
+
+  // Carousel
+  .carousel-caption {
+    position: static;
+  }
+
+}
+
+
+
+// LANDSCAPE PHONE TO SMALL DESKTOP & PORTRAIT TABLET
+// --------------------------------------------------
+
+@media (max-width: 767px) {
+
+  // Padding to set content in a bit
+  body {
+    padding-left: 20px;
+    padding-right: 20px;
+  }
+  .navbar-fixed-top {
+    margin-left: -20px;
+    margin-right: -20px;
+  }
+
+  // GRID & CONTAINERS
+  // -----------------
+  // Remove width from containers
+  .container {
+    width: auto;
+  }
+  // Fluid rows
+  .row-fluid {
+    width: 100%;
+  }
+  // Undo negative margin on rows
+  .row {
+    margin-left: 0;
+  }
+  // Make all columns even
+  .row > [class*="span"],
+  .row-fluid > [class*="span"] {
+    float: none;
+    display: block;
+    width: auto;
+    margin: 0;
+  }
+
+  // THUMBNAILS
+  // ----------
+  .thumbnails [class*="span"] {
+    width: auto;
+  }
+
+  // FORM FIELDS
+  // -----------
+  // Make span* classes full width
+  input[class*="span"],
+  select[class*="span"],
+  textarea[class*="span"],
+  .uneditable-input {
+    .input-block-level();
+  }
+  // But don't let it screw up prepend/append inputs
+  .input-prepend input[class*="span"],
+  .input-append input[class*="span"] {
+    width: auto;
+  }
+
+}
+
+
+
+// PORTRAIT TABLET TO DEFAULT DESKTOP
+// ----------------------------------
+
+@media (min-width: 768px) and (max-width: 979px) {
+
+  // Fixed grid
+  #grid > .core(42px, 20px);
+
+  // Fluid grid
+  #grid > .fluid(5.801104972%, 2.762430939%);
+
+  // Input grid
+  #grid > .input(42px, 20px);
+
+}
+
+
+
+// TABLETS AND BELOW
+// -----------------
+@media (max-width: 979px) {
+
+  // UNFIX THE TOPBAR
+  // ----------------
+  // Remove any padding from the body
+  body {
+    padding-top: 0;
+  }
+  // Unfix the navbar
+  .navbar-fixed-top {
+    position: static;
+    margin-bottom: @baseLineHeight;
+  }
+  .navbar-fixed-top .navbar-inner {
+    padding: 5px;
+  }
+  .navbar .container {
+    width: auto;
+    padding: 0;
+  }
+  // Account for brand name
+  .navbar .brand {
+    padding-left: 10px;
+    padding-right: 10px;
+    margin: 0 0 0 -5px;
+  }
+  // Nav collapse clears brand
+  .navbar .nav-collapse {
+    clear: left;
+  }
+  // Block-level the nav
+  .navbar .nav {
+    float: none;
+    margin: 0 0 (@baseLineHeight / 2);
+  }
+  .navbar .nav > li {
+    float: none;
+  }
+  .navbar .nav > li > a {
+    margin-bottom: 2px;
+  }
+  .navbar .nav > .divider-vertical {
+    display: none;
+  }
+  .navbar .nav .nav-header {
+    color: @navbarText;
+    text-shadow: none;
+  }
+  // Nav and dropdown links in navbar
+  .navbar .nav > li > a,
+  .navbar .dropdown-menu a {
+    padding: 6px 15px;
+    font-weight: bold;
+    color: @navbarLinkColor;
+    .border-radius(3px);
+  }
+  .navbar .dropdown-menu li + li a {
+    margin-bottom: 2px;
+  }
+  .navbar .nav > li > a:hover,
+  .navbar .dropdown-menu a:hover {
+    background-color: @navbarBackground;
+  }
+  // Dropdowns in the navbar
+  .navbar .dropdown-menu {
+    position: static;
+    top: auto;
+    left: auto;
+    float: none;
+    display: block;
+    max-width: none;
+    margin: 0 15px;
+    padding: 0;
+    background-color: transparent;
+    border: none;
+    .border-radius(0);
+    .box-shadow(none);
+  }
+  .navbar .dropdown-menu:before,
+  .navbar .dropdown-menu:after {
+    display: none;
+  }
+  .navbar .dropdown-menu .divider {
+    display: none;
+  }
+  // Forms in navbar
+  .navbar-form,
+  .navbar-search {
+    float: none;
+    padding: (@baseLineHeight / 2) 15px;
+    margin: (@baseLineHeight / 2) 0;
+    border-top: 1px solid @navbarBackground;
+    border-bottom: 1px solid @navbarBackground;
+    @shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.1);
+    .box-shadow(@shadow);
+  }
+  // Pull right (secondary) nav content
+  .navbar .nav.pull-right {
+    float: none;
+    margin-left: 0;
+  }
+  // Static navbar
+  .navbar-static .navbar-inner {
+    padding-left:  10px;
+    padding-right: 10px;
+  }
+  // Navbar button
+  .btn-navbar {
+    display: block;
+  }
+
+  // Hide everything in the navbar save .brand and toggle button */
+  .nav-collapse {
+    overflow: hidden;
+    height: 0;
+  }
+}
+
+
+
+// DEFAULT DESKTOP
+// ---------------
+
+@media (min-width: 980px) {
+  .nav-collapse.collapse {
+    height: auto !important;
+    overflow: visible !important;
+  }
+}
+
+
+
+// LARGE DESKTOP & UP
+// ------------------
+
+@media (min-width: 1200px) {
+
+  // Fixed grid
+  #grid > .core(70px, 30px);
+
+  // Fluid grid
+  #grid > .fluid(5.982905983%, 2.564102564%);
+
+  // Input grid
+  #grid > .input(70px, 30px);
+
+  // Thumbnails
+  .thumbnails {
+    margin-left: -30px;
+  }
+  .thumbnails > li {
+    margin-left: 30px;
+  }
+
+}

vendor/alchemy/mediavorus/docs/_static/less/scaffolding.less

@@ -0,0 +1,29 @@
+// Scaffolding
+// Basic and global styles for generating a grid system, structural layout, and page templates
+// -------------------------------------------------------------------------------------------
+
+
+// Body reset
+// ----------
+
+body {
+  margin: 0;
+  font-family: @baseFontFamily;
+  font-size: @baseFontSize;
+  line-height: @baseLineHeight;
+  color: @textColor;
+  background-color: @bodyBackground;
+}
+
+
+// Links
+// -----
+
+a {
+  color: @linkColor;
+  text-decoration: none;
+}
+a:hover {
+  color: @linkColorHover;
+  text-decoration: underline;
+}

vendor/alchemy/mediavorus/docs/_static/less/sprites.less

@@ -0,0 +1,158 @@
+// SPRITES
+// Glyphs and icons for buttons, nav, and more
+// -------------------------------------------
+
+
+// ICONS
+// -----
+
+// All icons receive the styles of the <i> tag with a base class 
+// of .i and are then given a unique class to add width, height, 
+// and background-position. Your resulting HTML will look like
+// <i class="icon-inbox"></i>.
+
+// For the white version of the icons, just add the .icon-white class:
+// <i class="icon-inbox icon-white"></i>
+
+[class^="icon-"],
+[class*=" icon-"] {
+  display: inline-block;
+  width: 14px;
+  height: 14px;
+  line-height: 14px;
+  vertical-align: text-top;
+  background-image: url("@{iconSpritePath}");
+  background-position: 14px 14px;
+  background-repeat: no-repeat;
+
+  .ie7-restore-right-whitespace();
+}
+.icon-white {
+  background-image: url("@{iconWhiteSpritePath}");
+}
+
+.icon-glass              { background-position: 0      0; }
+.icon-music              { background-position: -24px  0; }
+.icon-search             { background-position: -48px  0; }
+.icon-envelope           { background-position: -72px  0; }
+.icon-heart              { background-position: -96px  0; }
+.icon-star               { background-position: -120px 0; }
+.icon-star-empty         { background-position: -144px 0; }
+.icon-user               { background-position: -168px 0; }
+.icon-film               { background-position: -192px 0; }
+.icon-th-large           { background-position: -216px 0; }
+.icon-th                 { background-position: -240px 0; }
+.icon-th-list            { background-position: -264px 0; }
+.icon-ok                 { background-position: -288px 0; }
+.icon-remove             { background-position: -312px 0; }
+.icon-zoom-in            { background-position: -336px 0; }
+.icon-zoom-out           { background-position: -360px 0; }
+.icon-off                { background-position: -384px 0; }
+.icon-signal             { background-position: -408px 0; }
+.icon-cog                { background-position: -432px 0; }
+.icon-trash              { background-position: -456px 0; }
+
+.icon-home               { background-position: 0      -24px; }
+.icon-file               { background-position: -24px  -24px; }
+.icon-time               { background-position: -48px  -24px; }
+.icon-road               { background-position: -72px  -24px; }
+.icon-download-alt       { background-position: -96px  -24px; }
+.icon-download           { background-position: -120px -24px; }
+.icon-upload             { background-position: -144px -24px; }
+.icon-inbox              { background-position: -168px -24px; }
+.icon-play-circle        { background-position: -192px -24px; }
+.icon-repeat             { background-position: -216px -24px; }
+.icon-refresh            { background-position: -240px -24px; }
+.icon-list-alt           { background-position: -264px -24px; }
+.icon-lock               { background-position: -287px -24px; } // 1px off
+.icon-flag               { background-position: -312px -24px; }
+.icon-headphones         { background-position: -336px -24px; }
+.icon-volume-off         { background-position: -360px -24px; }
+.icon-volume-down        { background-position: -384px -24px; }
+.icon-volume-up          { background-position: -408px -24px; }
+.icon-qrcode             { background-position: -432px -24px; }
+.icon-barcode            { background-position: -456px -24px; }
+
+.icon-tag                { background-position: 0      -48px; }
+.icon-tags               { background-position: -25px  -48px; } // 1px off
+.icon-book               { background-position: -48px  -48px; }
+.icon-bookmark           { background-position: -72px  -48px; }
+.icon-print              { background-position: -96px  -48px; }
+.icon-camera             { background-position: -120px -48px; }
+.icon-font               { background-position: -144px -48px; }
+.icon-bold               { background-position: -167px -48px; } // 1px off
+.icon-italic             { background-position: -192px -48px; }
+.icon-text-height        { background-position: -216px -48px; }
+.icon-text-width         { background-position: -240px -48px; }
+.icon-align-left         { background-position: -264px -48px; }
+.icon-align-center       { background-position: -288px -48px; }
+.icon-align-right        { background-position: -312px -48px; }
+.icon-align-justify      { background-position: -336px -48px; }
+.icon-list               { background-position: -360px -48px; }
+.icon-indent-left        { background-position: -384px -48px; }
+.icon-indent-right       { background-position: -408px -48px; }
+.icon-facetime-video     { background-position: -432px -48px; }
+.icon-picture            { background-position: -456px -48px; }
+
+.icon-pencil             { background-position: 0      -72px; }
+.icon-map-marker         { background-position: -24px  -72px; }
+.icon-adjust             { background-position: -48px  -72px; }
+.icon-tint               { background-position: -72px  -72px; }
+.icon-edit               { background-position: -96px  -72px; }
+.icon-share              { background-position: -120px -72px; }
+.icon-check              { background-position: -144px -72px; }
+.icon-move               { background-position: -168px -72px; }
+.icon-step-backward      { background-position: -192px -72px; }
+.icon-fast-backward      { background-position: -216px -72px; }
+.icon-backward           { background-position: -240px -72px; }
+.icon-play               { background-position: -264px -72px; }
+.icon-pause              { background-position: -288px -72px; }
+.icon-stop               { background-position: -312px -72px; }
+.icon-forward            { background-position: -336px -72px; }
+.icon-fast-forward       { background-position: -360px -72px; }
+.icon-step-forward       { background-position: -384px -72px; }
+.icon-eject              { background-position: -408px -72px; }
+.icon-chevron-left       { background-position: -432px -72px; }
+.icon-chevron-right      { background-position: -456px -72px; }
+
+.icon-plus-sign          { background-position: 0      -96px; }
+.icon-minus-sign         { background-position: -24px  -96px; }
+.icon-remove-sign        { background-position: -48px  -96px; }
+.icon-ok-sign            { background-position: -72px  -96px; }
+.icon-question-sign      { background-position: -96px  -96px; }
+.icon-info-sign          { background-position: -120px -96px; }
+.icon-screenshot         { background-position: -144px -96px; }
+.icon-remove-circle      { background-position: -168px -96px; }
+.icon-ok-circle          { background-position: -192px -96px; }
+.icon-ban-circle         { background-position: -216px -96px; }
+.icon-arrow-left         { background-position: -240px -96px; }
+.icon-arrow-right        { background-position: -264px -96px; }
+.icon-arrow-up           { background-position: -289px -96px; } // 1px off
+.icon-arrow-down         { background-position: -312px -96px; }
+.icon-share-alt          { background-position: -336px -96px; }
+.icon-resize-full        { background-position: -360px -96px; }
+.icon-resize-small       { background-position: -384px -96px; }
+.icon-plus               { background-position: -408px -96px; }
+.icon-minus              { background-position: -433px -96px; }
+.icon-asterisk           { background-position: -456px -96px; }
+
+.icon-exclamation-sign   { background-position: 0      -120px; }
+.icon-gift               { background-position: -24px  -120px; }
+.icon-leaf               { background-position: -48px  -120px; }
+.icon-fire               { background-position: -72px  -120px; }
+.icon-eye-open           { background-position: -96px  -120px; }
+.icon-eye-close          { background-position: -120px -120px; }
+.icon-warning-sign       { background-position: -144px -120px; }
+.icon-plane              { background-position: -168px -120px; }
+.icon-calendar           { background-position: -192px -120px; }
+.icon-random             { background-position: -216px -120px; }
+.icon-comment            { background-position: -240px -120px; }
+.icon-magnet             { background-position: -264px -120px; }
+.icon-chevron-up         { background-position: -288px -120px; }
+.icon-chevron-down       { background-position: -313px -119px; } // 1px off
+.icon-retweet            { background-position: -336px -120px; }
+.icon-shopping-cart      { background-position: -360px -120px; }
+.icon-folder-close       { background-position: -384px -120px; }
+.icon-folder-open        { background-position: -408px -120px; }
+.icon-resize-vertical    { background-position: -432px -119px; }
+.icon-resize-horizontal  { background-position: -456px -118px; }

vendor/alchemy/mediavorus/docs/_static/less/tables.less

@@ -0,0 +1,159 @@
+//
+// Tables.less
+// Tables for, you guessed it, tabular data
+// ----------------------------------------
+
+
+// BASE TABLES
+// -----------------
+
+table {
+  max-width: 100%;
+  border-collapse: collapse;
+  border-spacing: 0;
+  background-color: @tableBackground;
+}
+
+// BASELINE STYLES
+// ---------------
+
+.table {
+  width: 100%;
+  margin-bottom: @baseLineHeight;
+  // Cells
+  th,
+  td {
+    padding: 8px;
+    line-height: @baseLineHeight;
+    text-align: left;
+    vertical-align: top;
+    border-top: 1px solid @tableBorder;
+  }
+  th {
+    font-weight: bold;
+  }
+  // Bottom align for column headings
+  thead th {
+    vertical-align: bottom;
+  }
+  // Remove top border from thead by default
+  colgroup + thead tr:first-child th,
+  colgroup + thead tr:first-child td,
+  thead:first-child tr:first-child th,
+  thead:first-child tr:first-child td {
+    border-top: 0;
+  }
+  // Account for multiple tbody instances
+  tbody + tbody {
+    border-top: 2px solid @tableBorder;
+  }
+}
+
+
+
+// CONDENSED TABLE W/ HALF PADDING
+// -------------------------------
+
+.table-condensed {
+  th,
+  td {
+    padding: 4px 5px;
+  }
+}
+
+
+// BORDERED VERSION
+// ----------------
+
+.table-bordered {
+  border: 1px solid @tableBorder;
+  border-left: 0;
+  border-collapse: separate; // Done so we can round those corners!
+  *border-collapse: collapsed; // IE7 can't round corners anyway
+  .border-radius(4px);
+  th,
+  td {
+    border-left: 1px solid @tableBorder;
+  }
+  // Prevent a double border
+  thead:first-child tr:first-child th,
+  tbody:first-child tr:first-child th,
+  tbody:first-child tr:first-child td {
+    border-top: 0;
+  }
+  // For first th or td in the first row in the first thead or tbody
+  thead:first-child tr:first-child th:first-child,
+  tbody:first-child tr:first-child td:first-child {
+    .border-radius(4px 0 0 0);
+  }
+  thead:first-child tr:first-child th:last-child,
+  tbody:first-child tr:first-child td:last-child {
+    .border-radius(0 4px 0 0);
+  }
+  // For first th or td in the first row in the first thead or tbody
+  thead:last-child tr:last-child th:first-child,
+  tbody:last-child tr:last-child td:first-child {
+    .border-radius(0 0 0 4px);
+  }
+  thead:last-child tr:last-child th:last-child,
+  tbody:last-child tr:last-child td:last-child {
+    .border-radius(0 0 4px 0);
+  }
+}
+
+
+// ZEBRA-STRIPING
+// --------------
+
+// Default zebra-stripe styles (alternating gray and transparent backgrounds)
+.table-striped {
+  tbody {
+    tr:nth-child(odd) td,
+    tr:nth-child(odd) th {
+      background-color: @tableBackgroundAccent;
+    }
+  }
+}
+
+
+// HOVER EFFECT
+// ------------
+// Placed here since it has to come after the potential zebra striping
+.table {
+  tbody tr:hover td,
+  tbody tr:hover th {
+    background-color: @tableBackgroundHover;
+  }
+}
+
+
+// TABLE CELL SIZING
+// -----------------
+
+// Change the columns
+table {
+  .span1     { .tableColumns(1); }
+  .span2     { .tableColumns(2); }
+  .span3     { .tableColumns(3); }
+  .span4     { .tableColumns(4); }
+  .span5     { .tableColumns(5); }
+  .span6     { .tableColumns(6); }
+  .span7     { .tableColumns(7); }
+  .span8     { .tableColumns(8); }
+  .span9     { .tableColumns(9); }
+  .span10    { .tableColumns(10); }
+  .span11    { .tableColumns(11); }
+  .span12    { .tableColumns(12); }
+  .span13    { .tableColumns(13); }
+  .span14    { .tableColumns(14); }
+  .span15    { .tableColumns(15); }
+  .span16    { .tableColumns(16); }
+  .span17    { .tableColumns(17); }
+  .span18    { .tableColumns(18); }
+  .span19    { .tableColumns(19); }
+  .span20    { .tableColumns(20); }
+  .span21    { .tableColumns(21); }
+  .span22    { .tableColumns(22); }
+  .span23    { .tableColumns(23); }
+  .span24    { .tableColumns(24); }
+}

vendor/alchemy/mediavorus/docs/_static/less/thumbnails.less

@@ -0,0 +1,35 @@
+// THUMBNAILS
+// ----------
+
+.thumbnails {
+  margin-left: -@gridGutterWidth;
+  list-style: none;
+  .clearfix();
+}
+.thumbnails > li {
+  float: left;
+  margin: 0 0 @baseLineHeight @gridGutterWidth;
+}
+.thumbnail {
+  display: block;
+  padding: 4px;
+  line-height: 1;
+  border: 1px solid #ddd;
+  .border-radius(4px);
+  .box-shadow(0 1px 1px rgba(0,0,0,.075));
+}
+// Add a hover state for linked versions only
+a.thumbnail:hover {
+  border-color: @linkColor;
+  .box-shadow(0 1px 4px rgba(0,105,214,.25));
+}
+// Images and captions
+.thumbnail > img {
+  display: block;
+  max-width: 100%;
+  margin-left: auto;
+  margin-right: auto;
+}
+.thumbnail .caption {
+  padding: 9px;
+}

vendor/alchemy/mediavorus/docs/_static/less/tooltip.less

@@ -0,0 +1,35 @@
+// TOOLTIP
+// ------=
+
+.tooltip {
+  position: absolute;
+  z-index: @zindexTooltip;
+  display: block;
+  visibility: visible;
+  padding: 5px;
+  font-size: 11px;
+  .opacity(0);
+  &.in     { .opacity(80); }
+  &.top    { margin-top:  -2px; }
+  &.right  { margin-left:  2px; }
+  &.bottom { margin-top:   2px; }
+  &.left   { margin-left: -2px; }
+  &.top .tooltip-arrow    { #popoverArrow > .top(); }
+  &.left .tooltip-arrow   { #popoverArrow > .left(); }
+  &.bottom .tooltip-arrow { #popoverArrow > .bottom(); }
+  &.right .tooltip-arrow  { #popoverArrow > .right(); }
+}
+.tooltip-inner {
+  max-width: 200px;
+  padding: 3px 8px;
+  color: @white;
+  text-align: center;
+  text-decoration: none;
+  background-color: @black;
+  .border-radius(4px);
+}
+.tooltip-arrow {
+  position: absolute;
+  width: 0;
+  height: 0;
+}

vendor/alchemy/mediavorus/docs/_static/less/type.less

@@ -0,0 +1,234 @@
+// Typography.less
+// Headings, body text, lists, code, and more for a versatile and durable typography system
+// ----------------------------------------------------------------------------------------
+
+
+// BODY TEXT
+// ---------
+
+p {
+  margin: 0 0 @baseLineHeight / 2;
+  font-family: @baseFontFamily;
+  font-size: @baseFontSize;
+  line-height: @baseLineHeight;
+  small {
+    font-size: @baseFontSize - 2;
+    color: @grayLight;
+  }
+}
+.lead {
+  margin-bottom: @baseLineHeight;
+  font-size: 20px;
+  font-weight: 200;
+  line-height: @baseLineHeight * 1.5;
+}
+
+// HEADINGS
+// --------
+
+h1, h2, h3, h4, h5, h6 {
+  margin: 0;
+  font-family: @headingsFontFamily;
+  font-weight: @headingsFontWeight;
+  color: @headingsColor;
+  text-rendering: optimizelegibility; // Fix the character spacing for headings
+  small {
+    font-weight: normal;
+    color: @grayLight;
+  }
+}
+h1 {
+  font-size: 30px;
+  line-height: @baseLineHeight * 2;
+  small {
+    font-size: 18px;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: @baseLineHeight * 2;
+  small {
+    font-size: 18px;
+  }
+}
+h3 {
+  line-height: @baseLineHeight * 1.5;
+  font-size: 18px;
+  small {
+    font-size: 14px;
+  }
+}
+h4, h5, h6 {
+  line-height: @baseLineHeight;
+}
+h4 {
+  font-size: 14px;
+  small {
+    font-size: 12px;
+  }
+}
+h5 {
+  font-size: 12px;
+}
+h6 {
+  font-size: 11px;
+  color: @grayLight;
+  text-transform: uppercase;
+}
+
+// Page header
+.page-header {
+  padding-bottom: @baseLineHeight - 1;
+  margin: @baseLineHeight 0;
+  border-bottom: 1px solid @grayLighter;
+}
+.page-header h1 {
+  line-height: 1;
+}
+
+
+
+// LISTS
+// -----
+
+// Unordered and Ordered lists
+ul, ol {
+  padding: 0;
+  margin: 0 0 @baseLineHeight / 2 25px;
+}
+ul ul,
+ul ol,
+ol ol,
+ol ul {
+  margin-bottom: 0;
+}
+ul {
+  list-style: disc;
+}
+ol {
+  list-style: decimal;
+}
+li {
+  line-height: @baseLineHeight;
+}
+ul.unstyled,
+ol.unstyled {
+  margin-left: 0;
+  list-style: none;
+}
+
+// Description Lists
+dl {
+  margin-bottom: @baseLineHeight;
+}
+dt,
+dd {
+  line-height: @baseLineHeight;
+}
+dt {
+  font-weight: bold;
+  line-height: @baseLineHeight - 1; // fix jank Helvetica Neue font bug
+}
+dd {
+  margin-left: @baseLineHeight / 2;
+}
+// Horizontal layout (like forms)
+.dl-horizontal {
+  dt {
+    float: left;
+    clear: left;
+    width: 120px;
+    text-align: right;
+  }
+  dd {
+    margin-left: 130px;
+  }
+}
+
+// MISC
+// ----
+
+// Horizontal rules
+hr {
+  margin: @baseLineHeight 0;
+  border: 0;
+  border-top: 1px solid @hrBorder;
+  border-bottom: 1px solid @white;
+}
+
+// Emphasis
+strong {
+  font-weight: bold;
+}
+em {
+  font-style: italic;
+}
+.muted {
+  color: @grayLight;
+}
+
+// Abbreviations and acronyms
+abbr[title] {
+  border-bottom: 1px dotted #ddd;
+  cursor: help;
+}
+abbr.initialism {
+  font-size: 90%;
+  text-transform: uppercase;
+}
+
+// Blockquotes
+blockquote {
+  padding: 0 0 0 15px;
+  margin: 0 0 @baseLineHeight;
+  border-left: 5px solid @grayLighter;
+  p {
+    margin-bottom: 0;
+    #font > .shorthand(16px,300,@baseLineHeight * 1.25);
+  }
+  small {
+    display: block;
+    line-height: @baseLineHeight;
+    color: @grayLight;
+    &:before {
+      content: '\2014 \00A0';
+    }
+  }
+
+  // Float right with text-align: right
+  &.pull-right {
+    float: right;
+    padding-left: 0;
+    padding-right: 15px;
+    border-left: 0;
+    border-right: 5px solid @grayLighter;
+    p,
+    small {
+      text-align: right;
+    }
+  }
+}
+
+// Quotes
+q:before,
+q:after,
+blockquote:before,
+blockquote:after {
+  content: "";
+}
+
+// Addresses
+address {
+  display: block;
+  margin-bottom: @baseLineHeight;
+  line-height: @baseLineHeight;
+  font-style: normal;
+}
+
+// Misc
+small {
+  font-size: 100%;
+}
+cite {
+  font-style: normal;
+}