`_
74 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Mock/MockObserver.php:
--------------------------------------------------------------------------------
1 | events as $event) {
20 | if ($event->getName() == $eventName) {
21 | return true;
22 | }
23 | }
24 |
25 | return false;
26 | }
27 |
28 | public function getLastEvent()
29 | {
30 | return end($this->events);
31 | }
32 |
33 | public function count()
34 | {
35 | return count($this->events);
36 | }
37 |
38 | public function getGrouped()
39 | {
40 | $events = array();
41 | foreach ($this->events as $event) {
42 | if (!isset($events[$event->getName()])) {
43 | $events[$event->getName()] = array();
44 | }
45 | $events[$event->getName()][] = $event;
46 | }
47 |
48 | return $events;
49 | }
50 |
51 | public function getData($event, $key, $occurrence = 0)
52 | {
53 | $grouped = $this->getGrouped();
54 | if (isset($grouped[$event])) {
55 | return $grouped[$event][$occurrence][$key];
56 | }
57 |
58 | return null;
59 | }
60 |
61 | public function update(Event $event)
62 | {
63 | $this->events[] = $event;
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Http/AbstractEntityBodyDecoratorTest.php:
--------------------------------------------------------------------------------
1 | getMockForAbstractClass('Guzzle\Http\AbstractEntityBodyDecorator', array($e));
16 |
17 | $this->assertSame($e->getStream(), $mock->getStream());
18 | $this->assertSame($e->getContentLength(), $mock->getContentLength());
19 | $this->assertSame($e->getSize(), $mock->getSize());
20 | $this->assertSame($e->getContentMd5(), $mock->getContentMd5());
21 | $this->assertSame($e->getContentType(), $mock->getContentType());
22 | $this->assertSame($e->__toString(), $mock->__toString());
23 | $this->assertSame($e->getUri(), $mock->getUri());
24 | $this->assertSame($e->getStreamType(), $mock->getStreamType());
25 | $this->assertSame($e->getWrapper(), $mock->getWrapper());
26 | $this->assertSame($e->getWrapperData(), $mock->getWrapperData());
27 | $this->assertSame($e->isReadable(), $mock->isReadable());
28 | $this->assertSame($e->isWritable(), $mock->isWritable());
29 | $this->assertSame($e->isConsumed(), $mock->isConsumed());
30 | $this->assertSame($e->isLocal(), $mock->isLocal());
31 | $this->assertSame($e->isSeekable(), $mock->isSeekable());
32 | $this->assertSame($e->getContentEncoding(), $mock->getContentEncoding());
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Batch/BatchClosureTransferTest.php:
--------------------------------------------------------------------------------
1 | itemsTransferred = null;
21 | $itemsTransferred =& $this->itemsTransferred;
22 |
23 | $this->transferStrategy = new BatchClosureTransfer(function (array $batch) use (&$itemsTransferred) {
24 | $itemsTransferred = $batch;
25 | return;
26 | });
27 | }
28 |
29 | public function testTransfersBatch()
30 | {
31 | $batchedItems = array('foo', 'bar', 'baz');
32 | $this->transferStrategy->transfer($batchedItems);
33 |
34 | $this->assertEquals($batchedItems, $this->itemsTransferred);
35 | }
36 |
37 | public function testTransferBailsOnEmptyBatch()
38 | {
39 | $batchedItems = array();
40 | $this->transferStrategy->transfer($batchedItems);
41 |
42 | $this->assertNull($this->itemsTransferred);
43 | }
44 |
45 | /**
46 | * @expectedException Guzzle\Common\Exception\InvalidArgumentException
47 | */
48 | public function testEnsuresCallableIsCallable()
49 | {
50 | $foo = new BatchClosureTransfer('uh oh!');
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/client/js/s3/uploader.js:
--------------------------------------------------------------------------------
1 | /*globals qq */
2 | /**
3 | * This defines FineUploader mode w/ support for uploading to S3, which provides all the basic
4 | * functionality of Fine Uploader as well as code to handle uploads directly to S3.
5 | * This module inherits all logic from FineUploader mode and FineUploaderBasicS3 mode and adds some UI-related logic
6 | * specific to the upload-to-S3 workflow. Some inherited options and API methods have a special meaning
7 | * in the context of the S3 uploader.
8 | */
9 | (function() {
10 | "use strict";
11 |
12 | qq.s3.FineUploader = function(o) {
13 | var options = {
14 | failedUploadTextDisplay: {
15 | mode: "custom"
16 | }
17 | };
18 |
19 | // Replace any default options with user defined ones
20 | qq.extend(options, o, true);
21 |
22 | // Inherit instance data from FineUploader, which should in turn inherit from s3.FineUploaderBasic.
23 | qq.FineUploader.call(this, options, "s3");
24 |
25 | if (!qq.supportedFeatures.ajaxUploading && options.iframeSupport.localBlankPagePath === undefined) {
26 | this._options.element.innerHTML = "You MUST set the localBlankPagePath property " +
27 | "of the iframeSupport option since this browser does not support the File API!
";
28 | }
29 | };
30 |
31 | // Inherit the API methods from FineUploaderBasicS3
32 | qq.extend(qq.s3.FineUploader.prototype, qq.s3.FineUploaderBasic.prototype);
33 |
34 | // Inherit public and private API methods related to UI
35 | qq.extend(qq.s3.FineUploader.prototype, qq.uiPublicApi);
36 | qq.extend(qq.s3.FineUploader.prototype, qq.uiPrivateApi);
37 | }());
38 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Inflection/InflectorTest.php:
--------------------------------------------------------------------------------
1 | assertSame(Inflector::getDefault(), Inflector::getDefault());
15 | }
16 |
17 | public function testSnake()
18 | {
19 | $this->assertEquals('camel_case', Inflector::getDefault()->snake('camelCase'));
20 | $this->assertEquals('camel_case', Inflector::getDefault()->snake('CamelCase'));
21 | $this->assertEquals('camel_case_words', Inflector::getDefault()->snake('CamelCaseWords'));
22 | $this->assertEquals('camel_case_words', Inflector::getDefault()->snake('CamelCase_words'));
23 | $this->assertEquals('test', Inflector::getDefault()->snake('test'));
24 | $this->assertEquals('test', Inflector::getDefault()->snake('test'));
25 | $this->assertEquals('expect100_continue', Inflector::getDefault()->snake('Expect100Continue'));
26 | }
27 |
28 | public function testCamel()
29 | {
30 | $this->assertEquals('CamelCase', Inflector::getDefault()->camel('camel_case'));
31 | $this->assertEquals('CamelCaseWords', Inflector::getDefault()->camel('camel_case_words'));
32 | $this->assertEquals('Test', Inflector::getDefault()->camel('test'));
33 | $this->assertEquals('Expect100Continue', ucfirst(Inflector::getDefault()->camel('expect100_continue')));
34 | // Get from cache
35 | $this->assertEquals('Test', Inflector::getDefault()->camel('test', false));
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/client/js/ui.handler.events.js:
--------------------------------------------------------------------------------
1 | /*globals qq */
2 | // Base handler for UI (FineUploader mode) events.
3 | // Some more specific handlers inherit from this one.
4 | qq.UiEventHandler = function(s, protectedApi) {
5 | "use strict";
6 |
7 | var disposer = new qq.DisposeSupport(),
8 | spec = {
9 | eventType: "click",
10 | attachTo: null,
11 | onHandled: function(target, event) {}
12 | };
13 |
14 | // This makes up the "public" API methods that will be accessible
15 | // to instances constructing a base or child handler
16 | qq.extend(this, {
17 | addHandler: function(element) {
18 | addHandler(element);
19 | },
20 |
21 | dispose: function() {
22 | disposer.dispose();
23 | }
24 | });
25 |
26 | function addHandler(element) {
27 | disposer.attach(element, spec.eventType, function(event) {
28 | // Only in IE: the `event` is a property of the `window`.
29 | event = event || window.event;
30 |
31 | // On older browsers, we must check the `srcElement` instead of the `target`.
32 | var target = event.target || event.srcElement;
33 |
34 | spec.onHandled(target, event);
35 | });
36 | }
37 |
38 | // These make up the "protected" API methods that children of this base handler will utilize.
39 | qq.extend(protectedApi, {
40 | getFileIdFromItem: function(item) {
41 | return item.qqFileId;
42 | },
43 |
44 | getDisposeSupport: function() {
45 | return disposer;
46 | }
47 | });
48 |
49 | qq.extend(spec, s);
50 |
51 | if (spec.attachTo) {
52 | addHandler(spec.attachTo);
53 | }
54 | };
55 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Service/CachingConfigLoaderTest.php:
--------------------------------------------------------------------------------
1 | getMockBuilder('Guzzle\Service\ConfigLoaderInterface')
18 | ->setMethods(array('load'))
19 | ->getMockForAbstractClass();
20 | $data = array('foo' => 'bar');
21 | $loader->expects($this->once())
22 | ->method('load')
23 | ->will($this->returnValue($data));
24 | $cache = new CachingConfigLoader($loader, $cache);
25 | $this->assertEquals($data, $cache->load('foo'));
26 | $this->assertEquals($data, $cache->load('foo'));
27 | }
28 |
29 | public function testDoesNotCacheArrays()
30 | {
31 | $cache = new DoctrineCacheAdapter(new ArrayCache());
32 | $loader = $this->getMockBuilder('Guzzle\Service\ConfigLoaderInterface')
33 | ->setMethods(array('load'))
34 | ->getMockForAbstractClass();
35 | $data = array('foo' => 'bar');
36 | $loader->expects($this->exactly(2))
37 | ->method('load')
38 | ->will($this->returnValue($data));
39 | $cache = new CachingConfigLoader($loader, $cache);
40 | $this->assertEquals($data, $cache->load(array()));
41 | $this->assertEquals($data, $cache->load(array()));
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/test/static/local/formdata.js:
--------------------------------------------------------------------------------
1 | /* globals assert, qq */
2 | function mockFormData() {
3 | "use strict";
4 |
5 | function FormData() {
6 | this.fake = true;
7 | this.boundary = "--------FormData" + Math.random();
8 | this.fields = {};
9 | }
10 |
11 | FormData.prototype.append = function(key, value) {
12 | if (this.fields[key] === undefined) {
13 | this.fields[key] = value;
14 | }
15 | else {
16 | assert.ok(false, "Duplicate field name appended!");
17 | }
18 | };
19 |
20 | FormData.prototype.toString = function() {
21 | var boundary = this.boundary;
22 | var body = "";
23 | qq.each(this.fields, function(field, value) {
24 | body += "--" + boundary + "\r\n";
25 | // file upload
26 | if (value.name) {
27 | var file = field[1];
28 | body += "Content-Disposition: form-data; name=\""+ field +"\"; filename=\""+ file.name +"\"\r\n";
29 | body += "Content-Type: "+ file.type +"\r\n\r\n";
30 | body += file.getAsBinary() + "\r\n";
31 | } else {
32 | body += "Content-Disposition: form-data; name=\""+ field +"\";\r\n\r\n";
33 | body += value + "\r\n";
34 | }
35 | });
36 | body += "--" + boundary +"--";
37 | return body;
38 | };
39 |
40 | if (window.FormData) {
41 | FormData.oldFormData = window.FormData;
42 | }
43 |
44 | window.FormData = FormData;
45 | }
46 |
47 | function unmockFormData() {
48 | "use strict";
49 |
50 | if (window.FormData && window.FormData.oldFormData) {
51 | window.FormData = window.FormData.oldFormData;
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/docs/api/events-s3.jmd:
--------------------------------------------------------------------------------
1 | {% extends "_templates/base.html" %}
2 | {% set page_title = "S3 Methods" %}
3 |
4 | {% block sidebar %}
5 |
6 | {% endblock %}
7 |
8 | {% block js_head %}
9 |
10 | {% endblock %}
11 |
12 | {% block js_footer %}
13 |
18 | {% endblock %}
19 |
20 | {% block content %}
21 | {% markdown %}
22 |
23 | # Events S3 {: .page-header }
24 |
25 | The S3 uploader provides many of the same events as the traditional
26 | uploader, but there are some additional events _exclusive_ to S3 endpoints.
27 | If you plan to use the S3 uploader, then use the following table as your event
28 | reference. **All methods outlined in the core/traditional documentation are also available
29 | in Fine Uploader S3, unless otherwise noted here.**
30 |
31 | ### Syntax
32 |
33 | The following syntax is the correct way to define event handlers:
34 |
35 | ```javascript
36 | callbacks: {
37 | onDelete: function(id) {
38 | //...
39 | },
40 | onDeleteComplete: function(id, xhr, isError) {
41 | //...
42 | }
43 | }
44 | ```
45 |
46 | {% endmarkdown %}
47 |
48 |
49 | {{ api_event("credentialsExpired", "onCredentialsExpired",
50 | "Called before a request is sent to S3 if the temporary credentials have expired. You must return a promise. If your attempt to refresh the temporary credentials is successful, you must fulfill the promise via the `success` method, passing the new `credentials` object. Otherwise, call `failure` with a descriptive reason.", [])}}
51 |
52 |
53 |
54 | {% endblock %}
55 |
--------------------------------------------------------------------------------
/docs/quickstart/03-setting_up_server-s3.jmd:
--------------------------------------------------------------------------------
1 | {% extends "_templates/base.html" %}
2 | {% set page_title = "Server Set-Up S3" %}
3 |
4 | {% block content %}
5 | {% markdown %}
6 | # Server Set-Up Amazon S3 {: .page-header}
7 |
8 | For this tutorial we are going to use [Node.js](http://nodejs.org/) to develop
9 | a simple server which will accept uploads from our Fine Uploader instance. If
10 | you don't have Node.js, now's the time to [get it](http://nodejs.org/download/).
11 |
12 | If Node.js is not your style, then feel free to browse the other
13 | [server-side demos repository](http://github.com/Widen/fine-uploader-server). **It's quite important for you to read
14 | the [Amazon S3 server-side integration instructions](../endpoint_handlers/amazon-s3.html) before you do any of this,
15 | though**.
16 |
17 | #### Getting Started
18 |
19 | Let's rock! First, download [express](https://npmjs.org/package/express) and the
20 | [aws-sdk](https://npmjs.org/package/aws-sdk):
21 |
22 | `npm install express aws-sdk`
23 |
24 | Now let's download our server:
25 |
26 | `wget -O server.js https://raw.github.com/Widen/fine-uploader-server/master/nodejs/s3/s3handler.js`
27 |
28 | Then set relevant environment variables:
29 |
30 | ```bash
31 | $ export CLIENT_SECRET_KEY = 'secret'
32 | $ export SERVER_PUBLIC_KEY = 'not really secret'
33 | $ export SERVER_SECRET_KEY = 'secret'
34 | ```
35 |
36 | And let's run it!
37 |
38 | `node server.js`
39 |
40 | Fire up the HTML page with the client-side uploader code on it, and attempt to
41 | upload.
42 |
43 | Booyakosha! You are on the fast-track to upload nirvana. Continue forth in your quest to learn to integrate Fine Uploader with your application by reviewing the rest of the [documentation](../)
44 | {% endmarkdown %}
45 | {% endblock %}
46 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Service/Resource/ResourceIteratorClassFactoryTest.php:
--------------------------------------------------------------------------------
1 | registerNamespace('Baz');
22 | $command = new MockCommand();
23 | $factory->build($command);
24 | }
25 |
26 | public function testBuildsResourceIterators()
27 | {
28 | $factory = new ResourceIteratorClassFactory('Guzzle\Tests\Service\Mock\Model');
29 | $command = new MockCommand();
30 | $iterator = $factory->build($command, array('client.namespace' => 'Guzzle\Tests\Service\Mock'));
31 | $this->assertInstanceOf('Guzzle\Tests\Service\Mock\Model\MockCommandIterator', $iterator);
32 | }
33 |
34 | public function testChecksIfCanBuild()
35 | {
36 | $factory = new ResourceIteratorClassFactory('Guzzle\Tests\Service');
37 | $this->assertFalse($factory->canBuild(new MockCommand()));
38 | $factory = new ResourceIteratorClassFactory('Guzzle\Tests\Service\Mock\Model');
39 | $this->assertTrue($factory->canBuild(new MockCommand()));
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/aws/aws-sdk-php/composer.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "aws/aws-sdk-php",
3 | "homepage": "http://aws.amazon.com/sdkforphp",
4 | "description": "AWS SDK for PHP - Use Amazon Web Services in your PHP project",
5 | "keywords": ["aws","amazon","sdk","s3","ec2","dynamodb","cloud","glacier"],
6 | "type": "library",
7 | "license": "Apache-2.0",
8 | "authors": [
9 | {
10 | "name": "Amazon Web Services",
11 | "homepage": "http://aws.amazon.com"
12 | }
13 | ],
14 | "support": {
15 | "forum": "https://forums.aws.amazon.com/forum.jspa?forumID=80",
16 | "issues": "https://github.com/aws/aws-sdk-php/issues"
17 | },
18 | "require": {
19 | "php": ">=5.3.3",
20 | "guzzle/guzzle": "~3.7"
21 | },
22 | "suggest": {
23 | "doctrine/cache": "Adds support for caching of credentials and responses",
24 | "ext-apc": "Allows service description opcode caching, request and response caching, and credentials caching",
25 | "ext-openssl": "Allows working with CloudFront private distributions and verifying received SNS messages",
26 | "monolog/monolog": "Adds support for logging HTTP requests and responses",
27 | "symfony/yaml": "Eases the ability to write manifests for creating jobs in AWS Import/Export"
28 | },
29 | "require-dev": {
30 | "ext-openssl": "*",
31 | "doctrine/cache": "~1.0",
32 | "monolog/monolog": "~1.4",
33 | "phpunit/phpunit": "~4.0",
34 | "symfony/yaml": "~2.1"
35 | },
36 | "autoload": {
37 | "psr-0": {
38 | "Aws": "src/"
39 | }
40 | },
41 | "extra": {
42 | "branch-alias": {
43 | "dev-master": "2.7-dev"
44 | }
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Common/EventTest.php:
--------------------------------------------------------------------------------
1 | '123',
19 | 'other' => '456',
20 | 'event' => 'test.notify'
21 | ));
22 | }
23 |
24 | public function testAllowsParameterInjection()
25 | {
26 | $event = new Event(array(
27 | 'test' => '123'
28 | ));
29 | $this->assertEquals('123', $event['test']);
30 | }
31 |
32 | public function testImplementsArrayAccess()
33 | {
34 | $event = $this->getEvent();
35 | $this->assertEquals('123', $event['test']);
36 | $this->assertNull($event['foobar']);
37 |
38 | $this->assertTrue($event->offsetExists('test'));
39 | $this->assertFalse($event->offsetExists('foobar'));
40 |
41 | unset($event['test']);
42 | $this->assertFalse($event->offsetExists('test'));
43 |
44 | $event['test'] = 'new';
45 | $this->assertEquals('new', $event['test']);
46 | }
47 |
48 | public function testImplementsIteratorAggregate()
49 | {
50 | $event = $this->getEvent();
51 | $this->assertInstanceOf('ArrayIterator', $event->getIterator());
52 | }
53 |
54 | public function testConvertsToArray()
55 | {
56 | $this->assertEquals(array(
57 | 'test' => '123',
58 | 'other' => '456',
59 | 'event' => 'test.notify'
60 | ), $this->getEvent()->toArray());
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Cache/Zf2CacheAdapterTest.php:
--------------------------------------------------------------------------------
1 | cache = StorageFactory::factory(array(
23 | 'adapter' => 'memory'
24 | ));
25 | $this->adapter = new Zf2CacheAdapter($this->cache);
26 | }
27 |
28 | /**
29 | * Cleans up the environment after running a test.
30 | */
31 | protected function tearDown()
32 | {
33 | $this->adapter = null;
34 | $this->cache = null;
35 | parent::tearDown();
36 | }
37 |
38 | public function testCachesDataUsingCallables()
39 | {
40 | $this->assertTrue($this->adapter->save('test', 'data', 1000));
41 | $this->assertEquals('data', $this->adapter->fetch('test'));
42 | }
43 |
44 | public function testChecksIfCacheContainsKeys()
45 | {
46 | $this->adapter->save('test', 'data', 1000);
47 | $this->assertTrue($this->adapter->contains('test'));
48 | $this->assertFalse($this->adapter->contains('foo'));
49 | }
50 |
51 | public function testDeletesFromCacheByKey()
52 | {
53 | $this->adapter->save('test', 'data', 1000);
54 | $this->assertTrue($this->adapter->contains('test'));
55 | $this->adapter->delete('test');
56 | $this->assertFalse($this->adapter->contains('test'));
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/client/js/upload-handler/upload.handler.js:
--------------------------------------------------------------------------------
1 | /* globals qq */
2 | /**
3 | * Common upload handler functions.
4 | *
5 | * @constructor
6 | */
7 | qq.UploadHandler = function(spec) {
8 | "use strict";
9 |
10 | var proxy = spec.proxy,
11 | fileState = {},
12 | onCancel = proxy.onCancel,
13 | getName = proxy.getName;
14 |
15 | qq.extend(this, {
16 | add: function(id, fileItem) {
17 | fileState[id] = fileItem;
18 | fileState[id].temp = {};
19 | },
20 |
21 | cancel: function(id) {
22 | var self = this,
23 | cancelFinalizationEffort = new qq.Promise(),
24 | onCancelRetVal = onCancel(id, getName(id), cancelFinalizationEffort);
25 |
26 | onCancelRetVal.then(function() {
27 | if (self.isValid(id)) {
28 | fileState[id].canceled = true;
29 | self.expunge(id);
30 | }
31 | cancelFinalizationEffort.success();
32 | });
33 | },
34 |
35 | expunge: function(id) {
36 | delete fileState[id];
37 | },
38 |
39 | getThirdPartyFileId: function(id) {
40 | return fileState[id].key;
41 | },
42 |
43 | isValid: function(id) {
44 | return fileState[id] !== undefined;
45 | },
46 |
47 | reset: function() {
48 | fileState = {};
49 | },
50 |
51 | _getFileState: function(id) {
52 | return fileState[id];
53 | },
54 |
55 | _setThirdPartyFileId: function(id, thirdPartyFileId) {
56 | fileState[id].key = thirdPartyFileId;
57 | },
58 |
59 | _wasCanceled: function(id) {
60 | return !!fileState[id].canceled;
61 | }
62 | });
63 | };
64 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/README.md:
--------------------------------------------------------------------------------
1 | Guzzle, PHP HTTP client and webservice framework
2 | ================================================
3 |
4 | # This is an old version of Guzzle
5 |
6 | This repository is for Guzzle 3.x. Guzzle 4.x, the new version of Guzzle, has
7 | been released and is available at
8 | [https://github.com/guzzle/guzzle](https://github.com/guzzle/guzzle). The
9 | documentation for Guzzle version 4+ can be found at
10 | [http://guzzlephp.org](http://guzzlephp.org).
11 |
12 | ### About Guzzle 3
13 |
14 | [](https://packagist.org/packages/guzzle/guzzle)
15 | [](http://travis-ci.org/guzzle/guzzle3)
16 |
17 | - Extremely powerful API provides all the power of cURL with a simple interface.
18 | - Truly take advantage of HTTP/1.1 with persistent connections, connection pooling, and parallel requests.
19 | - Service description DSL allows you build awesome web service clients faster.
20 | - Symfony2 event-based plugin system allows you to completely modify the behavior of a request.
21 |
22 | Get answers with: [Documentation](http://guzzle3.readthedocs.org/en/latest/), [Forums](https://groups.google.com/forum/?hl=en#!forum/guzzle), IRC ([#guzzlephp](irc://irc.freenode.net/#guzzlephp) @ irc.freenode.net)
23 |
24 | ### Installing via Composer
25 |
26 | The recommended way to install Guzzle is through [Composer](http://getcomposer.org).
27 |
28 | ```bash
29 | # Install Composer
30 | curl -sS https://getcomposer.org/installer | php
31 |
32 | # Add Guzzle as a dependency
33 | php composer.phar require guzzle/guzzle:~3.9
34 | ```
35 |
36 | After installing, you need to require Composer's autoloader:
37 |
38 | ```php
39 | require 'vendor/autoload.php';
40 | ```
41 |
--------------------------------------------------------------------------------
/test/static/third-party/json2/README:
--------------------------------------------------------------------------------
1 | JSON in JavaScript
2 |
3 |
4 | Douglas Crockford
5 | douglas@crockford.com
6 |
7 | 2010-11-18
8 |
9 |
10 | JSON is a light-weight, language independent, data interchange format.
11 | See http://www.JSON.org/
12 |
13 | The files in this collection implement JSON encoders/decoders in JavaScript.
14 |
15 | JSON became a built-in feature of JavaScript when the ECMAScript Programming
16 | Language Standard - Fifth Edition was adopted by the ECMA General Assembly
17 | in December 2009. Most of the files in this collection are for applications
18 | that are expected to run in obsolete web browsers. For most purposes, json2.js
19 | is the best choice.
20 |
21 |
22 | json2.js: This file creates a JSON property in the global object, if there
23 | isn't already one, setting its value to an object containing a stringify
24 | method and a parse method. The parse method uses the eval method to do the
25 | parsing, guarding it with several regular expressions to defend against
26 | accidental code execution hazards. On current browsers, this file does nothing,
27 | prefering the built-in JSON object.
28 |
29 | json.js: This file does everything that json2.js does. It also adds a
30 | toJSONString method and a parseJSON method to Object.prototype. Use of this
31 | file is not recommended.
32 |
33 | json_parse.js: This file contains an alternative JSON parse function that
34 | uses recursive descent instead of eval.
35 |
36 | json_parse_state.js: This files contains an alternative JSON parse function that
37 | uses a state machine instead of eval.
38 |
39 | cycle.js: This file contains two functions, JSON.decycle and JSON.retrocycle,
40 | which make it possible to encode cyclical structures and dags in JSON, and to
41 | then recover them. JSONPath is used to represent the links.
42 | http://GOESSNER.net/articles/JsonPath/
43 |
--------------------------------------------------------------------------------
/client/js/ui.handler.click.filebuttons.js:
--------------------------------------------------------------------------------
1 | /* global qq */
2 | qq.FileButtonsClickHandler = function(s) {
3 | "use strict";
4 |
5 | var inheritedInternalApi = {},
6 | spec = {
7 | templating: null,
8 | log: function(message, lvl) {},
9 | onDeleteFile: function(fileId) {},
10 | onCancel: function(fileId) {},
11 | onRetry: function(fileId) {},
12 | onPause: function(fileId) {},
13 | onContinue: function(fileId) {},
14 | onGetName: function(fileId) {}
15 | },
16 | buttonHandlers = {
17 | cancel: function(id) { spec.onCancel(id); },
18 | retry: function(id) { spec.onRetry(id); },
19 | deleteButton: function(id) { spec.onDeleteFile(id); },
20 | pause: function(id) { spec.onPause(id); },
21 | continueButton: function(id) { spec.onContinue(id); }
22 | };
23 |
24 | function examineEvent(target, event) {
25 | qq.each(buttonHandlers, function(buttonType, handler) {
26 | var firstLetterCapButtonType = buttonType.charAt(0).toUpperCase() + buttonType.slice(1),
27 | fileId;
28 |
29 | if (spec.templating["is" + firstLetterCapButtonType](target)) {
30 | fileId = spec.templating.getFileId(target);
31 | qq.preventDefault(event);
32 | spec.log(qq.format("Detected valid file button click event on file '{}', ID: {}.", spec.onGetName(fileId), fileId));
33 | handler(fileId);
34 | return false;
35 | }
36 | });
37 | }
38 |
39 | qq.extend(spec, s);
40 |
41 | spec.eventType = "click";
42 | spec.onHandled = examineEvent;
43 | spec.attachTo = spec.templating.getFileList();
44 |
45 | qq.extend(this, new qq.UiEventHandler(spec, inheritedInternalApi));
46 | };
47 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/symfony/event-dispatcher/Symfony/Component/EventDispatcher/EventSubscriberInterface.php:
--------------------------------------------------------------------------------
1 |
7 | *
8 | * For the full copyright and license information, please view the LICENSE
9 | * file that was distributed with this source code.
10 | */
11 |
12 | namespace Symfony\Component\EventDispatcher;
13 |
14 | /**
15 | * An EventSubscriber knows himself what events he is interested in.
16 | * If an EventSubscriber is added to an EventDispatcherInterface, the manager invokes
17 | * {@link getSubscribedEvents} and registers the subscriber as a listener for all
18 | * returned events.
19 | *
20 | * @author Guilherme Blanco
21 | * @author Jonathan Wage
22 | * @author Roman Borschel
23 | * @author Bernhard Schussek
24 | *
25 | * @api
26 | */
27 | interface EventSubscriberInterface
28 | {
29 | /**
30 | * Returns an array of event names this subscriber wants to listen to.
31 | *
32 | * The array keys are event names and the value can be:
33 | *
34 | * * The method name to call (priority defaults to 0)
35 | * * An array composed of the method name to call and the priority
36 | * * An array of arrays composed of the method names to call and respective
37 | * priorities, or 0 if unset
38 | *
39 | * For instance:
40 | *
41 | * * array('eventName' => 'methodName')
42 | * * array('eventName' => array('methodName', $priority))
43 | * * array('eventName' => array(array('methodName1', $priority), array('methodName2'))
44 | *
45 | * @return array The event names to listen to
46 | *
47 | * @api
48 | */
49 | public static function getSubscribedEvents();
50 | }
51 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Service/Command/ClosureCommandTest.php:
--------------------------------------------------------------------------------
1 | function($command, $api) {
27 | $command->set('testing', '123');
28 | $request = RequestFactory::getInstance()->create('GET', 'http://www.test.com/');
29 | return $request;
30 | }
31 | ));
32 |
33 | $client = $this->getServiceBuilder()->get('mock');
34 | $c->setClient($client)->prepare();
35 | $this->assertEquals('123', $c->get('testing'));
36 | $this->assertEquals('http://www.test.com/', $c->getRequest()->getUrl());
37 | }
38 |
39 | /**
40 | * @expectedException UnexpectedValueException
41 | * @expectedExceptionMessage Closure command did not return a RequestInterface object
42 | */
43 | public function testMustReturnRequest()
44 | {
45 | $c = new ClosureCommand(array(
46 | 'closure' => function($command, $api) {
47 | return false;
48 | }
49 | ));
50 |
51 | $client = $this->getServiceBuilder()->get('mock');
52 | $c->setClient($client)->prepare();
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Inflection/MemoizingInflectorTest.php:
--------------------------------------------------------------------------------
1 | getMock('Guzzle\Inflection\Inflector', array('snake', 'camel'));
16 | $mock->expects($this->once())->method('snake')->will($this->returnValue('foo_bar'));
17 | $mock->expects($this->once())->method('camel')->will($this->returnValue('FooBar'));
18 |
19 | $inflector = new MemoizingInflector($mock);
20 | $this->assertEquals('foo_bar', $inflector->snake('FooBar'));
21 | $this->assertEquals('foo_bar', $inflector->snake('FooBar'));
22 | $this->assertEquals('FooBar', $inflector->camel('foo_bar'));
23 | $this->assertEquals('FooBar', $inflector->camel('foo_bar'));
24 | }
25 |
26 | public function testProtectsAgainstCacheOverflow()
27 | {
28 | $inflector = new MemoizingInflector(new Inflector(), 10);
29 | for ($i = 1; $i < 11; $i++) {
30 | $inflector->camel('foo_' . $i);
31 | $inflector->snake('Foo' . $i);
32 | }
33 |
34 | $cache = $this->readAttribute($inflector, 'cache');
35 | $this->assertEquals(10, count($cache['snake']));
36 | $this->assertEquals(10, count($cache['camel']));
37 |
38 | $inflector->camel('baz!');
39 | $inflector->snake('baz!');
40 |
41 | // Now ensure that 20% of the cache was removed (2), then the item was added
42 | $cache = $this->readAttribute($inflector, 'cache');
43 | $this->assertEquals(9, count($cache['snake']));
44 | $this->assertEquals(9, count($cache['camel']));
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/build.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Cache/CacheAdapterFactoryTest.php:
--------------------------------------------------------------------------------
1 | cache = new ArrayCache();
28 | $this->adapter = new DoctrineCacheAdapter($this->cache);
29 | }
30 |
31 | /**
32 | * @expectedException \InvalidArgumentException
33 | */
34 | public function testEnsuresConfigIsObject()
35 | {
36 | CacheAdapterFactory::fromCache(array());
37 | }
38 |
39 | /**
40 | * @expectedException \InvalidArgumentException
41 | */
42 | public function testEnsuresKnownType()
43 | {
44 | CacheAdapterFactory::fromCache(new \stdClass());
45 | }
46 |
47 | public function cacheProvider()
48 | {
49 | return array(
50 | array(new DoctrineCacheAdapter(new ArrayCache()), 'Guzzle\Cache\DoctrineCacheAdapter'),
51 | array(new ArrayCache(), 'Guzzle\Cache\DoctrineCacheAdapter'),
52 | array(StorageFactory::factory(array('adapter' => 'memory')), 'Guzzle\Cache\Zf2CacheAdapter'),
53 | );
54 | }
55 |
56 | /**
57 | * @dataProvider cacheProvider
58 | */
59 | public function testCreatesNullCacheAdapterByDefault($cache, $type)
60 | {
61 | $adapter = CacheAdapterFactory::fromCache($cache);
62 | $this->assertInstanceOf($type, $adapter);
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Iterator/ChunkedIteratorTest.php:
--------------------------------------------------------------------------------
1 | assertEquals(11, count($chunks));
17 | foreach ($chunks as $j => $chunk) {
18 | $this->assertEquals(range($j * 10, min(100, $j * 10 + 9)), $chunk);
19 | }
20 | }
21 |
22 | public function testChunksIteratorWithOddValues()
23 | {
24 | $chunked = new ChunkedIterator(new \ArrayIterator(array(1, 2, 3, 4, 5)), 2);
25 | $chunks = iterator_to_array($chunked, false);
26 | $this->assertEquals(3, count($chunks));
27 | $this->assertEquals(array(1, 2), $chunks[0]);
28 | $this->assertEquals(array(3, 4), $chunks[1]);
29 | $this->assertEquals(array(5), $chunks[2]);
30 | }
31 |
32 | public function testMustNotTerminateWithTraversable()
33 | {
34 | $traversable = simplexml_load_string('')->foo;
35 | $chunked = new ChunkedIterator($traversable, 2);
36 | $actual = iterator_to_array($chunked, false);
37 | $this->assertCount(2, $actual);
38 | }
39 |
40 | public function testSizeOfZeroMakesIteratorInvalid() {
41 | $chunked = new ChunkedIterator(new \ArrayIterator(range(1, 5)), 0);
42 | $chunked->rewind();
43 | $this->assertFalse($chunked->valid());
44 | }
45 |
46 | /**
47 | * @expectedException \InvalidArgumentException
48 | */
49 | public function testSizeLowerZeroThrowsException() {
50 | new ChunkedIterator(new \ArrayIterator(range(1, 5)), -1);
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Plugin/Cookie/CookieJar/FileCookieJarTest.php:
--------------------------------------------------------------------------------
1 | file = tempnam('/tmp', 'file-cookies');
18 | }
19 |
20 | public function testLoadsFromFileFile()
21 | {
22 | $jar = new FileCookieJar($this->file);
23 | $this->assertEquals(array(), $jar->all());
24 | unlink($this->file);
25 | }
26 |
27 | public function testPersistsToFileFile()
28 | {
29 | $jar = new FileCookieJar($this->file);
30 | $jar->add(new Cookie(array(
31 | 'name' => 'foo',
32 | 'value' => 'bar',
33 | 'domain' => 'foo.com',
34 | 'expires' => time() + 1000
35 | )));
36 | $jar->add(new Cookie(array(
37 | 'name' => 'baz',
38 | 'value' => 'bar',
39 | 'domain' => 'foo.com',
40 | 'expires' => time() + 1000
41 | )));
42 | $jar->add(new Cookie(array(
43 | 'name' => 'boo',
44 | 'value' => 'bar',
45 | 'domain' => 'foo.com',
46 | )));
47 |
48 | $this->assertEquals(3, count($jar));
49 | unset($jar);
50 |
51 | // Make sure it wrote to the file
52 | $contents = file_get_contents($this->file);
53 | $this->assertNotEmpty($contents);
54 |
55 | // Load the cookieJar from the file
56 | $jar = new FileCookieJar($this->file);
57 |
58 | // Weeds out temporary and session cookies
59 | $this->assertEquals(2, count($jar));
60 | unset($jar);
61 | unlink($this->file);
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/docs/quickstart/03-setting_up_server.jmd:
--------------------------------------------------------------------------------
1 | {% extends "_templates/base.html" %}
2 | {% set page_title = "Server Set-Up" %}
3 |
4 | {% block content %}
5 | {% markdown %}
6 | # Server Set-Up {: .page-header}
7 |
8 | {{ alert(
9 | """This section of the tutorial is aimed at beginners looking to create their
10 | own upload server. Note that this example does not apply to S3 uploads. For
11 | more information on uploading to Amazon's Simple Storage Service,
12 | read the [Fine Uploader S3 server documentation](../endpoint_handlers/amazon-s3.html).""",
13 | "warn") }}
14 |
15 | For this tutorial we are going to use [Node.js](http://nodejs.org/) to develop
16 | a simple server which will accept uploads from our Fine Uploader instance. If
17 | you don't have Node.js, now's the time to [get it](http://nodejs.org/download/).
18 |
19 | If Node.js is not your style, then feel free to browse the other
20 | [server-side demos repository](http://github.com/Widen/fine-uploader-server). **It's quite important for you to read
21 | the [traditional server-side integration instructions](../endpoint_handlers/traditional.html) before you do any of this,
22 | though**.
23 |
24 | #### Getting Started
25 |
26 | Let's rock! First, download express:
27 |
28 | `npm install express rimraf mkdirp`
29 |
30 | Now let's download our server:
31 |
32 | `wget -O server.js https://raw.github.com/Widen/fine-uploader-server/master/nodejs/nodejs.js`
33 |
34 | Coooool. Create a new file in your text editor called `server.js`. Time to code the first part of the server:
35 |
36 | And let's have node run it!
37 |
38 | `node server.js`
39 |
40 | Make sure to set the request endpoint on your Fine Uploader instance to point to the corresponding URL on the express server. In this case, the endpoint is `/uploads`.
41 |
42 | Booyakosha! You are on the fast-track to upload nirvana. Continue forth in your quest to learn to integrate Fine Uploader with your application by reviewing the rest of the [documentation](../)
43 | {% endmarkdown %}
44 | {% endblock %}
45 |
--------------------------------------------------------------------------------
/test/dev/handlers/s3/vendor/guzzle/guzzle/tests/Guzzle/Tests/Service/Command/LocationVisitor/Request/QueryVisitorTest.php:
--------------------------------------------------------------------------------
1 | getNestedCommand('query')->getParam('foo')->setSentAs('test');
16 | $visitor->visit($this->command, $this->request, $param, '123');
17 | $this->assertEquals('123', $this->request->getQuery()->get('test'));
18 | }
19 |
20 | /**
21 | * @covers Guzzle\Service\Command\LocationVisitor\Request\QueryVisitor
22 | * @covers Guzzle\Service\Command\LocationVisitor\Request\AbstractRequestVisitor::resolveRecursively
23 | */
24 | public function testRecursivelyBuildsQueryStrings()
25 | {
26 | $command = $this->getCommand('query');
27 | $command->getOperation()->getParam('foo')->setSentAs('Foo');
28 | $request = $command->prepare();
29 | $this->assertEquals(
30 | 'Foo[test][baz]=1&Foo[test][Jenga_Yall!]=HELLO&Foo[bar]=123',
31 | rawurldecode($request->getQuery())
32 | );
33 | }
34 |
35 | /**
36 | * @covers Guzzle\Service\Command\LocationVisitor\Request\AbstractRequestVisitor::resolveRecursively
37 | */
38 | public function testFiltersAreAppliedToArrayParamType()
39 | {
40 | $command = $this->getCommandWithArrayParamAndFilters();
41 | $request = $command->prepare();
42 | $query = $request->getQuery();
43 | // param type 'string'
44 | $this->assertEquals('BAR', $query->get('Foo'));
45 | // param type 'array'
46 | $this->assertEquals('123,456,789', $query->get('Arr'));
47 | }
48 | }
49 |
--------------------------------------------------------------------------------