added compser vendors for mailgun librarie

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/.gitignore

@@ -0,0 +1,3 @@
+vendor/
+composer.lock
+phpunit.xml

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/CHANGELOG.md

@@ -0,0 +1,23 @@
+CHANGELOG
+=========
+
+2.5.0
+-----
+
+ * added Debug\TraceableEventDispatcher (originally in HttpKernel)
+ * changed Debug\TraceableEventDispatcherInterface to extend EventDispatcherInterface
+ * added RegisterListenersPass (originally in HttpKernel)
+
+2.1.0
+-----
+
+ * added TraceableEventDispatcherInterface
+ * added ContainerAwareEventDispatcher
+ * added a reference to the EventDispatcher on the Event
+ * added a reference to the Event name on the event
+ * added fluid interface to the dispatch() method which now returns the Event
+   object
+ * added GenericEvent event class
+ * added the possibility for subscribers to subscribe several times for the
+   same event
+ * added ImmutableEventDispatcher

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/ContainerAwareEventDispatcher.php

@@ -0,0 +1,197 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Lazily loads listeners and subscribers from the dependency injection
+ * container.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ * @author Jordan Alliot <jordan.alliot@gmail.com>
+ */
+class ContainerAwareEventDispatcher extends EventDispatcher
+{
+    /**
+     * The container from where services are loaded.
+     *
+     * @var ContainerInterface
+     */
+    private $container;
+
+    /**
+     * The service IDs of the event listeners and subscribers.
+     *
+     * @var array
+     */
+    private $listenerIds = array();
+
+    /**
+     * The services registered as listeners.
+     *
+     * @var array
+     */
+    private $listeners = array();
+
+    /**
+     * Constructor.
+     *
+     * @param ContainerInterface $container A ContainerInterface instance
+     */
+    public function __construct(ContainerInterface $container)
+    {
+        $this->container = $container;
+    }
+
+    /**
+     * Adds a service as event listener.
+     *
+     * @param string $eventName Event for which the listener is added
+     * @param array  $callback  The service ID of the listener service & the method
+     *                          name that has to be called
+     * @param int    $priority  The higher this value, the earlier an event listener
+     *                          will be triggered in the chain.
+     *                          Defaults to 0.
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function addListenerService($eventName, $callback, $priority = 0)
+    {
+        if (!is_array($callback) || 2 !== count($callback)) {
+            throw new \InvalidArgumentException('Expected an array("service", "method") argument');
+        }
+
+        $this->listenerIds[$eventName][] = array($callback[0], $callback[1], $priority);
+    }
+
+    public function removeListener($eventName, $listener)
+    {
+        $this->lazyLoad($eventName);
+
+        if (isset($this->listenerIds[$eventName])) {
+            foreach ($this->listenerIds[$eventName] as $i => $args) {
+                list($serviceId, $method, $priority) = $args;
+                $key = $serviceId.'.'.$method;
+                if (isset($this->listeners[$eventName][$key]) && $listener === array($this->listeners[$eventName][$key], $method)) {
+                    unset($this->listeners[$eventName][$key]);
+                    if (empty($this->listeners[$eventName])) {
+                        unset($this->listeners[$eventName]);
+                    }
+                    unset($this->listenerIds[$eventName][$i]);
+                    if (empty($this->listenerIds[$eventName])) {
+                        unset($this->listenerIds[$eventName]);
+                    }
+                }
+            }
+        }
+
+        parent::removeListener($eventName, $listener);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasListeners($eventName = null)
+    {
+        if (null === $eventName) {
+            return (bool) count($this->listenerIds) || (bool) count($this->listeners);
+        }
+
+        if (isset($this->listenerIds[$eventName])) {
+            return true;
+        }
+
+        return parent::hasListeners($eventName);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getListeners($eventName = null)
+    {
+        if (null === $eventName) {
+            foreach ($this->listenerIds as $serviceEventName => $args) {
+                $this->lazyLoad($serviceEventName);
+            }
+        } else {
+            $this->lazyLoad($eventName);
+        }
+
+        return parent::getListeners($eventName);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getListenerPriority($eventName, $listener)
+    {
+        $this->lazyLoad($eventName);
+
+        return parent::getListenerPriority($eventName, $listener);
+    }
+
+    /**
+     * Adds a service as event subscriber.
+     *
+     * @param string $serviceId The service ID of the subscriber service
+     * @param string $class     The service's class name (which must implement EventSubscriberInterface)
+     */
+    public function addSubscriberService($serviceId, $class)
+    {
+        foreach ($class::getSubscribedEvents() as $eventName => $params) {
+            if (is_string($params)) {
+                $this->listenerIds[$eventName][] = array($serviceId, $params, 0);
+            } elseif (is_string($params[0])) {
+                $this->listenerIds[$eventName][] = array($serviceId, $params[0], isset($params[1]) ? $params[1] : 0);
+            } else {
+                foreach ($params as $listener) {
+                    $this->listenerIds[$eventName][] = array($serviceId, $listener[0], isset($listener[1]) ? $listener[1] : 0);
+                }
+            }
+        }
+    }
+
+    public function getContainer()
+    {
+        return $this->container;
+    }
+
+    /**
+     * Lazily loads listeners for this event from the dependency injection
+     * container.
+     *
+     * @param string $eventName The name of the event to dispatch. The name of
+     *                          the event is the name of the method that is
+     *                          invoked on listeners.
+     */
+    protected function lazyLoad($eventName)
+    {
+        if (isset($this->listenerIds[$eventName])) {
+            foreach ($this->listenerIds[$eventName] as $args) {
+                list($serviceId, $method, $priority) = $args;
+                $listener = $this->container->get($serviceId);
+
+                $key = $serviceId.'.'.$method;
+                if (!isset($this->listeners[$eventName][$key])) {
+                    $this->addListener($eventName, array($listener, $method), $priority);
+                } elseif ($listener !== $this->listeners[$eventName][$key]) {
+                    parent::removeListener($eventName, array($this->listeners[$eventName][$key], $method));
+                    $this->addListener($eventName, array($listener, $method), $priority);
+                }
+
+                $this->listeners[$eventName][$key] = $listener;
+            }
+        }
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Debug/TraceableEventDispatcher.php

@@ -0,0 +1,376 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Debug;
+
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\Stopwatch\Stopwatch;
+use Psr\Log\LoggerInterface;
+
+/**
+ * Collects some data about event listeners.
+ *
+ * This event dispatcher delegates the dispatching to another one.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class TraceableEventDispatcher implements TraceableEventDispatcherInterface
+{
+    protected $logger;
+    protected $stopwatch;
+
+    private $called;
+    private $dispatcher;
+    private $wrappedListeners;
+
+    /**
+     * Constructor.
+     *
+     * @param EventDispatcherInterface $dispatcher An EventDispatcherInterface instance
+     * @param Stopwatch                $stopwatch  A Stopwatch instance
+     * @param LoggerInterface          $logger     A LoggerInterface instance
+     */
+    public function __construct(EventDispatcherInterface $dispatcher, Stopwatch $stopwatch, LoggerInterface $logger = null)
+    {
+        $this->dispatcher = $dispatcher;
+        $this->stopwatch = $stopwatch;
+        $this->logger = $logger;
+        $this->called = array();
+        $this->wrappedListeners = array();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addListener($eventName, $listener, $priority = 0)
+    {
+        $this->dispatcher->addListener($eventName, $listener, $priority);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addSubscriber(EventSubscriberInterface $subscriber)
+    {
+        $this->dispatcher->addSubscriber($subscriber);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function removeListener($eventName, $listener)
+    {
+        if (isset($this->wrappedListeners[$eventName])) {
+            foreach ($this->wrappedListeners[$eventName] as $index => $wrappedListener) {
+                if ($wrappedListener->getWrappedListener() === $listener) {
+                    $listener = $wrappedListener;
+                    unset($this->wrappedListeners[$eventName][$index]);
+                    break;
+                }
+            }
+        }
+
+        return $this->dispatcher->removeListener($eventName, $listener);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function removeSubscriber(EventSubscriberInterface $subscriber)
+    {
+        return $this->dispatcher->removeSubscriber($subscriber);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getListeners($eventName = null)
+    {
+        return $this->dispatcher->getListeners($eventName);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getListenerPriority($eventName, $listener)
+    {
+        if (!method_exists($this->dispatcher, 'getListenerPriority')) {
+            return 0;
+        }
+
+        return $this->dispatcher->getListenerPriority($eventName, $listener);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasListeners($eventName = null)
+    {
+        return $this->dispatcher->hasListeners($eventName);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function dispatch($eventName, Event $event = null)
+    {
+        if (null === $event) {
+            $event = new Event();
+        }
+
+        if (null !== $this->logger && $event->isPropagationStopped()) {
+            $this->logger->debug(sprintf('The "%s" event is already stopped. No listeners have been called.', $eventName));
+        }
+
+        $this->preProcess($eventName);
+        $this->preDispatch($eventName, $event);
+
+        $e = $this->stopwatch->start($eventName, 'section');
+
+        $this->dispatcher->dispatch($eventName, $event);
+
+        if ($e->isStarted()) {
+            $e->stop();
+        }
+
+        $this->postDispatch($eventName, $event);
+        $this->postProcess($eventName);
+
+        return $event;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getCalledListeners()
+    {
+        $called = array();
+        foreach ($this->called as $eventName => $listeners) {
+            foreach ($listeners as $listener) {
+                $info = $this->getListenerInfo($listener->getWrappedListener(), $eventName);
+                $called[$eventName.'.'.$info['pretty']] = $info;
+            }
+        }
+
+        return $called;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getNotCalledListeners()
+    {
+        try {
+            $allListeners = $this->getListeners();
+        } catch (\Exception $e) {
+            if (null !== $this->logger) {
+                $this->logger->info('An exception was thrown while getting the uncalled listeners.', array('exception' => $e));
+            }
+
+            // unable to retrieve the uncalled listeners
+            return array();
+        }
+
+        $notCalled = array();
+        foreach ($allListeners as $eventName => $listeners) {
+            foreach ($listeners as $listener) {
+                $called = false;
+                if (isset($this->called[$eventName])) {
+                    foreach ($this->called[$eventName] as $l) {
+                        if ($l->getWrappedListener() === $listener) {
+                            $called = true;
+
+                            break;
+                        }
+                    }
+                }
+
+                if (!$called) {
+                    $info = $this->getListenerInfo($listener, $eventName);
+                    $notCalled[$eventName.'.'.$info['pretty']] = $info;
+                }
+            }
+        }
+
+        uasort($notCalled, array($this, 'sortListenersByPriority'));
+
+        return $notCalled;
+    }
+
+    /**
+     * Proxies all method calls to the original event dispatcher.
+     *
+     * @param string $method    The method name
+     * @param array  $arguments The method arguments
+     *
+     * @return mixed
+     */
+    public function __call($method, $arguments)
+    {
+        return call_user_func_array(array($this->dispatcher, $method), $arguments);
+    }
+
+    /**
+     * Called before dispatching the event.
+     *
+     * @param string $eventName The event name
+     * @param Event  $event     The event
+     */
+    protected function preDispatch($eventName, Event $event)
+    {
+    }
+
+    /**
+     * Called after dispatching the event.
+     *
+     * @param string $eventName The event name
+     * @param Event  $event     The event
+     */
+    protected function postDispatch($eventName, Event $event)
+    {
+    }
+
+    private function preProcess($eventName)
+    {
+        foreach ($this->dispatcher->getListeners($eventName) as $listener) {
+            $info = $this->getListenerInfo($listener, $eventName);
+            $name = isset($info['class']) ? $info['class'] : $info['type'];
+            $wrappedListener = new WrappedListener($listener, $name, $this->stopwatch, $this);
+            $this->wrappedListeners[$eventName][] = $wrappedListener;
+            $this->dispatcher->removeListener($eventName, $listener);
+            $this->dispatcher->addListener($eventName, $wrappedListener, $info['priority']);
+        }
+    }
+
+    private function postProcess($eventName)
+    {
+        unset($this->wrappedListeners[$eventName]);
+        $skipped = false;
+        foreach ($this->dispatcher->getListeners($eventName) as $listener) {
+            if (!$listener instanceof WrappedListener) { // #12845: a new listener was added during dispatch.
+                continue;
+            }
+            // Unwrap listener
+            $priority = $this->getListenerPriority($eventName, $listener);
+            $this->dispatcher->removeListener($eventName, $listener);
+            $this->dispatcher->addListener($eventName, $listener->getWrappedListener(), $priority);
+
+            $info = $this->getListenerInfo($listener->getWrappedListener(), $eventName);
+            if ($listener->wasCalled()) {
+                if (null !== $this->logger) {
+                    $this->logger->debug(sprintf('Notified event "%s" to listener "%s".', $eventName, $info['pretty']));
+                }
+
+                if (!isset($this->called[$eventName])) {
+                    $this->called[$eventName] = new \SplObjectStorage();
+                }
+
+                $this->called[$eventName]->attach($listener);
+            }
+
+            if (null !== $this->logger && $skipped) {
+                $this->logger->debug(sprintf('Listener "%s" was not called for event "%s".', $info['pretty'], $eventName));
+            }
+
+            if ($listener->stoppedPropagation()) {
+                if (null !== $this->logger) {
+                    $this->logger->debug(sprintf('Listener "%s" stopped propagation of the event "%s".', $info['pretty'], $eventName));
+                }
+
+                $skipped = true;
+            }
+        }
+    }
+
+    /**
+     * Returns information about the listener.
+     *
+     * @param object $listener  The listener
+     * @param string $eventName The event name
+     *
+     * @return array Information about the listener
+     */
+    private function getListenerInfo($listener, $eventName)
+    {
+        $info = array(
+            'event' => $eventName,
+            'priority' => $this->getListenerPriority($eventName, $listener),
+        );
+        if ($listener instanceof \Closure) {
+            $info += array(
+                'type' => 'Closure',
+                'pretty' => 'closure',
+            );
+        } elseif (is_string($listener)) {
+            try {
+                $r = new \ReflectionFunction($listener);
+                $file = $r->getFileName();
+                $line = $r->getStartLine();
+            } catch (\ReflectionException $e) {
+                $file = null;
+                $line = null;
+            }
+            $info += array(
+                'type' => 'Function',
+                'function' => $listener,
+                'file' => $file,
+                'line' => $line,
+                'pretty' => $listener,
+            );
+        } elseif (is_array($listener) || (is_object($listener) && is_callable($listener))) {
+            if (!is_array($listener)) {
+                $listener = array($listener, '__invoke');
+            }
+            $class = is_object($listener[0]) ? get_class($listener[0]) : $listener[0];
+            try {
+                $r = new \ReflectionMethod($class, $listener[1]);
+                $file = $r->getFileName();
+                $line = $r->getStartLine();
+            } catch (\ReflectionException $e) {
+                $file = null;
+                $line = null;
+            }
+            $info += array(
+                'type' => 'Method',
+                'class' => $class,
+                'method' => $listener[1],
+                'file' => $file,
+                'line' => $line,
+                'pretty' => $class.'::'.$listener[1],
+            );
+        }
+
+        return $info;
+    }
+
+    private function sortListenersByPriority($a, $b)
+    {
+        if (is_int($a['priority']) && !is_int($b['priority'])) {
+            return 1;
+        }
+
+        if (!is_int($a['priority']) && is_int($b['priority'])) {
+            return -1;
+        }
+
+        if ($a['priority'] === $b['priority']) {
+            return 0;
+        }
+
+        if ($a['priority'] > $b['priority']) {
+            return -1;
+        }
+
+        return 1;
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Debug/TraceableEventDispatcherInterface.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Debug;
+
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface TraceableEventDispatcherInterface extends EventDispatcherInterface
+{
+    /**
+     * Gets the called listeners.
+     *
+     * @return array An array of called listeners
+     */
+    public function getCalledListeners();
+
+    /**
+     * Gets the not called listeners.
+     *
+     * @return array An array of not called listeners
+     */
+    public function getNotCalledListeners();
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Debug/WrappedListener.php

@@ -0,0 +1,71 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Debug;
+
+use Symfony\Component\Stopwatch\Stopwatch;
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class WrappedListener
+{
+    private $listener;
+    private $name;
+    private $called;
+    private $stoppedPropagation;
+    private $stopwatch;
+    private $dispatcher;
+
+    public function __construct($listener, $name, Stopwatch $stopwatch, EventDispatcherInterface $dispatcher = null)
+    {
+        $this->listener = $listener;
+        $this->name = $name;
+        $this->stopwatch = $stopwatch;
+        $this->dispatcher = $dispatcher;
+        $this->called = false;
+        $this->stoppedPropagation = false;
+    }
+
+    public function getWrappedListener()
+    {
+        return $this->listener;
+    }
+
+    public function wasCalled()
+    {
+        return $this->called;
+    }
+
+    public function stoppedPropagation()
+    {
+        return $this->stoppedPropagation;
+    }
+
+    public function __invoke(Event $event, $eventName, EventDispatcherInterface $dispatcher)
+    {
+        $this->called = true;
+
+        $e = $this->stopwatch->start($this->name, 'event_listener');
+
+        call_user_func($this->listener, $event, $eventName, $this->dispatcher ?: $dispatcher);
+
+        if ($e->isStarted()) {
+            $e->stop();
+        }
+
+        if ($event->isPropagationStopped()) {
+            $this->stoppedPropagation = true;
+        }
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/DependencyInjection/RegisterListenersPass.php

@@ -0,0 +1,109 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+
+/**
+ * Compiler pass to register tagged services for an event dispatcher.
+ */
+class RegisterListenersPass implements CompilerPassInterface
+{
+    /**
+     * @var string
+     */
+    protected $dispatcherService;
+
+    /**
+     * @var string
+     */
+    protected $listenerTag;
+
+    /**
+     * @var string
+     */
+    protected $subscriberTag;
+
+    /**
+     * Constructor.
+     *
+     * @param string $dispatcherService Service name of the event dispatcher in processed container
+     * @param string $listenerTag       Tag name used for listener
+     * @param string $subscriberTag     Tag name used for subscribers
+     */
+    public function __construct($dispatcherService = 'event_dispatcher', $listenerTag = 'kernel.event_listener', $subscriberTag = 'kernel.event_subscriber')
+    {
+        $this->dispatcherService = $dispatcherService;
+        $this->listenerTag = $listenerTag;
+        $this->subscriberTag = $subscriberTag;
+    }
+
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition($this->dispatcherService) && !$container->hasAlias($this->dispatcherService)) {
+            return;
+        }
+
+        $definition = $container->findDefinition($this->dispatcherService);
+
+        foreach ($container->findTaggedServiceIds($this->listenerTag) as $id => $events) {
+            $def = $container->getDefinition($id);
+            if (!$def->isPublic()) {
+                throw new \InvalidArgumentException(sprintf('The service "%s" must be public as event listeners are lazy-loaded.', $id));
+            }
+
+            if ($def->isAbstract()) {
+                throw new \InvalidArgumentException(sprintf('The service "%s" must not be abstract as event listeners are lazy-loaded.', $id));
+            }
+
+            foreach ($events as $event) {
+                $priority = isset($event['priority']) ? $event['priority'] : 0;
+
+                if (!isset($event['event'])) {
+                    throw new \InvalidArgumentException(sprintf('Service "%s" must define the "event" attribute on "%s" tags.', $id, $this->listenerTag));
+                }
+
+                if (!isset($event['method'])) {
+                    $event['method'] = 'on'.preg_replace_callback(array(
+                        '/(?<=\b)[a-z]/i',
+                        '/[^a-z0-9]/i',
+                    ), function ($matches) { return strtoupper($matches[0]); }, $event['event']);
+                    $event['method'] = preg_replace('/[^a-z0-9]/i', '', $event['method']);
+                }
+
+                $definition->addMethodCall('addListenerService', array($event['event'], array($id, $event['method']), $priority));
+            }
+        }
+
+        foreach ($container->findTaggedServiceIds($this->subscriberTag) as $id => $attributes) {
+            $def = $container->getDefinition($id);
+            if (!$def->isPublic()) {
+                throw new \InvalidArgumentException(sprintf('The service "%s" must be public as event subscribers are lazy-loaded.', $id));
+            }
+
+            if ($def->isAbstract()) {
+                throw new \InvalidArgumentException(sprintf('The service "%s" must not be abstract as event subscribers are lazy-loaded.', $id));
+            }
+
+            // We must assume that the class value has been correctly filled, even if the service is created by a factory
+            $class = $container->getParameterBag()->resolveValue($def->getClass());
+
+            $interface = 'Symfony\Component\EventDispatcher\EventSubscriberInterface';
+            if (!is_subclass_of($class, $interface)) {
+                throw new \InvalidArgumentException(sprintf('Service "%s" must implement interface "%s".', $id, $interface));
+            }
+
+            $definition->addMethodCall('addSubscriberService', array($id, $class));
+        }
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Event.php

@@ -0,0 +1,120 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher;
+
+/**
+ * Event is the base class for classes containing event data.
+ *
+ * This class contains no event data. It is used by events that do not pass
+ * state information to an event handler when an event is raised.
+ *
+ * You can call the method stopPropagation() to abort the execution of
+ * further listeners in your event listener.
+ *
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class Event
+{
+    /**
+     * @var bool Whether no further event listeners should be triggered
+     */
+    private $propagationStopped = false;
+
+    /**
+     * @var EventDispatcher Dispatcher that dispatched this event
+     */
+    private $dispatcher;
+
+    /**
+     * @var string This event's name
+     */
+    private $name;
+
+    /**
+     * Returns whether further event listeners should be triggered.
+     *
+     * @see Event::stopPropagation()
+     *
+     * @return bool Whether propagation was already stopped for this event
+     */
+    public function isPropagationStopped()
+    {
+        return $this->propagationStopped;
+    }
+
+    /**
+     * Stops the propagation of the event to further event listeners.
+     *
+     * If multiple event listeners are connected to the same event, no
+     * further event listener will be triggered once any trigger calls
+     * stopPropagation().
+     */
+    public function stopPropagation()
+    {
+        $this->propagationStopped = true;
+    }
+
+    /**
+     * Stores the EventDispatcher that dispatches this Event.
+     *
+     * @param EventDispatcherInterface $dispatcher
+     *
+     * @deprecated since version 2.4, to be removed in 3.0. The event dispatcher is passed to the listener call.
+     */
+    public function setDispatcher(EventDispatcherInterface $dispatcher)
+    {
+        $this->dispatcher = $dispatcher;
+    }
+
+    /**
+     * Returns the EventDispatcher that dispatches this Event.
+     *
+     * @return EventDispatcherInterface
+     *
+     * @deprecated since version 2.4, to be removed in 3.0. The event dispatcher is passed to the listener call.
+     */
+    public function getDispatcher()
+    {
+        @trigger_error('The '.__METHOD__.' method is deprecated since version 2.4 and will be removed in 3.0. The event dispatcher instance can be received in the listener call instead.', E_USER_DEPRECATED);
+
+        return $this->dispatcher;
+    }
+
+    /**
+     * Gets the event's name.
+     *
+     * @return string
+     *
+     * @deprecated since version 2.4, to be removed in 3.0. The event name is passed to the listener call.
+     */
+    public function getName()
+    {
+        @trigger_error('The '.__METHOD__.' method is deprecated since version 2.4 and will be removed in 3.0. The event name can be received in the listener call instead.', E_USER_DEPRECATED);
+
+        return $this->name;
+    }
+
+    /**
+     * Sets the event's name property.
+     *
+     * @param string $name The event name
+     *
+     * @deprecated since version 2.4, to be removed in 3.0. The event name is passed to the listener call.
+     */
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/EventDispatcher.php

@@ -0,0 +1,198 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher;
+
+/**
+ * The EventDispatcherInterface is the central point of Symfony's event listener system.
+ *
+ * Listeners are registered on the manager and events are dispatched through the
+ * manager.
+ *
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @author Jordan Alliot <jordan.alliot@gmail.com>
+ */
+class EventDispatcher implements EventDispatcherInterface
+{
+    private $listeners = array();
+    private $sorted = array();
+
+    /**
+     * {@inheritdoc}
+     */
+    public function dispatch($eventName, Event $event = null)
+    {
+        if (null === $event) {
+            $event = new Event();
+        }
+
+        $event->setDispatcher($this);
+        $event->setName($eventName);
+
+        if ($listeners = $this->getListeners($eventName)) {
+            $this->doDispatch($listeners, $eventName, $event);
+        }
+
+        return $event;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getListeners($eventName = null)
+    {
+        if (null !== $eventName) {
+            if (!isset($this->listeners[$eventName])) {
+                return array();
+            }
+
+            if (!isset($this->sorted[$eventName])) {
+                $this->sortListeners($eventName);
+            }
+
+            return $this->sorted[$eventName];
+        }
+
+        foreach ($this->listeners as $eventName => $eventListeners) {
+            if (!isset($this->sorted[$eventName])) {
+                $this->sortListeners($eventName);
+            }
+        }
+
+        return array_filter($this->sorted);
+    }
+
+    /**
+     * Gets the listener priority for a specific event.
+     *
+     * Returns null if the event or the listener does not exist.
+     *
+     * @param string   $eventName The name of the event
+     * @param callable $listener  The listener
+     *
+     * @return int|null The event listener priority
+     */
+    public function getListenerPriority($eventName, $listener)
+    {
+        if (!isset($this->listeners[$eventName])) {
+            return;
+        }
+
+        foreach ($this->listeners[$eventName] as $priority => $listeners) {
+            if (false !== ($key = array_search($listener, $listeners, true))) {
+                return $priority;
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasListeners($eventName = null)
+    {
+        return (bool) count($this->getListeners($eventName));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addListener($eventName, $listener, $priority = 0)
+    {
+        $this->listeners[$eventName][$priority][] = $listener;
+        unset($this->sorted[$eventName]);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function removeListener($eventName, $listener)
+    {
+        if (!isset($this->listeners[$eventName])) {
+            return;
+        }
+
+        foreach ($this->listeners[$eventName] as $priority => $listeners) {
+            if (false !== ($key = array_search($listener, $listeners, true))) {
+                unset($this->listeners[$eventName][$priority][$key], $this->sorted[$eventName]);
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addSubscriber(EventSubscriberInterface $subscriber)
+    {
+        foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
+            if (is_string($params)) {
+                $this->addListener($eventName, array($subscriber, $params));
+            } elseif (is_string($params[0])) {
+                $this->addListener($eventName, array($subscriber, $params[0]), isset($params[1]) ? $params[1] : 0);
+            } else {
+                foreach ($params as $listener) {
+                    $this->addListener($eventName, array($subscriber, $listener[0]), isset($listener[1]) ? $listener[1] : 0);
+                }
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function removeSubscriber(EventSubscriberInterface $subscriber)
+    {
+        foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
+            if (is_array($params) && is_array($params[0])) {
+                foreach ($params as $listener) {
+                    $this->removeListener($eventName, array($subscriber, $listener[0]));
+                }
+            } else {
+                $this->removeListener($eventName, array($subscriber, is_string($params) ? $params : $params[0]));
+            }
+        }
+    }
+
+    /**
+     * Triggers the listeners of an event.
+     *
+     * This method can be overridden to add functionality that is executed
+     * for each listener.
+     *
+     * @param callable[] $listeners The event listeners
+     * @param string     $eventName The name of the event to dispatch
+     * @param Event      $event     The event object to pass to the event handlers/listeners
+     */
+    protected function doDispatch($listeners, $eventName, Event $event)
+    {
+        foreach ($listeners as $listener) {
+            if ($event->isPropagationStopped()) {
+                break;
+            }
+            call_user_func($listener, $event, $eventName, $this);
+        }
+    }
+
+    /**
+     * Sorts the internal list of listeners for the given event by priority.
+     *
+     * @param string $eventName The name of the event
+     */
+    private function sortListeners($eventName)
+    {
+        krsort($this->listeners[$eventName]);
+        $this->sorted[$eventName] = call_user_func_array('array_merge', $this->listeners[$eventName]);
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/EventDispatcherInterface.php

@@ -0,0 +1,88 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher;
+
+/**
+ * The EventDispatcherInterface is the central point of Symfony's event listener system.
+ * Listeners are registered on the manager and events are dispatched through the
+ * manager.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+interface EventDispatcherInterface
+{
+    /**
+     * Dispatches an event to all registered listeners.
+     *
+     * @param string $eventName The name of the event to dispatch. The name of
+     *                          the event is the name of the method that is
+     *                          invoked on listeners.
+     * @param Event  $event     The event to pass to the event handlers/listeners
+     *                          If not supplied, an empty Event instance is created.
+     *
+     * @return Event
+     */
+    public function dispatch($eventName, Event $event = null);
+
+    /**
+     * Adds an event listener that listens on the specified events.
+     *
+     * @param string   $eventName The event to listen on
+     * @param callable $listener  The listener
+     * @param int      $priority  The higher this value, the earlier an event
+     *                            listener will be triggered in the chain (defaults to 0)
+     */
+    public function addListener($eventName, $listener, $priority = 0);
+
+    /**
+     * Adds an event subscriber.
+     *
+     * The subscriber is asked for all the events he is
+     * interested in and added as a listener for these events.
+     *
+     * @param EventSubscriberInterface $subscriber The subscriber
+     */
+    public function addSubscriber(EventSubscriberInterface $subscriber);
+
+    /**
+     * Removes an event listener from the specified events.
+     *
+     * @param string   $eventName The event to remove a listener from
+     * @param callable $listener  The listener to remove
+     */
+    public function removeListener($eventName, $listener);
+
+    /**
+     * Removes an event subscriber.
+     *
+     * @param EventSubscriberInterface $subscriber The subscriber
+     */
+    public function removeSubscriber(EventSubscriberInterface $subscriber);
+
+    /**
+     * Gets the listeners of a specific event or all listeners sorted by descending priority.
+     *
+     * @param string $eventName The name of the event
+     *
+     * @return array The event listeners for the specified event, or all event listeners by event name
+     */
+    public function getListeners($eventName = null);
+
+    /**
+     * Checks whether an event has any registered listeners.
+     *
+     * @param string $eventName The name of the event
+     *
+     * @return bool true if the specified event has any listeners, false otherwise
+     */
+    public function hasListeners($eventName = null);
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/EventSubscriberInterface.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher;
+
+/**
+ * An EventSubscriber knows himself what events he is interested in.
+ * If an EventSubscriber is added to an EventDispatcherInterface, the manager invokes
+ * {@link getSubscribedEvents} and registers the subscriber as a listener for all
+ * returned events.
+ *
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+interface EventSubscriberInterface
+{
+    /**
+     * Returns an array of event names this subscriber wants to listen to.
+     *
+     * The array keys are event names and the value can be:
+     *
+     *  * The method name to call (priority defaults to 0)
+     *  * An array composed of the method name to call and the priority
+     *  * An array of arrays composed of the method names to call and respective
+     *    priorities, or 0 if unset
+     *
+     * For instance:
+     *
+     *  * array('eventName' => 'methodName')
+     *  * array('eventName' => array('methodName', $priority))
+     *  * array('eventName' => array(array('methodName1', $priority), array('methodName2')))
+     *
+     * @return array The event names to listen to
+     */
+    public static function getSubscribedEvents();
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/GenericEvent.php

@@ -0,0 +1,186 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher;
+
+/**
+ * Event encapsulation class.
+ *
+ * Encapsulates events thus decoupling the observer from the subject they encapsulate.
+ *
+ * @author Drak <drak@zikula.org>
+ */
+class GenericEvent extends Event implements \ArrayAccess, \IteratorAggregate
+{
+    /**
+     * Event subject.
+     *
+     * @var mixed usually object or callable
+     */
+    protected $subject;
+
+    /**
+     * Array of arguments.
+     *
+     * @var array
+     */
+    protected $arguments;
+
+    /**
+     * Encapsulate an event with $subject and $args.
+     *
+     * @param mixed $subject   The subject of the event, usually an object
+     * @param array $arguments Arguments to store in the event
+     */
+    public function __construct($subject = null, array $arguments = array())
+    {
+        $this->subject = $subject;
+        $this->arguments = $arguments;
+    }
+
+    /**
+     * Getter for subject property.
+     *
+     * @return mixed $subject The observer subject
+     */
+    public function getSubject()
+    {
+        return $this->subject;
+    }
+
+    /**
+     * Get argument by key.
+     *
+     * @param string $key Key
+     *
+     * @return mixed Contents of array key
+     *
+     * @throws \InvalidArgumentException If key is not found.
+     */
+    public function getArgument($key)
+    {
+        if ($this->hasArgument($key)) {
+            return $this->arguments[$key];
+        }
+
+        throw new \InvalidArgumentException(sprintf('Argument "%s" not found.', $key));
+    }
+
+    /**
+     * Add argument to event.
+     *
+     * @param string $key   Argument name
+     * @param mixed  $value Value
+     *
+     * @return GenericEvent
+     */
+    public function setArgument($key, $value)
+    {
+        $this->arguments[$key] = $value;
+
+        return $this;
+    }
+
+    /**
+     * Getter for all arguments.
+     *
+     * @return array
+     */
+    public function getArguments()
+    {
+        return $this->arguments;
+    }
+
+    /**
+     * Set args property.
+     *
+     * @param array $args Arguments
+     *
+     * @return GenericEvent
+     */
+    public function setArguments(array $args = array())
+    {
+        $this->arguments = $args;
+
+        return $this;
+    }
+
+    /**
+     * Has argument.
+     *
+     * @param string $key Key of arguments array
+     *
+     * @return bool
+     */
+    public function hasArgument($key)
+    {
+        return array_key_exists($key, $this->arguments);
+    }
+
+    /**
+     * ArrayAccess for argument getter.
+     *
+     * @param string $key Array key
+     *
+     * @return mixed
+     *
+     * @throws \InvalidArgumentException If key does not exist in $this->args.
+     */
+    public function offsetGet($key)
+    {
+        return $this->getArgument($key);
+    }
+
+    /**
+     * ArrayAccess for argument setter.
+     *
+     * @param string $key   Array key to set
+     * @param mixed  $value Value
+     */
+    public function offsetSet($key, $value)
+    {
+        $this->setArgument($key, $value);
+    }
+
+    /**
+     * ArrayAccess for unset argument.
+     *
+     * @param string $key Array key
+     */
+    public function offsetUnset($key)
+    {
+        if ($this->hasArgument($key)) {
+            unset($this->arguments[$key]);
+        }
+    }
+
+    /**
+     * ArrayAccess has argument.
+     *
+     * @param string $key Array key
+     *
+     * @return bool
+     */
+    public function offsetExists($key)
+    {
+        return $this->hasArgument($key);
+    }
+
+    /**
+     * IteratorAggregate for iterating over the object like an array.
+     *
+     * @return \ArrayIterator
+     */
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->arguments);
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/ImmutableEventDispatcher.php

@@ -0,0 +1,101 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher;
+
+/**
+ * A read-only proxy for an event dispatcher.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class ImmutableEventDispatcher implements EventDispatcherInterface
+{
+    /**
+     * The proxied dispatcher.
+     *
+     * @var EventDispatcherInterface
+     */
+    private $dispatcher;
+
+    /**
+     * Creates an unmodifiable proxy for an event dispatcher.
+     *
+     * @param EventDispatcherInterface $dispatcher The proxied event dispatcher
+     */
+    public function __construct(EventDispatcherInterface $dispatcher)
+    {
+        $this->dispatcher = $dispatcher;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function dispatch($eventName, Event $event = null)
+    {
+        return $this->dispatcher->dispatch($eventName, $event);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addListener($eventName, $listener, $priority = 0)
+    {
+        throw new \BadMethodCallException('Unmodifiable event dispatchers must not be modified.');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addSubscriber(EventSubscriberInterface $subscriber)
+    {
+        throw new \BadMethodCallException('Unmodifiable event dispatchers must not be modified.');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function removeListener($eventName, $listener)
+    {
+        throw new \BadMethodCallException('Unmodifiable event dispatchers must not be modified.');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function removeSubscriber(EventSubscriberInterface $subscriber)
+    {
+        throw new \BadMethodCallException('Unmodifiable event dispatchers must not be modified.');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getListeners($eventName = null)
+    {
+        return $this->dispatcher->getListeners($eventName);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getListenerPriority($eventName, $listener)
+    {
+        return $this->dispatcher->getListenerPriority($eventName, $listener);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasListeners($eventName = null)
+    {
+        return $this->dispatcher->hasListeners($eventName);
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2004-2016 Fabien Potencier
+
+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.

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/README.md

@@ -0,0 +1,15 @@
+EventDispatcher Component
+=========================
+
+The EventDispatcher component provides tools that allow your application
+components to communicate with each other by dispatching events and listening to
+them.
+
+Resources
+---------
+
+  * [Documentation](https://symfony.com/doc/current/components/event_dispatcher/index.html)
+  * [Contributing](https://symfony.com/doc/current/contributing/index.html)
+  * [Report issues](https://github.com/symfony/symfony/issues) and
+    [send Pull Requests](https://github.com/symfony/symfony/pulls)
+    in the [main Symfony repository](https://github.com/symfony/symfony)

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Tests/AbstractEventDispatcherTest.php

@@ -0,0 +1,396 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Tests;
+
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\EventDispatcher\EventDispatcher;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+
+abstract class AbstractEventDispatcherTest extends \PHPUnit_Framework_TestCase
+{
+    /* Some pseudo events */
+    const preFoo = 'pre.foo';
+    const postFoo = 'post.foo';
+    const preBar = 'pre.bar';
+    const postBar = 'post.bar';
+
+    /**
+     * @var EventDispatcher
+     */
+    private $dispatcher;
+
+    private $listener;
+
+    protected function setUp()
+    {
+        $this->dispatcher = $this->createEventDispatcher();
+        $this->listener = new TestEventListener();
+    }
+
+    protected function tearDown()
+    {
+        $this->dispatcher = null;
+        $this->listener = null;
+    }
+
+    abstract protected function createEventDispatcher();
+
+    public function testInitialState()
+    {
+        $this->assertEquals(array(), $this->dispatcher->getListeners());
+        $this->assertFalse($this->dispatcher->hasListeners(self::preFoo));
+        $this->assertFalse($this->dispatcher->hasListeners(self::postFoo));
+    }
+
+    public function testAddListener()
+    {
+        $this->dispatcher->addListener('pre.foo', array($this->listener, 'preFoo'));
+        $this->dispatcher->addListener('post.foo', array($this->listener, 'postFoo'));
+        $this->assertTrue($this->dispatcher->hasListeners(self::preFoo));
+        $this->assertTrue($this->dispatcher->hasListeners(self::postFoo));
+        $this->assertCount(1, $this->dispatcher->getListeners(self::preFoo));
+        $this->assertCount(1, $this->dispatcher->getListeners(self::postFoo));
+        $this->assertCount(2, $this->dispatcher->getListeners());
+    }
+
+    public function testGetListenersSortsByPriority()
+    {
+        $listener1 = new TestEventListener();
+        $listener2 = new TestEventListener();
+        $listener3 = new TestEventListener();
+        $listener1->name = '1';
+        $listener2->name = '2';
+        $listener3->name = '3';
+
+        $this->dispatcher->addListener('pre.foo', array($listener1, 'preFoo'), -10);
+        $this->dispatcher->addListener('pre.foo', array($listener2, 'preFoo'), 10);
+        $this->dispatcher->addListener('pre.foo', array($listener3, 'preFoo'));
+
+        $expected = array(
+            array($listener2, 'preFoo'),
+            array($listener3, 'preFoo'),
+            array($listener1, 'preFoo'),
+        );
+
+        $this->assertSame($expected, $this->dispatcher->getListeners('pre.foo'));
+    }
+
+    public function testGetAllListenersSortsByPriority()
+    {
+        $listener1 = new TestEventListener();
+        $listener2 = new TestEventListener();
+        $listener3 = new TestEventListener();
+        $listener4 = new TestEventListener();
+        $listener5 = new TestEventListener();
+        $listener6 = new TestEventListener();
+
+        $this->dispatcher->addListener('pre.foo', $listener1, -10);
+        $this->dispatcher->addListener('pre.foo', $listener2);
+        $this->dispatcher->addListener('pre.foo', $listener3, 10);
+        $this->dispatcher->addListener('post.foo', $listener4, -10);
+        $this->dispatcher->addListener('post.foo', $listener5);
+        $this->dispatcher->addListener('post.foo', $listener6, 10);
+
+        $expected = array(
+            'pre.foo' => array($listener3, $listener2, $listener1),
+            'post.foo' => array($listener6, $listener5, $listener4),
+        );
+
+        $this->assertSame($expected, $this->dispatcher->getListeners());
+    }
+
+    public function testGetListenerPriority()
+    {
+        $listener1 = new TestEventListener();
+        $listener2 = new TestEventListener();
+
+        $this->dispatcher->addListener('pre.foo', $listener1, -10);
+        $this->dispatcher->addListener('pre.foo', $listener2);
+
+        $this->assertSame(-10, $this->dispatcher->getListenerPriority('pre.foo', $listener1));
+        $this->assertSame(0, $this->dispatcher->getListenerPriority('pre.foo', $listener2));
+        $this->assertNull($this->dispatcher->getListenerPriority('pre.bar', $listener2));
+        $this->assertNull($this->dispatcher->getListenerPriority('pre.foo', function () {}));
+    }
+
+    public function testDispatch()
+    {
+        $this->dispatcher->addListener('pre.foo', array($this->listener, 'preFoo'));
+        $this->dispatcher->addListener('post.foo', array($this->listener, 'postFoo'));
+        $this->dispatcher->dispatch(self::preFoo);
+        $this->assertTrue($this->listener->preFooInvoked);
+        $this->assertFalse($this->listener->postFooInvoked);
+        $this->assertInstanceOf('Symfony\Component\EventDispatcher\Event', $this->dispatcher->dispatch('noevent'));
+        $this->assertInstanceOf('Symfony\Component\EventDispatcher\Event', $this->dispatcher->dispatch(self::preFoo));
+        $event = new Event();
+        $return = $this->dispatcher->dispatch(self::preFoo, $event);
+        $this->assertSame($event, $return);
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testLegacyDispatch()
+    {
+        $event = new Event();
+        $return = $this->dispatcher->dispatch(self::preFoo, $event);
+        $this->assertEquals('pre.foo', $event->getName());
+    }
+
+    public function testDispatchForClosure()
+    {
+        $invoked = 0;
+        $listener = function () use (&$invoked) {
+            ++$invoked;
+        };
+        $this->dispatcher->addListener('pre.foo', $listener);
+        $this->dispatcher->addListener('post.foo', $listener);
+        $this->dispatcher->dispatch(self::preFoo);
+        $this->assertEquals(1, $invoked);
+    }
+
+    public function testStopEventPropagation()
+    {
+        $otherListener = new TestEventListener();
+
+        // postFoo() stops the propagation, so only one listener should
+        // be executed
+        // Manually set priority to enforce $this->listener to be called first
+        $this->dispatcher->addListener('post.foo', array($this->listener, 'postFoo'), 10);
+        $this->dispatcher->addListener('post.foo', array($otherListener, 'preFoo'));
+        $this->dispatcher->dispatch(self::postFoo);
+        $this->assertTrue($this->listener->postFooInvoked);
+        $this->assertFalse($otherListener->postFooInvoked);
+    }
+
+    public function testDispatchByPriority()
+    {
+        $invoked = array();
+        $listener1 = function () use (&$invoked) {
+            $invoked[] = '1';
+        };
+        $listener2 = function () use (&$invoked) {
+            $invoked[] = '2';
+        };
+        $listener3 = function () use (&$invoked) {
+            $invoked[] = '3';
+        };
+        $this->dispatcher->addListener('pre.foo', $listener1, -10);
+        $this->dispatcher->addListener('pre.foo', $listener2);
+        $this->dispatcher->addListener('pre.foo', $listener3, 10);
+        $this->dispatcher->dispatch(self::preFoo);
+        $this->assertEquals(array('3', '2', '1'), $invoked);
+    }
+
+    public function testRemoveListener()
+    {
+        $this->dispatcher->addListener('pre.bar', $this->listener);
+        $this->assertTrue($this->dispatcher->hasListeners(self::preBar));
+        $this->dispatcher->removeListener('pre.bar', $this->listener);
+        $this->assertFalse($this->dispatcher->hasListeners(self::preBar));
+        $this->dispatcher->removeListener('notExists', $this->listener);
+    }
+
+    public function testAddSubscriber()
+    {
+        $eventSubscriber = new TestEventSubscriber();
+        $this->dispatcher->addSubscriber($eventSubscriber);
+        $this->assertTrue($this->dispatcher->hasListeners(self::preFoo));
+        $this->assertTrue($this->dispatcher->hasListeners(self::postFoo));
+    }
+
+    public function testAddSubscriberWithPriorities()
+    {
+        $eventSubscriber = new TestEventSubscriber();
+        $this->dispatcher->addSubscriber($eventSubscriber);
+
+        $eventSubscriber = new TestEventSubscriberWithPriorities();
+        $this->dispatcher->addSubscriber($eventSubscriber);
+
+        $listeners = $this->dispatcher->getListeners('pre.foo');
+        $this->assertTrue($this->dispatcher->hasListeners(self::preFoo));
+        $this->assertCount(2, $listeners);
+        $this->assertInstanceOf('Symfony\Component\EventDispatcher\Tests\TestEventSubscriberWithPriorities', $listeners[0][0]);
+    }
+
+    public function testAddSubscriberWithMultipleListeners()
+    {
+        $eventSubscriber = new TestEventSubscriberWithMultipleListeners();
+        $this->dispatcher->addSubscriber($eventSubscriber);
+
+        $listeners = $this->dispatcher->getListeners('pre.foo');
+        $this->assertTrue($this->dispatcher->hasListeners(self::preFoo));
+        $this->assertCount(2, $listeners);
+        $this->assertEquals('preFoo2', $listeners[0][1]);
+    }
+
+    public function testRemoveSubscriber()
+    {
+        $eventSubscriber = new TestEventSubscriber();
+        $this->dispatcher->addSubscriber($eventSubscriber);
+        $this->assertTrue($this->dispatcher->hasListeners(self::preFoo));
+        $this->assertTrue($this->dispatcher->hasListeners(self::postFoo));
+        $this->dispatcher->removeSubscriber($eventSubscriber);
+        $this->assertFalse($this->dispatcher->hasListeners(self::preFoo));
+        $this->assertFalse($this->dispatcher->hasListeners(self::postFoo));
+    }
+
+    public function testRemoveSubscriberWithPriorities()
+    {
+        $eventSubscriber = new TestEventSubscriberWithPriorities();
+        $this->dispatcher->addSubscriber($eventSubscriber);
+        $this->assertTrue($this->dispatcher->hasListeners(self::preFoo));
+        $this->dispatcher->removeSubscriber($eventSubscriber);
+        $this->assertFalse($this->dispatcher->hasListeners(self::preFoo));
+    }
+
+    public function testRemoveSubscriberWithMultipleListeners()
+    {
+        $eventSubscriber = new TestEventSubscriberWithMultipleListeners();
+        $this->dispatcher->addSubscriber($eventSubscriber);
+        $this->assertTrue($this->dispatcher->hasListeners(self::preFoo));
+        $this->assertCount(2, $this->dispatcher->getListeners(self::preFoo));
+        $this->dispatcher->removeSubscriber($eventSubscriber);
+        $this->assertFalse($this->dispatcher->hasListeners(self::preFoo));
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testLegacyEventReceivesTheDispatcherInstance()
+    {
+        $dispatcher = null;
+        $this->dispatcher->addListener('test', function ($event) use (&$dispatcher) {
+            $dispatcher = $event->getDispatcher();
+        });
+        $this->dispatcher->dispatch('test');
+        $this->assertSame($this->dispatcher, $dispatcher);
+    }
+
+    public function testEventReceivesTheDispatcherInstanceAsArgument()
+    {
+        $listener = new TestWithDispatcher();
+        $this->dispatcher->addListener('test', array($listener, 'foo'));
+        $this->assertNull($listener->name);
+        $this->assertNull($listener->dispatcher);
+        $this->dispatcher->dispatch('test');
+        $this->assertEquals('test', $listener->name);
+        $this->assertSame($this->dispatcher, $listener->dispatcher);
+    }
+
+    /**
+     * @see https://bugs.php.net/bug.php?id=62976
+     *
+     * This bug affects:
+     *  - The PHP 5.3 branch for versions < 5.3.18
+     *  - The PHP 5.4 branch for versions < 5.4.8
+     *  - The PHP 5.5 branch is not affected
+     */
+    public function testWorkaroundForPhpBug62976()
+    {
+        $dispatcher = $this->createEventDispatcher();
+        $dispatcher->addListener('bug.62976', new CallableClass());
+        $dispatcher->removeListener('bug.62976', function () {});
+        $this->assertTrue($dispatcher->hasListeners('bug.62976'));
+    }
+
+    public function testHasListenersWhenAddedCallbackListenerIsRemoved()
+    {
+        $listener = function () {};
+        $this->dispatcher->addListener('foo', $listener);
+        $this->dispatcher->removeListener('foo', $listener);
+        $this->assertFalse($this->dispatcher->hasListeners());
+    }
+
+    public function testGetListenersWhenAddedCallbackListenerIsRemoved()
+    {
+        $listener = function () {};
+        $this->dispatcher->addListener('foo', $listener);
+        $this->dispatcher->removeListener('foo', $listener);
+        $this->assertSame(array(), $this->dispatcher->getListeners());
+    }
+
+    public function testHasListenersWithoutEventsReturnsFalseAfterHasListenersWithEventHasBeenCalled()
+    {
+        $this->assertFalse($this->dispatcher->hasListeners('foo'));
+        $this->assertFalse($this->dispatcher->hasListeners());
+    }
+}
+
+class CallableClass
+{
+    public function __invoke()
+    {
+    }
+}
+
+class TestEventListener
+{
+    public $preFooInvoked = false;
+    public $postFooInvoked = false;
+
+    /* Listener methods */
+
+    public function preFoo(Event $e)
+    {
+        $this->preFooInvoked = true;
+    }
+
+    public function postFoo(Event $e)
+    {
+        $this->postFooInvoked = true;
+
+        $e->stopPropagation();
+    }
+}
+
+class TestWithDispatcher
+{
+    public $name;
+    public $dispatcher;
+
+    public function foo(Event $e, $name, $dispatcher)
+    {
+        $this->name = $name;
+        $this->dispatcher = $dispatcher;
+    }
+}
+
+class TestEventSubscriber implements EventSubscriberInterface
+{
+    public static function getSubscribedEvents()
+    {
+        return array('pre.foo' => 'preFoo', 'post.foo' => 'postFoo');
+    }
+}
+
+class TestEventSubscriberWithPriorities implements EventSubscriberInterface
+{
+    public static function getSubscribedEvents()
+    {
+        return array(
+            'pre.foo' => array('preFoo', 10),
+            'post.foo' => array('postFoo'),
+            );
+    }
+}
+
+class TestEventSubscriberWithMultipleListeners implements EventSubscriberInterface
+{
+    public static function getSubscribedEvents()
+    {
+        return array('pre.foo' => array(
+            array('preFoo1'),
+            array('preFoo2', 10),
+        ));
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Tests/ContainerAwareEventDispatcherTest.php

@@ -0,0 +1,277 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Tests;
+
+use Symfony\Component\DependencyInjection\Container;
+use Symfony\Component\DependencyInjection\Scope;
+use Symfony\Component\EventDispatcher\ContainerAwareEventDispatcher;
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+
+class ContainerAwareEventDispatcherTest extends AbstractEventDispatcherTest
+{
+    protected function createEventDispatcher()
+    {
+        $container = new Container();
+
+        return new ContainerAwareEventDispatcher($container);
+    }
+
+    public function testAddAListenerService()
+    {
+        $event = new Event();
+
+        $service = $this->getMock('Symfony\Component\EventDispatcher\Tests\Service');
+
+        $service
+            ->expects($this->once())
+            ->method('onEvent')
+            ->with($event)
+        ;
+
+        $container = new Container();
+        $container->set('service.listener', $service);
+
+        $dispatcher = new ContainerAwareEventDispatcher($container);
+        $dispatcher->addListenerService('onEvent', array('service.listener', 'onEvent'));
+
+        $dispatcher->dispatch('onEvent', $event);
+    }
+
+    public function testAddASubscriberService()
+    {
+        $event = new Event();
+
+        $service = $this->getMock('Symfony\Component\EventDispatcher\Tests\SubscriberService');
+
+        $service
+            ->expects($this->once())
+            ->method('onEvent')
+            ->with($event)
+        ;
+
+        $service
+            ->expects($this->once())
+            ->method('onEventWithPriority')
+            ->with($event)
+        ;
+
+        $service
+            ->expects($this->once())
+            ->method('onEventNested')
+            ->with($event)
+        ;
+
+        $container = new Container();
+        $container->set('service.subscriber', $service);
+
+        $dispatcher = new ContainerAwareEventDispatcher($container);
+        $dispatcher->addSubscriberService('service.subscriber', 'Symfony\Component\EventDispatcher\Tests\SubscriberService');
+
+        $dispatcher->dispatch('onEvent', $event);
+        $dispatcher->dispatch('onEventWithPriority', $event);
+        $dispatcher->dispatch('onEventNested', $event);
+    }
+
+    public function testPreventDuplicateListenerService()
+    {
+        $event = new Event();
+
+        $service = $this->getMock('Symfony\Component\EventDispatcher\Tests\Service');
+
+        $service
+            ->expects($this->once())
+            ->method('onEvent')
+            ->with($event)
+        ;
+
+        $container = new Container();
+        $container->set('service.listener', $service);
+
+        $dispatcher = new ContainerAwareEventDispatcher($container);
+        $dispatcher->addListenerService('onEvent', array('service.listener', 'onEvent'), 5);
+        $dispatcher->addListenerService('onEvent', array('service.listener', 'onEvent'), 10);
+
+        $dispatcher->dispatch('onEvent', $event);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @group legacy
+     */
+    public function testTriggerAListenerServiceOutOfScope()
+    {
+        $service = $this->getMock('Symfony\Component\EventDispatcher\Tests\Service');
+
+        $scope = new Scope('scope');
+        $container = new Container();
+        $container->addScope($scope);
+        $container->enterScope('scope');
+
+        $container->set('service.listener', $service, 'scope');
+
+        $dispatcher = new ContainerAwareEventDispatcher($container);
+        $dispatcher->addListenerService('onEvent', array('service.listener', 'onEvent'));
+
+        $container->leaveScope('scope');
+        $dispatcher->dispatch('onEvent');
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testReEnteringAScope()
+    {
+        $event = new Event();
+
+        $service1 = $this->getMock('Symfony\Component\EventDispatcher\Tests\Service');
+
+        $service1
+            ->expects($this->exactly(2))
+            ->method('onEvent')
+            ->with($event)
+        ;
+
+        $scope = new Scope('scope');
+        $container = new Container();
+        $container->addScope($scope);
+        $container->enterScope('scope');
+
+        $container->set('service.listener', $service1, 'scope');
+
+        $dispatcher = new ContainerAwareEventDispatcher($container);
+        $dispatcher->addListenerService('onEvent', array('service.listener', 'onEvent'));
+        $dispatcher->dispatch('onEvent', $event);
+
+        $service2 = $this->getMock('Symfony\Component\EventDispatcher\Tests\Service');
+
+        $service2
+            ->expects($this->once())
+            ->method('onEvent')
+            ->with($event)
+        ;
+
+        $container->enterScope('scope');
+        $container->set('service.listener', $service2, 'scope');
+
+        $dispatcher->dispatch('onEvent', $event);
+
+        $container->leaveScope('scope');
+
+        $dispatcher->dispatch('onEvent');
+    }
+
+    public function testHasListenersOnLazyLoad()
+    {
+        $event = new Event();
+
+        $service = $this->getMock('Symfony\Component\EventDispatcher\Tests\Service');
+
+        $container = new Container();
+        $container->set('service.listener', $service);
+
+        $dispatcher = new ContainerAwareEventDispatcher($container);
+        $dispatcher->addListenerService('onEvent', array('service.listener', 'onEvent'));
+
+        $event->setDispatcher($dispatcher);
+        $event->setName('onEvent');
+
+        $service
+            ->expects($this->once())
+            ->method('onEvent')
+            ->with($event)
+        ;
+
+        $this->assertTrue($dispatcher->hasListeners());
+
+        if ($dispatcher->hasListeners('onEvent')) {
+            $dispatcher->dispatch('onEvent');
+        }
+    }
+
+    public function testGetListenersOnLazyLoad()
+    {
+        $service = $this->getMock('Symfony\Component\EventDispatcher\Tests\Service');
+
+        $container = new Container();
+        $container->set('service.listener', $service);
+
+        $dispatcher = new ContainerAwareEventDispatcher($container);
+        $dispatcher->addListenerService('onEvent', array('service.listener', 'onEvent'));
+
+        $listeners = $dispatcher->getListeners();
+
+        $this->assertTrue(isset($listeners['onEvent']));
+
+        $this->assertCount(1, $dispatcher->getListeners('onEvent'));
+    }
+
+    public function testRemoveAfterDispatch()
+    {
+        $service = $this->getMock('Symfony\Component\EventDispatcher\Tests\Service');
+
+        $container = new Container();
+        $container->set('service.listener', $service);
+
+        $dispatcher = new ContainerAwareEventDispatcher($container);
+        $dispatcher->addListenerService('onEvent', array('service.listener', 'onEvent'));
+
+        $dispatcher->dispatch('onEvent', new Event());
+        $dispatcher->removeListener('onEvent', array($container->get('service.listener'), 'onEvent'));
+        $this->assertFalse($dispatcher->hasListeners('onEvent'));
+    }
+
+    public function testRemoveBeforeDispatch()
+    {
+        $service = $this->getMock('Symfony\Component\EventDispatcher\Tests\Service');
+
+        $container = new Container();
+        $container->set('service.listener', $service);
+
+        $dispatcher = new ContainerAwareEventDispatcher($container);
+        $dispatcher->addListenerService('onEvent', array('service.listener', 'onEvent'));
+
+        $dispatcher->removeListener('onEvent', array($container->get('service.listener'), 'onEvent'));
+        $this->assertFalse($dispatcher->hasListeners('onEvent'));
+    }
+}
+
+class Service
+{
+    public function onEvent(Event $e)
+    {
+    }
+}
+
+class SubscriberService implements EventSubscriberInterface
+{
+    public static function getSubscribedEvents()
+    {
+        return array(
+            'onEvent' => 'onEvent',
+            'onEventWithPriority' => array('onEventWithPriority', 10),
+            'onEventNested' => array(array('onEventNested')),
+        );
+    }
+
+    public function onEvent(Event $e)
+    {
+    }
+
+    public function onEventWithPriority(Event $e)
+    {
+    }
+
+    public function onEventNested(Event $e)
+    {
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Tests/Debug/TraceableEventDispatcherTest.php

@@ -0,0 +1,226 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Tests\Debug;
+
+use Symfony\Component\EventDispatcher\Debug\TraceableEventDispatcher;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\EventDispatcher\EventDispatcher;
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\Stopwatch\Stopwatch;
+
+class TraceableEventDispatcherTest extends \PHPUnit_Framework_TestCase
+{
+    public function testAddRemoveListener()
+    {
+        $dispatcher = new EventDispatcher();
+        $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
+
+        $tdispatcher->addListener('foo', $listener = function () {});
+        $listeners = $dispatcher->getListeners('foo');
+        $this->assertCount(1, $listeners);
+        $this->assertSame($listener, $listeners[0]);
+
+        $tdispatcher->removeListener('foo', $listener);
+        $this->assertCount(0, $dispatcher->getListeners('foo'));
+    }
+
+    public function testGetListeners()
+    {
+        $dispatcher = new EventDispatcher();
+        $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
+
+        $tdispatcher->addListener('foo', $listener = function () {});
+        $this->assertSame($dispatcher->getListeners('foo'), $tdispatcher->getListeners('foo'));
+    }
+
+    public function testHasListeners()
+    {
+        $dispatcher = new EventDispatcher();
+        $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
+
+        $this->assertFalse($dispatcher->hasListeners('foo'));
+        $this->assertFalse($tdispatcher->hasListeners('foo'));
+
+        $tdispatcher->addListener('foo', $listener = function () {});
+        $this->assertTrue($dispatcher->hasListeners('foo'));
+        $this->assertTrue($tdispatcher->hasListeners('foo'));
+    }
+
+    public function testGetListenerPriority()
+    {
+        $dispatcher = new EventDispatcher();
+        $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
+
+        $tdispatcher->addListener('foo', function () {}, 123);
+
+        $listeners = $dispatcher->getListeners('foo');
+        $this->assertSame(123, $tdispatcher->getListenerPriority('foo', $listeners[0]));
+
+        // Verify that priority is preserved when listener is removed and re-added
+        // in preProcess() and postProcess().
+        $tdispatcher->dispatch('foo', new Event());
+        $listeners = $dispatcher->getListeners('foo');
+        $this->assertSame(123, $tdispatcher->getListenerPriority('foo', $listeners[0]));
+    }
+
+    public function testGetListenerPriorityReturnsZeroWhenWrappedMethodDoesNotExist()
+    {
+        $dispatcher = $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface');
+        $traceableEventDispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
+        $traceableEventDispatcher->addListener('foo', function () {}, 123);
+        $listeners = $traceableEventDispatcher->getListeners('foo');
+
+        $this->assertSame(0, $traceableEventDispatcher->getListenerPriority('foo', $listeners[0]));
+    }
+
+    public function testAddRemoveSubscriber()
+    {
+        $dispatcher = new EventDispatcher();
+        $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
+
+        $subscriber = new EventSubscriber();
+
+        $tdispatcher->addSubscriber($subscriber);
+        $listeners = $dispatcher->getListeners('foo');
+        $this->assertCount(1, $listeners);
+        $this->assertSame(array($subscriber, 'call'), $listeners[0]);
+
+        $tdispatcher->removeSubscriber($subscriber);
+        $this->assertCount(0, $dispatcher->getListeners('foo'));
+    }
+
+    public function testGetCalledListeners()
+    {
+        $dispatcher = new EventDispatcher();
+        $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
+        $tdispatcher->addListener('foo', $listener = function () {});
+
+        $this->assertEquals(array(), $tdispatcher->getCalledListeners());
+        $this->assertEquals(array('foo.closure' => array('event' => 'foo', 'type' => 'Closure', 'pretty' => 'closure', 'priority' => 0)), $tdispatcher->getNotCalledListeners());
+
+        $tdispatcher->dispatch('foo');
+
+        $this->assertEquals(array('foo.closure' => array('event' => 'foo', 'type' => 'Closure', 'pretty' => 'closure', 'priority' => null)), $tdispatcher->getCalledListeners());
+        $this->assertEquals(array(), $tdispatcher->getNotCalledListeners());
+    }
+
+    public function testGetCalledListenersNested()
+    {
+        $tdispatcher = null;
+        $dispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
+        $dispatcher->addListener('foo', function (Event $event, $eventName, $dispatcher) use (&$tdispatcher) {
+            $tdispatcher = $dispatcher;
+            $dispatcher->dispatch('bar');
+        });
+        $dispatcher->addListener('bar', function (Event $event) {});
+        $dispatcher->dispatch('foo');
+        $this->assertSame($dispatcher, $tdispatcher);
+        $this->assertCount(2, $dispatcher->getCalledListeners());
+    }
+
+    public function testLogger()
+    {
+        $logger = $this->getMock('Psr\Log\LoggerInterface');
+
+        $dispatcher = new EventDispatcher();
+        $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch(), $logger);
+        $tdispatcher->addListener('foo', $listener1 = function () {});
+        $tdispatcher->addListener('foo', $listener2 = function () {});
+
+        $logger->expects($this->at(0))->method('debug')->with('Notified event "foo" to listener "closure".');
+        $logger->expects($this->at(1))->method('debug')->with('Notified event "foo" to listener "closure".');
+
+        $tdispatcher->dispatch('foo');
+    }
+
+    public function testLoggerWithStoppedEvent()
+    {
+        $logger = $this->getMock('Psr\Log\LoggerInterface');
+
+        $dispatcher = new EventDispatcher();
+        $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch(), $logger);
+        $tdispatcher->addListener('foo', $listener1 = function (Event $event) { $event->stopPropagation(); });
+        $tdispatcher->addListener('foo', $listener2 = function () {});
+
+        $logger->expects($this->at(0))->method('debug')->with('Notified event "foo" to listener "closure".');
+        $logger->expects($this->at(1))->method('debug')->with('Listener "closure" stopped propagation of the event "foo".');
+        $logger->expects($this->at(2))->method('debug')->with('Listener "closure" was not called for event "foo".');
+
+        $tdispatcher->dispatch('foo');
+    }
+
+    public function testDispatchCallListeners()
+    {
+        $called = array();
+
+        $dispatcher = new EventDispatcher();
+        $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
+        $tdispatcher->addListener('foo', function () use (&$called) { $called[] = 'foo1'; }, 10);
+        $tdispatcher->addListener('foo', function () use (&$called) { $called[] = 'foo2'; }, 20);
+
+        $tdispatcher->dispatch('foo');
+
+        $this->assertSame(array('foo2', 'foo1'), $called);
+    }
+
+    public function testDispatchNested()
+    {
+        $dispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
+        $loop = 1;
+        $dispatcher->addListener('foo', $listener1 = function () use ($dispatcher, &$loop) {
+            ++$loop;
+            if (2 == $loop) {
+                $dispatcher->dispatch('foo');
+            }
+        });
+
+        $dispatcher->dispatch('foo');
+    }
+
+    public function testDispatchReusedEventNested()
+    {
+        $nestedCall = false;
+        $dispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
+        $dispatcher->addListener('foo', function (Event $e) use ($dispatcher) {
+            $dispatcher->dispatch('bar', $e);
+        });
+        $dispatcher->addListener('bar', function (Event $e) use (&$nestedCall) {
+            $nestedCall = true;
+        });
+
+        $this->assertFalse($nestedCall);
+        $dispatcher->dispatch('foo');
+        $this->assertTrue($nestedCall);
+    }
+
+    public function testListenerCanRemoveItselfWhenExecuted()
+    {
+        $eventDispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
+        $listener1 = function ($event, $eventName, EventDispatcherInterface $dispatcher) use (&$listener1) {
+            $dispatcher->removeListener('foo', $listener1);
+        };
+        $eventDispatcher->addListener('foo', $listener1);
+        $eventDispatcher->addListener('foo', function () {});
+        $eventDispatcher->dispatch('foo');
+
+        $this->assertCount(1, $eventDispatcher->getListeners('foo'), 'expected listener1 to be removed');
+    }
+}
+
+class EventSubscriber implements EventSubscriberInterface
+{
+    public static function getSubscribedEvents()
+    {
+        return array('foo' => 'call');
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Tests/DependencyInjection/RegisterListenersPassTest.php

@@ -0,0 +1,200 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Tests\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\EventDispatcher\DependencyInjection\RegisterListenersPass;
+
+class RegisterListenersPassTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * Tests that event subscribers not implementing EventSubscriberInterface
+     * trigger an exception.
+     *
+     * @expectedException \InvalidArgumentException
+     */
+    public function testEventSubscriberWithoutInterface()
+    {
+        // one service, not implementing any interface
+        $services = array(
+            'my_event_subscriber' => array(0 => array()),
+        );
+
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $definition->expects($this->atLeastOnce())
+            ->method('isPublic')
+            ->will($this->returnValue(true));
+        $definition->expects($this->atLeastOnce())
+            ->method('getClass')
+            ->will($this->returnValue('stdClass'));
+
+        $builder = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('hasDefinition', 'findTaggedServiceIds', 'getDefinition')
+        );
+        $builder->expects($this->any())
+            ->method('hasDefinition')
+            ->will($this->returnValue(true));
+
+        // We don't test kernel.event_listener here
+        $builder->expects($this->atLeastOnce())
+            ->method('findTaggedServiceIds')
+            ->will($this->onConsecutiveCalls(array(), $services));
+
+        $builder->expects($this->atLeastOnce())
+            ->method('getDefinition')
+            ->will($this->returnValue($definition));
+
+        $registerListenersPass = new RegisterListenersPass();
+        $registerListenersPass->process($builder);
+    }
+
+    public function testValidEventSubscriber()
+    {
+        $services = array(
+            'my_event_subscriber' => array(0 => array()),
+        );
+
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $definition->expects($this->atLeastOnce())
+            ->method('isPublic')
+            ->will($this->returnValue(true));
+        $definition->expects($this->atLeastOnce())
+            ->method('getClass')
+            ->will($this->returnValue('Symfony\Component\EventDispatcher\Tests\DependencyInjection\SubscriberService'));
+
+        $builder = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('hasDefinition', 'findTaggedServiceIds', 'getDefinition', 'findDefinition')
+        );
+        $builder->expects($this->any())
+            ->method('hasDefinition')
+            ->will($this->returnValue(true));
+
+        // We don't test kernel.event_listener here
+        $builder->expects($this->atLeastOnce())
+            ->method('findTaggedServiceIds')
+            ->will($this->onConsecutiveCalls(array(), $services));
+
+        $builder->expects($this->atLeastOnce())
+            ->method('getDefinition')
+            ->will($this->returnValue($definition));
+
+        $builder->expects($this->atLeastOnce())
+            ->method('findDefinition')
+            ->will($this->returnValue($definition));
+
+        $registerListenersPass = new RegisterListenersPass();
+        $registerListenersPass->process($builder);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The service "foo" must be public as event listeners are lazy-loaded.
+     */
+    public function testPrivateEventListener()
+    {
+        $container = new ContainerBuilder();
+        $container->register('foo', 'stdClass')->setPublic(false)->addTag('kernel.event_listener', array());
+        $container->register('event_dispatcher', 'stdClass');
+
+        $registerListenersPass = new RegisterListenersPass();
+        $registerListenersPass->process($container);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The service "foo" must be public as event subscribers are lazy-loaded.
+     */
+    public function testPrivateEventSubscriber()
+    {
+        $container = new ContainerBuilder();
+        $container->register('foo', 'stdClass')->setPublic(false)->addTag('kernel.event_subscriber', array());
+        $container->register('event_dispatcher', 'stdClass');
+
+        $registerListenersPass = new RegisterListenersPass();
+        $registerListenersPass->process($container);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The service "foo" must not be abstract as event listeners are lazy-loaded.
+     */
+    public function testAbstractEventListener()
+    {
+        $container = new ContainerBuilder();
+        $container->register('foo', 'stdClass')->setAbstract(true)->addTag('kernel.event_listener', array());
+        $container->register('event_dispatcher', 'stdClass');
+
+        $registerListenersPass = new RegisterListenersPass();
+        $registerListenersPass->process($container);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The service "foo" must not be abstract as event subscribers are lazy-loaded.
+     */
+    public function testAbstractEventSubscriber()
+    {
+        $container = new ContainerBuilder();
+        $container->register('foo', 'stdClass')->setAbstract(true)->addTag('kernel.event_subscriber', array());
+        $container->register('event_dispatcher', 'stdClass');
+
+        $registerListenersPass = new RegisterListenersPass();
+        $registerListenersPass->process($container);
+    }
+
+    public function testEventSubscriberResolvableClassName()
+    {
+        $container = new ContainerBuilder();
+
+        $container->setParameter('subscriber.class', 'Symfony\Component\EventDispatcher\Tests\DependencyInjection\SubscriberService');
+        $container->register('foo', '%subscriber.class%')->addTag('kernel.event_subscriber', array());
+        $container->register('event_dispatcher', 'stdClass');
+
+        $registerListenersPass = new RegisterListenersPass();
+        $registerListenersPass->process($container);
+
+        $definition = $container->getDefinition('event_dispatcher');
+        $expected_calls = array(
+            array(
+                'addSubscriberService',
+                array(
+                    'foo',
+                    'Symfony\Component\EventDispatcher\Tests\DependencyInjection\SubscriberService',
+                ),
+            ),
+        );
+        $this->assertSame($expected_calls, $definition->getMethodCalls());
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage You have requested a non-existent parameter "subscriber.class"
+     */
+    public function testEventSubscriberUnresolvableClassName()
+    {
+        $container = new ContainerBuilder();
+        $container->register('foo', '%subscriber.class%')->addTag('kernel.event_subscriber', array());
+        $container->register('event_dispatcher', 'stdClass');
+
+        $registerListenersPass = new RegisterListenersPass();
+        $registerListenersPass->process($container);
+    }
+}
+
+class SubscriberService implements \Symfony\Component\EventDispatcher\EventSubscriberInterface
+{
+    public static function getSubscribedEvents()
+    {
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Tests/EventDispatcherTest.php

@@ -0,0 +1,22 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Tests;
+
+use Symfony\Component\EventDispatcher\EventDispatcher;
+
+class EventDispatcherTest extends AbstractEventDispatcherTest
+{
+    protected function createEventDispatcher()
+    {
+        return new EventDispatcher();
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Tests/EventTest.php

@@ -0,0 +1,96 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Tests;
+
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\EventDispatcher\EventDispatcher;
+
+/**
+ * Test class for Event.
+ */
+class EventTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var \Symfony\Component\EventDispatcher\Event
+     */
+    protected $event;
+
+    /**
+     * @var \Symfony\Component\EventDispatcher\EventDispatcher
+     */
+    protected $dispatcher;
+
+    /**
+     * Sets up the fixture, for example, opens a network connection.
+     * This method is called before a test is executed.
+     */
+    protected function setUp()
+    {
+        $this->event = new Event();
+        $this->dispatcher = new EventDispatcher();
+    }
+
+    /**
+     * Tears down the fixture, for example, closes a network connection.
+     * This method is called after a test is executed.
+     */
+    protected function tearDown()
+    {
+        $this->event = null;
+        $this->dispatcher = null;
+    }
+
+    public function testIsPropagationStopped()
+    {
+        $this->assertFalse($this->event->isPropagationStopped());
+    }
+
+    public function testStopPropagationAndIsPropagationStopped()
+    {
+        $this->event->stopPropagation();
+        $this->assertTrue($this->event->isPropagationStopped());
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testLegacySetDispatcher()
+    {
+        $this->event->setDispatcher($this->dispatcher);
+        $this->assertSame($this->dispatcher, $this->event->getDispatcher());
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testLegacyGetDispatcher()
+    {
+        $this->assertNull($this->event->getDispatcher());
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testLegacyGetName()
+    {
+        $this->assertNull($this->event->getName());
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testLegacySetName()
+    {
+        $this->event->setName('foo');
+        $this->assertEquals('foo', $this->event->getName());
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Tests/GenericEventTest.php

@@ -0,0 +1,139 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Tests;
+
+use Symfony\Component\EventDispatcher\GenericEvent;
+
+/**
+ * Test class for Event.
+ */
+class GenericEventTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var GenericEvent
+     */
+    private $event;
+
+    private $subject;
+
+    /**
+     * Prepares the environment before running a test.
+     */
+    protected function setUp()
+    {
+        parent::setUp();
+
+        $this->subject = new \stdClass();
+        $this->event = new GenericEvent($this->subject, array('name' => 'Event'));
+    }
+
+    /**
+     * Cleans up the environment after running a test.
+     */
+    protected function tearDown()
+    {
+        $this->subject = null;
+        $this->event = null;
+
+        parent::tearDown();
+    }
+
+    public function testConstruct()
+    {
+        $this->assertEquals($this->event, new GenericEvent($this->subject, array('name' => 'Event')));
+    }
+
+    /**
+     * Tests Event->getArgs().
+     */
+    public function testGetArguments()
+    {
+        // test getting all
+        $this->assertSame(array('name' => 'Event'), $this->event->getArguments());
+    }
+
+    public function testSetArguments()
+    {
+        $result = $this->event->setArguments(array('foo' => 'bar'));
+        $this->assertAttributeSame(array('foo' => 'bar'), 'arguments', $this->event);
+        $this->assertSame($this->event, $result);
+    }
+
+    public function testSetArgument()
+    {
+        $result = $this->event->setArgument('foo2', 'bar2');
+        $this->assertAttributeSame(array('name' => 'Event', 'foo2' => 'bar2'), 'arguments', $this->event);
+        $this->assertEquals($this->event, $result);
+    }
+
+    public function testGetArgument()
+    {
+        // test getting key
+        $this->assertEquals('Event', $this->event->getArgument('name'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testGetArgException()
+    {
+        $this->event->getArgument('nameNotExist');
+    }
+
+    public function testOffsetGet()
+    {
+        // test getting key
+        $this->assertEquals('Event', $this->event['name']);
+
+        // test getting invalid arg
+        $this->setExpectedException('InvalidArgumentException');
+        $this->assertFalse($this->event['nameNotExist']);
+    }
+
+    public function testOffsetSet()
+    {
+        $this->event['foo2'] = 'bar2';
+        $this->assertAttributeSame(array('name' => 'Event', 'foo2' => 'bar2'), 'arguments', $this->event);
+    }
+
+    public function testOffsetUnset()
+    {
+        unset($this->event['name']);
+        $this->assertAttributeSame(array(), 'arguments', $this->event);
+    }
+
+    public function testOffsetIsset()
+    {
+        $this->assertTrue(isset($this->event['name']));
+        $this->assertFalse(isset($this->event['nameNotExist']));
+    }
+
+    public function testHasArgument()
+    {
+        $this->assertTrue($this->event->hasArgument('name'));
+        $this->assertFalse($this->event->hasArgument('nameNotExist'));
+    }
+
+    public function testGetSubject()
+    {
+        $this->assertSame($this->subject, $this->event->getSubject());
+    }
+
+    public function testHasIterator()
+    {
+        $data = array();
+        foreach ($this->event as $key => $value) {
+            $data[$key] = $value;
+        }
+        $this->assertEquals(array('name' => 'Event'), $data);
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/Tests/ImmutableEventDispatcherTest.php

@@ -0,0 +1,105 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\EventDispatcher\Tests;
+
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\EventDispatcher\ImmutableEventDispatcher;
+
+/**
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class ImmutableEventDispatcherTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var \PHPUnit_Framework_MockObject_MockObject
+     */
+    private $innerDispatcher;
+
+    /**
+     * @var ImmutableEventDispatcher
+     */
+    private $dispatcher;
+
+    protected function setUp()
+    {
+        $this->innerDispatcher = $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface');
+        $this->dispatcher = new ImmutableEventDispatcher($this->innerDispatcher);
+    }
+
+    public function testDispatchDelegates()
+    {
+        $event = new Event();
+
+        $this->innerDispatcher->expects($this->once())
+            ->method('dispatch')
+            ->with('event', $event)
+            ->will($this->returnValue('result'));
+
+        $this->assertSame('result', $this->dispatcher->dispatch('event', $event));
+    }
+
+    public function testGetListenersDelegates()
+    {
+        $this->innerDispatcher->expects($this->once())
+            ->method('getListeners')
+            ->with('event')
+            ->will($this->returnValue('result'));
+
+        $this->assertSame('result', $this->dispatcher->getListeners('event'));
+    }
+
+    public function testHasListenersDelegates()
+    {
+        $this->innerDispatcher->expects($this->once())
+            ->method('hasListeners')
+            ->with('event')
+            ->will($this->returnValue('result'));
+
+        $this->assertSame('result', $this->dispatcher->hasListeners('event'));
+    }
+
+    /**
+     * @expectedException \BadMethodCallException
+     */
+    public function testAddListenerDisallowed()
+    {
+        $this->dispatcher->addListener('event', function () { return 'foo'; });
+    }
+
+    /**
+     * @expectedException \BadMethodCallException
+     */
+    public function testAddSubscriberDisallowed()
+    {
+        $subscriber = $this->getMock('Symfony\Component\EventDispatcher\EventSubscriberInterface');
+
+        $this->dispatcher->addSubscriber($subscriber);
+    }
+
+    /**
+     * @expectedException \BadMethodCallException
+     */
+    public function testRemoveListenerDisallowed()
+    {
+        $this->dispatcher->removeListener('event', function () { return 'foo'; });
+    }
+
+    /**
+     * @expectedException \BadMethodCallException
+     */
+    public function testRemoveSubscriberDisallowed()
+    {
+        $subscriber = $this->getMock('Symfony\Component\EventDispatcher\EventSubscriberInterface');
+
+        $this->dispatcher->removeSubscriber($subscriber);
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/composer.json

@@ -0,0 +1,44 @@
+{
+    "name": "symfony/event-dispatcher",
+    "type": "library",
+    "description": "Symfony EventDispatcher Component",
+    "keywords": [],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Fabien Potencier",
+            "email": "fabien@symfony.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.9"
+    },
+    "require-dev": {
+        "symfony/dependency-injection": "~2.6|~3.0.0",
+        "symfony/expression-language": "~2.6|~3.0.0",
+        "symfony/config": "~2.0,>=2.0.5|~3.0.0",
+        "symfony/stopwatch": "~2.3|~3.0.0",
+        "psr/log": "~1.0"
+    },
+    "suggest": {
+        "symfony/dependency-injection": "",
+        "symfony/http-kernel": ""
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Component\\EventDispatcher\\": "" },
+        "exclude-from-classmap": [
+            "/Tests/"
+        ]
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.8-dev"
+        }
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/event-dispatcher/phpunit.xml.dist

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.1/phpunit.xsd"
+         backupGlobals="false"
+         colors="true"
+         bootstrap="vendor/autoload.php"
+>
+    <php>
+        <ini name="error_reporting" value="-1" />
+    </php>
+
+    <testsuites>
+        <testsuite name="Symfony EventDispatcher Component Test Suite">
+            <directory>./Tests/</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory>./</directory>
+            <exclude>
+                <directory>./Resources</directory>
+                <directory>./Tests</directory>
+                <directory>./vendor</directory>
+            </exclude>
+        </whitelist>
+    </filter>
+</phpunit>

sites/all/libraries/mailgun/vendor/symfony/yaml/.gitignore

@@ -0,0 +1,3 @@
+vendor/
+composer.lock
+phpunit.xml

sites/all/libraries/mailgun/vendor/symfony/yaml/CHANGELOG.md

@@ -0,0 +1,28 @@
+CHANGELOG
+=========
+
+2.8.0
+-----
+
+ * Deprecated usage of a colon in an unquoted mapping value
+ * Deprecated usage of @, \`, | and > at the beginning of an unquoted string
+ * When surrounding strings with double-quotes, you must now escape `\` characters. Not
+   escaping those characters (when surrounded by double-quotes) is deprecated.
+
+   Before:
+
+   ```yml
+   class: "Foo\Var"
+   ```
+
+   After:
+
+   ```yml
+   class: "Foo\\Var"
+   ```
+
+2.1.0
+-----
+
+ * Yaml::parse() does not evaluate loaded files as PHP files by default
+   anymore (call Yaml::enablePhpParsing() to get back the old behavior)

sites/all/libraries/mailgun/vendor/symfony/yaml/Dumper.php

@@ -0,0 +1,77 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+/**
+ * Dumper dumps PHP variables to YAML strings.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Dumper
+{
+    /**
+     * The amount of spaces to use for indentation of nested nodes.
+     *
+     * @var int
+     */
+    protected $indentation = 4;
+
+    /**
+     * Sets the indentation.
+     *
+     * @param int $num The amount of spaces to use for indentation of nested nodes
+     */
+    public function setIndentation($num)
+    {
+        if ($num < 1) {
+            throw new \InvalidArgumentException('The indentation must be greater than zero.');
+        }
+
+        $this->indentation = (int) $num;
+    }
+
+    /**
+     * Dumps a PHP value to YAML.
+     *
+     * @param mixed $input                  The PHP value
+     * @param int   $inline                 The level where you switch to inline YAML
+     * @param int   $indent                 The level of indentation (used internally)
+     * @param bool  $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param bool  $objectSupport          true if object support is enabled, false otherwise
+     *
+     * @return string The YAML representation of the PHP value
+     */
+    public function dump($input, $inline = 0, $indent = 0, $exceptionOnInvalidType = false, $objectSupport = false)
+    {
+        $output = '';
+        $prefix = $indent ? str_repeat(' ', $indent) : '';
+
+        if ($inline <= 0 || !is_array($input) || empty($input)) {
+            $output .= $prefix.Inline::dump($input, $exceptionOnInvalidType, $objectSupport);
+        } else {
+            $isAHash = Inline::isHash($input);
+
+            foreach ($input as $key => $value) {
+                $willBeInlined = $inline - 1 <= 0 || !is_array($value) || empty($value);
+
+                $output .= sprintf('%s%s%s%s',
+                    $prefix,
+                    $isAHash ? Inline::dump($key, $exceptionOnInvalidType, $objectSupport).':' : '-',
+                    $willBeInlined ? ' ' : "\n",
+                    $this->dump($value, $inline - 1, $willBeInlined ? 0 : $indent + $this->indentation, $exceptionOnInvalidType, $objectSupport)
+                ).($willBeInlined ? "\n" : '');
+            }
+        }
+
+        return $output;
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Escaper.php

@@ -0,0 +1,99 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+/**
+ * Escaper encapsulates escaping rules for single and double-quoted
+ * YAML strings.
+ *
+ * @author Matthew Lewinski <matthew@lewinski.org>
+ *
+ * @internal
+ */
+class Escaper
+{
+    // Characters that would cause a dumped string to require double quoting.
+    const REGEX_CHARACTER_TO_ESCAPE = "[\\x00-\\x1f]|\xc2\x85|\xc2\xa0|\xe2\x80\xa8|\xe2\x80\xa9";
+
+    // Mapping arrays for escaping a double quoted string. The backslash is
+    // first to ensure proper escaping because str_replace operates iteratively
+    // on the input arrays. This ordering of the characters avoids the use of strtr,
+    // which performs more slowly.
+    private static $escapees = array('\\', '\\\\', '\\"', '"',
+                                     "\x00",  "\x01",  "\x02",  "\x03",  "\x04",  "\x05",  "\x06",  "\x07",
+                                     "\x08",  "\x09",  "\x0a",  "\x0b",  "\x0c",  "\x0d",  "\x0e",  "\x0f",
+                                     "\x10",  "\x11",  "\x12",  "\x13",  "\x14",  "\x15",  "\x16",  "\x17",
+                                     "\x18",  "\x19",  "\x1a",  "\x1b",  "\x1c",  "\x1d",  "\x1e",  "\x1f",
+                                     "\xc2\x85", "\xc2\xa0", "\xe2\x80\xa8", "\xe2\x80\xa9");
+    private static $escaped = array('\\\\', '\\"', '\\\\', '\\"',
+                                     '\\0',   '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\a',
+                                     '\\b',   '\\t',   '\\n',   '\\v',   '\\f',   '\\r',   '\\x0e', '\\x0f',
+                                     '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17',
+                                     '\\x18', '\\x19', '\\x1a', '\\e',   '\\x1c', '\\x1d', '\\x1e', '\\x1f',
+                                     '\\N', '\\_', '\\L', '\\P');
+
+    /**
+     * Determines if a PHP value would require double quoting in YAML.
+     *
+     * @param string $value A PHP value
+     *
+     * @return bool True if the value would require double quotes
+     */
+    public static function requiresDoubleQuoting($value)
+    {
+        return preg_match('/'.self::REGEX_CHARACTER_TO_ESCAPE.'/u', $value);
+    }
+
+    /**
+     * Escapes and surrounds a PHP value with double quotes.
+     *
+     * @param string $value A PHP value
+     *
+     * @return string The quoted, escaped string
+     */
+    public static function escapeWithDoubleQuotes($value)
+    {
+        return sprintf('"%s"', str_replace(self::$escapees, self::$escaped, $value));
+    }
+
+    /**
+     * Determines if a PHP value would require single quoting in YAML.
+     *
+     * @param string $value A PHP value
+     *
+     * @return bool True if the value would require single quotes
+     */
+    public static function requiresSingleQuoting($value)
+    {
+        // Determines if a PHP value is entirely composed of a value that would
+        // require single quoting in YAML.
+        if (in_array(strtolower($value), array('null', '~', 'true', 'false', 'y', 'n', 'yes', 'no', 'on', 'off'))) {
+            return true;
+        }
+
+        // Determines if the PHP value contains any single characters that would
+        // cause it to require single quoting in YAML.
+        return preg_match('/[ \s \' " \: \{ \} \[ \] , & \* \# \?] | \A[ \- ? | < > = ! % @ ` ]/x', $value);
+    }
+
+    /**
+     * Escapes and surrounds a PHP value with single quotes.
+     *
+     * @param string $value A PHP value
+     *
+     * @return string The quoted, escaped string
+     */
+    public static function escapeWithSingleQuotes($value)
+    {
+        return sprintf("'%s'", str_replace('\'', '\'\'', $value));
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Exception/DumpException.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception class thrown when an error occurs during dumping.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class DumpException extends RuntimeException
+{
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Exception/ExceptionInterface.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception interface for all exceptions thrown by the component.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface ExceptionInterface
+{
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Exception/ParseException.php

@@ -0,0 +1,146 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception class thrown when an error occurs during parsing.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ParseException extends RuntimeException
+{
+    private $parsedFile;
+    private $parsedLine;
+    private $snippet;
+    private $rawMessage;
+
+    /**
+     * Constructor.
+     *
+     * @param string     $message    The error message
+     * @param int        $parsedLine The line where the error occurred
+     * @param int        $snippet    The snippet of code near the problem
+     * @param string     $parsedFile The file name where the error occurred
+     * @param \Exception $previous   The previous exception
+     */
+    public function __construct($message, $parsedLine = -1, $snippet = null, $parsedFile = null, \Exception $previous = null)
+    {
+        $this->parsedFile = $parsedFile;
+        $this->parsedLine = $parsedLine;
+        $this->snippet = $snippet;
+        $this->rawMessage = $message;
+
+        $this->updateRepr();
+
+        parent::__construct($this->message, 0, $previous);
+    }
+
+    /**
+     * Gets the snippet of code near the error.
+     *
+     * @return string The snippet of code
+     */
+    public function getSnippet()
+    {
+        return $this->snippet;
+    }
+
+    /**
+     * Sets the snippet of code near the error.
+     *
+     * @param string $snippet The code snippet
+     */
+    public function setSnippet($snippet)
+    {
+        $this->snippet = $snippet;
+
+        $this->updateRepr();
+    }
+
+    /**
+     * Gets the filename where the error occurred.
+     *
+     * This method returns null if a string is parsed.
+     *
+     * @return string The filename
+     */
+    public function getParsedFile()
+    {
+        return $this->parsedFile;
+    }
+
+    /**
+     * Sets the filename where the error occurred.
+     *
+     * @param string $parsedFile The filename
+     */
+    public function setParsedFile($parsedFile)
+    {
+        $this->parsedFile = $parsedFile;
+
+        $this->updateRepr();
+    }
+
+    /**
+     * Gets the line where the error occurred.
+     *
+     * @return int The file line
+     */
+    public function getParsedLine()
+    {
+        return $this->parsedLine;
+    }
+
+    /**
+     * Sets the line where the error occurred.
+     *
+     * @param int $parsedLine The file line
+     */
+    public function setParsedLine($parsedLine)
+    {
+        $this->parsedLine = $parsedLine;
+
+        $this->updateRepr();
+    }
+
+    private function updateRepr()
+    {
+        $this->message = $this->rawMessage;
+
+        $dot = false;
+        if ('.' === substr($this->message, -1)) {
+            $this->message = substr($this->message, 0, -1);
+            $dot = true;
+        }
+
+        if (null !== $this->parsedFile) {
+            if (PHP_VERSION_ID >= 50400) {
+                $jsonOptions = JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE;
+            } else {
+                $jsonOptions = 0;
+            }
+            $this->message .= sprintf(' in %s', json_encode($this->parsedFile, $jsonOptions));
+        }
+
+        if ($this->parsedLine >= 0) {
+            $this->message .= sprintf(' at line %d', $this->parsedLine);
+        }
+
+        if ($this->snippet) {
+            $this->message .= sprintf(' (near "%s")', $this->snippet);
+        }
+
+        if ($dot) {
+            $this->message .= '.';
+        }
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Exception/RuntimeException.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Exception;
+
+/**
+ * Exception class thrown when an error occurs during parsing.
+ *
+ * @author Romain Neutron <imprec@gmail.com>
+ */
+class RuntimeException extends \RuntimeException implements ExceptionInterface
+{
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Inline.php

@@ -0,0 +1,589 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+use Symfony\Component\Yaml\Exception\ParseException;
+use Symfony\Component\Yaml\Exception\DumpException;
+
+/**
+ * Inline implements a YAML parser/dumper for the YAML inline syntax.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Inline
+{
+    const REGEX_QUOTED_STRING = '(?:"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'([^\']*(?:\'\'[^\']*)*)\')';
+
+    private static $exceptionOnInvalidType = false;
+    private static $objectSupport = false;
+    private static $objectForMap = false;
+
+    /**
+     * Converts a YAML string to a PHP array.
+     *
+     * @param string $value                  A YAML string
+     * @param bool   $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param bool   $objectSupport          true if object support is enabled, false otherwise
+     * @param bool   $objectForMap           true if maps should return a stdClass instead of array()
+     * @param array  $references             Mapping of variable names to values
+     *
+     * @return array A PHP array representing the YAML string
+     *
+     * @throws ParseException
+     */
+    public static function parse($value, $exceptionOnInvalidType = false, $objectSupport = false, $objectForMap = false, $references = array())
+    {
+        self::$exceptionOnInvalidType = $exceptionOnInvalidType;
+        self::$objectSupport = $objectSupport;
+        self::$objectForMap = $objectForMap;
+
+        $value = trim($value);
+
+        if ('' === $value) {
+            return '';
+        }
+
+        if (2 /* MB_OVERLOAD_STRING */ & (int) ini_get('mbstring.func_overload')) {
+            $mbEncoding = mb_internal_encoding();
+            mb_internal_encoding('ASCII');
+        }
+
+        $i = 0;
+        switch ($value[0]) {
+            case '[':
+                $result = self::parseSequence($value, $i, $references);
+                ++$i;
+                break;
+            case '{':
+                $result = self::parseMapping($value, $i, $references);
+                ++$i;
+                break;
+            default:
+                $result = self::parseScalar($value, null, array('"', "'"), $i, true, $references);
+        }
+
+        // some comments are allowed at the end
+        if (preg_replace('/\s+#.*$/A', '', substr($value, $i))) {
+            throw new ParseException(sprintf('Unexpected characters near "%s".', substr($value, $i)));
+        }
+
+        if (isset($mbEncoding)) {
+            mb_internal_encoding($mbEncoding);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Dumps a given PHP variable to a YAML string.
+     *
+     * @param mixed $value                  The PHP variable to convert
+     * @param bool  $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param bool  $objectSupport          true if object support is enabled, false otherwise
+     *
+     * @return string The YAML string representing the PHP array
+     *
+     * @throws DumpException When trying to dump PHP resource
+     */
+    public static function dump($value, $exceptionOnInvalidType = false, $objectSupport = false)
+    {
+        switch (true) {
+            case is_resource($value):
+                if ($exceptionOnInvalidType) {
+                    throw new DumpException(sprintf('Unable to dump PHP resources in a YAML file ("%s").', get_resource_type($value)));
+                }
+
+                return 'null';
+            case is_object($value):
+                if ($objectSupport) {
+                    return '!php/object:'.serialize($value);
+                }
+
+                if ($exceptionOnInvalidType) {
+                    throw new DumpException('Object support when dumping a YAML file has been disabled.');
+                }
+
+                return 'null';
+            case is_array($value):
+                return self::dumpArray($value, $exceptionOnInvalidType, $objectSupport);
+            case null === $value:
+                return 'null';
+            case true === $value:
+                return 'true';
+            case false === $value:
+                return 'false';
+            case ctype_digit($value):
+                return is_string($value) ? "'$value'" : (int) $value;
+            case is_numeric($value):
+                $locale = setlocale(LC_NUMERIC, 0);
+                if (false !== $locale) {
+                    setlocale(LC_NUMERIC, 'C');
+                }
+                if (is_float($value)) {
+                    $repr = (string) $value;
+                    if (is_infinite($value)) {
+                        $repr = str_ireplace('INF', '.Inf', $repr);
+                    } elseif (floor($value) == $value && $repr == $value) {
+                        // Preserve float data type since storing a whole number will result in integer value.
+                        $repr = '!!float '.$repr;
+                    }
+                } else {
+                    $repr = is_string($value) ? "'$value'" : (string) $value;
+                }
+                if (false !== $locale) {
+                    setlocale(LC_NUMERIC, $locale);
+                }
+
+                return $repr;
+            case '' == $value:
+                return "''";
+            case Escaper::requiresDoubleQuoting($value):
+                return Escaper::escapeWithDoubleQuotes($value);
+            case Escaper::requiresSingleQuoting($value):
+            case preg_match(self::getHexRegex(), $value):
+            case preg_match(self::getTimestampRegex(), $value):
+                return Escaper::escapeWithSingleQuotes($value);
+            default:
+                return $value;
+        }
+    }
+
+    /**
+     * Check if given array is hash or just normal indexed array.
+     *
+     * @internal
+     *
+     * @param array $value The PHP array to check
+     *
+     * @return bool true if value is hash array, false otherwise
+     */
+    public static function isHash(array $value)
+    {
+        $expectedKey = 0;
+
+        foreach ($value as $key => $val) {
+            if ($key !== $expectedKey++) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Dumps a PHP array to a YAML string.
+     *
+     * @param array $value                  The PHP array to dump
+     * @param bool  $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param bool  $objectSupport          true if object support is enabled, false otherwise
+     *
+     * @return string The YAML string representing the PHP array
+     */
+    private static function dumpArray($value, $exceptionOnInvalidType, $objectSupport)
+    {
+        // array
+        if ($value && !self::isHash($value)) {
+            $output = array();
+            foreach ($value as $val) {
+                $output[] = self::dump($val, $exceptionOnInvalidType, $objectSupport);
+            }
+
+            return sprintf('[%s]', implode(', ', $output));
+        }
+
+        // hash
+        $output = array();
+        foreach ($value as $key => $val) {
+            $output[] = sprintf('%s: %s', self::dump($key, $exceptionOnInvalidType, $objectSupport), self::dump($val, $exceptionOnInvalidType, $objectSupport));
+        }
+
+        return sprintf('{ %s }', implode(', ', $output));
+    }
+
+    /**
+     * Parses a scalar to a YAML string.
+     *
+     * @param string $scalar
+     * @param string $delimiters
+     * @param array  $stringDelimiters
+     * @param int    &$i
+     * @param bool   $evaluate
+     * @param array  $references
+     *
+     * @return string A YAML string
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     *
+     * @internal
+     */
+    public static function parseScalar($scalar, $delimiters = null, $stringDelimiters = array('"', "'"), &$i = 0, $evaluate = true, $references = array())
+    {
+        if (in_array($scalar[$i], $stringDelimiters)) {
+            // quoted scalar
+            $output = self::parseQuotedScalar($scalar, $i);
+
+            if (null !== $delimiters) {
+                $tmp = ltrim(substr($scalar, $i), ' ');
+                if (!in_array($tmp[0], $delimiters)) {
+                    throw new ParseException(sprintf('Unexpected characters (%s).', substr($scalar, $i)));
+                }
+            }
+        } else {
+            // "normal" string
+            if (!$delimiters) {
+                $output = substr($scalar, $i);
+                $i += strlen($output);
+
+                // remove comments
+                if (preg_match('/[ \t]+#/', $output, $match, PREG_OFFSET_CAPTURE)) {
+                    $output = substr($output, 0, $match[0][1]);
+                }
+            } elseif (preg_match('/^(.+?)('.implode('|', $delimiters).')/', substr($scalar, $i), $match)) {
+                $output = $match[1];
+                $i += strlen($output);
+            } else {
+                throw new ParseException(sprintf('Malformed inline YAML string (%s).', $scalar));
+            }
+
+            // a non-quoted string cannot start with @ or ` (reserved) nor with a scalar indicator (| or >)
+            if ($output && ('@' === $output[0] || '`' === $output[0] || '|' === $output[0] || '>' === $output[0])) {
+                @trigger_error(sprintf('Not quoting the scalar "%s" starting with "%s" is deprecated since Symfony 2.8 and will throw a ParseException in 3.0.', $output, $output[0]), E_USER_DEPRECATED);
+
+                // to be thrown in 3.0
+                // throw new ParseException(sprintf('The reserved indicator "%s" cannot start a plain scalar; you need to quote the scalar.', $output[0]));
+            }
+
+            if ($evaluate) {
+                $output = self::evaluateScalar($output, $references);
+            }
+        }
+
+        return $output;
+    }
+
+    /**
+     * Parses a quoted scalar to YAML.
+     *
+     * @param string $scalar
+     * @param int    &$i
+     *
+     * @return string A YAML string
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     */
+    private static function parseQuotedScalar($scalar, &$i)
+    {
+        if (!preg_match('/'.self::REGEX_QUOTED_STRING.'/Au', substr($scalar, $i), $match)) {
+            throw new ParseException(sprintf('Malformed inline YAML string (%s).', substr($scalar, $i)));
+        }
+
+        $output = substr($match[0], 1, strlen($match[0]) - 2);
+
+        $unescaper = new Unescaper();
+        if ('"' == $scalar[$i]) {
+            $output = $unescaper->unescapeDoubleQuotedString($output);
+        } else {
+            $output = $unescaper->unescapeSingleQuotedString($output);
+        }
+
+        $i += strlen($match[0]);
+
+        return $output;
+    }
+
+    /**
+     * Parses a sequence to a YAML string.
+     *
+     * @param string $sequence
+     * @param int    &$i
+     * @param array  $references
+     *
+     * @return string A YAML string
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     */
+    private static function parseSequence($sequence, &$i = 0, $references = array())
+    {
+        $output = array();
+        $len = strlen($sequence);
+        ++$i;
+
+        // [foo, bar, ...]
+        while ($i < $len) {
+            switch ($sequence[$i]) {
+                case '[':
+                    // nested sequence
+                    $output[] = self::parseSequence($sequence, $i, $references);
+                    break;
+                case '{':
+                    // nested mapping
+                    $output[] = self::parseMapping($sequence, $i, $references);
+                    break;
+                case ']':
+                    return $output;
+                case ',':
+                case ' ':
+                    break;
+                default:
+                    $isQuoted = in_array($sequence[$i], array('"', "'"));
+                    $value = self::parseScalar($sequence, array(',', ']'), array('"', "'"), $i, true, $references);
+
+                    // the value can be an array if a reference has been resolved to an array var
+                    if (!is_array($value) && !$isQuoted && false !== strpos($value, ': ')) {
+                        // embedded mapping?
+                        try {
+                            $pos = 0;
+                            $value = self::parseMapping('{'.$value.'}', $pos, $references);
+                        } catch (\InvalidArgumentException $e) {
+                            // no, it's not
+                        }
+                    }
+
+                    $output[] = $value;
+
+                    --$i;
+            }
+
+            ++$i;
+        }
+
+        throw new ParseException(sprintf('Malformed inline YAML string %s', $sequence));
+    }
+
+    /**
+     * Parses a mapping to a YAML string.
+     *
+     * @param string $mapping
+     * @param int    &$i
+     * @param array  $references
+     *
+     * @return string A YAML string
+     *
+     * @throws ParseException When malformed inline YAML string is parsed
+     */
+    private static function parseMapping($mapping, &$i = 0, $references = array())
+    {
+        $output = array();
+        $len = strlen($mapping);
+        ++$i;
+
+        // {foo: bar, bar:foo, ...}
+        while ($i < $len) {
+            switch ($mapping[$i]) {
+                case ' ':
+                case ',':
+                    ++$i;
+                    continue 2;
+                case '}':
+                    if (self::$objectForMap) {
+                        return (object) $output;
+                    }
+
+                    return $output;
+            }
+
+            // key
+            $key = self::parseScalar($mapping, array(':', ' '), array('"', "'"), $i, false);
+
+            // value
+            $done = false;
+
+            while ($i < $len) {
+                switch ($mapping[$i]) {
+                    case '[':
+                        // nested sequence
+                        $value = self::parseSequence($mapping, $i, $references);
+                        // Spec: Keys MUST be unique; first one wins.
+                        // Parser cannot abort this mapping earlier, since lines
+                        // are processed sequentially.
+                        if (!isset($output[$key])) {
+                            $output[$key] = $value;
+                        }
+                        $done = true;
+                        break;
+                    case '{':
+                        // nested mapping
+                        $value = self::parseMapping($mapping, $i, $references);
+                        // Spec: Keys MUST be unique; first one wins.
+                        // Parser cannot abort this mapping earlier, since lines
+                        // are processed sequentially.
+                        if (!isset($output[$key])) {
+                            $output[$key] = $value;
+                        }
+                        $done = true;
+                        break;
+                    case ':':
+                    case ' ':
+                        break;
+                    default:
+                        $value = self::parseScalar($mapping, array(',', '}'), array('"', "'"), $i, true, $references);
+                        // Spec: Keys MUST be unique; first one wins.
+                        // Parser cannot abort this mapping earlier, since lines
+                        // are processed sequentially.
+                        if (!isset($output[$key])) {
+                            $output[$key] = $value;
+                        }
+                        $done = true;
+                        --$i;
+                }
+
+                ++$i;
+
+                if ($done) {
+                    continue 2;
+                }
+            }
+        }
+
+        throw new ParseException(sprintf('Malformed inline YAML string %s', $mapping));
+    }
+
+    /**
+     * Evaluates scalars and replaces magic values.
+     *
+     * @param string $scalar
+     * @param array  $references
+     *
+     * @return string A YAML string
+     *
+     * @throws ParseException when object parsing support was disabled and the parser detected a PHP object or when a reference could not be resolved
+     */
+    private static function evaluateScalar($scalar, $references = array())
+    {
+        $scalar = trim($scalar);
+        $scalarLower = strtolower($scalar);
+
+        if (0 === strpos($scalar, '*')) {
+            if (false !== $pos = strpos($scalar, '#')) {
+                $value = substr($scalar, 1, $pos - 2);
+            } else {
+                $value = substr($scalar, 1);
+            }
+
+            // an unquoted *
+            if (false === $value || '' === $value) {
+                throw new ParseException('A reference must contain at least one character.');
+            }
+
+            if (!array_key_exists($value, $references)) {
+                throw new ParseException(sprintf('Reference "%s" does not exist.', $value));
+            }
+
+            return $references[$value];
+        }
+
+        switch (true) {
+            case 'null' === $scalarLower:
+            case '' === $scalar:
+            case '~' === $scalar:
+                return;
+            case 'true' === $scalarLower:
+                return true;
+            case 'false' === $scalarLower:
+                return false;
+            // Optimise for returning strings.
+            case $scalar[0] === '+' || $scalar[0] === '-' || $scalar[0] === '.' || $scalar[0] === '!' || is_numeric($scalar[0]):
+                switch (true) {
+                    case 0 === strpos($scalar, '!str'):
+                        return (string) substr($scalar, 5);
+                    case 0 === strpos($scalar, '! '):
+                        return (int) self::parseScalar(substr($scalar, 2));
+                    case 0 === strpos($scalar, '!php/object:'):
+                        if (self::$objectSupport) {
+                            return unserialize(substr($scalar, 12));
+                        }
+
+                        if (self::$exceptionOnInvalidType) {
+                            throw new ParseException('Object support when parsing a YAML file has been disabled.');
+                        }
+
+                        return;
+                    case 0 === strpos($scalar, '!!php/object:'):
+                        if (self::$objectSupport) {
+                            return unserialize(substr($scalar, 13));
+                        }
+
+                        if (self::$exceptionOnInvalidType) {
+                            throw new ParseException('Object support when parsing a YAML file has been disabled.');
+                        }
+
+                        return;
+                    case 0 === strpos($scalar, '!!float '):
+                        return (float) substr($scalar, 8);
+                    case ctype_digit($scalar):
+                        $raw = $scalar;
+                        $cast = (int) $scalar;
+
+                        return '0' == $scalar[0] ? octdec($scalar) : (((string) $raw == (string) $cast) ? $cast : $raw);
+                    case '-' === $scalar[0] && ctype_digit(substr($scalar, 1)):
+                        $raw = $scalar;
+                        $cast = (int) $scalar;
+
+                        return '0' == $scalar[1] ? octdec($scalar) : (((string) $raw === (string) $cast) ? $cast : $raw);
+                    case is_numeric($scalar):
+                    case preg_match(self::getHexRegex(), $scalar):
+                        return '0x' === $scalar[0].$scalar[1] ? hexdec($scalar) : (float) $scalar;
+                    case '.inf' === $scalarLower:
+                    case '.nan' === $scalarLower:
+                        return -log(0);
+                    case '-.inf' === $scalarLower:
+                        return log(0);
+                    case preg_match('/^(-|\+)?[0-9,]+(\.[0-9]+)?$/', $scalar):
+                        return (float) str_replace(',', '', $scalar);
+                    case preg_match(self::getTimestampRegex(), $scalar):
+                        $timeZone = date_default_timezone_get();
+                        date_default_timezone_set('UTC');
+                        $time = strtotime($scalar);
+                        date_default_timezone_set($timeZone);
+
+                        return $time;
+                }
+            default:
+                return (string) $scalar;
+        }
+    }
+
+    /**
+     * Gets a regex that matches a YAML date.
+     *
+     * @return string The regular expression
+     *
+     * @see http://www.yaml.org/spec/1.2/spec.html#id2761573
+     */
+    private static function getTimestampRegex()
+    {
+        return <<<EOF
+        ~^
+        (?P<year>[0-9][0-9][0-9][0-9])
+        -(?P<month>[0-9][0-9]?)
+        -(?P<day>[0-9][0-9]?)
+        (?:(?:[Tt]|[ \t]+)
+        (?P<hour>[0-9][0-9]?)
+        :(?P<minute>[0-9][0-9])
+        :(?P<second>[0-9][0-9])
+        (?:\.(?P<fraction>[0-9]*))?
+        (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
+        (?::(?P<tz_minute>[0-9][0-9]))?))?)?
+        $~x
+EOF;
+    }
+
+    /**
+     * Gets a regex that matches a YAML number in hexadecimal notation.
+     *
+     * @return string
+     */
+    private static function getHexRegex()
+    {
+        return '~^0x[0-9a-f]++$~i';
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2004-2016 Fabien Potencier
+
+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.

sites/all/libraries/mailgun/vendor/symfony/yaml/Parser.php

@@ -0,0 +1,832 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+use Symfony\Component\Yaml\Exception\ParseException;
+
+/**
+ * Parser parses YAML strings to convert them to PHP arrays.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Parser
+{
+    const BLOCK_SCALAR_HEADER_PATTERN = '(?P<separator>\||>)(?P<modifiers>\+|\-|\d+|\+\d+|\-\d+|\d+\+|\d+\-)?(?P<comments> +#.*)?';
+    // BC - wrongly named
+    const FOLDED_SCALAR_PATTERN = self::BLOCK_SCALAR_HEADER_PATTERN;
+
+    private $offset = 0;
+    private $totalNumberOfLines;
+    private $lines = array();
+    private $currentLineNb = -1;
+    private $currentLine = '';
+    private $refs = array();
+    private $skippedLineNumbers = array();
+    private $locallySkippedLineNumbers = array();
+
+    /**
+     * Constructor.
+     *
+     * @param int      $offset             The offset of YAML document (used for line numbers in error messages)
+     * @param int|null $totalNumberOfLines The overall number of lines being parsed
+     * @param int[]    $skippedLineNumbers Number of comment lines that have been skipped by the parser
+     */
+    public function __construct($offset = 0, $totalNumberOfLines = null, array $skippedLineNumbers = array())
+    {
+        $this->offset = $offset;
+        $this->totalNumberOfLines = $totalNumberOfLines;
+        $this->skippedLineNumbers = $skippedLineNumbers;
+    }
+
+    /**
+     * Parses a YAML string to a PHP value.
+     *
+     * @param string $value                  A YAML string
+     * @param bool   $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param bool   $objectSupport          true if object support is enabled, false otherwise
+     * @param bool   $objectForMap           true if maps should return a stdClass instead of array()
+     *
+     * @return mixed A PHP value
+     *
+     * @throws ParseException If the YAML is not valid
+     */
+    public function parse($value, $exceptionOnInvalidType = false, $objectSupport = false, $objectForMap = false)
+    {
+        if (!preg_match('//u', $value)) {
+            throw new ParseException('The YAML value does not appear to be valid UTF-8.');
+        }
+        $this->currentLineNb = -1;
+        $this->currentLine = '';
+        $value = $this->cleanup($value);
+        $this->lines = explode("\n", $value);
+
+        if (null === $this->totalNumberOfLines) {
+            $this->totalNumberOfLines = count($this->lines);
+        }
+
+        if (2 /* MB_OVERLOAD_STRING */ & (int) ini_get('mbstring.func_overload')) {
+            $mbEncoding = mb_internal_encoding();
+            mb_internal_encoding('UTF-8');
+        }
+
+        $data = array();
+        $context = null;
+        $allowOverwrite = false;
+        while ($this->moveToNextLine()) {
+            if ($this->isCurrentLineEmpty()) {
+                continue;
+            }
+
+            // tab?
+            if ("\t" === $this->currentLine[0]) {
+                throw new ParseException('A YAML file cannot contain tabs as indentation.', $this->getRealCurrentLineNb() + 1, $this->currentLine);
+            }
+
+            $isRef = $mergeNode = false;
+            if (preg_match('#^\-((?P<leadspaces>\s+)(?P<value>.+?))?\s*$#u', $this->currentLine, $values)) {
+                if ($context && 'mapping' == $context) {
+                    throw new ParseException('You cannot define a sequence item when in a mapping', $this->getRealCurrentLineNb() + 1, $this->currentLine);
+                }
+                $context = 'sequence';
+
+                if (isset($values['value']) && preg_match('#^&(?P<ref>[^ ]+) *(?P<value>.*)#u', $values['value'], $matches)) {
+                    $isRef = $matches['ref'];
+                    $values['value'] = $matches['value'];
+                }
+
+                // array
+                if (!isset($values['value']) || '' == trim($values['value'], ' ') || 0 === strpos(ltrim($values['value'], ' '), '#')) {
+                    $data[] = $this->parseBlock($this->getRealCurrentLineNb() + 1, $this->getNextEmbedBlock(null, true), $exceptionOnInvalidType, $objectSupport, $objectForMap);
+                } else {
+                    if (isset($values['leadspaces'])
+                        && preg_match('#^(?P<key>'.Inline::REGEX_QUOTED_STRING.'|[^ \'"\{\[].*?) *\:(\s+(?P<value>.+?))?\s*$#u', $values['value'], $matches)
+                    ) {
+                        // this is a compact notation element, add to next block and parse
+                        $block = $values['value'];
+                        if ($this->isNextLineIndented()) {
+                            $block .= "\n".$this->getNextEmbedBlock($this->getCurrentLineIndentation() + strlen($values['leadspaces']) + 1);
+                        }
+
+                        $data[] = $this->parseBlock($this->getRealCurrentLineNb(), $block, $exceptionOnInvalidType, $objectSupport, $objectForMap);
+                    } else {
+                        $data[] = $this->parseValue($values['value'], $exceptionOnInvalidType, $objectSupport, $objectForMap, $context);
+                    }
+                }
+                if ($isRef) {
+                    $this->refs[$isRef] = end($data);
+                }
+            } elseif (preg_match('#^(?P<key>'.Inline::REGEX_QUOTED_STRING.'|[^ \'"\[\{].*?) *\:(\s+(?P<value>.+?))?\s*$#u', $this->currentLine, $values) && (false === strpos($values['key'], ' #') || in_array($values['key'][0], array('"', "'")))) {
+                if ($context && 'sequence' == $context) {
+                    throw new ParseException('You cannot define a mapping item when in a sequence', $this->currentLineNb + 1, $this->currentLine);
+                }
+                $context = 'mapping';
+
+                // force correct settings
+                Inline::parse(null, $exceptionOnInvalidType, $objectSupport, $objectForMap, $this->refs);
+                try {
+                    $key = Inline::parseScalar($values['key']);
+                } catch (ParseException $e) {
+                    $e->setParsedLine($this->getRealCurrentLineNb() + 1);
+                    $e->setSnippet($this->currentLine);
+
+                    throw $e;
+                }
+
+                // Convert float keys to strings, to avoid being converted to integers by PHP
+                if (is_float($key)) {
+                    $key = (string) $key;
+                }
+
+                if ('<<' === $key) {
+                    $mergeNode = true;
+                    $allowOverwrite = true;
+                    if (isset($values['value']) && 0 === strpos($values['value'], '*')) {
+                        $refName = substr($values['value'], 1);
+                        if (!array_key_exists($refName, $this->refs)) {
+                            throw new ParseException(sprintf('Reference "%s" does not exist.', $refName), $this->getRealCurrentLineNb() + 1, $this->currentLine);
+                        }
+
+                        $refValue = $this->refs[$refName];
+
+                        if (!is_array($refValue)) {
+                            throw new ParseException('YAML merge keys used with a scalar value instead of an array.', $this->getRealCurrentLineNb() + 1, $this->currentLine);
+                        }
+
+                        foreach ($refValue as $key => $value) {
+                            if (!isset($data[$key])) {
+                                $data[$key] = $value;
+                            }
+                        }
+                    } else {
+                        if (isset($values['value']) && $values['value'] !== '') {
+                            $value = $values['value'];
+                        } else {
+                            $value = $this->getNextEmbedBlock();
+                        }
+                        $parsed = $this->parseBlock($this->getRealCurrentLineNb() + 1, $value, $exceptionOnInvalidType, $objectSupport, $objectForMap);
+
+                        if (!is_array($parsed)) {
+                            throw new ParseException('YAML merge keys used with a scalar value instead of an array.', $this->getRealCurrentLineNb() + 1, $this->currentLine);
+                        }
+
+                        if (isset($parsed[0])) {
+                            // If the value associated with the merge key is a sequence, then this sequence is expected to contain mapping nodes
+                            // and each of these nodes is merged in turn according to its order in the sequence. Keys in mapping nodes earlier
+                            // in the sequence override keys specified in later mapping nodes.
+                            foreach ($parsed as $parsedItem) {
+                                if (!is_array($parsedItem)) {
+                                    throw new ParseException('Merge items must be arrays.', $this->getRealCurrentLineNb() + 1, $parsedItem);
+                                }
+
+                                foreach ($parsedItem as $key => $value) {
+                                    if (!isset($data[$key])) {
+                                        $data[$key] = $value;
+                                    }
+                                }
+                            }
+                        } else {
+                            // If the value associated with the key is a single mapping node, each of its key/value pairs is inserted into the
+                            // current mapping, unless the key already exists in it.
+                            foreach ($parsed as $key => $value) {
+                                if (!isset($data[$key])) {
+                                    $data[$key] = $value;
+                                }
+                            }
+                        }
+                    }
+                } elseif (isset($values['value']) && preg_match('#^&(?P<ref>[^ ]+) *(?P<value>.*)#u', $values['value'], $matches)) {
+                    $isRef = $matches['ref'];
+                    $values['value'] = $matches['value'];
+                }
+
+                if ($mergeNode) {
+                    // Merge keys
+                } elseif (!isset($values['value']) || '' == trim($values['value'], ' ') || 0 === strpos(ltrim($values['value'], ' '), '#')) {
+                    // hash
+                    // if next line is less indented or equal, then it means that the current value is null
+                    if (!$this->isNextLineIndented() && !$this->isNextLineUnIndentedCollection()) {
+                        // Spec: Keys MUST be unique; first one wins.
+                        // But overwriting is allowed when a merge node is used in current block.
+                        if ($allowOverwrite || !isset($data[$key])) {
+                            $data[$key] = null;
+                        }
+                    } else {
+                        $value = $this->parseBlock($this->getRealCurrentLineNb() + 1, $this->getNextEmbedBlock(), $exceptionOnInvalidType, $objectSupport, $objectForMap);
+                        // Spec: Keys MUST be unique; first one wins.
+                        // But overwriting is allowed when a merge node is used in current block.
+                        if ($allowOverwrite || !isset($data[$key])) {
+                            $data[$key] = $value;
+                        }
+                    }
+                } else {
+                    $value = $this->parseValue($values['value'], $exceptionOnInvalidType, $objectSupport, $objectForMap, $context);
+                    // Spec: Keys MUST be unique; first one wins.
+                    // But overwriting is allowed when a merge node is used in current block.
+                    if ($allowOverwrite || !isset($data[$key])) {
+                        $data[$key] = $value;
+                    }
+                }
+                if ($isRef) {
+                    $this->refs[$isRef] = $data[$key];
+                }
+            } else {
+                // multiple documents are not supported
+                if ('---' === $this->currentLine) {
+                    throw new ParseException('Multiple documents are not supported.', $this->currentLineNb + 1, $this->currentLine);
+                }
+
+                // 1-liner optionally followed by newline(s)
+                if (is_string($value) && $this->lines[0] === trim($value)) {
+                    try {
+                        $value = Inline::parse($this->lines[0], $exceptionOnInvalidType, $objectSupport, $objectForMap, $this->refs);
+                    } catch (ParseException $e) {
+                        $e->setParsedLine($this->getRealCurrentLineNb() + 1);
+                        $e->setSnippet($this->currentLine);
+
+                        throw $e;
+                    }
+
+                    if (is_array($value)) {
+                        $first = reset($value);
+                        if (is_string($first) && 0 === strpos($first, '*')) {
+                            $data = array();
+                            foreach ($value as $alias) {
+                                $data[] = $this->refs[substr($alias, 1)];
+                            }
+                            $value = $data;
+                        }
+                    }
+
+                    if (isset($mbEncoding)) {
+                        mb_internal_encoding($mbEncoding);
+                    }
+
+                    return $value;
+                }
+
+                switch (preg_last_error()) {
+                    case PREG_INTERNAL_ERROR:
+                        $error = 'Internal PCRE error.';
+                        break;
+                    case PREG_BACKTRACK_LIMIT_ERROR:
+                        $error = 'pcre.backtrack_limit reached.';
+                        break;
+                    case PREG_RECURSION_LIMIT_ERROR:
+                        $error = 'pcre.recursion_limit reached.';
+                        break;
+                    case PREG_BAD_UTF8_ERROR:
+                        $error = 'Malformed UTF-8 data.';
+                        break;
+                    case PREG_BAD_UTF8_OFFSET_ERROR:
+                        $error = 'Offset doesn\'t correspond to the begin of a valid UTF-8 code point.';
+                        break;
+                    default:
+                        $error = 'Unable to parse.';
+                }
+
+                throw new ParseException($error, $this->getRealCurrentLineNb() + 1, $this->currentLine);
+            }
+        }
+
+        if (isset($mbEncoding)) {
+            mb_internal_encoding($mbEncoding);
+        }
+
+        if ($objectForMap && !is_object($data) && 'mapping' === $context) {
+            $object = new \stdClass();
+
+            foreach ($data as $key => $value) {
+                $object->$key = $value;
+            }
+
+            $data = $object;
+        }
+
+        return empty($data) ? null : $data;
+    }
+
+    private function parseBlock($offset, $yaml, $exceptionOnInvalidType, $objectSupport, $objectForMap)
+    {
+        $skippedLineNumbers = $this->skippedLineNumbers;
+
+        foreach ($this->locallySkippedLineNumbers as $lineNumber) {
+            if ($lineNumber < $offset) {
+                continue;
+            }
+
+            $skippedLineNumbers[] = $lineNumber;
+        }
+
+        $parser = new self($offset, $this->totalNumberOfLines, $skippedLineNumbers);
+        $parser->refs = &$this->refs;
+
+        return $parser->parse($yaml, $exceptionOnInvalidType, $objectSupport, $objectForMap);
+    }
+
+    /**
+     * Returns the current line number (takes the offset into account).
+     *
+     * @return int The current line number
+     */
+    private function getRealCurrentLineNb()
+    {
+        $realCurrentLineNumber = $this->currentLineNb + $this->offset;
+
+        foreach ($this->skippedLineNumbers as $skippedLineNumber) {
+            if ($skippedLineNumber > $realCurrentLineNumber) {
+                break;
+            }
+
+            ++$realCurrentLineNumber;
+        }
+
+        return $realCurrentLineNumber;
+    }
+
+    /**
+     * Returns the current line indentation.
+     *
+     * @return int The current line indentation
+     */
+    private function getCurrentLineIndentation()
+    {
+        return strlen($this->currentLine) - strlen(ltrim($this->currentLine, ' '));
+    }
+
+    /**
+     * Returns the next embed block of YAML.
+     *
+     * @param int  $indentation The indent level at which the block is to be read, or null for default
+     * @param bool $inSequence  True if the enclosing data structure is a sequence
+     *
+     * @return string A YAML string
+     *
+     * @throws ParseException When indentation problem are detected
+     */
+    private function getNextEmbedBlock($indentation = null, $inSequence = false)
+    {
+        $oldLineIndentation = $this->getCurrentLineIndentation();
+        $blockScalarIndentations = array();
+
+        if ($this->isBlockScalarHeader()) {
+            $blockScalarIndentations[] = $this->getCurrentLineIndentation();
+        }
+
+        if (!$this->moveToNextLine()) {
+            return;
+        }
+
+        if (null === $indentation) {
+            $newIndent = $this->getCurrentLineIndentation();
+
+            $unindentedEmbedBlock = $this->isStringUnIndentedCollectionItem();
+
+            if (!$this->isCurrentLineEmpty() && 0 === $newIndent && !$unindentedEmbedBlock) {
+                throw new ParseException('Indentation problem.', $this->getRealCurrentLineNb() + 1, $this->currentLine);
+            }
+        } else {
+            $newIndent = $indentation;
+        }
+
+        $data = array();
+        if ($this->getCurrentLineIndentation() >= $newIndent) {
+            $data[] = substr($this->currentLine, $newIndent);
+        } else {
+            $this->moveToPreviousLine();
+
+            return;
+        }
+
+        if ($inSequence && $oldLineIndentation === $newIndent && isset($data[0][0]) && '-' === $data[0][0]) {
+            // the previous line contained a dash but no item content, this line is a sequence item with the same indentation
+            // and therefore no nested list or mapping
+            $this->moveToPreviousLine();
+
+            return;
+        }
+
+        $isItUnindentedCollection = $this->isStringUnIndentedCollectionItem();
+
+        if (empty($blockScalarIndentations) && $this->isBlockScalarHeader()) {
+            $blockScalarIndentations[] = $this->getCurrentLineIndentation();
+        }
+
+        $previousLineIndentation = $this->getCurrentLineIndentation();
+
+        while ($this->moveToNextLine()) {
+            $indent = $this->getCurrentLineIndentation();
+
+            // terminate all block scalars that are more indented than the current line
+            if (!empty($blockScalarIndentations) && $indent < $previousLineIndentation && trim($this->currentLine) !== '') {
+                foreach ($blockScalarIndentations as $key => $blockScalarIndentation) {
+                    if ($blockScalarIndentation >= $this->getCurrentLineIndentation()) {
+                        unset($blockScalarIndentations[$key]);
+                    }
+                }
+            }
+
+            if (empty($blockScalarIndentations) && !$this->isCurrentLineComment() && $this->isBlockScalarHeader()) {
+                $blockScalarIndentations[] = $this->getCurrentLineIndentation();
+            }
+
+            $previousLineIndentation = $indent;
+
+            if ($isItUnindentedCollection && !$this->isStringUnIndentedCollectionItem() && $newIndent === $indent) {
+                $this->moveToPreviousLine();
+                break;
+            }
+
+            if ($this->isCurrentLineBlank()) {
+                $data[] = substr($this->currentLine, $newIndent);
+                continue;
+            }
+
+            // we ignore "comment" lines only when we are not inside a scalar block
+            if (empty($blockScalarIndentations) && $this->isCurrentLineComment()) {
+                // remember ignored comment lines (they are used later in nested
+                // parser calls to determine real line numbers)
+                //
+                // CAUTION: beware to not populate the global property here as it
+                // will otherwise influence the getRealCurrentLineNb() call here
+                // for consecutive comment lines and subsequent embedded blocks
+                $this->locallySkippedLineNumbers[] = $this->getRealCurrentLineNb();
+
+                continue;
+            }
+
+            if ($indent >= $newIndent) {
+                $data[] = substr($this->currentLine, $newIndent);
+            } elseif (0 == $indent) {
+                $this->moveToPreviousLine();
+
+                break;
+            } else {
+                throw new ParseException('Indentation problem.', $this->getRealCurrentLineNb() + 1, $this->currentLine);
+            }
+        }
+
+        return implode("\n", $data);
+    }
+
+    /**
+     * Moves the parser to the next line.
+     *
+     * @return bool
+     */
+    private function moveToNextLine()
+    {
+        if ($this->currentLineNb >= count($this->lines) - 1) {
+            return false;
+        }
+
+        $this->currentLine = $this->lines[++$this->currentLineNb];
+
+        return true;
+    }
+
+    /**
+     * Moves the parser to the previous line.
+     *
+     * @return bool
+     */
+    private function moveToPreviousLine()
+    {
+        if ($this->currentLineNb < 1) {
+            return false;
+        }
+
+        $this->currentLine = $this->lines[--$this->currentLineNb];
+
+        return true;
+    }
+
+    /**
+     * Parses a YAML value.
+     *
+     * @param string $value                  A YAML value
+     * @param bool   $exceptionOnInvalidType True if an exception must be thrown on invalid types false otherwise
+     * @param bool   $objectSupport          True if object support is enabled, false otherwise
+     * @param bool   $objectForMap           true if maps should return a stdClass instead of array()
+     * @param string $context                The parser context (either sequence or mapping)
+     *
+     * @return mixed A PHP value
+     *
+     * @throws ParseException When reference does not exist
+     */
+    private function parseValue($value, $exceptionOnInvalidType, $objectSupport, $objectForMap, $context)
+    {
+        if (0 === strpos($value, '*')) {
+            if (false !== $pos = strpos($value, '#')) {
+                $value = substr($value, 1, $pos - 2);
+            } else {
+                $value = substr($value, 1);
+            }
+
+            if (!array_key_exists($value, $this->refs)) {
+                throw new ParseException(sprintf('Reference "%s" does not exist.', $value), $this->currentLineNb + 1, $this->currentLine);
+            }
+
+            return $this->refs[$value];
+        }
+
+        if (preg_match('/^'.self::BLOCK_SCALAR_HEADER_PATTERN.'$/', $value, $matches)) {
+            $modifiers = isset($matches['modifiers']) ? $matches['modifiers'] : '';
+
+            return $this->parseBlockScalar($matches['separator'], preg_replace('#\d+#', '', $modifiers), (int) abs($modifiers));
+        }
+
+        try {
+            $parsedValue = Inline::parse($value, $exceptionOnInvalidType, $objectSupport, $objectForMap, $this->refs);
+
+            if ('mapping' === $context && '"' !== $value[0] && "'" !== $value[0] && '[' !== $value[0] && '{' !== $value[0] && '!' !== $value[0] && false !== strpos($parsedValue, ': ')) {
+                @trigger_error(sprintf('Using a colon in the unquoted mapping value "%s" in line %d is deprecated since Symfony 2.8 and will throw a ParseException in 3.0.', $value, $this->getRealCurrentLineNb() + 1), E_USER_DEPRECATED);
+
+                // to be thrown in 3.0
+                // throw new ParseException('A colon cannot be used in an unquoted mapping value.');
+            }
+
+            return $parsedValue;
+        } catch (ParseException $e) {
+            $e->setParsedLine($this->getRealCurrentLineNb() + 1);
+            $e->setSnippet($this->currentLine);
+
+            throw $e;
+        }
+    }
+
+    /**
+     * Parses a block scalar.
+     *
+     * @param string $style       The style indicator that was used to begin this block scalar (| or >)
+     * @param string $chomping    The chomping indicator that was used to begin this block scalar (+ or -)
+     * @param int    $indentation The indentation indicator that was used to begin this block scalar
+     *
+     * @return string The text value
+     */
+    private function parseBlockScalar($style, $chomping = '', $indentation = 0)
+    {
+        $notEOF = $this->moveToNextLine();
+        if (!$notEOF) {
+            return '';
+        }
+
+        $isCurrentLineBlank = $this->isCurrentLineBlank();
+        $blockLines = array();
+
+        // leading blank lines are consumed before determining indentation
+        while ($notEOF && $isCurrentLineBlank) {
+            // newline only if not EOF
+            if ($notEOF = $this->moveToNextLine()) {
+                $blockLines[] = '';
+                $isCurrentLineBlank = $this->isCurrentLineBlank();
+            }
+        }
+
+        // determine indentation if not specified
+        if (0 === $indentation) {
+            if (preg_match('/^ +/', $this->currentLine, $matches)) {
+                $indentation = strlen($matches[0]);
+            }
+        }
+
+        if ($indentation > 0) {
+            $pattern = sprintf('/^ {%d}(.*)$/', $indentation);
+
+            while (
+                $notEOF && (
+                    $isCurrentLineBlank ||
+                    preg_match($pattern, $this->currentLine, $matches)
+                )
+            ) {
+                if ($isCurrentLineBlank && strlen($this->currentLine) > $indentation) {
+                    $blockLines[] = substr($this->currentLine, $indentation);
+                } elseif ($isCurrentLineBlank) {
+                    $blockLines[] = '';
+                } else {
+                    $blockLines[] = $matches[1];
+                }
+
+                // newline only if not EOF
+                if ($notEOF = $this->moveToNextLine()) {
+                    $isCurrentLineBlank = $this->isCurrentLineBlank();
+                }
+            }
+        } elseif ($notEOF) {
+            $blockLines[] = '';
+        }
+
+        if ($notEOF) {
+            $blockLines[] = '';
+            $this->moveToPreviousLine();
+        } elseif (!$notEOF && !$this->isCurrentLineLastLineInDocument()) {
+            $blockLines[] = '';
+        }
+
+        // folded style
+        if ('>' === $style) {
+            $text = '';
+            $previousLineIndented = false;
+            $previousLineBlank = false;
+
+            for ($i = 0; $i < count($blockLines); ++$i) {
+                if ('' === $blockLines[$i]) {
+                    $text .= "\n";
+                    $previousLineIndented = false;
+                    $previousLineBlank = true;
+                } elseif (' ' === $blockLines[$i][0]) {
+                    $text .= "\n".$blockLines[$i];
+                    $previousLineIndented = true;
+                    $previousLineBlank = false;
+                } elseif ($previousLineIndented) {
+                    $text .= "\n".$blockLines[$i];
+                    $previousLineIndented = false;
+                    $previousLineBlank = false;
+                } elseif ($previousLineBlank || 0 === $i) {
+                    $text .= $blockLines[$i];
+                    $previousLineIndented = false;
+                    $previousLineBlank = false;
+                } else {
+                    $text .= ' '.$blockLines[$i];
+                    $previousLineIndented = false;
+                    $previousLineBlank = false;
+                }
+            }
+        } else {
+            $text = implode("\n", $blockLines);
+        }
+
+        // deal with trailing newlines
+        if ('' === $chomping) {
+            $text = preg_replace('/\n+$/', "\n", $text);
+        } elseif ('-' === $chomping) {
+            $text = preg_replace('/\n+$/', '', $text);
+        }
+
+        return $text;
+    }
+
+    /**
+     * Returns true if the next line is indented.
+     *
+     * @return bool Returns true if the next line is indented, false otherwise
+     */
+    private function isNextLineIndented()
+    {
+        $currentIndentation = $this->getCurrentLineIndentation();
+        $EOF = !$this->moveToNextLine();
+
+        while (!$EOF && $this->isCurrentLineEmpty()) {
+            $EOF = !$this->moveToNextLine();
+        }
+
+        if ($EOF) {
+            return false;
+        }
+
+        $ret = false;
+        if ($this->getCurrentLineIndentation() > $currentIndentation) {
+            $ret = true;
+        }
+
+        $this->moveToPreviousLine();
+
+        return $ret;
+    }
+
+    /**
+     * Returns true if the current line is blank or if it is a comment line.
+     *
+     * @return bool Returns true if the current line is empty or if it is a comment line, false otherwise
+     */
+    private function isCurrentLineEmpty()
+    {
+        return $this->isCurrentLineBlank() || $this->isCurrentLineComment();
+    }
+
+    /**
+     * Returns true if the current line is blank.
+     *
+     * @return bool Returns true if the current line is blank, false otherwise
+     */
+    private function isCurrentLineBlank()
+    {
+        return '' == trim($this->currentLine, ' ');
+    }
+
+    /**
+     * Returns true if the current line is a comment line.
+     *
+     * @return bool Returns true if the current line is a comment line, false otherwise
+     */
+    private function isCurrentLineComment()
+    {
+        //checking explicitly the first char of the trim is faster than loops or strpos
+        $ltrimmedLine = ltrim($this->currentLine, ' ');
+
+        return '' !== $ltrimmedLine && $ltrimmedLine[0] === '#';
+    }
+
+    private function isCurrentLineLastLineInDocument()
+    {
+        return ($this->offset + $this->currentLineNb) >= ($this->totalNumberOfLines - 1);
+    }
+
+    /**
+     * Cleanups a YAML string to be parsed.
+     *
+     * @param string $value The input YAML string
+     *
+     * @return string A cleaned up YAML string
+     */
+    private function cleanup($value)
+    {
+        $value = str_replace(array("\r\n", "\r"), "\n", $value);
+
+        // strip YAML header
+        $count = 0;
+        $value = preg_replace('#^\%YAML[: ][\d\.]+.*\n#u', '', $value, -1, $count);
+        $this->offset += $count;
+
+        // remove leading comments
+        $trimmedValue = preg_replace('#^(\#.*?\n)+#s', '', $value, -1, $count);
+        if ($count == 1) {
+            // items have been removed, update the offset
+            $this->offset += substr_count($value, "\n") - substr_count($trimmedValue, "\n");
+            $value = $trimmedValue;
+        }
+
+        // remove start of the document marker (---)
+        $trimmedValue = preg_replace('#^\-\-\-.*?\n#s', '', $value, -1, $count);
+        if ($count == 1) {
+            // items have been removed, update the offset
+            $this->offset += substr_count($value, "\n") - substr_count($trimmedValue, "\n");
+            $value = $trimmedValue;
+
+            // remove end of the document marker (...)
+            $value = preg_replace('#\.\.\.\s*$#', '', $value);
+        }
+
+        return $value;
+    }
+
+    /**
+     * Returns true if the next line starts unindented collection.
+     *
+     * @return bool Returns true if the next line starts unindented collection, false otherwise
+     */
+    private function isNextLineUnIndentedCollection()
+    {
+        $currentIndentation = $this->getCurrentLineIndentation();
+        $notEOF = $this->moveToNextLine();
+
+        while ($notEOF && $this->isCurrentLineEmpty()) {
+            $notEOF = $this->moveToNextLine();
+        }
+
+        if (false === $notEOF) {
+            return false;
+        }
+
+        $ret = false;
+        if (
+            $this->getCurrentLineIndentation() == $currentIndentation
+            &&
+            $this->isStringUnIndentedCollectionItem()
+        ) {
+            $ret = true;
+        }
+
+        $this->moveToPreviousLine();
+
+        return $ret;
+    }
+
+    /**
+     * Returns true if the string is un-indented collection item.
+     *
+     * @return bool Returns true if the string is un-indented collection item, false otherwise
+     */
+    private function isStringUnIndentedCollectionItem()
+    {
+        return '-' === rtrim($this->currentLine) || 0 === strpos($this->currentLine, '- ');
+    }
+
+    /**
+     * Tests whether or not the current line is the header of a block scalar.
+     *
+     * @return bool
+     */
+    private function isBlockScalarHeader()
+    {
+        return (bool) preg_match('~'.self::BLOCK_SCALAR_HEADER_PATTERN.'$~', $this->currentLine);
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/README.md

@@ -0,0 +1,13 @@
+Yaml Component
+==============
+
+The Yaml component loads and dumps YAML files.
+
+Resources
+---------
+
+  * [Documentation](https://symfony.com/doc/current/components/yaml/index.html)
+  * [Contributing](https://symfony.com/doc/current/contributing/index.html)
+  * [Report issues](https://github.com/symfony/symfony/issues) and
+    [send Pull Requests](https://github.com/symfony/symfony/pulls)
+    in the [main Symfony repository](https://github.com/symfony/symfony)

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/DumperTest.php

@@ -0,0 +1,254 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Tests;
+
+use Symfony\Component\Yaml\Parser;
+use Symfony\Component\Yaml\Dumper;
+
+class DumperTest extends \PHPUnit_Framework_TestCase
+{
+    protected $parser;
+    protected $dumper;
+    protected $path;
+
+    protected $array = array(
+        '' => 'bar',
+        'foo' => '#bar',
+        'foo\'bar' => array(),
+        'bar' => array(1, 'foo'),
+        'foobar' => array(
+            'foo' => 'bar',
+            'bar' => array(1, 'foo'),
+            'foobar' => array(
+                'foo' => 'bar',
+                'bar' => array(1, 'foo'),
+            ),
+        ),
+    );
+
+    protected function setUp()
+    {
+        $this->parser = new Parser();
+        $this->dumper = new Dumper();
+        $this->path = __DIR__.'/Fixtures';
+    }
+
+    protected function tearDown()
+    {
+        $this->parser = null;
+        $this->dumper = null;
+        $this->path = null;
+        $this->array = null;
+    }
+
+    public function testSetIndentation()
+    {
+        $this->dumper->setIndentation(7);
+
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar:
+       - 1
+       - foo
+foobar:
+       foo: bar
+       bar:
+              - 1
+              - foo
+       foobar:
+              foo: bar
+              bar:
+                     - 1
+                     - foo
+
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 4, 0));
+    }
+
+    public function testSpecifications()
+    {
+        $files = $this->parser->parse(file_get_contents($this->path.'/index.yml'));
+        foreach ($files as $file) {
+            $yamls = file_get_contents($this->path.'/'.$file.'.yml');
+
+            // split YAMLs documents
+            foreach (preg_split('/^---( %YAML\:1\.0)?/m', $yamls) as $yaml) {
+                if (!$yaml) {
+                    continue;
+                }
+
+                $test = $this->parser->parse($yaml);
+                if (isset($test['dump_skip']) && $test['dump_skip']) {
+                    continue;
+                } elseif (isset($test['todo']) && $test['todo']) {
+                    // TODO
+                } else {
+                    eval('$expected = '.trim($test['php']).';');
+                    $this->assertSame($expected, $this->parser->parse($this->dumper->dump($expected, 10)), $test['test']);
+                }
+            }
+        }
+    }
+
+    public function testInlineLevel()
+    {
+        $expected = <<<'EOF'
+{ '': bar, foo: '#bar', 'foo''bar': {  }, bar: [1, foo], foobar: { foo: bar, bar: [1, foo], foobar: { foo: bar, bar: [1, foo] } } }
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, -10), '->dump() takes an inline level argument');
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 0), '->dump() takes an inline level argument');
+
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar: [1, foo]
+foobar: { foo: bar, bar: [1, foo], foobar: { foo: bar, bar: [1, foo] } }
+
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 1), '->dump() takes an inline level argument');
+
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar:
+    - 1
+    - foo
+foobar:
+    foo: bar
+    bar: [1, foo]
+    foobar: { foo: bar, bar: [1, foo] }
+
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 2), '->dump() takes an inline level argument');
+
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar:
+    - 1
+    - foo
+foobar:
+    foo: bar
+    bar:
+        - 1
+        - foo
+    foobar:
+        foo: bar
+        bar: [1, foo]
+
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 3), '->dump() takes an inline level argument');
+
+        $expected = <<<'EOF'
+'': bar
+foo: '#bar'
+'foo''bar': {  }
+bar:
+    - 1
+    - foo
+foobar:
+    foo: bar
+    bar:
+        - 1
+        - foo
+    foobar:
+        foo: bar
+        bar:
+            - 1
+            - foo
+
+EOF;
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 4), '->dump() takes an inline level argument');
+        $this->assertEquals($expected, $this->dumper->dump($this->array, 10), '->dump() takes an inline level argument');
+    }
+
+    public function testObjectSupportEnabled()
+    {
+        $dump = $this->dumper->dump(array('foo' => new A(), 'bar' => 1), 0, 0, false, true);
+
+        $this->assertEquals('{ foo: !php/object:O:30:"Symfony\Component\Yaml\Tests\A":1:{s:1:"a";s:3:"foo";}, bar: 1 }', $dump, '->dump() is able to dump objects');
+    }
+
+    public function testObjectSupportDisabledButNoExceptions()
+    {
+        $dump = $this->dumper->dump(array('foo' => new A(), 'bar' => 1));
+
+        $this->assertEquals('{ foo: null, bar: 1 }', $dump, '->dump() does not dump objects when disabled');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\DumpException
+     */
+    public function testObjectSupportDisabledWithExceptions()
+    {
+        $this->dumper->dump(array('foo' => new A(), 'bar' => 1), 0, 0, true, false);
+    }
+
+    /**
+     * @dataProvider getEscapeSequences
+     */
+    public function testEscapedEscapeSequencesInQuotedScalar($input, $expected)
+    {
+        $this->assertEquals($expected, $this->dumper->dump($input));
+    }
+
+    public function getEscapeSequences()
+    {
+        return array(
+            'null' => array("\t\\0", '"\t\\\\0"'),
+            'bell' => array("\t\\a", '"\t\\\\a"'),
+            'backspace' => array("\t\\b", '"\t\\\\b"'),
+            'horizontal-tab' => array("\t\\t", '"\t\\\\t"'),
+            'line-feed' => array("\t\\n", '"\t\\\\n"'),
+            'vertical-tab' => array("\t\\v", '"\t\\\\v"'),
+            'form-feed' => array("\t\\f", '"\t\\\\f"'),
+            'carriage-return' => array("\t\\r", '"\t\\\\r"'),
+            'escape' => array("\t\\e", '"\t\\\\e"'),
+            'space' => array("\t\\ ", '"\t\\\\ "'),
+            'double-quote' => array("\t\\\"", '"\t\\\\\\""'),
+            'slash' => array("\t\\/", '"\t\\\\/"'),
+            'backslash' => array("\t\\\\", '"\t\\\\\\\\"'),
+            'next-line' => array("\t\\N", '"\t\\\\N"'),
+            'non-breaking-space' => array("\t\\<EFBFBD>", '"\t\\\\<5C>"'),
+            'line-separator' => array("\t\\L", '"\t\\\\L"'),
+            'paragraph-separator' => array("\t\\P", '"\t\\\\P"'),
+        );
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The indentation must be greater than zero
+     */
+    public function testZeroIndentationThrowsException()
+    {
+        $this->dumper->setIndentation(0);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The indentation must be greater than zero
+     */
+    public function testNegativeIndentationThrowsException()
+    {
+        $this->dumper->setIndentation(-4);
+    }
+}
+
+class A
+{
+    public $a = 'foo';
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/YtsAnchorAlias.yml

@@ -0,0 +1,31 @@
+--- %YAML:1.0
+test: Simple Alias Example
+brief: >
+    If you need to refer to the same item of data twice,
+    you can give that item an alias.  The alias is a plain
+    string, starting with an ampersand.  The item may then
+    be referred to by the alias throughout your document
+    by using an asterisk before the name of the alias.
+    This is called an anchor.
+yaml: |
+    - &showell Steve
+    - Clark
+    - Brian
+    - Oren
+    - *showell
+php: |
+    array('Steve', 'Clark', 'Brian', 'Oren', 'Steve')
+
+---
+test: Alias of a Mapping
+brief: >
+    An alias can be used on any item of data, including
+    sequences, mappings, and other complex data types.
+yaml: |
+    - &hello
+        Meat: pork
+        Starch: potato
+    - banana
+    - *hello
+php: |
+    array(array('Meat'=>'pork', 'Starch'=>'potato'), 'banana', array('Meat'=>'pork', 'Starch'=>'potato'))

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/YtsBasicTests.yml

@@ -0,0 +1,202 @@
+--- %YAML:1.0
+test: Simple Sequence
+brief: |
+    You can specify a list in YAML by placing each
+    member of the list on a new line with an opening
+    dash. These lists are called sequences.
+yaml: |
+    - apple
+    - banana
+    - carrot
+php: |
+    array('apple', 'banana', 'carrot')
+---
+test: Sequence With Item Being Null In The Middle
+brief: |
+    You can specify a list in YAML by placing each
+    member of the list on a new line with an opening
+    dash. These lists are called sequences.
+yaml: |
+    - apple
+    -
+    - carrot
+php: |
+    array('apple', null, 'carrot')
+---
+test: Sequence With Last Item Being Null
+brief: |
+    You can specify a list in YAML by placing each
+    member of the list on a new line with an opening
+    dash. These lists are called sequences.
+yaml: |
+    - apple
+    - banana
+    -
+php: |
+    array('apple', 'banana', null)
+---
+test: Nested Sequences
+brief: |
+    You can include a sequence within another
+    sequence by giving the sequence an empty
+    dash, followed by an indented list.
+yaml: |
+    -
+     - foo
+     - bar
+     - baz
+php: |
+    array(array('foo', 'bar', 'baz'))
+---
+test: Mixed Sequences
+brief: |
+    Sequences can contain any YAML data,
+    including strings and other sequences.
+yaml: |
+    - apple
+    -
+     - foo
+     - bar
+     - x123
+    - banana
+    - carrot
+php: |
+    array('apple', array('foo', 'bar', 'x123'), 'banana', 'carrot')
+---
+test: Deeply Nested Sequences
+brief: |
+    Sequences can be nested even deeper, with each
+    level of indentation representing a level of
+    depth.
+yaml: |
+    -
+     -
+      - uno
+      - dos
+php: |
+    array(array(array('uno', 'dos')))
+---
+test: Simple Mapping
+brief: |
+    You can add a keyed list (also known as a dictionary or
+    hash) to your document by placing each member of the
+    list on a new line, with a colon separating the key
+    from its value.  In YAML, this type of list is called
+    a mapping.
+yaml: |
+    foo: whatever
+    bar: stuff
+php: |
+    array('foo' => 'whatever', 'bar' => 'stuff')
+---
+test: Sequence in a Mapping
+brief: |
+    A value in a mapping can be a sequence.
+yaml: |
+    foo: whatever
+    bar:
+     - uno
+     - dos
+php: |
+    array('foo' => 'whatever', 'bar' => array('uno', 'dos'))
+---
+test: Nested Mappings
+brief: |
+    A value in a mapping can be another mapping.
+yaml: |
+    foo: whatever
+    bar:
+     fruit: apple
+     name: steve
+     sport: baseball
+php: |
+    array(
+      'foo' => 'whatever',
+      'bar' => array(
+         'fruit' => 'apple',
+         'name' => 'steve',
+         'sport' => 'baseball'
+       )
+    )
+---
+test: Mixed Mapping
+brief: |
+    A mapping can contain any assortment
+    of mappings and sequences as values.
+yaml: |
+    foo: whatever
+    bar:
+     -
+       fruit: apple
+       name: steve
+       sport: baseball
+     - more
+     -
+       python: rocks
+       perl: papers
+       ruby: scissorses
+php: |
+    array(
+      'foo' => 'whatever',
+      'bar' => array(
+        array(
+            'fruit' => 'apple',
+            'name' => 'steve',
+            'sport' => 'baseball'
+        ),
+        'more',
+        array(
+            'python' => 'rocks',
+            'perl' => 'papers',
+            'ruby' => 'scissorses'
+        )
+      )
+    )
+---
+test: Mapping-in-Sequence Shortcut
+todo: true
+brief: |
+     If you are adding a mapping to a sequence, you
+     can place the mapping on the same line as the
+     dash as a shortcut.
+yaml: |
+     - work on YAML.py:
+        - work on Store
+php: |
+    array(array('work on YAML.py' => array('work on Store')))
+---
+test: Sequence-in-Mapping Shortcut
+todo: true
+brief: |
+     The dash in a sequence counts as indentation, so
+     you can add a sequence inside of a mapping without
+     needing spaces as indentation.
+yaml: |
+     allow:
+     - 'localhost'
+     - '%.sourceforge.net'
+     - '%.freepan.org'
+php: |
+     array('allow' => array('localhost', '%.sourceforge.net', '%.freepan.org'))
+---
+todo: true
+test: Merge key
+brief: |
+     A merge key ('<<') can be used in a mapping to insert other mappings.  If
+     the value associated with the merge key is a mapping, each of its key/value
+     pairs is inserted into the current mapping.
+yaml: |
+     mapping:
+       name: Joe
+       job: Accountant
+       <<:
+         age: 38
+php: |
+     array(
+       'mapping' =>
+       array(
+         'name' => 'Joe',
+         'job' => 'Accountant',
+         'age' => 38
+       )
+     )

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/YtsBlockMapping.yml

@@ -0,0 +1,51 @@
+---
+test: One Element Mapping
+brief: |
+    A mapping with one key/value pair
+yaml: |
+    foo: bar
+php: |
+    array('foo' => 'bar')
+---
+test: Multi Element Mapping
+brief: |
+    More than one key/value pair
+yaml: |
+    red: baron
+    white: walls
+    blue: berries
+php: |
+    array(
+     'red' => 'baron',
+     'white' => 'walls',
+     'blue' => 'berries',
+    )
+---
+test: Values aligned
+brief: |
+    Often times human editors of documents will align the values even
+    though YAML emitters generally don't.
+yaml: |
+    red:   baron
+    white: walls
+    blue:  berries
+php: |
+    array(
+     'red' => 'baron',
+     'white' => 'walls',
+     'blue' => 'berries',
+    )
+---
+test: Colons aligned
+brief: |
+    Spaces can come before the ': ' key/value separator.
+yaml: |
+    red   : baron
+    white : walls
+    blue  : berries
+php: |
+    array(
+     'red' => 'baron',
+     'white' => 'walls',
+     'blue' => 'berries',
+    )

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/YtsDocumentSeparator.yml

@@ -0,0 +1,85 @@
+--- %YAML:1.0
+test: Trailing Document Separator
+todo: true
+brief: >
+    You can separate YAML documents
+    with a string of three dashes.
+yaml: |
+    - foo: 1
+      bar: 2
+    ---
+    more: stuff
+python: |
+    [
+        [ { 'foo': 1, 'bar': 2 } ],
+        { 'more': 'stuff' }
+    ]
+ruby: |
+    [ { 'foo' => 1, 'bar' => 2 } ]
+
+---
+test: Leading Document Separator
+todo: true
+brief: >
+    You can explicitly give an opening
+    document separator to your YAML stream.
+yaml: |
+    ---
+    - foo: 1
+      bar: 2
+    ---
+    more: stuff
+python: |
+    [
+        [ {'foo': 1, 'bar': 2}],
+        {'more': 'stuff'}
+    ]
+ruby: |
+    [ { 'foo' => 1, 'bar' => 2 } ]
+
+---
+test: YAML Header
+todo: true
+brief: >
+    The opening separator can contain directives
+    to the YAML parser, such as the version
+    number.
+yaml: |
+    --- %YAML:1.0
+    foo: 1
+    bar: 2
+php: |
+    array('foo' => 1, 'bar' => 2)
+documents: 1
+
+---
+test: Red Herring Document Separator
+brief: >
+    Separators included in blocks or strings
+    are treated as blocks or strings, as the
+    document separator should have no indentation
+    preceding it.
+yaml: |
+    foo: |
+        ---
+php: |
+    array('foo' => "---\n")
+
+---
+test: Multiple Document Separators in Block
+brief: >
+    This technique allows you to embed other YAML
+    documents within literal blocks.
+yaml: |
+    foo: |
+        ---
+        foo: bar
+        ---
+        yo: baz
+    bar: |
+        fooness
+php: |
+    array(
+       'foo' => "---\nfoo: bar\n---\nyo: baz\n",
+       'bar' => "fooness\n"
+    )

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/YtsErrorTests.yml

@@ -0,0 +1,25 @@
+---
+test: Missing value for hash item
+todo: true
+brief: |
+    Third item in this hash doesn't have a value
+yaml: |
+    okay: value
+    also okay: ~
+    causes error because no value specified
+    last key: value okay here too
+python-error: causes error because no value specified
+
+---
+test: Not indenting enough
+brief: |
+    There was a bug in PyYaml where it was off by one
+    in the indentation check.  It was allowing the YAML
+    below.
+# This is actually valid YAML now. Someone should tell showell.
+yaml: |
+    foo:
+    firstline: 1
+    secondline: 2
+php: |
+  array('foo' => null, 'firstline' => 1, 'secondline' => 2)

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/YtsFlowCollections.yml

@@ -0,0 +1,60 @@
+---
+test: Simple Inline Array
+brief: >
+    Sequences can be contained on a
+    single line, using the inline syntax.
+    Separate each entry with commas and
+    enclose in square brackets.
+yaml: |
+    seq: [ a, b, c ]
+php: |
+    array('seq' => array('a', 'b', 'c'))
+---
+test: Simple Inline Hash
+brief: >
+    Mapping can also be contained on
+    a single line, using the inline
+    syntax.  Each key-value pair is
+    separated by a colon, with a comma
+    between each entry in the mapping.
+    Enclose with curly braces.
+yaml: |
+    hash: { name: Steve, foo: bar }
+php: |
+    array('hash' => array('name' => 'Steve', 'foo' => 'bar'))
+---
+test: Multi-line Inline Collections
+todo: true
+brief: >
+    Both inline sequences and inline mappings
+    can span multiple lines, provided that you
+    indent the additional lines.
+yaml: |
+    languages: [ Ruby,
+                 Perl,
+                 Python ]
+    websites: { YAML: yaml.org,
+                Ruby: ruby-lang.org,
+                Python: python.org,
+                Perl: use.perl.org }
+php: |
+    array(
+      'languages' => array('Ruby', 'Perl', 'Python'),
+      'websites' => array(
+        'YAML' => 'yaml.org',
+        'Ruby' => 'ruby-lang.org',
+        'Python' => 'python.org',
+        'Perl' => 'use.perl.org'
+      )
+    )
+---
+test: Commas in Values (not in the spec!)
+todo: true
+brief: >
+    List items in collections are delimited by commas, but
+    there must be a space after each comma.  This allows you
+    to add numbers without quoting.
+yaml: |
+    attendances: [ 45,123, 70,000, 17,222 ]
+php: |
+    array('attendances' => array(45123, 70000, 17222))

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/YtsFoldedScalars.yml

@@ -0,0 +1,176 @@
+--- %YAML:1.0
+test: Single ending newline
+brief: >
+    A pipe character, followed by an indented
+    block of text is treated as a literal
+    block, in which newlines are preserved
+    throughout the block, including the final
+    newline.
+yaml: |
+    ---
+    this: |
+        Foo
+        Bar
+php: |
+    array('this' => "Foo\nBar\n")
+---
+test: The '+' indicator
+brief: >
+    The '+' indicator says to keep newlines at the end of text
+    blocks.
+yaml: |
+    normal: |
+      extra new lines not kept
+
+    preserving: |+
+      extra new lines are kept
+
+
+    dummy: value
+php: |
+    array(
+        'normal' => "extra new lines not kept\n",
+        'preserving' => "extra new lines are kept\n\n\n",
+        'dummy' => 'value'
+    )
+---
+test: Three trailing newlines in literals
+brief: >
+    To give you more control over how space
+    is preserved in text blocks, YAML has
+    the keep '+' and chomp '-' indicators.
+    The keep indicator will preserve all
+    ending newlines, while the chomp indicator
+    will strip all ending newlines.
+yaml: |
+    clipped: |
+        This has one newline.
+
+
+
+    same as "clipped" above: "This has one newline.\n"
+
+    stripped: |-
+        This has no newline.
+
+
+
+    same as "stripped" above: "This has no newline."
+
+    kept: |+
+        This has four newlines.
+
+
+
+    same as "kept" above: "This has four newlines.\n\n\n\n"
+php: |
+    array(
+      'clipped' => "This has one newline.\n",
+      'same as "clipped" above' => "This has one newline.\n",
+      'stripped' => 'This has no newline.',
+      'same as "stripped" above' => 'This has no newline.',
+      'kept' => "This has four newlines.\n\n\n\n",
+      'same as "kept" above' => "This has four newlines.\n\n\n\n"
+    )
+---
+test: Extra trailing newlines with spaces
+todo: true
+brief: >
+    Normally, only a single newline is kept
+    from the end of a literal block, unless the
+    keep '+' character is used in combination
+    with the pipe.  The following example
+    will preserve all ending whitespace
+    since the last line of both literal blocks
+    contains spaces which extend past the indentation
+    level.
+yaml: |
+    ---
+    this: |
+        Foo
+
+
+    kept: |+
+        Foo
+
+
+php: |
+    array('this' => "Foo\n\n  \n",
+      'kept' => "Foo\n\n  \n" )
+
+---
+test: Folded Block in a Sequence
+brief: >
+    A greater-then character, followed by an indented
+    block of text is treated as a folded block, in
+    which lines of text separated by a single newline
+    are concatenated as a single line.
+yaml: |
+    ---
+    - apple
+    - banana
+    - >
+        can't you see
+        the beauty of yaml?
+        hmm
+    - dog
+php: |
+    array(
+        'apple',
+        'banana',
+        "can't you see the beauty of yaml? hmm\n",
+        'dog'
+    )
+---
+test: Folded Block as a Mapping Value
+brief: >
+    Both literal and folded blocks can be
+    used in collections, as values in a
+    sequence or a mapping.
+yaml: |
+    ---
+    quote: >
+        Mark McGwire's
+        year was crippled
+        by a knee injury.
+    source: espn
+php: |
+    array(
+        'quote' => "Mark McGwire's year was crippled by a knee injury.\n",
+        'source' => 'espn'
+    )
+---
+test: Three trailing newlines in folded blocks
+brief: >
+    The keep and chomp indicators can also
+    be applied to folded blocks.
+yaml: |
+    clipped: >
+        This has one newline.
+
+
+
+    same as "clipped" above: "This has one newline.\n"
+
+    stripped: >-
+        This has no newline.
+
+
+
+    same as "stripped" above: "This has no newline."
+
+    kept: >+
+        This has four newlines.
+
+
+
+    same as "kept" above: "This has four newlines.\n\n\n\n"
+php: |
+    array(
+      'clipped' => "This has one newline.\n",
+      'same as "clipped" above' => "This has one newline.\n",
+      'stripped' => 'This has no newline.',
+      'same as "stripped" above' => 'This has no newline.',
+      'kept' => "This has four newlines.\n\n\n\n",
+      'same as "kept" above' => "This has four newlines.\n\n\n\n"
+    )

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/YtsNullsAndEmpties.yml

@@ -0,0 +1,45 @@
+--- %YAML:1.0
+test: Empty Sequence
+brief: >
+    You can represent the empty sequence
+    with an empty inline sequence.
+yaml: |
+    empty: []
+php: |
+    array('empty' => array())
+---
+test: Empty Mapping
+brief: >
+    You can represent the empty mapping
+    with an empty inline mapping.
+yaml: |
+    empty: {}
+php: |
+    array('empty' => array())
+---
+test: Empty Sequence as Entire Document
+yaml: |
+    []
+php: |
+    array()
+---
+test: Empty Mapping as Entire Document
+yaml: |
+    {}
+php: |
+    array()
+---
+test: Null as Document
+yaml: |
+    ~
+php: |
+    null
+---
+test: Empty String
+brief: >
+    You can represent an empty string
+    with a pair of quotes.
+yaml: |
+    ''
+php: |
+    ''

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/YtsTypeTransfers.yml

@@ -0,0 +1,244 @@
+--- %YAML:1.0
+test: Strings
+brief: >
+    Any group of characters beginning with an
+    alphabetic or numeric character is a string,
+    unless it belongs to one of the groups below
+    (such as an Integer or Time).
+yaml: |
+    String
+php: |
+    'String'
+---
+test: String characters
+brief: >
+    A string can contain any alphabetic or
+    numeric character, along with many
+    punctuation characters, including the
+    period, dash, space, quotes, exclamation, and
+    question mark.
+yaml: |
+    - What's Yaml?
+    - It's for writing data structures in plain text.
+    - And?
+    - And what? That's not good enough for you?
+    - No, I mean, "And what about Yaml?"
+    - Oh, oh yeah. Uh.. Yaml for Ruby.
+php: |
+    array(
+      "What's Yaml?",
+      "It's for writing data structures in plain text.",
+      "And?",
+      "And what? That's not good enough for you?",
+      "No, I mean, \"And what about Yaml?\"",
+      "Oh, oh yeah. Uh.. Yaml for Ruby."
+    )
+---
+test: Indicators in Strings
+brief: >
+    Be careful using indicators in strings.  In particular,
+    the comma, colon, and pound sign must be used carefully.
+yaml: |
+    the colon followed by space is an indicator: but is a string:right here
+    same for the pound sign: here we have it#in a string
+    the comma can, honestly, be used in most cases: [ but not in, inline collections ]
+php: |
+    array(
+      'the colon followed by space is an indicator' => 'but is a string:right here',
+      'same for the pound sign' => 'here we have it#in a string',
+      'the comma can, honestly, be used in most cases' => array('but not in', 'inline collections')
+    )
+---
+test: Forcing Strings
+brief: >
+    Any YAML type can be forced into a string using the
+    explicit !str method.
+yaml: |
+    date string: !str 2001-08-01
+    number string: !str 192
+php: |
+    array(
+      'date string' => '2001-08-01',
+      'number string' => '192'
+    )
+---
+test: Single-quoted Strings
+brief: >
+    You can also enclose your strings within single quotes,
+    which allows use of slashes, colons, and other indicators
+    freely.  Inside single quotes, you can represent a single
+    quote in your string by using two single quotes next to
+    each other.
+yaml: |
+    all my favorite symbols: '#:!/%.)'
+    a few i hate: '&(*'
+    why do i hate them?: 'it''s very hard to explain'
+    entities: '£ me'
+php: |
+    array(
+      'all my favorite symbols' => '#:!/%.)',
+      'a few i hate' => '&(*',
+      'why do i hate them?' => 'it\'s very hard to explain',
+      'entities' => '£ me'
+    )
+---
+test: Double-quoted Strings
+brief: >
+    Enclosing strings in double quotes allows you
+    to use escapings to represent ASCII and
+    Unicode characters.
+yaml: |
+    i know where i want my line breaks: "one here\nand another here\n"
+php: |
+    array(
+      'i know where i want my line breaks' => "one here\nand another here\n"
+    )
+---
+test: Multi-line Quoted Strings
+todo: true
+brief: >
+    Both single- and double-quoted strings may be
+    carried on to new lines in your YAML document.
+    They must be indented a step and indentation
+    is interpreted as a single space.
+yaml: |
+    i want a long string: "so i'm going to
+      let it go on and on to other lines
+      until i end it with a quote."
+php: |
+    array('i want a long string' => "so i'm going to ".
+         "let it go on and on to other lines ".
+         "until i end it with a quote."
+    )
+
+---
+test: Plain scalars
+todo: true
+brief: >
+    Unquoted strings may also span multiple lines, if they
+    are free of YAML space indicators and indented.
+yaml: |
+    - My little toe is broken in two places;
+    - I'm crazy to have skied this way;
+    - I'm not the craziest he's seen, since there was always the German guy
+      who skied for 3 hours on a broken shin bone (just below the kneecap);
+    - Nevertheless, second place is respectable, and he doesn't
+      recommend going for the record;
+    - He's going to put my foot in plaster for a month;
+    - This would impair my skiing ability somewhat for the
+      duration, as can be imagined.
+php: |
+    array(
+      "My little toe is broken in two places;",
+      "I'm crazy to have skied this way;",
+      "I'm not the craziest he's seen, since there was always ".
+         "the German guy who skied for 3 hours on a broken shin ".
+         "bone (just below the kneecap);",
+      "Nevertheless, second place is respectable, and he doesn't ".
+         "recommend going for the record;",
+      "He's going to put my foot in plaster for a month;",
+      "This would impair my skiing ability somewhat for the duration, ".
+         "as can be imagined."
+    )
+---
+test: 'Null'
+brief: >
+    You can use the tilde '~' character for a null value.
+yaml: |
+    name: Mr. Show
+    hosted by: Bob and David
+    date of next season: ~
+php: |
+    array(
+      'name' => 'Mr. Show',
+      'hosted by' => 'Bob and David',
+      'date of next season' => null
+    )
+---
+test: Boolean
+brief: >
+    You can use 'true' and 'false' for Boolean values.
+yaml: |
+    Is Gus a Liar?: true
+    Do I rely on Gus for Sustenance?: false
+php: |
+    array(
+      'Is Gus a Liar?' => true,
+      'Do I rely on Gus for Sustenance?' => false
+    )
+---
+test: Integers
+dump_skip: true
+brief: >
+    An integer is a series of numbers, optionally
+    starting with a positive or negative sign.  Integers
+    may also contain commas for readability.
+yaml: |
+    zero: 0
+    simple: 12
+    one-thousand: 1,000
+    negative one-thousand: -1,000
+php: |
+    array(
+      'zero' => 0,
+      'simple' => 12,
+      'one-thousand' => 1000.0,
+      'negative one-thousand' => -1000.0
+    )
+---
+test: Integers as Map Keys
+brief: >
+    An integer can be used a dictionary key.
+yaml: |
+    1: one
+    2: two
+    3: three
+php: |
+    array(
+        1 => 'one',
+        2 => 'two',
+        3 => 'three'
+    )
+---
+test: Floats
+dump_skip: true
+brief: >
+     Floats are represented by numbers with decimals,
+     allowing for scientific notation, as well as
+     positive and negative infinity and "not a number."
+yaml: |
+     a simple float: 2.00
+     larger float: 1,000.09
+     scientific notation: 1.00009e+3
+php: |
+     array(
+       'a simple float' => 2.0,
+       'larger float' => 1000.09,
+       'scientific notation' => 1000.09
+     )
+---
+test: Time
+todo: true
+brief: >
+    You can represent timestamps by using
+    ISO8601 format, or a variation which
+    allows spaces between the date, time and
+    time zone.
+yaml: |
+    iso8601: 2001-12-14t21:59:43.10-05:00
+    space separated: 2001-12-14 21:59:43.10 -05:00
+php: |
+    array(
+      'iso8601' => mktime( 2001, 12, 14, 21, 59, 43, 0.10, "-05:00" ),
+      'space separated' => mktime( 2001, 12, 14, 21, 59, 43, 0.10, "-05:00" )
+    )
+---
+test: Date
+todo: true
+brief: >
+    A date can be represented by its year,
+    month and day in ISO8601 order.
+yaml: |
+    1976-07-31
+php: |
+    date( 1976, 7, 31 )

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/embededPhp.yml

@@ -0,0 +1 @@
+value: <?php echo 1 + 2 + 3 ?>

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/escapedCharacters.yml

@@ -0,0 +1,155 @@
+test: outside double quotes
+yaml: |
+    \0 \ \a \b \n
+php: |
+    "\\0 \\ \\a \\b \\n"
+---
+test: null
+yaml: |
+    "\0"
+php: |
+    "\x00"
+---
+test: bell
+yaml: |
+    "\a"
+php: |
+    "\x07"
+---
+test: backspace
+yaml: |
+    "\b"
+php: |
+    "\x08"
+---
+test: horizontal tab (1)
+yaml: |
+    "\t"
+php: |
+    "\x09"
+---
+test: horizontal tab (2)
+yaml: |
+    "\	"
+php: |
+    "\x09"
+---
+test: line feed
+yaml: |
+    "\n"
+php: |
+    "\x0a"
+---
+test: vertical tab
+yaml: |
+    "\v"
+php: |
+    "\x0b"
+---
+test: form feed
+yaml: |
+    "\f"
+php: |
+    "\x0c"
+---
+test: carriage return
+yaml: |
+    "\r"
+php: |
+    "\x0d"
+---
+test: escape
+yaml: |
+    "\e"
+php: |
+   "\x1b"
+---
+test: space
+yaml: |
+    "\ "
+php: |
+    "\x20"
+---
+test: slash
+yaml: |
+    "\/"
+php: |
+    "\x2f"
+---
+test: backslash
+yaml: |
+    "\\"
+php: |
+    "\\"
+---
+test: Unicode next line
+yaml: |
+    "\N"
+php: |
+    "\xc2\x85"
+---
+test: Unicode non-breaking space
+yaml: |
+    "\_"
+php: |
+    "\xc2\xa0"
+---
+test: Unicode line separator
+yaml: |
+    "\L"
+php: |
+    "\xe2\x80\xa8"
+---
+test: Unicode paragraph separator
+yaml: |
+    "\P"
+php: |
+    "\xe2\x80\xa9"
+---
+test: Escaped 8-bit Unicode
+yaml: |
+    "\x42"
+php: |
+    "B"
+---
+test: Escaped 16-bit Unicode
+yaml: |
+    "\u20ac"
+php: |
+    "\xe2\x82\xac"
+---
+test: Escaped 32-bit Unicode
+yaml: |
+    "\U00000043"
+php: |
+    "C"
+---
+test: Example 5.13 Escaped Characters
+note: |
+    Currently throws an error parsing first line. Maybe Symfony Yaml doesn't support
+    continuation of string across multiple lines? Keeping test here but disabled.
+todo: true
+yaml: |
+    "Fun with \\
+    \" \a \b \e \f \
+    \n \r \t \v \0 \
+    \  \_ \N \L \P \
+    \x41 \u0041 \U00000041"
+php: |
+    "Fun with \x5C\n\x22 \x07 \x08 \x1B \x0C\n\x0A \x0D \x09 \x0B \x00\n\x20 \xA0 \x85 \xe2\x80\xa8 \xe2\x80\xa9\nA A A"
+---
+test: Double quotes with a line feed
+yaml: |
+   { double: "some value\n \"some quoted string\" and 'some single quotes one'" }
+php: |
+    array(
+        'double' => "some value\n \"some quoted string\" and 'some single quotes one'"
+    )
+---
+test: Backslashes
+yaml: |
+    { single: 'foo\Var', no-quotes: foo\Var, double: "foo\\Var" }
+php: |
+    array(
+        'single' => 'foo\Var', 'no-quotes' => 'foo\Var', 'double' => 'foo\Var'
+    )

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/index.yml

@@ -0,0 +1,18 @@
+- escapedCharacters
+- sfComments
+- sfCompact
+- sfTests
+- sfObjects
+- sfMergeKey
+- sfQuotes
+- YtsAnchorAlias
+- YtsBasicTests
+- YtsBlockMapping
+- YtsDocumentSeparator
+- YtsErrorTests
+- YtsFlowCollections
+- YtsFoldedScalars
+- YtsNullsAndEmpties
+- YtsSpecificationExamples
+- YtsTypeTransfers
+- unindentedCollections

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/sfComments.yml

@@ -0,0 +1,76 @@
+--- %YAML:1.0
+test: Comments at the end of a line
+brief: >
+    Comments at the end of a line
+yaml: |
+    ex1: "foo # bar"
+    ex2: "foo # bar" # comment
+    ex3: 'foo # bar' # comment
+    ex4: foo # comment
+    ex5: foo	#	comment with tab before  
+    ex6: foo#foo # comment here
+    ex7: foo 	# ignore me # and me
+php: |
+    array('ex1' => 'foo # bar', 'ex2' => 'foo # bar', 'ex3' => 'foo # bar', 'ex4' => 'foo', 'ex5' => 'foo', 'ex6' => 'foo#foo', 'ex7' => 'foo')
+---
+test: Comments in the middle
+brief: >
+  Comments in the middle
+yaml: |
+    foo:
+    # some comment
+    # some comment
+      bar: foo
+    # some comment
+    # some comment
+php: |
+    array('foo' => array('bar' => 'foo'))
+---
+test: Comments on a hash line
+brief: >
+  Comments on a hash line
+yaml: |
+    foo:   # a comment
+      foo: bar # a comment
+php: |
+    array('foo' => array('foo' => 'bar'))
+---
+test: 'Value starting with a #'
+brief: >
+  'Value starting with a #'
+yaml: |
+    foo:   '#bar'
+php: |
+    array('foo' => '#bar')
+---
+test: Document starting with a comment and a separator
+brief: >
+  Commenting before document start is allowed
+yaml: |
+    # document comment
+    ---
+    foo: bar # a comment
+php: |
+    array('foo' => 'bar')
+---
+test: Comment containing a colon on a hash line
+brief: >
+    Comment containing a colon on a scalar line
+yaml: 'foo # comment: this is also part of the comment'
+php: |
+    'foo'
+---
+test: 'Hash key containing a #'
+brief: >
+    'Hash key containing a #'
+yaml: 'foo#bar: baz'
+php: |
+    array('foo#bar' => 'baz')
+---
+test: 'Hash key ending with a space and a #'
+brief: >
+    'Hash key ending with a space and a #'
+yaml: |
+    'foo #': baz
+php: |
+    array('foo #' => 'baz')

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/sfCompact.yml

@@ -0,0 +1,159 @@
+--- %YAML:1.0
+test: Compact notation
+brief: |
+    Compact notation for sets of mappings with single element
+yaml: |
+  ---
+  # products purchased
+  - item    : Super Hoop
+  - item    : Basketball
+    quantity: 1
+  - item:
+      name: Big Shoes
+      nick: Biggies
+    quantity: 1
+php: |
+  array (
+    array (
+      'item' => 'Super Hoop',
+    ),
+    array (
+      'item' => 'Basketball',
+      'quantity' => 1,
+    ),
+    array (
+      'item' => array(
+        'name' => 'Big Shoes',
+        'nick' => 'Biggies'
+      ),
+      'quantity' => 1
+    )
+  )
+---
+test: Compact notation combined with inline notation
+brief: |
+    Combinations of compact and inline notation are allowed
+yaml: |
+  ---
+  items:
+    - { item: Super Hoop, quantity: 1 }
+    - [ Basketball, Big Shoes ]
+php: |
+  array (
+    'items' => array (
+      array (
+        'item' => 'Super Hoop',
+        'quantity' => 1,
+      ),
+      array (
+        'Basketball',
+        'Big Shoes'
+      )
+    )
+  )
+--- %YAML:1.0
+test: Compact notation
+brief: |
+    Compact notation for sets of mappings with single element
+yaml: |
+  ---
+  # products purchased
+  - item    : Super Hoop
+  - item    : Basketball
+    quantity: 1
+  - item:
+      name: Big Shoes
+      nick: Biggies
+    quantity: 1
+php: |
+  array (
+    array (
+      'item' => 'Super Hoop',
+    ),
+    array (
+      'item' => 'Basketball',
+      'quantity' => 1,
+    ),
+    array (
+      'item' => array(
+        'name' => 'Big Shoes',
+        'nick' => 'Biggies'
+      ),
+      'quantity' => 1
+    )
+  )
+---
+test: Compact notation combined with inline notation
+brief: |
+    Combinations of compact and inline notation are allowed
+yaml: |
+  ---
+  items:
+    - { item: Super Hoop, quantity: 1 }
+    - [ Basketball, Big Shoes ]
+php: |
+  array (
+    'items' => array (
+      array (
+        'item' => 'Super Hoop',
+        'quantity' => 1,
+      ),
+      array (
+        'Basketball',
+        'Big Shoes'
+      )
+    )
+  )
+--- %YAML:1.0
+test: Compact notation
+brief: |
+    Compact notation for sets of mappings with single element
+yaml: |
+  ---
+  # products purchased
+  - item    : Super Hoop
+  - item    : Basketball
+    quantity: 1
+  - item:
+      name: Big Shoes
+      nick: Biggies
+    quantity: 1
+php: |
+  array (
+    array (
+      'item' => 'Super Hoop',
+    ),
+    array (
+      'item' => 'Basketball',
+      'quantity' => 1,
+    ),
+    array (
+      'item' => array(
+        'name' => 'Big Shoes',
+        'nick' => 'Biggies'
+      ),
+      'quantity' => 1
+    )
+  )
+---
+test: Compact notation combined with inline notation
+brief: |
+    Combinations of compact and inline notation are allowed
+yaml: |
+  ---
+  items:
+    - { item: Super Hoop, quantity: 1 }
+    - [ Basketball, Big Shoes ]
+php: |
+  array (
+    'items' => array (
+      array (
+        'item' => 'Super Hoop',
+        'quantity' => 1,
+      ),
+      array (
+        'Basketball',
+        'Big Shoes'
+      )
+    )
+  )

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/sfMergeKey.yml

@@ -0,0 +1,58 @@
+--- %YAML:1.0
+test: Simple In Place Substitution
+brief: >
+    If you want to reuse an entire alias, only overwriting what is different
+    you can use a << in place substitution. This is not part of the official
+    YAML spec, but a widely implemented extension. See the following URL for
+    details: http://yaml.org/type/merge.html
+yaml: |
+    foo: &foo
+        a: Steve
+        b: Clark
+        c: Brian
+    bar:
+        a: before
+        d: other
+        <<: *foo
+        b: new
+        x: Oren
+        c:
+            foo: bar
+            foo: ignore
+            bar: foo
+    duplicate:
+        foo: bar
+        foo: ignore
+    foo2: &foo2
+        a: Ballmer
+    ding: &dong [ fi, fei, fo, fam]
+    check:
+        <<:
+            - *foo
+            - *dong
+        isit: tested
+    head:
+        <<: [ *foo , *dong , *foo2 ]
+    taz: &taz
+        a: Steve
+        w:
+            p: 1234
+    nested:
+        <<: *taz
+        d: Doug
+        w: &nestedref
+            p: 12345
+        z:
+            <<: *nestedref
+php: |
+    array(
+        'foo' => array('a' => 'Steve', 'b' => 'Clark', 'c' => 'Brian'),
+        'bar' => array('a' => 'before', 'd' => 'other', 'b' => 'new', 'c' => array('foo' => 'bar', 'bar' => 'foo'), 'x' => 'Oren'),
+        'duplicate' => array('foo' => 'bar'),
+        'foo2' => array('a' => 'Ballmer'),
+        'ding' => array('fi', 'fei', 'fo', 'fam'),
+        'check' => array('a' => 'Steve', 'b' => 'Clark', 'c' => 'Brian', 'fi', 'fei', 'fo', 'fam', 'isit' => 'tested'),
+        'head' => array('a' => 'Steve', 'b' => 'Clark', 'c' => 'Brian', 'fi', 'fei', 'fo', 'fam'),
+        'taz' => array('a' => 'Steve', 'w' => array('p' => 1234)),
+        'nested' => array('a' => 'Steve', 'w' => array('p' => 12345), 'd' => 'Doug', 'z' => array('p' => 12345))
+    )

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/sfObjects.yml

@@ -0,0 +1,11 @@
+--- %YAML:1.0
+test: Objects
+brief: >
+    Comments at the end of a line
+yaml: |
+    ex1: "foo # bar"
+    ex2: "foo # bar" # comment
+    ex3: 'foo # bar' # comment
+    ex4: foo # comment
+php: |
+    array('ex1' => 'foo # bar', 'ex2' => 'foo # bar', 'ex3' => 'foo # bar', 'ex4' => 'foo')

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/sfQuotes.yml

@@ -0,0 +1,33 @@
+--- %YAML:1.0
+test: Some characters at the beginning of a string must be escaped
+brief: >
+    Some characters at the beginning of a string must be escaped
+yaml: |
+    foo: '| bar'
+php: |
+    array('foo' => '| bar')
+---
+test: A key can be a quoted string
+brief: >
+  A key can be a quoted string
+yaml: |
+    "foo1": bar
+    'foo2': bar
+    "foo \" bar": bar
+    'foo '' bar': bar
+    'foo3: ': bar
+    "foo4: ": bar
+    foo5: { "foo \" bar: ": bar, 'foo '' bar: ': bar }
+php: |
+    array(
+      'foo1' => 'bar',
+      'foo2' => 'bar',
+      'foo " bar' => 'bar',
+      'foo \' bar' => 'bar',
+      'foo3: ' => 'bar',
+      'foo4: ' => 'bar',
+      'foo5' => array(
+        'foo " bar: ' => 'bar',
+        'foo \' bar: ' => 'bar',
+      ),
+    )

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/sfTests.yml

@@ -0,0 +1,149 @@
+--- %YAML:1.0
+test: Multiple quoted string on one line
+brief: >
+    Multiple quoted string on one line
+yaml: |
+    stripped_title: { name: "foo bar", help: "bar foo" }
+php: |
+    array('stripped_title' => array('name' => 'foo bar', 'help' => 'bar foo'))
+---
+test: Empty sequence
+yaml: |
+    foo: [ ]
+php: |
+    array('foo' => array())
+---
+test: Empty value
+yaml: |
+    foo:
+php: |
+    array('foo' => null)
+---
+test: Inline string parsing
+brief: >
+    Inline string parsing
+yaml: |
+    test: ['complex: string', 'another [string]']
+php: |
+    array('test' => array('complex: string', 'another [string]'))
+---
+test: Boolean
+brief: >
+    Boolean
+yaml: |
+    - false
+    - true
+    - null
+    - ~
+    - 'false'
+    - 'true'
+    - 'null'
+    - '~'
+php: |
+    array(
+      false,
+      true,
+      null,
+      null,
+      'false',
+      'true',
+      'null',
+      '~',
+    )
+---
+test: Empty lines in literal blocks
+brief: >
+  Empty lines in literal blocks
+yaml: |
+  foo:
+    bar: |
+      foo
+
+
+        
+      bar
+php: |
+  array('foo' => array('bar' => "foo\n\n\n  \nbar\n"))
+---
+test: Empty lines in folded blocks
+brief: >
+  Empty lines in folded blocks
+yaml: |
+  foo:
+    bar: >
+
+      foo
+
+      
+      bar
+php: |
+  array('foo' => array('bar' => "\nfoo\n\nbar\n"))
+---
+test: IP addresses
+brief: >
+  IP addresses
+yaml: |
+  foo: 10.0.0.2
+php: |
+  array('foo' => '10.0.0.2')
+---
+test: A sequence with an embedded mapping
+brief: >
+  A sequence with an embedded mapping
+yaml: |
+  - foo
+  - bar: { bar: foo }
+php: |
+  array('foo', array('bar' => array('bar' => 'foo')))
+---
+test: A sequence with an unordered array
+brief: >
+  A sequence with an unordered array
+yaml: |
+  1: foo
+  0: bar
+php: |
+  array(1 => 'foo', 0 => 'bar')
+---
+test: Octal
+brief: as in spec example 2.19, octal value is converted
+yaml: |
+  foo: 0123
+php: |
+  array('foo' => 83)
+---
+test: Octal strings
+brief: Octal notation in a string must remain a string
+yaml: |
+  foo: "0123"
+php: |
+  array('foo' => '0123')
+---
+test: Octal strings
+brief: Octal notation in a string must remain a string
+yaml: |
+  foo: '0123'
+php: |
+  array('foo' => '0123')
+---
+test: Octal strings
+brief: Octal notation in a string must remain a string
+yaml: |
+  foo: |
+    0123
+php: |
+  array('foo' => "0123\n")
+---
+test: Document as a simple hash
+brief: Document as a simple hash
+yaml: |
+  { foo: bar }
+php: |
+  array('foo' => 'bar')
+---
+test: Document as a simple array
+brief: Document as a simple array
+yaml: |
+  [ foo, bar ]
+php: |
+  array('foo', 'bar')

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/Fixtures/unindentedCollections.yml

@@ -0,0 +1,82 @@
+--- %YAML:1.0
+test: Unindented collection
+brief: >
+    Unindented collection
+yaml: |
+    collection:
+    - item1
+    - item2
+    - item3
+php: |
+    array('collection' => array('item1', 'item2', 'item3'))
+---
+test: Nested unindented collection (two levels)
+brief: >
+    Nested unindented collection
+yaml: |
+    collection:
+        key:
+        - a
+        - b
+        - c
+php: |
+    array('collection' => array('key' => array('a', 'b', 'c')))
+---
+test: Nested unindented collection (three levels)
+brief: >
+    Nested unindented collection
+yaml: |
+    collection:
+        key:
+            subkey:
+            - one
+            - two
+            - three
+php: |
+    array('collection' => array('key' => array('subkey' => array('one', 'two', 'three'))))
+---
+test: Key/value after unindented collection (1)
+brief: >
+    Key/value after unindented collection (1)
+yaml: |
+    collection:
+        key:
+        - a
+        - b
+        - c
+    foo: bar
+php: |
+    array('collection' => array('key' => array('a', 'b', 'c')), 'foo' => 'bar')
+---
+test: Key/value after unindented collection (at the same level)
+brief: >
+    Key/value after unindented collection
+yaml: |
+    collection:
+        key:
+        - a
+        - b
+        - c
+        foo: bar
+php: |
+    array('collection' => array('key' => array('a', 'b', 'c'), 'foo' => 'bar'))
+---
+test: Shortcut Key after unindented collection
+brief: >
+    Key/value after unindented collection
+yaml: |
+    collection:
+    - key: foo
+      foo: bar
+php: |
+    array('collection' => array(array('key' => 'foo', 'foo' => 'bar')))
+---
+test: Shortcut Key after unindented collection with custom spaces
+brief: >
+    Key/value after unindented collection
+yaml: |
+    collection:
+    -  key: foo
+       foo: bar
+php: |
+    array('collection' => array(array('key' => 'foo', 'foo' => 'bar')))

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/InlineTest.php

@@ -0,0 +1,451 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Tests;
+
+use Symfony\Component\Yaml\Inline;
+
+class InlineTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @dataProvider getTestsForParse
+     */
+    public function testParse($yaml, $value)
+    {
+        $this->assertSame($value, Inline::parse($yaml), sprintf('::parse() converts an inline YAML to a PHP structure (%s)', $yaml));
+    }
+
+    /**
+     * @dataProvider getTestsForParseWithMapObjects
+     */
+    public function testParseWithMapObjects($yaml, $value)
+    {
+        $actual = Inline::parse($yaml, false, false, true);
+
+        $this->assertSame(serialize($value), serialize($actual));
+    }
+
+    /**
+     * @dataProvider getTestsForDump
+     */
+    public function testDump($yaml, $value)
+    {
+        $this->assertEquals($yaml, Inline::dump($value), sprintf('::dump() converts a PHP structure to an inline YAML (%s)', $yaml));
+
+        $this->assertSame($value, Inline::parse(Inline::dump($value)), 'check consistency');
+    }
+
+    public function testDumpNumericValueWithLocale()
+    {
+        $locale = setlocale(LC_NUMERIC, 0);
+        if (false === $locale) {
+            $this->markTestSkipped('Your platform does not support locales.');
+        }
+
+        try {
+            $requiredLocales = array('fr_FR.UTF-8', 'fr_FR.UTF8', 'fr_FR.utf-8', 'fr_FR.utf8', 'French_France.1252');
+            if (false === setlocale(LC_NUMERIC, $requiredLocales)) {
+                $this->markTestSkipped('Could not set any of required locales: '.implode(', ', $requiredLocales));
+            }
+
+            $this->assertEquals('1.2', Inline::dump(1.2));
+            $this->assertContains('fr', strtolower(setlocale(LC_NUMERIC, 0)));
+            setlocale(LC_NUMERIC, $locale);
+        } catch (\Exception $e) {
+            setlocale(LC_NUMERIC, $locale);
+            throw $e;
+        }
+    }
+
+    public function testHashStringsResemblingExponentialNumericsShouldNotBeChangedToINF()
+    {
+        $value = '686e444';
+
+        $this->assertSame($value, Inline::parse(Inline::dump($value)));
+    }
+
+    /**
+     * @group legacy
+     * throws \Symfony\Component\Yaml\Exception\ParseException in 3.0
+     */
+    public function testParseScalarWithNonEscapedBlackslashShouldThrowException()
+    {
+        $this->assertSame('Foo\Var', Inline::parse('"Foo\Var"'));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseScalarWithNonEscapedBlackslashAtTheEndShouldThrowException()
+    {
+        Inline::parse('"Foo\\"');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseScalarWithIncorrectlyQuotedStringShouldThrowException()
+    {
+        $value = "'don't do somthin' like that'";
+        Inline::parse($value);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseScalarWithIncorrectlyDoubleQuotedStringShouldThrowException()
+    {
+        $value = '"don"t do somthin" like that"';
+        Inline::parse($value);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseInvalidMappingKeyShouldThrowException()
+    {
+        $value = '{ "foo " bar": "bar" }';
+        Inline::parse($value);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseInvalidMappingShouldThrowException()
+    {
+        Inline::parse('[foo] bar');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     */
+    public function testParseInvalidSequenceShouldThrowException()
+    {
+        Inline::parse('{ foo: bar } bar');
+    }
+
+    public function testParseScalarWithCorrectlyQuotedStringShouldReturnString()
+    {
+        $value = "'don''t do somthin'' like that'";
+        $expect = "don't do somthin' like that";
+
+        $this->assertSame($expect, Inline::parseScalar($value));
+    }
+
+    /**
+     * @dataProvider getDataForParseReferences
+     */
+    public function testParseReferences($yaml, $expected)
+    {
+        $this->assertSame($expected, Inline::parse($yaml, false, false, false, array('var' => 'var-value')));
+    }
+
+    public function getDataForParseReferences()
+    {
+        return array(
+            'scalar' => array('*var', 'var-value'),
+            'list' => array('[ *var ]', array('var-value')),
+            'list-in-list' => array('[[ *var ]]', array(array('var-value'))),
+            'map-in-list' => array('[ { key: *var } ]', array(array('key' => 'var-value'))),
+            'embedded-mapping-in-list' => array('[ key: *var ]', array(array('key' => 'var-value'))),
+            'map' => array('{ key: *var }', array('key' => 'var-value')),
+            'list-in-map' => array('{ key: [*var] }', array('key' => array('var-value'))),
+            'map-in-map' => array('{ foo: { bar: *var } }', array('foo' => array('bar' => 'var-value'))),
+        );
+    }
+
+    public function testParseMapReferenceInSequence()
+    {
+        $foo = array(
+            'a' => 'Steve',
+            'b' => 'Clark',
+            'c' => 'Brian',
+        );
+        $this->assertSame(array($foo), Inline::parse('[*foo]', false, false, false, array('foo' => $foo)));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     * @expectedExceptionMessage A reference must contain at least one character.
+     */
+    public function testParseUnquotedAsterisk()
+    {
+        Inline::parse('{ foo: * }');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Yaml\Exception\ParseException
+     * @expectedExceptionMessage A reference must contain at least one character.
+     */
+    public function testParseUnquotedAsteriskFollowedByAComment()
+    {
+        Inline::parse('{ foo: * #foo }');
+    }
+
+    /**
+     * @group legacy
+     * @dataProvider getReservedIndicators
+     * throws \Symfony\Component\Yaml\Exception\ParseException in 3.0
+     */
+    public function testParseUnquotedScalarStartingWithReservedIndicator($indicator)
+    {
+        Inline::parse(sprintf('{ foo: %sfoo }', $indicator));
+    }
+
+    public function getReservedIndicators()
+    {
+        return array(array('@'), array('`'));
+    }
+
+    /**
+     * @group legacy
+     * @dataProvider getScalarIndicators
+     * throws \Symfony\Component\Yaml\Exception\ParseException in 3.0
+     */
+    public function testParseUnquotedScalarStartingWithScalarIndicator($indicator)
+    {
+        Inline::parse(sprintf('{ foo: %sfoo }', $indicator));
+    }
+
+    public function getScalarIndicators()
+    {
+        return array(array('|'), array('>'));
+    }
+
+    /**
+     * @dataProvider getDataForIsHash
+     */
+    public function testIsHash($array, $expected)
+    {
+        $this->assertSame($expected, Inline::isHash($array));
+    }
+
+    public function getDataForIsHash()
+    {
+        return array(
+            array(array(), false),
+            array(array(1, 2, 3), false),
+            array(array(2 => 1, 1 => 2, 0 => 3), true),
+            array(array('foo' => 1, 'bar' => 2), true),
+        );
+    }
+
+    public function getTestsForParse()
+    {
+        return array(
+            array('', ''),
+            array('null', null),
+            array('false', false),
+            array('true', true),
+            array('12', 12),
+            array('-12', -12),
+            array('"quoted string"', 'quoted string'),
+            array("'quoted string'", 'quoted string'),
+            array('12.30e+02', 12.30e+02),
+            array('0x4D2', 0x4D2),
+            array('02333', 02333),
+            array('.Inf', -log(0)),
+            array('-.Inf', log(0)),
+            array("'686e444'", '686e444'),
+            array('686e444', 646e444),
+            array('123456789123456789123456789123456789', '123456789123456789123456789123456789'),
+            array('"foo\r\nbar"', "foo\r\nbar"),
+            array("'foo#bar'", 'foo#bar'),
+            array("'foo # bar'", 'foo # bar'),
+            array("'#cfcfcf'", '#cfcfcf'),
+            array('::form_base.html.twig', '::form_base.html.twig'),
+
+            // Pre-YAML-1.2 booleans
+            array("'y'", 'y'),
+            array("'n'", 'n'),
+            array("'yes'", 'yes'),
+            array("'no'", 'no'),
+            array("'on'", 'on'),
+            array("'off'", 'off'),
+
+            array('2007-10-30', gmmktime(0, 0, 0, 10, 30, 2007)),
+            array('2007-10-30T02:59:43Z', gmmktime(2, 59, 43, 10, 30, 2007)),
+            array('2007-10-30 02:59:43 Z', gmmktime(2, 59, 43, 10, 30, 2007)),
+            array('1960-10-30 02:59:43 Z', gmmktime(2, 59, 43, 10, 30, 1960)),
+            array('1730-10-30T02:59:43Z', gmmktime(2, 59, 43, 10, 30, 1730)),
+
+            array('"a \\"string\\" with \'quoted strings inside\'"', 'a "string" with \'quoted strings inside\''),
+            array("'a \"string\" with ''quoted strings inside'''", 'a "string" with \'quoted strings inside\''),
+
+            // sequences
+            // urls are no key value mapping. see #3609. Valid yaml "key: value" mappings require a space after the colon
+            array('[foo, http://urls.are/no/mappings, false, null, 12]', array('foo', 'http://urls.are/no/mappings', false, null, 12)),
+            array('[  foo  ,   bar , false  ,  null     ,  12  ]', array('foo', 'bar', false, null, 12)),
+            array('[\'foo,bar\', \'foo bar\']', array('foo,bar', 'foo bar')),
+
+            // mappings
+            array('{foo:bar,bar:foo,false:false,null:null,integer:12}', array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12)),
+            array('{ foo  : bar, bar : foo,  false  :   false,  null  :   null,  integer :  12  }', array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12)),
+            array('{foo: \'bar\', bar: \'foo: bar\'}', array('foo' => 'bar', 'bar' => 'foo: bar')),
+            array('{\'foo\': \'bar\', "bar": \'foo: bar\'}', array('foo' => 'bar', 'bar' => 'foo: bar')),
+            array('{\'foo\'\'\': \'bar\', "bar\"": \'foo: bar\'}', array('foo\'' => 'bar', 'bar"' => 'foo: bar')),
+            array('{\'foo: \': \'bar\', "bar: ": \'foo: bar\'}', array('foo: ' => 'bar', 'bar: ' => 'foo: bar')),
+
+            // nested sequences and mappings
+            array('[foo, [bar, foo]]', array('foo', array('bar', 'foo'))),
+            array('[foo, {bar: foo}]', array('foo', array('bar' => 'foo'))),
+            array('{ foo: {bar: foo} }', array('foo' => array('bar' => 'foo'))),
+            array('{ foo: [bar, foo] }', array('foo' => array('bar', 'foo'))),
+
+            array('[  foo, [  bar, foo  ]  ]', array('foo', array('bar', 'foo'))),
+
+            array('[{ foo: {bar: foo} }]', array(array('foo' => array('bar' => 'foo')))),
+
+            array('[foo, [bar, [foo, [bar, foo]], foo]]', array('foo', array('bar', array('foo', array('bar', 'foo')), 'foo'))),
+
+            array('[foo, {bar: foo, foo: [foo, {bar: foo}]}, [foo, {bar: foo}]]', array('foo', array('bar' => 'foo', 'foo' => array('foo', array('bar' => 'foo'))), array('foo', array('bar' => 'foo')))),
+
+            array('[foo, bar: { foo: bar }]', array('foo', '1' => array('bar' => array('foo' => 'bar')))),
+            array('[foo, \'@foo.baz\', { \'%foo%\': \'foo is %foo%\', bar: \'%foo%\' }, true, \'@service_container\']', array('foo', '@foo.baz', array('%foo%' => 'foo is %foo%', 'bar' => '%foo%'), true, '@service_container')),
+        );
+    }
+
+    public function getTestsForParseWithMapObjects()
+    {
+        return array(
+            array('', ''),
+            array('null', null),
+            array('false', false),
+            array('true', true),
+            array('12', 12),
+            array('-12', -12),
+            array('"quoted string"', 'quoted string'),
+            array("'quoted string'", 'quoted string'),
+            array('12.30e+02', 12.30e+02),
+            array('0x4D2', 0x4D2),
+            array('02333', 02333),
+            array('.Inf', -log(0)),
+            array('-.Inf', log(0)),
+            array("'686e444'", '686e444'),
+            array('686e444', 646e444),
+            array('123456789123456789123456789123456789', '123456789123456789123456789123456789'),
+            array('"foo\r\nbar"', "foo\r\nbar"),
+            array("'foo#bar'", 'foo#bar'),
+            array("'foo # bar'", 'foo # bar'),
+            array("'#cfcfcf'", '#cfcfcf'),
+            array('::form_base.html.twig', '::form_base.html.twig'),
+
+            array('2007-10-30', gmmktime(0, 0, 0, 10, 30, 2007)),
+            array('2007-10-30T02:59:43Z', gmmktime(2, 59, 43, 10, 30, 2007)),
+            array('2007-10-30 02:59:43 Z', gmmktime(2, 59, 43, 10, 30, 2007)),
+            array('1960-10-30 02:59:43 Z', gmmktime(2, 59, 43, 10, 30, 1960)),
+            array('1730-10-30T02:59:43Z', gmmktime(2, 59, 43, 10, 30, 1730)),
+
+            array('"a \\"string\\" with \'quoted strings inside\'"', 'a "string" with \'quoted strings inside\''),
+            array("'a \"string\" with ''quoted strings inside'''", 'a "string" with \'quoted strings inside\''),
+
+            // sequences
+            // urls are no key value mapping. see #3609. Valid yaml "key: value" mappings require a space after the colon
+            array('[foo, http://urls.are/no/mappings, false, null, 12]', array('foo', 'http://urls.are/no/mappings', false, null, 12)),
+            array('[  foo  ,   bar , false  ,  null     ,  12  ]', array('foo', 'bar', false, null, 12)),
+            array('[\'foo,bar\', \'foo bar\']', array('foo,bar', 'foo bar')),
+
+            // mappings
+            array('{foo:bar,bar:foo,false:false,null:null,integer:12}', (object) array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12)),
+            array('{ foo  : bar, bar : foo,  false  :   false,  null  :   null,  integer :  12  }', (object) array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12)),
+            array('{foo: \'bar\', bar: \'foo: bar\'}', (object) array('foo' => 'bar', 'bar' => 'foo: bar')),
+            array('{\'foo\': \'bar\', "bar": \'foo: bar\'}', (object) array('foo' => 'bar', 'bar' => 'foo: bar')),
+            array('{\'foo\'\'\': \'bar\', "bar\"": \'foo: bar\'}', (object) array('foo\'' => 'bar', 'bar"' => 'foo: bar')),
+            array('{\'foo: \': \'bar\', "bar: ": \'foo: bar\'}', (object) array('foo: ' => 'bar', 'bar: ' => 'foo: bar')),
+
+            // nested sequences and mappings
+            array('[foo, [bar, foo]]', array('foo', array('bar', 'foo'))),
+            array('[foo, {bar: foo}]', array('foo', (object) array('bar' => 'foo'))),
+            array('{ foo: {bar: foo} }', (object) array('foo' => (object) array('bar' => 'foo'))),
+            array('{ foo: [bar, foo] }', (object) array('foo' => array('bar', 'foo'))),
+
+            array('[  foo, [  bar, foo  ]  ]', array('foo', array('bar', 'foo'))),
+
+            array('[{ foo: {bar: foo} }]', array((object) array('foo' => (object) array('bar' => 'foo')))),
+
+            array('[foo, [bar, [foo, [bar, foo]], foo]]', array('foo', array('bar', array('foo', array('bar', 'foo')), 'foo'))),
+
+            array('[foo, {bar: foo, foo: [foo, {bar: foo}]}, [foo, {bar: foo}]]', array('foo', (object) array('bar' => 'foo', 'foo' => array('foo', (object) array('bar' => 'foo'))), array('foo', (object) array('bar' => 'foo')))),
+
+            array('[foo, bar: { foo: bar }]', array('foo', '1' => (object) array('bar' => (object) array('foo' => 'bar')))),
+            array('[foo, \'@foo.baz\', { \'%foo%\': \'foo is %foo%\', bar: \'%foo%\' }, true, \'@service_container\']', array('foo', '@foo.baz', (object) array('%foo%' => 'foo is %foo%', 'bar' => '%foo%'), true, '@service_container')),
+
+            array('{}', new \stdClass()),
+            array('{ foo  : bar, bar : {}  }', (object) array('foo' => 'bar', 'bar' => new \stdClass())),
+            array('{ foo  : [], bar : {}  }', (object) array('foo' => array(), 'bar' => new \stdClass())),
+            array('{foo: \'bar\', bar: {} }', (object) array('foo' => 'bar', 'bar' => new \stdClass())),
+            array('{\'foo\': \'bar\', "bar": {}}', (object) array('foo' => 'bar', 'bar' => new \stdClass())),
+            array('{\'foo\': \'bar\', "bar": \'{}\'}', (object) array('foo' => 'bar', 'bar' => '{}')),
+
+            array('[foo, [{}, {}]]', array('foo', array(new \stdClass(), new \stdClass()))),
+            array('[foo, [[], {}]]', array('foo', array(array(), new \stdClass()))),
+            array('[foo, [[{}, {}], {}]]', array('foo', array(array(new \stdClass(), new \stdClass()), new \stdClass()))),
+            array('[foo, {bar: {}}]', array('foo', '1' => (object) array('bar' => new \stdClass()))),
+        );
+    }
+
+    public function getTestsForDump()
+    {
+        return array(
+            array('null', null),
+            array('false', false),
+            array('true', true),
+            array('12', 12),
+            array("'quoted string'", 'quoted string'),
+            array('!!float 1230', 12.30e+02),
+            array('1234', 0x4D2),
+            array('1243', 02333),
+            array('.Inf', -log(0)),
+            array('-.Inf', log(0)),
+            array("'686e444'", '686e444'),
+            array('"foo\r\nbar"', "foo\r\nbar"),
+            array("'foo#bar'", 'foo#bar'),
+            array("'foo # bar'", 'foo # bar'),
+            array("'#cfcfcf'", '#cfcfcf'),
+
+            array("'a \"string\" with ''quoted strings inside'''", 'a "string" with \'quoted strings inside\''),
+
+            array("'-dash'", '-dash'),
+            array("'-'", '-'),
+
+            // Pre-YAML-1.2 booleans
+            array("'y'", 'y'),
+            array("'n'", 'n'),
+            array("'yes'", 'yes'),
+            array("'no'", 'no'),
+            array("'on'", 'on'),
+            array("'off'", 'off'),
+
+            // sequences
+            array('[foo, bar, false, null, 12]', array('foo', 'bar', false, null, 12)),
+            array('[\'foo,bar\', \'foo bar\']', array('foo,bar', 'foo bar')),
+
+            // mappings
+            array('{ foo: bar, bar: foo, \'false\': false, \'null\': null, integer: 12 }', array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12)),
+            array('{ foo: bar, bar: \'foo: bar\' }', array('foo' => 'bar', 'bar' => 'foo: bar')),
+
+            // nested sequences and mappings
+            array('[foo, [bar, foo]]', array('foo', array('bar', 'foo'))),
+
+            array('[foo, [bar, [foo, [bar, foo]], foo]]', array('foo', array('bar', array('foo', array('bar', 'foo')), 'foo'))),
+
+            array('{ foo: { bar: foo } }', array('foo' => array('bar' => 'foo'))),
+
+            array('[foo, { bar: foo }]', array('foo', array('bar' => 'foo'))),
+
+            array('[foo, { bar: foo, foo: [foo, { bar: foo }] }, [foo, { bar: foo }]]', array('foo', array('bar' => 'foo', 'foo' => array('foo', array('bar' => 'foo'))), array('foo', array('bar' => 'foo')))),
+
+            array('[foo, \'@foo.baz\', { \'%foo%\': \'foo is %foo%\', bar: \'%foo%\' }, true, \'@service_container\']', array('foo', '@foo.baz', array('%foo%' => 'foo is %foo%', 'bar' => '%foo%'), true, '@service_container')),
+
+            array('{ foo: { bar: { 1: 2, baz: 3 } } }', array('foo' => array('bar' => array(1 => 2, 'baz' => 3)))),
+        );
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/ParseExceptionTest.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Tests;
+
+use Symfony\Component\Yaml\Exception\ParseException;
+
+class ParseExceptionTest extends \PHPUnit_Framework_TestCase
+{
+    public function testGetMessage()
+    {
+        $exception = new ParseException('Error message', 42, 'foo: bar', '/var/www/app/config.yml');
+        if (PHP_VERSION_ID >= 50400) {
+            $message = 'Error message in "/var/www/app/config.yml" at line 42 (near "foo: bar")';
+        } else {
+            $message = 'Error message in "\\/var\\/www\\/app\\/config.yml" at line 42 (near "foo: bar")';
+        }
+
+        $this->assertEquals($message, $exception->getMessage());
+    }
+
+    public function testGetMessageWithUnicodeInFilename()
+    {
+        $exception = new ParseException('Error message', 42, 'foo: bar', 'äöü.yml');
+        if (PHP_VERSION_ID >= 50400) {
+            $message = 'Error message in "äöü.yml" at line 42 (near "foo: bar")';
+        } else {
+            $message = 'Error message in "\u00e4\u00f6\u00fc.yml" at line 42 (near "foo: bar")';
+        }
+
+        $this->assertEquals($message, $exception->getMessage());
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Tests/YamlTest.php

@@ -0,0 +1,55 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml\Tests;
+
+use Symfony\Component\Yaml\Yaml;
+
+class YamlTest extends \PHPUnit_Framework_TestCase
+{
+    public function testParseAndDump()
+    {
+        $data = array('lorem' => 'ipsum', 'dolor' => 'sit');
+        $yml = Yaml::dump($data);
+        $parsed = Yaml::parse($yml);
+        $this->assertEquals($data, $parsed);
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testLegacyParseFromFile()
+    {
+        $filename = __DIR__.'/Fixtures/index.yml';
+        $contents = file_get_contents($filename);
+        $parsedByFilename = Yaml::parse($filename);
+        $parsedByContents = Yaml::parse($contents);
+        $this->assertEquals($parsedByFilename, $parsedByContents);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The indentation must be greater than zero
+     */
+    public function testZeroIndentationThrowsException()
+    {
+        Yaml::dump(array('lorem' => 'ipsum', 'dolor' => 'sit'), 2, 0);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The indentation must be greater than zero
+     */
+    public function testNegativeIndentationThrowsException()
+    {
+        Yaml::dump(array('lorem' => 'ipsum', 'dolor' => 'sit'), 2, -4);
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Unescaper.php

@@ -0,0 +1,156 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+/**
+ * Unescaper encapsulates unescaping rules for single and double-quoted
+ * YAML strings.
+ *
+ * @author Matthew Lewinski <matthew@lewinski.org>
+ *
+ * @internal
+ */
+class Unescaper
+{
+    /**
+     * Parser and Inline assume UTF-8 encoding, so escaped Unicode characters
+     * must be converted to that encoding.
+     *
+     * @deprecated since version 2.5, to be removed in 3.0
+     *
+     * @internal
+     */
+    const ENCODING = 'UTF-8';
+
+    /**
+     * Regex fragment that matches an escaped character in a double quoted string.
+     */
+    const REGEX_ESCAPED_CHARACTER = '\\\\(x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|.)';
+
+    /**
+     * Unescapes a single quoted string.
+     *
+     * @param string $value A single quoted string
+     *
+     * @return string The unescaped string
+     */
+    public function unescapeSingleQuotedString($value)
+    {
+        return str_replace('\'\'', '\'', $value);
+    }
+
+    /**
+     * Unescapes a double quoted string.
+     *
+     * @param string $value A double quoted string
+     *
+     * @return string The unescaped string
+     */
+    public function unescapeDoubleQuotedString($value)
+    {
+        $self = $this;
+        $callback = function ($match) use ($self) {
+            return $self->unescapeCharacter($match[0]);
+        };
+
+        // evaluate the string
+        return preg_replace_callback('/'.self::REGEX_ESCAPED_CHARACTER.'/u', $callback, $value);
+    }
+
+    /**
+     * Unescapes a character that was found in a double-quoted string.
+     *
+     * @param string $value An escaped character
+     *
+     * @return string The unescaped character
+     *
+     * @internal This method is public to be usable as callback. It should not
+     *           be used in user code. Should be changed in 3.0.
+     */
+    public function unescapeCharacter($value)
+    {
+        switch ($value[1]) {
+            case '0':
+                return "\x0";
+            case 'a':
+                return "\x7";
+            case 'b':
+                return "\x8";
+            case 't':
+                return "\t";
+            case "\t":
+                return "\t";
+            case 'n':
+                return "\n";
+            case 'v':
+                return "\xB";
+            case 'f':
+                return "\xC";
+            case 'r':
+                return "\r";
+            case 'e':
+                return "\x1B";
+            case ' ':
+                return ' ';
+            case '"':
+                return '"';
+            case '/':
+                return '/';
+            case '\\':
+                return '\\';
+            case 'N':
+                // U+0085 NEXT LINE
+                return "\xC2\x85";
+            case '_':
+                // U+00A0 NO-BREAK SPACE
+                return "\xC2\xA0";
+            case 'L':
+                // U+2028 LINE SEPARATOR
+                return "\xE2\x80\xA8";
+            case 'P':
+                // U+2029 PARAGRAPH SEPARATOR
+                return "\xE2\x80\xA9";
+            case 'x':
+                return self::utf8chr(hexdec(substr($value, 2, 2)));
+            case 'u':
+                return self::utf8chr(hexdec(substr($value, 2, 4)));
+            case 'U':
+                return self::utf8chr(hexdec(substr($value, 2, 8)));
+            default:
+                @trigger_error('Not escaping a backslash in a double-quoted string is deprecated since Symfony 2.8 and will throw a ParseException in 3.0.', E_USER_DEPRECATED);
+
+                return $value;
+        }
+    }
+
+    /**
+     * Get the UTF-8 character for the given code point.
+     *
+     * @param int $c The unicode code point
+     *
+     * @return string The corresponding UTF-8 character
+     */
+    private static function utf8chr($c)
+    {
+        if (0x80 > $c %= 0x200000) {
+            return chr($c);
+        }
+        if (0x800 > $c) {
+            return chr(0xC0 | $c >> 6).chr(0x80 | $c & 0x3F);
+        }
+        if (0x10000 > $c) {
+            return chr(0xE0 | $c >> 12).chr(0x80 | $c >> 6 & 0x3F).chr(0x80 | $c & 0x3F);
+        }
+
+        return chr(0xF0 | $c >> 18).chr(0x80 | $c >> 12 & 0x3F).chr(0x80 | $c >> 6 & 0x3F).chr(0x80 | $c & 0x3F);
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/Yaml.php

@@ -0,0 +1,100 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Yaml;
+
+use Symfony\Component\Yaml\Exception\ParseException;
+
+/**
+ * Yaml offers convenience methods to load and dump YAML.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Yaml
+{
+    /**
+     * Parses YAML into a PHP value.
+     *
+     *  Usage:
+     *  <code>
+     *   $array = Yaml::parse(file_get_contents('config.yml'));
+     *   print_r($array);
+     *  </code>
+     *
+     * As this method accepts both plain strings and file names as an input,
+     * you must validate the input before calling this method. Passing a file
+     * as an input is a deprecated feature and will be removed in 3.0.
+     *
+     * Note: the ability to pass file names to the Yaml::parse method is deprecated since version 2.2 and will be removed in 3.0. Pass the YAML contents of the file instead.
+     *
+     * @param string $input                  Path to a YAML file or a string containing YAML
+     * @param bool   $exceptionOnInvalidType True if an exception must be thrown on invalid types false otherwise
+     * @param bool   $objectSupport          True if object support is enabled, false otherwise
+     * @param bool   $objectForMap           True if maps should return a stdClass instead of array()
+     *
+     * @return mixed The YAML converted to a PHP value
+     *
+     * @throws ParseException If the YAML is not valid
+     */
+    public static function parse($input, $exceptionOnInvalidType = false, $objectSupport = false, $objectForMap = false)
+    {
+        // if input is a file, process it
+        $file = '';
+        if (strpos($input, "\n") === false && is_file($input)) {
+            @trigger_error('The ability to pass file names to the '.__METHOD__.' method is deprecated since version 2.2 and will be removed in 3.0. Pass the YAML contents of the file instead.', E_USER_DEPRECATED);
+
+            if (false === is_readable($input)) {
+                throw new ParseException(sprintf('Unable to parse "%s" as the file is not readable.', $input));
+            }
+
+            $file = $input;
+            $input = file_get_contents($file);
+        }
+
+        $yaml = new Parser();
+
+        try {
+            return $yaml->parse($input, $exceptionOnInvalidType, $objectSupport, $objectForMap);
+        } catch (ParseException $e) {
+            if ($file) {
+                $e->setParsedFile($file);
+            }
+
+            throw $e;
+        }
+    }
+
+    /**
+     * Dumps a PHP array to a YAML string.
+     *
+     * The dump method, when supplied with an array, will do its best
+     * to convert the array into friendly YAML.
+     *
+     * @param array $array                  PHP array
+     * @param int   $inline                 The level where you switch to inline YAML
+     * @param int   $indent                 The amount of spaces to use for indentation of nested nodes
+     * @param bool  $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise
+     * @param bool  $objectSupport          true if object support is enabled, false otherwise
+     *
+     * @return string A YAML string representing the original PHP array
+     */
+    public static function dump($array, $inline = 2, $indent = 4, $exceptionOnInvalidType = false, $objectSupport = false)
+    {
+        if ($indent < 1) {
+            throw new \InvalidArgumentException('The indentation must be greater than zero.');
+        }
+
+        $yaml = new Dumper();
+        $yaml->setIndentation($indent);
+
+        return $yaml->dump($array, $inline, 0, $exceptionOnInvalidType, $objectSupport);
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/composer.json

@@ -0,0 +1,33 @@
+{
+    "name": "symfony/yaml",
+    "type": "library",
+    "description": "Symfony Yaml Component",
+    "keywords": [],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Fabien Potencier",
+            "email": "fabien@symfony.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.9"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Component\\Yaml\\": "" },
+        "exclude-from-classmap": [
+            "/Tests/"
+        ]
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.8-dev"
+        }
+    }
+}

sites/all/libraries/mailgun/vendor/symfony/yaml/phpunit.xml.dist

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.1/phpunit.xsd"
+         backupGlobals="false"
+         colors="true"
+         bootstrap="vendor/autoload.php"
+>
+    <php>
+        <ini name="error_reporting" value="-1" />
+    </php>
+
+    <testsuites>
+        <testsuite name="Symfony Yaml Component Test Suite">
+            <directory>./Tests/</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory>./</directory>
+            <exclude>
+                <directory>./Tests</directory>
+                <directory>./vendor</directory>
+            </exclude>
+        </whitelist>
+    </filter>
+</phpunit>