<?php

try {
    $response = (new Artax\Client)->request('http://www.google.com')->wait();
    printf(
        "\nHTTP/%s %d %s\n",
        $response->getProtocol(),
        $response->getStatus(),
        $response->getReason()
    );
} catch (Exception $error) {
    echo $error;
}

<?php

try {
    $request = (new Artax\Request)
        ->setUri('http://httpbin.org/post')
        ->setProtocol('1.1')
        ->setMethod('POST')
        ->setBody('woot!')
        ->setAllHeaders([
            'Content-Type' => 'text/plain; charset=utf-8',
            'Cookie' => ['Cookie1=val1', 'Cookie2=val2']
        ])
    ;

    $response = (new Artax\Client)->request($request)->wait();

} catch (Exception $error) {
    echo $error;
}

<?php

$body = (new Artax\FormBody)
    ->addField('name', 'Zoroaster')
    ->addFileField('file1', '/hard/path/to/some/file1')
    ->addFileField('file2', '/hard/path/to/some/file2')
;

$request = (new Artax\Request)
    ->setUri('http://httpbin.org/post')
    ->setMethod('POST')
    ->setBody($body)
;

$response = (new Artax\Client)->request($request)->wait();

<?php
$client = new Artax\Client;

// Here we pass dispatch two requests at the same time
$arrayOfPromises = $client->requestMulti([
    'http://www.google.com',
    'http://www.bing.com'
]);
list($googleResponse, $bingResponse) = After\all($arrayOfPromises)->wait();


// Here we invoke the two requests individually
$googlePromise = $client->request('http://www.google.com');
$bingPromise = $client->request('http://www.bing.com');
$comboPromise = After\all([$googlePromise, $bingPromise]);
list($googleResponse, $bingResponse) = $comboPromise->wait();

<?php
$client = new Artax\Client;

list($googlePromise, $bingPromise) = $client->request([
    'http://www.google.com',
    'http://www.bing.com'
]);

$googleResponse = null;
$googlePromise->when(function($error, $result) use (&$googleResponse) {
    if ($error) {
        // the request failed for some reason. Get the exception message
        echo $error->getMessage();
    } else {
        // Do something with the completed $response here
        $googleResponse = $result;
    }
});

// After\all() combines our array of promises into a single promise that will
// fail if any one of the individual promises fails. Remember that Promise::wait()
// will throw if resolution fails!
$comboPromise = After\all([$googlePromise, $bingPromise]);
list($googleResponse2, $bingResponse) = $comboPromise->wait();

// They're the same instance!
assert($googleResponse === $googleResponse2);

<?php

$arrayOfPromises = (new Artax\Client)->request([
    'google'    => 'http://www.google.com',
    'news'      => 'http://news.google.com',
    'bing'      => 'http://www.bing.com',
    'yahoo'     => 'https://www.yahoo.com',
]);

// After\all() combines our array of promises into a single promise that
// will fail if any one of the individual promises fails
$responses = After\all($promises)->wait();

foreach ($responses as $key => $response) {
    printf(
        "%s | HTTP/%s %d %s\n",
        $key, // <-- these keys will match those from our original request array
        $response->getProtocol(),
        $response->getStatus(),
        $response->getReason()
    );
}

<?php
/**
 * All Artax progress notifications take the form of an indexed array. The
 * first element is a notification code denoting the type of event being
 * broadcast. The remaining items are data associated with the event at hand.
 */
function myNotifyCallback(array $notifyData) {
    $event = array_shift($notifyData);
    switch ($event) {
        case Artax\Notify::SOCK_PROCURED:
            echo "SOCK_PROCURED\n";
            break;
        case Artax\Notify::SOCK_DATA_IN:
            echo "SOCK_DATA_IN\n";
            break;
        case Artax\Notify::SOCK_DATA_OUT:
            echo "SOCK_DATA_OUT\n";
            break;
        case Artax\Notify::REQUEST_SENT:
            echo "REQUEST_SENT\n";
            break;
        case Artax\Notify::RESPONSE_HEADERS:
            echo "RESPONSE_HEADERS\n";
            break;
        case Artax\Notify::RESPONSE_BODY_DATA:
            echo "RESPONSE_BODY_DATA\n";
            break;
        case Artax\Notify::RESPONSE:
            echo "RESPONSE\n";
            break;
        case Artax\Notify::REDIRECT:
            echo "REDIRECT\n";
            break;
        case Artax\Notify::ERROR:
            echo "ERROR\n";
            break;
    }
}

/**
 * Progress updates are distributed by the promise. To "listen" for update
 * notifications simply pass a callback to Promise::watch() as demonstrated
 * below.
 */
$promise = (new Artax\Client)->request('http://www.google.com');
$promise->watch('myNotifyCallback');
$response = $promise->wait();

printf(
    "\nResponse: HTTP/%s %d %s\n\n",
    $response->getProtocol(),
    $response->getStatus(),
    $response->getReason()
);

<?php
$promise = (new Artax\Client)->request($request);
$promise->watch(new Artax\Progress(function($update) {
    printf(
        "\r%s %s%%\r",
        $update['bar'],
        round($update['percent_complete'] * 100)
    );
}));
$response = $promise->wait();