diff --git a/composer.lock b/composer.lock
index 025d5bf798625537cb6a0fa5c5ce20b22a1e4d11..725d8b5bb020ab4fb6380cd86d224c7ca9b27802 100644
--- a/composer.lock
+++ b/composer.lock
@@ -4,7 +4,7 @@
"Read more about it at https://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file",
"This file is @generated automatically"
],
- "hash": "8c9fdf621ce53640f24b24749e59717c",
+ "hash": "2be29019515c847055593ea41b88475d",
"content-hash": "f38613812a285c03a1a18458384fe0b1",
"packages": [
{
@@ -2004,7 +2004,7 @@
},
"dist": {
"type": "zip",
- "url": "https://api.github.com/repos/wikimedia/composer-merge-plugin/zipball/47bb3388cfeae41a38087ac8465a7d08fa92ea2e",
+ "url": "https://api.github.com/repos/wikimedia/composer-merge-plugin/zipball/6bfcdcfe0aab6c11dcccfbd28dea01a592afd5b3",
"reference": "47bb3388cfeae41a38087ac8465a7d08fa92ea2e",
"shasum": ""
},
@@ -2585,6 +2585,63 @@
],
"time": "2015-08-29 16:16:56"
},
+ {
+ "name": "jcalderonzumba/gastonjs",
+ "version": "dev-master",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/jcalderonzumba/gastonjs.git",
+ "reference": "5e231b4df98275c404e1371fc5fadd34f6a121ad"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/jcalderonzumba/gastonjs/zipball/5e231b4df98275c404e1371fc5fadd34f6a121ad",
+ "reference": "5e231b4df98275c404e1371fc5fadd34f6a121ad",
+ "shasum": ""
+ },
+ "require": {
+ "guzzlehttp/guzzle": "~5.0|~6.0",
+ "php": ">=5.4"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "~4.6",
+ "silex/silex": "~1.2",
+ "symfony/phpunit-bridge": "~2.7",
+ "symfony/process": "~2.1"
+ },
+ "type": "phantomjs-api",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.1.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Zumba\\GastonJS\\": "src"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Juan Francisco Calderón Zumba",
+ "email": "juanfcz@gmail.com",
+ "homepage": "http://github.com/jcalderonzumba"
+ }
+ ],
+ "description": "PhantomJS API based server for webpage automation",
+ "homepage": "https://github.com/jcalderonzumba/gastonjs",
+ "keywords": [
+ "api",
+ "automation",
+ "browser",
+ "headless",
+ "phantomjs"
+ ],
+ "time": "2015-10-07 11:40:41"
+ },
{
"name": "mikey179/vfsStream",
"version": "v1.6.0",
@@ -3672,6 +3729,7 @@
"composer/semver": 0,
"behat/mink": 0,
"behat/mink-goutte-driver": 0,
+ "jcalderonzumba/gastonjs": 20,
"mikey179/vfsstream": 0,
"phpunit/phpunit": 0,
"symfony/css-selector": 0
diff --git a/core/composer.json b/core/composer.json
index 24890691831090e39e10770976aae901e05da0be..0323158c6a8c1fb59c251b4cc0cb9dfc44d90987 100644
--- a/core/composer.json
+++ b/core/composer.json
@@ -34,6 +34,7 @@
"require-dev": {
"behat/mink": "~1.6",
"behat/mink-goutte-driver": "~1.2",
+ "jcalderonzumba/gastonjs": "^1.1@dev",
"mikey179/vfsStream": "~1.2",
"phpunit/phpunit": "~4.8",
"symfony/css-selector": "2.7.*"
diff --git a/core/lib/Drupal/Core/Composer/Composer.php b/core/lib/Drupal/Core/Composer/Composer.php
index cec08c9c7925a0125cc8d11879e0a1de950bff04..112913d385f51d2e3ed621600393aba39eaefbde 100644
--- a/core/lib/Drupal/Core/Composer/Composer.php
+++ b/core/lib/Drupal/Core/Composer/Composer.php
@@ -31,6 +31,9 @@ class Composer {
'fabpot/goutte' => ['Goutte/Tests'],
'guzzlehttp/promises' => ['tests'],
'guzzlehttp/psr7' => ['tests'],
+ 'jcalderonzumba/gastonjs' => ['docs'],
+ 'jcalderonzumba/gastonjs' => ['examples'],
+ 'jcalderonzumba/gastonjs' => ['tests'],
'masterminds/html5' => ['test'],
'mikey179/vfsStream' => ['src/test'],
'phpdocumentor/reflection-docblock' => ['tests'],
diff --git a/vendor/composer/autoload_psr4.php b/vendor/composer/autoload_psr4.php
index 8d5b5ef27e423b41ea0f84bdc5fdaac939e4d98a..b948ef6a81b46357d72ae61d29037b5fd67d9644 100644
--- a/vendor/composer/autoload_psr4.php
+++ b/vendor/composer/autoload_psr4.php
@@ -6,6 +6,7 @@
$baseDir = dirname($vendorDir);
return array(
+ 'Zumba\\GastonJS\\' => array($vendorDir . '/jcalderonzumba/gastonjs/src'),
'Zend\\Stdlib\\' => array($vendorDir . '/zendframework/zend-stdlib/src'),
'Zend\\Hydrator\\' => array($vendorDir . '/zendframework/zend-hydrator/src'),
'Zend\\Feed\\' => array($vendorDir . '/zendframework/zend-feed/src'),
diff --git a/vendor/composer/installed.json b/vendor/composer/installed.json
index 4c4df5b1c6681a880f423bd0d9d0b69c2f9e4bee..e7564c9c9eecb1039ca4620730270f3e937f0be1 100644
--- a/vendor/composer/installed.json
+++ b/vendor/composer/installed.json
@@ -107,7 +107,7 @@
},
"dist": {
"type": "zip",
- "url": "https://api.github.com/repos/wikimedia/composer-merge-plugin/zipball/47bb3388cfeae41a38087ac8465a7d08fa92ea2e",
+ "url": "https://api.github.com/repos/wikimedia/composer-merge-plugin/zipball/6bfcdcfe0aab6c11dcccfbd28dea01a592afd5b3",
"reference": "47bb3388cfeae41a38087ac8465a7d08fa92ea2e",
"shasum": ""
},
@@ -3757,5 +3757,64 @@
],
"description": "Symfony EventDispatcher Component",
"homepage": "https://symfony.com"
+ },
+ {
+ "name": "jcalderonzumba/gastonjs",
+ "version": "dev-master",
+ "version_normalized": "9999999-dev",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/jcalderonzumba/gastonjs.git",
+ "reference": "5e231b4df98275c404e1371fc5fadd34f6a121ad"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/jcalderonzumba/gastonjs/zipball/5e231b4df98275c404e1371fc5fadd34f6a121ad",
+ "reference": "5e231b4df98275c404e1371fc5fadd34f6a121ad",
+ "shasum": ""
+ },
+ "require": {
+ "guzzlehttp/guzzle": "~5.0|~6.0",
+ "php": ">=5.4"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "~4.6",
+ "silex/silex": "~1.2",
+ "symfony/phpunit-bridge": "~2.7",
+ "symfony/process": "~2.1"
+ },
+ "time": "2015-10-07 11:40:41",
+ "type": "phantomjs-api",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.1.x-dev"
+ }
+ },
+ "installation-source": "source",
+ "autoload": {
+ "psr-4": {
+ "Zumba\\GastonJS\\": "src"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Juan Francisco Calderón Zumba",
+ "email": "juanfcz@gmail.com",
+ "homepage": "http://github.com/jcalderonzumba"
+ }
+ ],
+ "description": "PhantomJS API based server for webpage automation",
+ "homepage": "https://github.com/jcalderonzumba/gastonjs",
+ "keywords": [
+ "api",
+ "automation",
+ "browser",
+ "headless",
+ "phantomjs"
+ ]
}
]
diff --git a/vendor/jcalderonzumba/gastonjs/.travis.yml b/vendor/jcalderonzumba/gastonjs/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..c64d755106db0019994d3c19597226a1a2f526fe
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/.travis.yml
@@ -0,0 +1,37 @@
+language: php
+
+php:
+ - 5.4
+ - 5.5
+ - 5.6
+ - 7.0
+ - hhvm
+
+matrix:
+ fast_finish: true
+ include:
+ - php: 5.4
+ env: COMPOSER_FLAGS='--prefer-lowest --prefer-stable' SYMFONY_DEPRECATIONS_HELPER=weak
+ - php: 5.6
+ env: DEPENDENCIES=dev
+ allow_failures:
+ - php: 7.0
+ - php: hhvm
+
+cache:
+ directories:
+ - $HOME/.composer/cache/files
+
+before_install:
+ - composer self-update
+ - if [ "$DEPENDENCIES" = "dev" ]; then perl -pi -e 's/^}$/,"minimum-stability":"dev"}/' composer.json; fi;
+
+install:
+ - composer update $COMPOSER_FLAGS
+
+script:
+ - bin/run-tests.sh
+
+after_script:
+ - ps axo pid,command | grep phantomjs | grep -v grep | awk '{print $1}' | xargs -I {} kill {}
+ - ps axo pid,command | grep php | grep -v grep | awk '{print $1}' | xargs -I {} kill {}
diff --git a/vendor/jcalderonzumba/gastonjs/LICENSE b/vendor/jcalderonzumba/gastonjs/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..7ba018acd071864e41f4ee88f799ada6bfb7aa6c
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Juan Francisco Calderón Zumba
+
+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.
diff --git a/vendor/jcalderonzumba/gastonjs/README.md b/vendor/jcalderonzumba/gastonjs/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4f8e83d57c647fa08df082032aba9b395fddeab8
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/README.md
@@ -0,0 +1,8 @@
+GastonJS for Webpage automation
+================================
+[](https://travis-ci.org/jcalderonzumba/gastonjs)
+[](https://packagist.org/packages/jcalderonzumba/gastonjs)
+[](https://packagist.org/packages/jcalderonzumba/gastonjs)
+
+
+For full documentation go to [GastonJS doc](http://gastonjs.readthedocs.org/en/latest/)
diff --git a/vendor/jcalderonzumba/gastonjs/bin/run-tests.sh b/vendor/jcalderonzumba/gastonjs/bin/run-tests.sh
new file mode 100755
index 0000000000000000000000000000000000000000..426ec94f1ccff236607f4455598abf167a59cfe9
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/bin/run-tests.sh
@@ -0,0 +1,26 @@
+#!/bin/sh
+set -e
+
+start_browser_api(){
+ CURRENT_DIR=$(pwd)
+ LOCAL_PHANTOMJS="${CURRENT_DIR}/bin/phantomjs"
+ if [ -f ${LOCAL_PHANTOMJS} ]; then
+ ${LOCAL_PHANTOMJS} --ssl-protocol=any --ignore-ssl-errors=true src/Client/main.js 8510 1024 768 2>&1 &
+ else
+ phantomjs --ssl-protocol=any --ignore-ssl-errors=true src/Client/main.js 8510 1024 768 2>&1 >> /dev/null &
+ fi
+ sleep 2
+}
+
+stop_services(){
+ ps axo pid,command | grep phantomjs | grep -v grep | awk '{print $1}' | xargs -I {} kill {}
+ ps axo pid,command | grep php | grep -v grep | grep -v phpstorm | awk '{print $1}' | xargs -I {} kill {}
+ sleep 2
+}
+
+mkdir -p /tmp/jcalderonzumba/phantomjs
+stop_services
+start_browser_api
+CURRENT_DIR=$(pwd)
+${CURRENT_DIR}/bin/phpunit --configuration unit_tests.xml
+
diff --git a/vendor/jcalderonzumba/gastonjs/composer.json b/vendor/jcalderonzumba/gastonjs/composer.json
new file mode 100644
index 0000000000000000000000000000000000000000..7e5d96e6abbdd726ce7b7cc5b0e247e212c0bdff
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/composer.json
@@ -0,0 +1,49 @@
+{
+ "name": "jcalderonzumba/gastonjs",
+ "description": "PhantomJS API based server for webpage automation",
+ "keywords": [
+ "phantomjs",
+ "headless",
+ "api",
+ "automation",
+ "browser"
+ ],
+ "homepage": "https://github.com/jcalderonzumba/gastonjs",
+ "type": "phantomjs-api",
+ "license": "MIT",
+ "authors": [
+ {
+ "name": "Juan Francisco Calderón Zumba",
+ "email": "juanfcz@gmail.com",
+ "homepage": "http://github.com/jcalderonzumba"
+ }
+ ],
+ "require": {
+ "php": ">=5.4",
+ "guzzlehttp/guzzle": "~5.0|~6.0"
+ },
+ "require-dev": {
+ "symfony/process": "~2.1",
+ "symfony/phpunit-bridge": "~2.7",
+ "phpunit/phpunit": "~4.6",
+ "silex/silex": "~1.2"
+ },
+ "config": {
+ "bin-dir": "bin"
+ },
+ "autoload": {
+ "psr-4": {
+ "Zumba\\GastonJS\\": "src"
+ }
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "Zumba\\GastonJS\\Tests\\": "tests/unit"
+ }
+ },
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.1.x-dev"
+ }
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/mkdocs.yml b/vendor/jcalderonzumba/gastonjs/mkdocs.yml
new file mode 100644
index 0000000000000000000000000000000000000000..51d881f57591c61c0e8c35c1c2faa6914fe93bec
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/mkdocs.yml
@@ -0,0 +1,40 @@
+site_name: GastonJS Documentation
+pages:
+ - GastonJS introduction: index.md
+ - GastonJS API :
+ - 'Introduction': api/index.md
+ - 'Available commands': api/command-list.md
+ - 'Navigation commands':
+ - 'visit': api/commands/navigation/visit.md
+ - 'current_url': api/commands/navigation/current_url.md
+ - 'reload': api/commands/navigation/reload.md
+ - 'go_back': api/commands/navigation/go_back.md
+ - 'go_forward': api/commands/navigation/go_forward.md
+ - 'Header commands' :
+ - 'get_headers': api/commands/headers/get_headers.md
+ - 'response_headers': api/commands/headers/response_headers.md
+ - 'set_headers': api/commands/headers/set_headers.md
+ - 'add_headers': api/commands/headers/add_headers.md
+ - 'add_header': api/commands/headers/add_header.md
+ - 'Javascript commands' :
+ - 'add_extension': api/commands/javascript/add_extension.md
+ - 'execute': api/commands/javascript/execute.md
+ - 'evaluate': api/commands/javascript/evaluate.md
+ - 'set_js_errors': api/commands/javascript/set_js_errors.md
+ - 'Cookies commands' :
+ - 'cookies': api/commands/cookies/cookies.md
+ - 'clear_cookies': api/commands/cookies/clear_cookies.md
+ - 'cookies_enabled': api/commands/cookies/cookies_enabled.md
+ - 'remove_cookie': api/commands/cookies/remove_cookie.md
+ - 'set_cookie': api/commands/cookies/set_cookie.md
+ - 'Mouse commands':
+ - 'click': api/commands/mouse/click.md
+ - 'right_click': api/commands/mouse/right_click.md
+ - 'hover': api/commands/mouse/hover.md
+ - 'double_click': api/commands/mouse/double_click.md
+ - 'click_coordinates': api/commands/mouse/click_coordinates.md
+ - 'mouse_event': api/commands/mouse/mouse_event.md
+ - 'Render commands':
+ - 'render': api/commands/render/render.md
+ - 'render_base64': api/commands/render/render_base64.md
+ - GastonJS PHP client: clients/php/index.md
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/Browser.php b/vendor/jcalderonzumba/gastonjs/src/Browser/Browser.php
new file mode 100644
index 0000000000000000000000000000000000000000..5c2a3374e9fefc2d2262696bd103b6fa232f33ae
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/Browser.php
@@ -0,0 +1,120 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Class Browser
+ * @package Zumba\GastonJS
+ */
+class Browser extends BrowserBase {
+
+ use BrowserAuthenticationTrait;
+ use BrowserConfigurationTrait;
+ use BrowserCookieTrait;
+ use BrowserFileTrait;
+ use BrowserFrameTrait;
+ use BrowserHeadersTrait;
+ use BrowserMouseEventTrait;
+ use BrowserNavigateTrait;
+ use BrowserNetworkTrait;
+ use BrowserPageElementTrait;
+ use BrowserPageTrait;
+ use BrowserRenderTrait;
+ use BrowserScriptTrait;
+ use BrowserWindowTrait;
+
+ /**
+ * @param string $phantomJSHost
+ * @param mixed $logger
+ */
+ public function __construct($phantomJSHost, $logger = null) {
+ $this->phantomJSHost = $phantomJSHost;
+ $this->logger = $logger;
+ $this->debug = false;
+ $this->createApiClient();
+ }
+
+ /**
+ * Returns the value of a given element in a page
+ * @param $pageId
+ * @param $elementId
+ * @return mixed
+ */
+ public function value($pageId, $elementId) {
+ return $this->command('value', $pageId, $elementId);
+ }
+
+ /**
+ * Sets a value to a given element in a given page
+ * @param $pageId
+ * @param $elementId
+ * @param $value
+ * @return mixed
+ */
+ public function set($pageId, $elementId, $value) {
+ return $this->command('set', $pageId, $elementId, $value);
+ }
+
+ /**
+ * Tells whether an element on a page is visible or not
+ * @param $pageId
+ * @param $elementId
+ * @return bool
+ */
+ public function isVisible($pageId, $elementId) {
+ return $this->command('visible', $pageId, $elementId);
+ }
+
+ /**
+ * @param $pageId
+ * @param $elementId
+ * @return bool
+ */
+ public function isDisabled($pageId, $elementId) {
+ return $this->command('disabled', $pageId, $elementId);
+ }
+
+ /**
+ * Drag an element to a another in a given page
+ * @param $pageId
+ * @param $fromId
+ * @param $toId
+ * @return mixed
+ */
+ public function drag($pageId, $fromId, $toId) {
+ return $this->command('drag', $pageId, $fromId, $toId);
+ }
+
+ /**
+ * Selects a value in the given element and page
+ * @param $pageId
+ * @param $elementId
+ * @param $value
+ * @return mixed
+ */
+ public function select($pageId, $elementId, $value) {
+ return $this->command('select', $pageId, $elementId, $value);
+ }
+
+ /**
+ * Triggers an event to a given element on the given page
+ * @param $pageId
+ * @param $elementId
+ * @param $event
+ * @return mixed
+ */
+ public function trigger($pageId, $elementId, $event) {
+ return $this->command('trigger', $pageId, $elementId, $event);
+ }
+
+ /**
+ * TODO: not sure what this does, needs to do normalizeKeys
+ * @param int $pageId
+ * @param int $elementId
+ * @param array $keys
+ * @return mixed
+ */
+ public function sendKeys($pageId, $elementId, $keys) {
+ return $this->command('send_keys', $pageId, $elementId, $this->normalizeKeys($keys));
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserAuthenticationTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserAuthenticationTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..7416a76e55fa769a4d8f619470d332a56ac38f54
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserAuthenticationTrait.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Trait BrowserAuthenticationTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserAuthenticationTrait {
+ /**
+ * Sets basic HTTP authentication
+ * @param $user
+ * @param $password
+ * @return bool
+ */
+ public function setHttpAuth($user, $password) {
+ return $this->command('set_http_auth', $user, $password);
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserBase.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserBase.php
new file mode 100644
index 0000000000000000000000000000000000000000..3ef14d0d7ca7a82bc6738c367442e6b674bd3100
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserBase.php
@@ -0,0 +1,124 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+use Zumba\GastonJS\Exception\BrowserError;
+use Zumba\GastonJS\Exception\DeadClient;
+use GuzzleHttp\Client;
+use GuzzleHttp\Exception\ConnectException;
+use GuzzleHttp\Exception\ServerException;
+
+/**
+ * Class BrowserBase
+ * @package Zumba\GastonJS\Browser
+ */
+class BrowserBase {
+ /** @var mixed */
+ protected $logger;
+ /** @var bool */
+ protected $debug;
+ /** @var string */
+ protected $phantomJSHost;
+ /** @var Client */
+ protected $apiClient;
+
+ /**
+ * Creates an http client to consume the phantomjs API
+ */
+ protected function createApiClient() {
+ // Provide a BC switch between guzzle 5 and guzzle 6.
+ if (class_exists('GuzzleHttp\Psr7\Response')) {
+ $this->apiClient = new Client(array("base_uri" => $this->getPhantomJSHost()));
+ }
+ else {
+ $this->apiClient = new Client(array("base_url" => $this->getPhantomJSHost()));
+ }
+ }
+
+ /**
+ * TODO: not sure how to do the normalizeKeys stuff fix when needed
+ * @param $keys
+ * @return mixed
+ */
+ protected function normalizeKeys($keys) {
+ return $keys;
+ }
+
+ /**
+ * @return Client
+ */
+ public function getApiClient() {
+ return $this->apiClient;
+ }
+
+ /**
+ * @return string
+ */
+ public function getPhantomJSHost() {
+ return $this->phantomJSHost;
+ }
+
+ /**
+ * @return mixed
+ */
+ public function getLogger() {
+ return $this->logger;
+ }
+
+ /**
+ * Restarts the browser
+ */
+ public function restart() {
+ //TODO: Do we really need to do this?, we are just a client
+ }
+
+ /**
+ * Sends a command to the browser
+ * @throws BrowserError
+ * @throws \Exception
+ * @return mixed
+ */
+ public function command() {
+ try {
+ $args = func_get_args();
+ $commandName = $args[0];
+ array_shift($args);
+ $messageToSend = json_encode(array('name' => $commandName, 'args' => $args));
+ /** @var $commandResponse \GuzzleHttp\Psr7\Response|\GuzzleHttp\Message\Response */
+ $commandResponse = $this->getApiClient()->post("/api", array("body" => $messageToSend));
+ $jsonResponse = json_decode($commandResponse->getBody(), TRUE);
+ } catch (ServerException $e) {
+ $jsonResponse = json_decode($e->getResponse()->getBody()->getContents(), true);
+ } catch (ConnectException $e) {
+ throw new DeadClient($e->getMessage(), $e->getCode(), $e);
+ } catch (\Exception $e) {
+ throw $e;
+ }
+
+ if (isset($jsonResponse['error'])) {
+ throw $this->getErrorClass($jsonResponse);
+ }
+
+ return $jsonResponse['response'];
+ }
+
+ /**
+ * @param $error
+ * @return BrowserError
+ */
+ protected function getErrorClass($error) {
+ $errorClassMap = array(
+ 'Poltergeist.JavascriptError' => "Zumba\\GastonJS\\Exception\\JavascriptError",
+ 'Poltergeist.FrameNotFound' => "Zumba\\GastonJS\\Exception\\FrameNotFound",
+ 'Poltergeist.InvalidSelector' => "Zumba\\GastonJS\\Exception\\InvalidSelector",
+ 'Poltergeist.StatusFailError' => "Zumba\\GastonJS\\Exception\\StatusFailError",
+ 'Poltergeist.NoSuchWindowError' => "Zumba\\GastonJS\\Exception\\NoSuchWindowError",
+ 'Poltergeist.ObsoleteNode' => "Zumba\\GastonJS\\Exception\\ObsoleteNode"
+ );
+ if (isset($error['error']['name']) && isset($errorClassMap[$error["error"]["name"]])) {
+ return new $errorClassMap[$error["error"]["name"]]($error);
+ }
+
+ return new BrowserError($error);
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserConfigurationTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserConfigurationTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..0db7f07acc22e50a2be5dae3d0aa0904ad9b2ba0
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserConfigurationTrait.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+
+/**
+ * Trait BrowserConfigurationTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserConfigurationTrait {
+ /**
+ * Set whether to fail or not on javascript errors found on the page
+ * @param bool $enabled
+ * @return bool
+ */
+ public function jsErrors($enabled = true) {
+ return $this->command('set_js_errors', $enabled);
+ }
+
+ /**
+ * Set a blacklist of urls that we are not supposed to load
+ * @param array $blackList
+ * @return bool
+ */
+ public function urlBlacklist($blackList) {
+ return $this->command('set_url_blacklist', $blackList);
+ }
+
+ /**
+ * Set the debug mode on the browser
+ * @param bool $enable
+ * @return bool
+ */
+ public function debug($enable = false) {
+ $this->debug = $enable;
+ return $this->command('set_debug', $this->debug);
+ }
+
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserCookieTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserCookieTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..e2318a4fa2eb01685e301d91da97b1819f09685f
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserCookieTrait.php
@@ -0,0 +1,65 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+use Zumba\GastonJS\Cookie;
+
+/**
+ * Trait BrowserCookieTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserCookieTrait {
+ /**
+ * Gets the cookies on the browser
+ *
+ * @return Cookie[]
+ */
+ public function cookies() {
+ $cookies = $this->command('cookies');
+ $objCookies = array();
+ foreach ($cookies as $cookie) {
+ $objCookies[$cookie["name"]] = new Cookie($cookie);
+ }
+ return $objCookies;
+ }
+
+ /**
+ * Sets a cookie on the browser, expires times is set in seconds
+ * @param $cookie
+ * @return mixed
+ */
+ public function setCookie($cookie) {
+ //TODO: add error control when the cookie array is not valid
+ if (isset($cookie["expires"])) {
+ $cookie["expires"] = intval($cookie["expires"]) * 1000;
+ }
+ $cookie['value'] = urlencode($cookie['value']);
+ return $this->command('set_cookie', $cookie);
+ }
+
+ /**
+ * Deletes a cookie on the browser if exists
+ * @param $cookieName
+ * @return bool
+ */
+ public function removeCookie($cookieName) {
+ return $this->command('remove_cookie', $cookieName);
+ }
+
+ /**
+ * Clear all the cookies
+ * @return bool
+ */
+ public function clearCookies() {
+ return $this->command('clear_cookies');
+ }
+
+ /**
+ * Enables or disables the cookies con phantomjs
+ * @param bool $enabled
+ * @return bool
+ */
+ public function cookiesEnabled($enabled = true) {
+ return $this->command('cookies_enabled', $enabled);
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserFileTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserFileTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..51fc745f622c5d03cb47403b3b1dd905408d302a
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserFileTrait.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Trait BrowserFileTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserFileTrait {
+ /**
+ * Selects a file to send to the browser to a given page
+ * @param $pageId
+ * @param $elementId
+ * @param $value
+ * @return mixed
+ */
+ public function selectFile($pageId, $elementId, $value) {
+ return $this->command('select_file', $pageId, $elementId, $value);
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserFrameTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserFrameTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..edefe5eb109816eceeb5847fce2e8e0d87150ab6
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserFrameTrait.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Trait BrowserFrameTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserFrameTrait {
+ /**
+ * Back to the parent of the iframe if possible
+ * @return mixed
+ * @throws \Zumba\GastonJS\Exception\BrowserError
+ * @throws \Exception
+ */
+ public function popFrame() {
+ return $this->command("pop_frame");
+ }
+
+ /**
+ * Goes into the iframe to do stuff
+ * @param string $name
+ * @param int $timeout
+ * @return mixed
+ * @throws \Zumba\GastonJS\Exception\BrowserError
+ * @throws \Exception
+ */
+ public function pushFrame($name, $timeout = null) {
+ return $this->command("push_frame", $name, $timeout);
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserHeadersTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserHeadersTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..8300048a8064bc0d97316e7e13132645ed59eb65
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserHeadersTrait.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Trait BrowserHeadersTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserHeadersTrait {
+ /**
+ * Returns the headers of the current page that will be used the next request
+ * @return mixed
+ */
+ public function getHeaders() {
+ return $this->command('get_headers');
+ }
+
+ /**
+ * Given an array of headers, set such headers for the requests, removing all others
+ * @param array $headers
+ * @return mixed
+ */
+ public function setHeaders($headers) {
+ return $this->command('set_headers', $headers);
+ }
+
+ /**
+ * Adds headers to current page overriding the existing ones for the next requests
+ * @param $headers
+ * @return mixed
+ */
+ public function addHeaders($headers) {
+ return $this->command('add_headers', $headers);
+ }
+
+ /**
+ * Adds a header to the page making it permanent if needed
+ * @param $header
+ * @param $permanent
+ * @return mixed
+ */
+ public function addHeader($header, $permanent = false) {
+ return $this->command('add_header', $header, $permanent);
+ }
+
+ /**
+ * Gets the response headers after a request
+ * @return mixed
+ */
+ public function responseHeaders() {
+ return $this->command('response_headers');
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserMouseEventTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserMouseEventTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..38ec5a60ce5458b9558ffcd490bc49a3d60603e0
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserMouseEventTrait.php
@@ -0,0 +1,69 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Trait BrowserMouseEventTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserMouseEventTrait {
+ /**
+ * Click on a given page and element
+ * @param $pageId
+ * @param $elementId
+ * @return mixed
+ */
+ public function click($pageId, $elementId) {
+ return $this->command('click', $pageId, $elementId);
+ }
+
+ /**
+ * Triggers a right click on a page an element
+ * @param $pageId
+ * @param $elementId
+ * @return mixed
+ */
+ public function rightClick($pageId, $elementId) {
+ return $this->command('right_click', $pageId, $elementId);
+ }
+
+ /**
+ * Triggers a double click in a given page and element
+ * @param $pageId
+ * @param $elementId
+ * @return mixed
+ */
+ public function doubleClick($pageId, $elementId) {
+ return $this->command('double_click', $pageId, $elementId);
+ }
+
+ /**
+ * Hovers over an element in a given page
+ * @param $pageId
+ * @param $elementId
+ * @return mixed
+ */
+ public function hover($pageId, $elementId) {
+ return $this->command('hover', $pageId, $elementId);
+ }
+
+ /**
+ * Click on given coordinates, THIS DOES NOT depend on the page, it just clicks on where we are right now
+ * @param $coordX
+ * @param $coordY
+ * @return mixed
+ */
+ public function clickCoordinates($coordX, $coordY) {
+ return $this->command('click_coordinates', $coordX, $coordY);
+ }
+
+ /**
+ * Scrolls the page by a given left and top coordinates
+ * @param $left
+ * @param $top
+ * @return mixed
+ */
+ public function scrollTo($left, $top) {
+ return $this->command('scroll_to', $left, $top);
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserNavigateTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserNavigateTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..24189af77722b356c4bbf8518049de87128b6fe7
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserNavigateTrait.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+use Zumba\GastonJS\Exception\BrowserError;
+
+/**
+ * Trait BrowserNavigateTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserNavigateTrait {
+
+ /**
+ * Send a visit command to the browser
+ * @param $url
+ * @return mixed
+ */
+ public function visit($url) {
+ return $this->command('visit', $url);
+ }
+
+ /**
+ * Gets the current url we are in
+ * @return mixed
+ */
+ public function currentUrl() {
+ return $this->command('current_url');
+ }
+
+ /**
+ * Goes back on the browser history if possible
+ * @return bool
+ * @throws BrowserError
+ * @throws \Exception
+ */
+ public function goBack() {
+ return $this->command('go_back');
+ }
+
+ /**
+ * Goes forward on the browser history if possible
+ * @return mixed
+ * @throws BrowserError
+ * @throws \Exception
+ */
+ public function goForward() {
+ return $this->command('go_forward');
+ }
+
+ /**
+ * Reloads the current page we are in
+ */
+ public function reload() {
+ return $this->command('reload');
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserNetworkTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserNetworkTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..d79d21ec3d1b1a1ea45268dd6f0537b683a3613f
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserNetworkTrait.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+use Zumba\GastonJS\NetworkTraffic\Request;
+
+/**
+ * Trait BrowserNetworkTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserNetworkTrait {
+ /**
+ * Get all the network traffic that the page have created
+ * @return array
+ */
+ public function networkTraffic() {
+ $networkTraffic = $this->command('network_traffic');
+ $requestTraffic = array();
+
+ if (count($networkTraffic) === 0) {
+ return null;
+ }
+
+ foreach ($networkTraffic as $traffic) {
+ $requestTraffic[] = new Request($traffic["request"], $traffic["responseParts"]);
+ }
+
+ return $requestTraffic;
+ }
+
+ /**
+ * Clear the network traffic data stored on the phantomjs code
+ * @return mixed
+ */
+ public function clearNetworkTraffic() {
+ return $this->command('clear_network_traffic');
+ }
+
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserPageElementTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserPageElementTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..3f998fa9d451e4b52a4a4508a94dbbc88b9fab8f
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserPageElementTrait.php
@@ -0,0 +1,193 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Trait BrowserPageElementTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserPageElementTrait {
+ /**
+ * Find elements given a method and a selector
+ * @param $method
+ * @param $selector
+ * @return array
+ */
+ public function find($method, $selector) {
+ $result = $this->command('find', $method, $selector);
+ $found["page_id"] = $result["page_id"];
+ foreach ($result["ids"] as $id) {
+ $found["ids"][] = $id;
+ }
+ return $found;
+ }
+
+ /**
+ * Find elements within a page, method and selector
+ * @param $pageId
+ * @param $elementId
+ * @param $method
+ * @param $selector
+ * @return mixed
+ */
+ public function findWithin($pageId, $elementId, $method, $selector) {
+ return $this->command('find_within', $pageId, $elementId, $method, $selector);
+ }
+
+ /**
+ * @param $pageId
+ * @param $elementId
+ * @return mixed
+ */
+ public function getParents($pageId, $elementId) {
+ return $this->command('parents', $pageId, $elementId);
+ }
+
+ /**
+ * Returns the text of a given page and element
+ * @param $pageId
+ * @param $elementId
+ * @return mixed
+ */
+ public function allText($pageId, $elementId) {
+ return $this->command('all_text', $pageId, $elementId);
+ }
+
+ /**
+ * Returns the inner or outer html of the given page and element
+ * @param $pageId
+ * @param $elementId
+ * @param $type
+ * @return mixed
+ * @throws \Zumba\GastonJS\Exception\BrowserError
+ * @throws \Exception
+ */
+ public function allHtml($pageId, $elementId, $type = "inner") {
+ return $this->command('all_html', $pageId, $elementId, $type);
+ }
+
+ /**
+ * Returns ONLY the visible text of a given page and element
+ * @param $pageId
+ * @param $elementId
+ * @return mixed
+ */
+ public function visibleText($pageId, $elementId) {
+ return $this->command('visible_text', $pageId, $elementId);
+ }
+
+ /**
+ * Deletes the text of a given page and element
+ * @param $pageId
+ * @param $elementId
+ * @return mixed
+ */
+ public function deleteText($pageId, $elementId) {
+ return $this->command('delete_text', $pageId, $elementId);
+ }
+
+ /**
+ * Gets the tag name of a given element and page
+ * @param $pageId
+ * @param $elementId
+ * @return string
+ */
+ public function tagName($pageId, $elementId) {
+ return strtolower($this->command('tag_name', $pageId, $elementId));
+ }
+
+ /**
+ * Check if two elements are the same on a give
+ * @param $pageId
+ * @param $firstId
+ * @param $secondId
+ * @return bool
+ */
+ public function equals($pageId, $firstId, $secondId) {
+ return $this->command('equals', $pageId, $firstId, $secondId);
+ }
+
+ /**
+ * Returns the attributes of an element in a given page
+ * @param $pageId
+ * @param $elementId
+ * @return mixed
+ */
+ public function attributes($pageId, $elementId) {
+ return $this->command('attributes', $pageId, $elementId);
+ }
+
+ /**
+ * Returns the attribute of an element by name in a given page
+ * @param $pageId
+ * @param $elementId
+ * @param $name
+ * @return mixed
+ */
+ public function attribute($pageId, $elementId, $name) {
+ return $this->command('attribute', $pageId, $elementId, $name);
+ }
+
+ /**
+ * Set an attribute to the given element in the given page
+ * @param $pageId
+ * @param $elementId
+ * @param $name
+ * @param $value
+ * @return mixed
+ * @throws \Zumba\GastonJS\Exception\BrowserError
+ * @throws \Exception
+ */
+ public function setAttribute($pageId, $elementId, $name, $value) {
+ return $this->command('set_attribute', $pageId, $elementId, $name, $value);
+ }
+
+ /**
+ * Remove an attribute for a given page and element
+ * @param $pageId
+ * @param $elementId
+ * @param $name
+ * @return mixed
+ * @throws \Zumba\GastonJS\Exception\BrowserError
+ * @throws \Exception
+ */
+ public function removeAttribute($pageId, $elementId, $name) {
+ return $this->command('remove_attribute', $pageId, $elementId, $name);
+ }
+
+ /**
+ * Checks if an element is visible or not
+ * @param $pageId
+ * @param $elementId
+ * @return boolean
+ */
+ public function isVisible($pageId, $elementId) {
+ return $this->command("visible", $pageId, $elementId);
+ }
+
+ /**
+ * Sends the order to execute a key event on a given element
+ * @param $pageId
+ * @param $elementId
+ * @param $keyEvent
+ * @param $key
+ * @param $modifier
+ * @return mixed
+ */
+ public function keyEvent($pageId, $elementId, $keyEvent, $key, $modifier) {
+ return $this->command("key_event", $pageId, $elementId, $keyEvent, $key, $modifier);
+ }
+
+ /**
+ * Sends the command to select and option given a value
+ * @param $pageId
+ * @param $elementId
+ * @param $value
+ * @param bool $multiple
+ * @return mixed
+ */
+ public function selectOption($pageId, $elementId, $value, $multiple = false) {
+ return $this->command("select_option", $pageId, $elementId, $value, $multiple);
+ }
+
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserPageTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserPageTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..3d5f9f1212828b4f40856bbe56cbb2de74a02a78
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserPageTrait.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Trait BrowserPageTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserPageTrait {
+ /**
+ * Gets the status code of the request we are currently in
+ * @return mixed
+ */
+ public function getStatusCode() {
+ return $this->command('status_code');
+ }
+
+ /**
+ * Returns the body of the response to a given browser request
+ * @return mixed
+ */
+ public function getBody() {
+ return $this->command('body');
+ }
+
+ /**
+ * Returns the source of the current page
+ * @return mixed
+ */
+ public function getSource() {
+ return $this->command('source');
+ }
+
+ /**
+ * Gets the current page title
+ * @return mixed
+ */
+ public function getTitle() {
+ return $this->command('title');
+ }
+
+ /**
+ * Resize the current page
+ * @param $width
+ * @param $height
+ * @return mixed
+ */
+ public function resize($width, $height) {
+ return $this->command('resize', $width, $height);
+ }
+
+ /**
+ * Resets the page we are in to a clean slate
+ * @return mixed
+ */
+ public function reset() {
+ return $this->command('reset');
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserRenderTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserRenderTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..3aa10aafbe78ef616b69bf41ec42785ee5ded409
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserRenderTrait.php
@@ -0,0 +1,65 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Trait BrowserRenderTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserRenderTrait {
+ /**
+ * Check and fix render options
+ * @param $options
+ * @return mixed
+ */
+ protected function checkRenderOptions($options) {
+ //Default is full and no selection
+ if (count($options) === 0) {
+ $options["full"] = true;
+ $options["selector"] = null;
+ }
+
+ if (isset($options["full"]) && isset($options["selector"])) {
+ if ($options["full"]) {
+ //Whatever it is, full is more powerful than selection
+ $options["selector"] = null;
+ }
+ } else {
+ if (!isset($options["full"]) && isset($options["selector"])) {
+ $options["full"] = false;
+ }
+ }
+ return $options;
+ }
+
+ /**
+ * Renders a page or selection to a file given by path
+ * @param string $path
+ * @param array $options
+ * @return mixed
+ */
+ public function render($path, $options = array()) {
+ $fixedOptions = $this->checkRenderOptions($options);
+ return $this->command('render', $path, $fixedOptions["full"], $fixedOptions["selector"]);
+ }
+
+ /**
+ * Renders base64 a page or selection to a file given by path
+ * @param string $imageFormat (PNG, GIF, JPEG)
+ * @param array $options
+ * @return mixed
+ */
+ public function renderBase64($imageFormat, $options = array()) {
+ $fixedOptions = $this->checkRenderOptions($options);
+ return $this->command('render_base64', $imageFormat, $fixedOptions["full"], $fixedOptions["selector"]);
+ }
+
+ /**
+ * Sets the paper size, useful when saving to PDF
+ * @param $paperSize
+ * @return mixed
+ */
+ public function setPaperSize($paperSize) {
+ return $this->command('set_paper_size', $paperSize);
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserScriptTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserScriptTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..769b86fc510737b01c36e9c6b1fb6d95fe5b14d0
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserScriptTrait.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Trait BrowserScriptTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserScriptTrait {
+ /**
+ * Evaluates a script on the browser
+ * @param $script
+ * @return mixed
+ */
+ public function evaluate($script) {
+ return $this->command('evaluate', $script);
+ }
+
+ /**
+ * Executes a script on the browser
+ * @param $script
+ * @return mixed
+ */
+ public function execute($script) {
+ return $this->command('execute', $script);
+ }
+
+ /**
+ * Add desired extensions to phantomjs
+ * @param $extensions
+ * @return bool
+ */
+ public function extensions($extensions) {
+ //TODO: add error control for when extensions do not exist physically
+ foreach ($extensions as $extensionName) {
+ $this->command('add_extension', $extensionName);
+ }
+ return true;
+ }
+
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserWindowTrait.php b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserWindowTrait.php
new file mode 100644
index 0000000000000000000000000000000000000000..8647ffcbbec666c23868c263de53e39107671f06
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Browser/BrowserWindowTrait.php
@@ -0,0 +1,81 @@
+<?php
+
+namespace Zumba\GastonJS\Browser;
+
+/**
+ * Class BrowserWindowTrait
+ * @package Zumba\GastonJS\Browser
+ */
+trait BrowserWindowTrait {
+ /**
+ * Returns the current window handle name in the browser
+ * @param string $name
+ * @return mixed
+ */
+ public function windowHandle($name = null) {
+ return $this->command('window_handle', $name);
+ }
+
+ /**
+ * Returns all the window handles present in the browser
+ * @return array
+ */
+ public function windowHandles() {
+ return $this->command('window_handles');
+ }
+
+ /**
+ * Change the browser focus to another window
+ * @param $windowHandleName
+ * @return mixed
+ */
+ public function switchToWindow($windowHandleName) {
+ return $this->command('switch_to_window', $windowHandleName);
+ }
+
+ /**
+ * Opens a new window on the browser
+ * @return mixed
+ */
+ public function openNewWindow() {
+ return $this->command('open_new_window');
+ }
+
+ /**
+ * Closes a window on the browser by a given handler name
+ * @param $windowHandleName
+ * @return mixed
+ */
+ public function closeWindow($windowHandleName) {
+ return $this->command('close_window', $windowHandleName);
+ }
+
+ /**
+ * Gets the current request window name
+ * @return string
+ * @throws \Zumba\GastonJS\Exception\BrowserError
+ * @throws \Exception
+ */
+ public function windowName() {
+ return $this->command('window_name');
+ }
+
+ /**
+ * Zoom factor for a web page
+ * @param $zoomFactor
+ * @return mixed
+ */
+ public function setZoomFactor($zoomFactor) {
+ return $this->command('set_zoom_factor', $zoomFactor);
+ }
+
+ /**
+ * Gets the window size
+ * @param $windowHandleName
+ * @return mixed
+ */
+ public function windowSize($windowHandleName) {
+ return $this->command('window_size', $windowHandleName);
+ }
+
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Errors/browser_error.js b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/browser_error.js
new file mode 100644
index 0000000000000000000000000000000000000000..892333caa903499d5d568bc6c1de8aa740d3c32f
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/browser_error.js
@@ -0,0 +1,17 @@
+Poltergeist.BrowserError = (function (_super) {
+ __extends(BrowserError, _super);
+
+ function BrowserError(message, stack) {
+ this.message = message;
+ this.stack = stack;
+ }
+
+ BrowserError.prototype.name = "Poltergeist.BrowserError";
+
+ BrowserError.prototype.args = function () {
+ return [this.message, this.stack];
+ };
+
+ return BrowserError;
+
+})(Poltergeist.Error);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Errors/error.js b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/error.js
new file mode 100644
index 0000000000000000000000000000000000000000..5a6f1f6990e9f3f5dda71c5a9110fbd534dee9d1
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/error.js
@@ -0,0 +1,10 @@
+/**
+ * Poltergeist base error class
+ */
+Poltergeist.Error = (function () {
+ function Error() {
+ }
+
+ return Error;
+
+})();
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Errors/frame_not_found.js b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/frame_not_found.js
new file mode 100644
index 0000000000000000000000000000000000000000..d42e87256077c969f315b6661104cfc7dbf20a2f
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/frame_not_found.js
@@ -0,0 +1,16 @@
+Poltergeist.FrameNotFound = (function (_super) {
+ __extends(FrameNotFound, _super);
+
+ function FrameNotFound(frameName) {
+ this.frameName = frameName;
+ }
+
+ FrameNotFound.prototype.name = "Poltergeist.FrameNotFound";
+
+ FrameNotFound.prototype.args = function () {
+ return [this.frameName];
+ };
+
+ return FrameNotFound;
+
+})(Poltergeist.Error);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Errors/invalid_selector.js b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/invalid_selector.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ef4ae94d44c6b41a54c116bbb72099abe64077f
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/invalid_selector.js
@@ -0,0 +1,17 @@
+Poltergeist.InvalidSelector = (function (_super) {
+ __extends(InvalidSelector, _super);
+
+ function InvalidSelector(method, selector) {
+ this.method = method;
+ this.selector = selector;
+ }
+
+ InvalidSelector.prototype.name = "Poltergeist.InvalidSelector";
+
+ InvalidSelector.prototype.args = function () {
+ return [this.method, this.selector];
+ };
+
+ return InvalidSelector;
+
+})(Poltergeist.Error);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Errors/javascript_error.js b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/javascript_error.js
new file mode 100644
index 0000000000000000000000000000000000000000..b8679e4f68e7e453565ccc73ba7fdd1e6594e408
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/javascript_error.js
@@ -0,0 +1,16 @@
+Poltergeist.JavascriptError = (function (_super) {
+ __extends(JavascriptError, _super);
+
+ function JavascriptError(errors) {
+ this.errors = errors;
+ }
+
+ JavascriptError.prototype.name = "Poltergeist.JavascriptError";
+
+ JavascriptError.prototype.args = function () {
+ return [this.errors];
+ };
+
+ return JavascriptError;
+
+})(Poltergeist.Error);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Errors/mouse_event_failed.js b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/mouse_event_failed.js
new file mode 100644
index 0000000000000000000000000000000000000000..f3d4e854dae5b143e25e83de441641b38564f703
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/mouse_event_failed.js
@@ -0,0 +1,18 @@
+Poltergeist.MouseEventFailed = (function (_super) {
+ __extends(MouseEventFailed, _super);
+
+ function MouseEventFailed(eventName, selector, position) {
+ this.eventName = eventName;
+ this.selector = selector;
+ this.position = position;
+ }
+
+ MouseEventFailed.prototype.name = "Poltergeist.MouseEventFailed";
+
+ MouseEventFailed.prototype.args = function () {
+ return [this.eventName, this.selector, this.position];
+ };
+
+ return MouseEventFailed;
+
+})(Poltergeist.Error);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Errors/no_such_window_error.js b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/no_such_window_error.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee1d5ad7a40ff8d20c3b1d3a15086c203e34a63b
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/no_such_window_error.js
@@ -0,0 +1,17 @@
+Poltergeist.NoSuchWindowError = (function (_super) {
+ __extends(NoSuchWindowError, _super);
+
+ function NoSuchWindowError() {
+ _ref2 = NoSuchWindowError.__super__.constructor.apply(this, arguments);
+ return _ref2;
+ }
+
+ NoSuchWindowError.prototype.name = "Poltergeist.NoSuchWindowError";
+
+ NoSuchWindowError.prototype.args = function () {
+ return [];
+ };
+
+ return NoSuchWindowError;
+
+})(Poltergeist.Error);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Errors/obsolete_node.js b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/obsolete_node.js
new file mode 100644
index 0000000000000000000000000000000000000000..758cfd6b289ac426cd3e61aabb008a01f2907822
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/obsolete_node.js
@@ -0,0 +1,21 @@
+Poltergeist.ObsoleteNode = (function (_super) {
+ __extends(ObsoleteNode, _super);
+
+ function ObsoleteNode() {
+ _ref = ObsoleteNode.__super__.constructor.apply(this, arguments);
+ return _ref;
+ }
+
+ ObsoleteNode.prototype.name = "Poltergeist.ObsoleteNode";
+
+ ObsoleteNode.prototype.args = function () {
+ return [];
+ };
+
+ ObsoleteNode.prototype.toString = function () {
+ return this.name;
+ };
+
+ return ObsoleteNode;
+
+})(Poltergeist.Error);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Errors/status_fail_error.js b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/status_fail_error.js
new file mode 100644
index 0000000000000000000000000000000000000000..55f1871b1461a9ecf6bd0fef8258b1013d68b79c
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Errors/status_fail_error.js
@@ -0,0 +1,17 @@
+Poltergeist.StatusFailError = (function (_super) {
+ __extends(StatusFailError, _super);
+
+ function StatusFailError() {
+ _ref1 = StatusFailError.__super__.constructor.apply(this, arguments);
+ return _ref1;
+ }
+
+ StatusFailError.prototype.name = "Poltergeist.StatusFailError";
+
+ StatusFailError.prototype.args = function () {
+ return [];
+ };
+
+ return StatusFailError;
+
+})(Poltergeist.Error);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Server/server.js b/vendor/jcalderonzumba/gastonjs/src/Client/Server/server.js
new file mode 100644
index 0000000000000000000000000000000000000000..120d1fd686dd1b9a95a7ca7417ffe55358c1e7a5
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Server/server.js
@@ -0,0 +1,80 @@
+Poltergeist.Server = (function () {
+
+ /**
+ * Server constructor
+ * @param owner
+ * @param port
+ * @constructor
+ */
+ function Server(owner, port) {
+ this.server = require('webserver').create();
+ this.port = port;
+ this.owner = owner;
+ this.webServer = null;
+ }
+
+ /**
+ * Starts the web server
+ */
+ Server.prototype.start = function () {
+ var self = this;
+ this.webServer = this.server.listen(this.port, function (request, response) {
+ self.handleRequest(request, response);
+ });
+ };
+
+ /**
+ * Send error back with code and message
+ * @param response
+ * @param code
+ * @param message
+ * @return {boolean}
+ */
+ Server.prototype.sendError = function (response, code, message) {
+ response.statusCode = code;
+ response.setHeader('Content-Type', 'application/json');
+ response.write(JSON.stringify(message, null, 4));
+ response.close();
+ return true;
+ };
+
+
+ /**
+ * Send response back to the client
+ * @param response
+ * @param data
+ * @return {boolean}
+ */
+ Server.prototype.send = function (response, data) {
+ console.log("RESPONSE: " + JSON.stringify(data, null, 4).substr(0, 200));
+
+ response.statusCode = 200;
+ response.setHeader('Content-Type', 'application/json');
+ response.write(JSON.stringify(data, null, 4));
+ response.close();
+ return true;
+ };
+
+ /**
+ * Handles a request to the server
+ * @param request
+ * @param response
+ * @return {boolean}
+ */
+ Server.prototype.handleRequest = function (request, response) {
+ var commandData;
+ if (request.method !== "POST") {
+ return this.sendError(response, 405, "Only POST method is allowed in the service");
+ }
+ console.log("REQUEST: " + request.post + "\n");
+ try {
+ commandData = JSON.parse(request.post);
+ } catch (parseError) {
+ return this.sendError(response, 400, "JSON data invalid error: " + parseError.message);
+ }
+
+ return this.owner.serverRunCommand(commandData, response);
+ };
+
+ return Server;
+})();
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/Tools/inherit.js b/vendor/jcalderonzumba/gastonjs/src/Client/Tools/inherit.js
new file mode 100644
index 0000000000000000000000000000000000000000..a67a75cc60e75fb1e0178819b9b9086756762fd8
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/Tools/inherit.js
@@ -0,0 +1,28 @@
+var __extends;
+/**
+ * Helper function so objects can inherit from another
+ * @param child
+ * @param parent
+ * @return {Object}
+ * @private
+ */
+__extends = function (child, parent) {
+ var __hasProp;
+ __hasProp = {}.hasOwnProperty;
+ for (var key in parent) {
+ if (parent.hasOwnProperty(key)) {
+ if (__hasProp.call(parent, key)) {
+ child[key] = parent[key];
+ }
+ }
+ }
+
+ function ClassConstructor() {
+ this.constructor = child;
+ }
+
+ ClassConstructor.prototype = parent.prototype;
+ child.prototype = new ClassConstructor();
+ child.__super__ = parent.prototype;
+ return child;
+};
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/agent.js b/vendor/jcalderonzumba/gastonjs/src/Client/agent.js
new file mode 100644
index 0000000000000000000000000000000000000000..606a6c16662bb8016f6ce8197b2a314bf659e37a
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/agent.js
@@ -0,0 +1,896 @@
+var PoltergeistAgent;
+
+PoltergeistAgent = (function () {
+ function PoltergeistAgent() {
+ this.elements = [];
+ this.nodes = {};
+ }
+
+ /**
+ * Executes an external call done from the web page class
+ * @param name
+ * @param args
+ * @return {*}
+ */
+ PoltergeistAgent.prototype.externalCall = function (name, args) {
+ var error;
+ try {
+ return {
+ value: this[name].apply(this, args)
+ };
+ } catch (_error) {
+ error = _error;
+ return {
+ error: {
+ message: error.toString(),
+ stack: error.stack
+ }
+ };
+ }
+ };
+
+ /**
+ * Object stringifycation
+ * @param object
+ * @return {*}
+ */
+ PoltergeistAgent.stringify = function (object) {
+ var error;
+ try {
+ return JSON.stringify(object, function (key, value) {
+ if (Array.isArray(this[key])) {
+ return this[key];
+ } else {
+ return value;
+ }
+ });
+ } catch (_error) {
+ error = _error;
+ if (error instanceof TypeError) {
+ return '"(cyclic structure)"';
+ } else {
+ throw error;
+ }
+ }
+ };
+
+ /**
+ * Name speaks for itself
+ * @return {string}
+ */
+ PoltergeistAgent.prototype.currentUrl = function () {
+ return encodeURI(decodeURI(window.location.href));
+ };
+
+ /**
+ * Given a method of selection (xpath or css), a selector and a possible element to search
+ * tries to find the elements that matches such selection
+ * @param method
+ * @param selector
+ * @param within
+ * @return {Array}
+ */
+ PoltergeistAgent.prototype.find = function (method, selector, within) {
+ var elementForXpath, error, i, results, xpath, _i, _len, _results;
+ if (within == null) {
+ within = document;
+ }
+ try {
+ if (method === "xpath") {
+ xpath = document.evaluate(selector, within, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+ results = (function () {
+ var _i, _ref, _results;
+ _results = [];
+ for (i = _i = 0, _ref = xpath.snapshotLength; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
+ _results.push(xpath.snapshotItem(i));
+ }
+ return _results;
+ })();
+ } else {
+ results = within.querySelectorAll(selector);
+ }
+ _results = [];
+ for (_i = 0, _len = results.length; _i < _len; _i++) {
+ elementForXpath = results[_i];
+ _results.push(this.register(elementForXpath));
+ }
+ return _results;
+ } catch (_error) {
+ error = _error;
+ if (error.code === DOMException.SYNTAX_ERR || error.code === 51) {
+ throw new PoltergeistAgent.InvalidSelector;
+ } else {
+ throw error;
+ }
+ }
+ };
+
+ /**
+ * Register the element in the agent
+ * @param element
+ * @return {number}
+ */
+ PoltergeistAgent.prototype.register = function (element) {
+ this.elements.push(element);
+ return this.elements.length - 1;
+ };
+
+ /**
+ * Gets the size of the document
+ * @return {{height: number, width: number}}
+ */
+ PoltergeistAgent.prototype.documentSize = function () {
+ return {
+ height: document.documentElement.scrollHeight || document.documentElement.clientHeight,
+ width: document.documentElement.scrollWidth || document.documentElement.clientWidth
+ };
+ };
+
+ /**
+ * Gets a Node by a given id
+ * @param id
+ * @return {PoltergeistAgent.Node}
+ */
+ PoltergeistAgent.prototype.get = function (id) {
+ if (typeof this.nodes[id] == "undefined" || this.nodes[id] === null) {
+ //Let's try now the elements approach
+ if (typeof this.elements[id] == "undefined" || this.elements[id] === null) {
+ throw new PoltergeistAgent.ObsoleteNode;
+ }
+ return new PoltergeistAgent.Node(this, this.elements[id]);
+ }
+
+ return this.nodes[id];
+ };
+
+ /**
+ * Calls a Node agent function from the Node caller via delegates
+ * @param id
+ * @param name
+ * @param args
+ * @return {*}
+ */
+ PoltergeistAgent.prototype.nodeCall = function (id, name, args) {
+ var node;
+
+ node = this.get(id);
+ if (node.isObsolete()) {
+ throw new PoltergeistAgent.ObsoleteNode;
+ }
+ //TODO: add some error control here, we might not be able to call name function
+ return node[name].apply(node, args);
+ };
+
+ PoltergeistAgent.prototype.beforeUpload = function (id) {
+ return this.get(id).setAttribute('_poltergeist_selected', '');
+ };
+
+ PoltergeistAgent.prototype.afterUpload = function (id) {
+ return this.get(id).removeAttribute('_poltergeist_selected');
+ };
+
+ PoltergeistAgent.prototype.clearLocalStorage = function () {
+ //TODO: WTF where is variable...
+ return localStorage.clear();
+ };
+
+ return PoltergeistAgent;
+
+})();
+
+PoltergeistAgent.ObsoleteNode = (function () {
+ function ObsoleteNode() {
+ }
+
+ ObsoleteNode.prototype.toString = function () {
+ return "PoltergeistAgent.ObsoleteNode";
+ };
+
+ return ObsoleteNode;
+
+})();
+
+PoltergeistAgent.InvalidSelector = (function () {
+ function InvalidSelector() {
+ }
+
+ InvalidSelector.prototype.toString = function () {
+ return "PoltergeistAgent.InvalidSelector";
+ };
+
+ return InvalidSelector;
+
+})();
+
+PoltergeistAgent.Node = (function () {
+
+ Node.EVENTS = {
+ FOCUS: ['blur', 'focus', 'focusin', 'focusout'],
+ MOUSE: ['click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseover', 'mouseout', 'mouseup', 'contextmenu'],
+ FORM: ['submit']
+ };
+
+ function Node(agent, element) {
+ this.agent = agent;
+ this.element = element;
+ }
+
+ /**
+ * Give me the node id of the parent of this node
+ * @return {number}
+ */
+ Node.prototype.parentId = function () {
+ return this.agent.register(this.element.parentNode);
+ };
+
+ /**
+ * Returns all the node parents ids up to first child of the dom
+ * @return {Array}
+ */
+ Node.prototype.parentIds = function () {
+ var ids, parent;
+ ids = [];
+ parent = this.element.parentNode;
+ while (parent !== document) {
+ ids.push(this.agent.register(parent));
+ parent = parent.parentNode;
+ }
+ return ids;
+ };
+
+ /**
+ * Finds and returns the node ids that matches the selector within this node
+ * @param method
+ * @param selector
+ * @return {Array}
+ */
+ Node.prototype.find = function (method, selector) {
+ return this.agent.find(method, selector, this.element);
+ };
+
+ /**
+ * Checks whether the node is obsolete or not
+ * @return boolean
+ */
+ Node.prototype.isObsolete = function () {
+ var obsolete;
+
+ obsolete = function (element) {
+ if (element.parentNode != null) {
+ if (element.parentNode === document) {
+ return false;
+ } else {
+ return obsolete(element.parentNode);
+ }
+ } else {
+ return true;
+ }
+ };
+
+ return obsolete(this.element);
+ };
+
+ Node.prototype.changed = function () {
+ var event;
+ event = document.createEvent('HTMLEvents');
+ event.initEvent('change', true, false);
+ return this.element.dispatchEvent(event);
+ };
+
+ Node.prototype.input = function () {
+ var event;
+ event = document.createEvent('HTMLEvents');
+ event.initEvent('input', true, false);
+ return this.element.dispatchEvent(event);
+ };
+
+ Node.prototype.keyupdowned = function (eventName, keyCode) {
+ var event;
+ event = document.createEvent('UIEvents');
+ event.initEvent(eventName, true, true);
+ event.keyCode = keyCode;
+ event.which = keyCode;
+ event.charCode = 0;
+ return this.element.dispatchEvent(event);
+ };
+
+ Node.prototype.keypressed = function (altKey, ctrlKey, shiftKey, metaKey, keyCode, charCode) {
+ var event;
+ event = document.createEvent('UIEvents');
+ event.initEvent('keypress', true, true);
+ event.window = this.agent.window;
+ event.altKey = altKey;
+ event.ctrlKey = ctrlKey;
+ event.shiftKey = shiftKey;
+ event.metaKey = metaKey;
+ event.keyCode = keyCode;
+ event.charCode = charCode;
+ event.which = keyCode;
+ return this.element.dispatchEvent(event);
+ };
+
+ /**
+ * Tells if the node is inside the body of the document and not somewhere else
+ * @return {boolean}
+ */
+ Node.prototype.insideBody = function () {
+ return this.element === document.body || document.evaluate('ancestor::body', this.element, null, XPathResult.BOOLEAN_TYPE, null).booleanValue;
+ };
+
+ /**
+ * Returns all text visible or not of the node
+ * @return {string}
+ */
+ Node.prototype.allText = function () {
+ return this.element.textContent;
+ };
+
+ /**
+ * Returns the inner html our outer
+ * @returns {string}
+ */
+ Node.prototype.allHTML = function (type) {
+ var returnType = type || 'inner';
+
+ if (returnType === "inner") {
+ return this.element.innerHTML;
+ }
+
+ if (returnType === "outer") {
+ if (this.element.outerHTML) {
+ return this.element.outerHTML;
+ }
+ // polyfill:
+ var wrapper = document.createElement('div');
+ wrapper.appendChild(this.element.cloneNode(true));
+ return wrapper.innerHTML;
+ }
+
+ return '';
+ };
+
+ /**
+ * If the element is visible then we return the text
+ * @return {string}
+ */
+ Node.prototype.visibleText = function () {
+ if (!this.isVisible(null)) {
+ return null;
+ }
+
+ if (this.element.nodeName === "TEXTAREA") {
+ return this.element.textContent;
+ }
+
+ return this.element.innerText;
+ };
+
+ /**
+ * Deletes the actual text being represented by a selection object from the node's element DOM.
+ * @return {*}
+ */
+ Node.prototype.deleteText = function () {
+ var range;
+ range = document.createRange();
+ range.selectNodeContents(this.element);
+ window.getSelection().removeAllRanges();
+ window.getSelection().addRange(range);
+ return window.getSelection().deleteFromDocument();
+ };
+
+ /**
+ * Returns all the attributes {name:value} in the element
+ * @return {{}}
+ */
+ Node.prototype.getAttributes = function () {
+ var attributes, i, elementAttributes;
+
+ elementAttributes = this.element.attributes;
+ attributes = {};
+ for (i = 0; i < elementAttributes.length; i++) {
+ attributes[elementAttributes[i].name] = elementAttributes[i].value.replace("\n", "\\n");
+ }
+
+ return attributes;
+ };
+
+ /**
+ * Name speaks for it self, returns the value of a given attribute by name
+ * @param name
+ * @return {string}
+ */
+ Node.prototype.getAttribute = function (name) {
+ if (name === 'checked' || name === 'selected' || name === 'multiple') {
+ return this.element[name];
+ }
+ return this.element.getAttribute(name);
+ };
+
+ /**
+ * Scrolls the current element into the visible area of the browser window
+ * @return {*}
+ */
+ Node.prototype.scrollIntoView = function () {
+ return this.element.scrollIntoViewIfNeeded();
+ };
+
+ /**
+ * Returns the element.value property with special treatment if the element is a select
+ * @return {*}
+ */
+ Node.prototype.value = function () {
+ var options, i, values;
+
+ if (this.element.tagName.toLowerCase() === 'select' && this.element.multiple) {
+ values = [];
+ options = this.element.children;
+ for (i = 0; i < options.length; i++) {
+ if (options[i].selected) {
+ values.push(options[i].value);
+ }
+ }
+ return values;
+ }
+
+ return this.element.value;
+ };
+
+ /**
+ * Sets a given value in the element value property by simulation key interaction
+ * @param value
+ * @return {*}
+ */
+ Node.prototype.set = function (value) {
+ var char, keyCode, i, len;
+
+ if (this.element.readOnly) {
+ return null;
+ }
+
+ //respect the maxLength property if present
+ if (this.element.maxLength >= 0) {
+ value = value.substr(0, this.element.maxLength);
+ }
+
+ this.element.value = '';
+ this.trigger('focus');
+
+ if (this.element.type === 'number') {
+ this.element.value = value;
+ } else {
+ for (i = 0, len = value.length; i < len; i++) {
+ char = value[i];
+ keyCode = this.characterToKeyCode(char);
+ this.keyupdowned('keydown', keyCode);
+ this.element.value += char;
+ this.keypressed(false, false, false, false, char.charCodeAt(0), char.charCodeAt(0));
+ this.keyupdowned('keyup', keyCode);
+ }
+ }
+
+ this.changed();
+ this.input();
+
+ return this.trigger('blur');
+ };
+
+ /**
+ * Is the node multiple
+ * @return {boolean}
+ */
+ Node.prototype.isMultiple = function () {
+ return this.element.multiple;
+ };
+
+ /**
+ * Sets the value of an attribute given by name
+ * @param name
+ * @param value
+ * @return {boolean}
+ */
+ Node.prototype.setAttribute = function (name, value) {
+ if (value === null) {
+ return this.removeAttribute(name);
+ }
+
+ this.element.setAttribute(name, value);
+ return true;
+ };
+
+ /**
+ * Removes and attribute by name
+ * @param name
+ * @return {boolean}
+ */
+ Node.prototype.removeAttribute = function (name) {
+ this.element.removeAttribute(name);
+ return true;
+ };
+
+ /**
+ * Selects the current node
+ * @param value
+ * @return {boolean}
+ */
+ Node.prototype.select = function (value) {
+ if (value === false && !this.element.parentNode.multiple) {
+ return false;
+ }
+
+ this.element.selected = value;
+ this.changed();
+ return true;
+ };
+
+ /**
+ * Selects the radio button that has the defined value
+ * @param value
+ * @return {boolean}
+ */
+ Node.prototype.selectRadioValue = function (value) {
+ if (this.element.value == value) {
+ this.element.checked = true;
+ this.trigger('focus');
+ this.trigger('click');
+ this.changed();
+ return true;
+ }
+
+ var formElements = this.element.form.elements;
+ var name = this.element.getAttribute('name');
+ var element, i;
+
+ var deselectAllRadios = function (elements, radioName) {
+ var inputRadioElement;
+
+ for (i = 0; i < elements.length; i++) {
+ inputRadioElement = elements[i];
+ if (inputRadioElement.tagName.toLowerCase() == 'input' && inputRadioElement.type.toLowerCase() == 'radio' && inputRadioElement.name == radioName) {
+ inputRadioElement.checked = false;
+ }
+ }
+ };
+
+ var radioChange = function (radioElement) {
+ var radioEvent;
+ radioEvent = document.createEvent('HTMLEvents');
+ radioEvent.initEvent('change', true, false);
+ return radioElement.dispatchEvent(radioEvent);
+ };
+
+ var radioClickEvent = function (radioElement, name) {
+ var radioEvent;
+ radioEvent = document.createEvent('MouseEvent');
+ radioEvent.initMouseEvent(name, true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+ return radioElement.dispatchEvent(radioEvent);
+ };
+
+ if (!name) {
+ throw new Poltergeist.BrowserError('The radio button does not have the value "' + value + '"');
+ }
+
+ for (i = 0; i < formElements.length; i++) {
+ element = formElements[i];
+ if (element.tagName.toLowerCase() == 'input' && element.type.toLowerCase() == 'radio' && element.name === name) {
+ if (value === element.value) {
+ deselectAllRadios(formElements, name);
+ element.checked = true;
+ radioClickEvent(element, 'click');
+ radioChange(element);
+ return true;
+ }
+ }
+ }
+
+ throw new Poltergeist.BrowserError('The radio group "' + name + '" does not have an option "' + value + '"');
+ };
+
+ /**
+ * Checks or uncheck a radio option
+ * @param value
+ * @return {boolean}
+ */
+ Node.prototype.checked = function (value) {
+ //TODO: add error control for the checked stuff
+ this.element.checked = value;
+ return true;
+ };
+
+ /**
+ * Returns the element tag name as is, no transformations done
+ * @return {string}
+ */
+ Node.prototype.tagName = function () {
+ return this.element.tagName;
+ };
+
+ /**
+ * Checks if the element is visible either by itself of because the parents are visible
+ * @param element
+ * @return {boolean}
+ */
+ Node.prototype.isVisible = function (element) {
+ var nodeElement = element || this.element;
+
+ if (window.getComputedStyle(nodeElement).display === 'none') {
+ return false;
+ } else if (nodeElement.parentElement) {
+ return this.isVisible(nodeElement.parentElement);
+ } else {
+ return true;
+ }
+ };
+
+ /**
+ * Is the node disabled for operations with it?
+ * @return {boolean}
+ */
+ Node.prototype.isDisabled = function () {
+ return this.element.disabled || this.element.tagName === 'OPTION' && this.element.parentNode.disabled;
+ };
+
+ /**
+ * Does the node contains the selections
+ * @return {boolean}
+ */
+ Node.prototype.containsSelection = function () {
+ var selectedNode;
+
+ selectedNode = document.getSelection().focusNode;
+ if (!selectedNode) {
+ return false;
+ }
+ //this magic number is NODE.TEXT_NODE
+ if (selectedNode.nodeType === 3) {
+ selectedNode = selectedNode.parentNode;
+ }
+
+ return this.element.contains(selectedNode);
+ };
+
+ /**
+ * Returns the offset of the node in relation to the current frame
+ * @return {{top: number, left: number}}
+ */
+ Node.prototype.frameOffset = function () {
+ var offset, rect, style, win;
+ win = window;
+ offset = {
+ top: 0,
+ left: 0
+ };
+ while (win.frameElement) {
+ rect = win.frameElement.getClientRects()[0];
+ style = win.getComputedStyle(win.frameElement);
+ win = win.parent;
+ offset.top += rect.top + parseInt(style.getPropertyValue("padding-top"), 10);
+ offset.left += rect.left + parseInt(style.getPropertyValue("padding-left"), 10);
+ }
+ return offset;
+ };
+
+ /**
+ * Returns the object position in relation to the window
+ * @return {{top: *, right: *, left: *, bottom: *, width: *, height: *}}
+ */
+ Node.prototype.position = function () {
+ var frameOffset, pos, rect;
+
+ rect = this.element.getClientRects()[0];
+ if (!rect) {
+ throw new PoltergeistAgent.ObsoleteNode;
+ }
+
+ frameOffset = this.frameOffset();
+ pos = {
+ top: rect.top + frameOffset.top,
+ right: rect.right + frameOffset.left,
+ left: rect.left + frameOffset.left,
+ bottom: rect.bottom + frameOffset.top,
+ width: rect.width,
+ height: rect.height
+ };
+
+ return pos;
+ };
+
+ /**
+ * Triggers a DOM event related to the node element
+ * @param name
+ * @return {boolean}
+ */
+ Node.prototype.trigger = function (name) {
+ var event;
+ if (Node.EVENTS.MOUSE.indexOf(name) !== -1) {
+ event = document.createEvent('MouseEvent');
+ event.initMouseEvent(name, true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+ } else if (Node.EVENTS.FOCUS.indexOf(name) !== -1) {
+ event = this.obtainEvent(name);
+ } else if (Node.EVENTS.FORM.indexOf(name) !== -1) {
+ event = this.obtainEvent(name);
+ } else {
+ throw "Unknown event";
+ }
+ return this.element.dispatchEvent(event);
+ };
+
+ /**
+ * Creates a generic HTMLEvent to be use in the node element
+ * @param name
+ * @return {Event}
+ */
+ Node.prototype.obtainEvent = function (name) {
+ var event;
+ event = document.createEvent('HTMLEvents');
+ event.initEvent(name, true, true);
+ return event;
+ };
+
+ /**
+ * Does a check to see if the coordinates given
+ * match the node element or some of the parents chain
+ * @param x
+ * @param y
+ * @return {*}
+ */
+ Node.prototype.mouseEventTest = function (x, y) {
+ var elementForXpath, frameOffset, origEl;
+
+ frameOffset = this.frameOffset();
+ x -= frameOffset.left;
+ y -= frameOffset.top;
+
+ elementForXpath = origEl = document.elementFromPoint(x, y);
+ while (elementForXpath) {
+ if (elementForXpath === this.element) {
+ return {
+ status: 'success'
+ };
+ } else {
+ elementForXpath = elementForXpath.parentNode;
+ }
+ }
+
+ return {
+ status: 'failure',
+ selector: origEl && this.getSelector(origEl)
+ };
+ };
+
+ /**
+ * Returns the node selector in CSS style (NO xpath)
+ * @param elementForXpath
+ * @return {string}
+ */
+ Node.prototype.getSelector = function (elementForXpath) {
+ var className, selector, i, len, classNames;
+
+ selector = elementForXpath.tagName !== 'HTML' ? this.getSelector(elementForXpath.parentNode) + ' ' : '';
+ selector += elementForXpath.tagName.toLowerCase();
+
+ if (elementForXpath.id) {
+ selector += "#" + elementForXpath.id;
+ }
+
+ classNames = elementForXpath.classList;
+ for (i = 0, len = classNames.length; i < len; i++) {
+ className = classNames[i];
+ selector += "." + className;
+ }
+
+ return selector;
+ };
+
+ /**
+ * Returns the key code that represents the character
+ * @param character
+ * @return {number}
+ */
+ Node.prototype.characterToKeyCode = function (character) {
+ var code, specialKeys;
+ code = character.toUpperCase().charCodeAt(0);
+ specialKeys = {
+ 96: 192,
+ 45: 189,
+ 61: 187,
+ 91: 219,
+ 93: 221,
+ 92: 220,
+ 59: 186,
+ 39: 222,
+ 44: 188,
+ 46: 190,
+ 47: 191,
+ 127: 46,
+ 126: 192,
+ 33: 49,
+ 64: 50,
+ 35: 51,
+ 36: 52,
+ 37: 53,
+ 94: 54,
+ 38: 55,
+ 42: 56,
+ 40: 57,
+ 41: 48,
+ 95: 189,
+ 43: 187,
+ 123: 219,
+ 125: 221,
+ 124: 220,
+ 58: 186,
+ 34: 222,
+ 60: 188,
+ 62: 190,
+ 63: 191
+ };
+ return specialKeys[code] || code;
+ };
+
+ /**
+ * Checks if one element is equal to other given by its node id
+ * @param other_id
+ * @return {boolean}
+ */
+ Node.prototype.isDOMEqual = function (other_id) {
+ return this.element === this.agent.get(other_id).element;
+ };
+
+ /**
+ * The following function allows one to pass an element and an XML document to find a unique string XPath expression leading back to that element.
+ * @param element
+ * @return {string}
+ */
+ Node.prototype.getXPathForElement = function (element) {
+ var elementForXpath = element || this.element;
+ var xpath = '';
+ var pos, tempitem2;
+
+ while (elementForXpath !== document.documentElement) {
+ pos = 0;
+ tempitem2 = elementForXpath;
+ while (tempitem2) {
+ if (tempitem2.nodeType === 1 && tempitem2.nodeName === elementForXpath.nodeName) { // If it is ELEMENT_NODE of the same name
+ pos += 1;
+ }
+ tempitem2 = tempitem2.previousSibling;
+ }
+
+ xpath = "*[name()='" + elementForXpath.nodeName + "' and namespace-uri()='" + (elementForXpath.namespaceURI === null ? '' : elementForXpath.namespaceURI) + "'][" + pos + ']' + '/' + xpath;
+
+ elementForXpath = elementForXpath.parentNode;
+ }
+
+ xpath = '/*' + "[name()='" + document.documentElement.nodeName + "' and namespace-uri()='" + (elementForXpath.namespaceURI === null ? '' : elementForXpath.namespaceURI) + "']" + '/' + xpath;
+ xpath = xpath.replace(/\/$/, '');
+ return xpath;
+ };
+
+ /**
+ * Deselect all the options for this element
+ */
+ Node.prototype.deselectAllOptions = function () {
+ //TODO: error control when the node is not a select node
+ var i, l = this.element.options.length;
+ for (i = 0; i < l; i++) {
+ this.element.options[i].selected = false;
+ }
+ };
+
+ return Node;
+
+})();
+
+window.__poltergeist = new PoltergeistAgent;
+
+document.addEventListener('DOMContentLoaded', function () {
+ return console.log('__DOMContentLoaded');
+});
+
+window.confirm = function (message) {
+ return true;
+};
+
+window.prompt = function (message, _default) {
+ return _default || null;
+};
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/browser.js b/vendor/jcalderonzumba/gastonjs/src/Client/browser.js
new file mode 100644
index 0000000000000000000000000000000000000000..df667fbac76f5918333b26acafbdf3b3bae5c74d
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/browser.js
@@ -0,0 +1,1293 @@
+var __indexOf = [].indexOf || function (item) {
+ for (var i = 0, l = this.length; i < l; i++) {
+ if (i in this && this[i] === item) return i;
+ }
+ return -1;
+ };
+
+var xpathStringLiteral = function (s) {
+ if (s.indexOf('"') === -1)
+ return '"' + s + '"';
+ if (s.indexOf("'") === -1)
+ return "'" + s + "'";
+ return 'concat("' + s.replace(/"/g, '",\'"\',"') + '")';
+};
+
+Poltergeist.Browser = (function () {
+ /**
+ * Creates the "browser" inside phantomjs
+ * @param owner
+ * @param width
+ * @param height
+ * @constructor
+ */
+ function Browser(owner, width, height) {
+ this.owner = owner;
+ this.width = width || 1024;
+ this.height = height || 768;
+ this.pages = [];
+ this.js_errors = true;
+ this._debug = false;
+ this._counter = 0;
+ this.resetPage();
+ }
+
+ /**
+ * Resets the browser to a clean slate
+ * @return {Function}
+ */
+ Browser.prototype.resetPage = function () {
+ var _ref;
+ var self = this;
+
+ _ref = [0, []];
+ this._counter = _ref[0];
+ this.pages = _ref[1];
+
+ if (this.page != null) {
+ if (!this.page.closed) {
+ if (this.page.currentUrl() !== 'about:blank') {
+ this.page.clearLocalStorage();
+ }
+ this.page.release();
+ }
+ phantom.clearCookies();
+ }
+
+ this.page = this.currentPage = new Poltergeist.WebPage;
+ this.page.setViewportSize({
+ width: this.width,
+ height: this.height
+ });
+ this.page.handle = "" + (this._counter++);
+ this.pages.push(this.page);
+
+ return this.page.onPageCreated = function (newPage) {
+ var page;
+ page = new Poltergeist.WebPage(newPage);
+ page.handle = "" + (self._counter++);
+ return self.pages.push(page);
+ };
+ };
+
+ /**
+ * Given a page handle id, tries to get it from the browser page list
+ * @param handle
+ * @return {WebPage}
+ */
+ Browser.prototype.getPageByHandle = function (handle) {
+ var filteredPages;
+
+ //TODO: perhaps we should throw a PageNotFoundByHandle or something like that..
+ if (handle === null || typeof handle == "undefined") {
+ return null;
+ }
+
+ filteredPages = this.pages.filter(function (p) {
+ return !p.closed && p.handle === handle;
+ });
+
+ if (filteredPages.length === 1) {
+ return filteredPages[0];
+ }
+
+ return null;
+ };
+
+ /**
+ * Sends a debug message to the console
+ * @param message
+ * @return {*}
+ */
+ Browser.prototype.debug = function (message) {
+ if (this._debug) {
+ return console.log("poltergeist [" + (new Date().getTime()) + "] " + message);
+ }
+ };
+
+ /**
+ * Given a page_id and id, gets if possible the node in such page
+ * @param page_id
+ * @param id
+ * @return {Poltergeist.Node}
+ */
+ Browser.prototype.node = function (page_id, id) {
+ if (this.currentPage.id === page_id) {
+ return this.currentPage.get(id);
+ } else {
+ throw new Poltergeist.ObsoleteNode;
+ }
+ };
+
+ /**
+ * Returns the frameUrl related to the frame given by name
+ * @param frame_name
+ * @return {*}
+ */
+ Browser.prototype.frameUrl = function (frame_name) {
+ return this.currentPage.frameUrl(frame_name);
+ };
+
+ /**
+ * This method defines the rectangular area of the web page to be rasterized when render is invoked.
+ * If no clipping rectangle is set, render will process the entire web page.
+ * @param full
+ * @param selector
+ * @return {*}
+ */
+ Browser.prototype.set_clip_rect = function (full, selector) {
+ var dimensions, clipDocument, rect, clipViewport;
+
+ dimensions = this.currentPage.validatedDimensions();
+ clipDocument = dimensions.document;
+ clipViewport = dimensions.viewport;
+
+ if (full) {
+ rect = {
+ left: 0,
+ top: 0,
+ width: clipDocument.width,
+ height: clipDocument.height
+ };
+ } else {
+ if (selector != null) {
+ rect = this.currentPage.elementBounds(selector);
+ } else {
+ rect = {
+ left: 0,
+ top: 0,
+ width: clipViewport.width,
+ height: clipViewport.height
+ };
+ }
+ }
+
+ this.currentPage.setClipRect(rect);
+ return dimensions;
+ };
+
+ /**
+ * Kill the browser, i.e kill phantomjs current process
+ * @return {int}
+ */
+ Browser.prototype.exit = function () {
+ return phantom.exit(0);
+ };
+
+ /**
+ * Do nothing
+ */
+ Browser.prototype.noop = function () {
+ };
+
+ /**
+ * Throws a new Object error
+ */
+ Browser.prototype.browser_error = function () {
+ throw new Error('zomg');
+ };
+
+ /**
+ * Visits a page and load its content
+ * @param serverResponse
+ * @param url
+ * @return {*}
+ */
+ Browser.prototype.visit = function (serverResponse, url) {
+ var prevUrl;
+ var self = this;
+ this.currentPage.state = 'loading';
+ prevUrl = this.currentPage.source === null ? 'about:blank' : this.currentPage.currentUrl();
+ this.currentPage.open(url);
+ if (/#/.test(url) && prevUrl.split('#')[0] === url.split('#')[0]) {
+ this.currentPage.state = 'default';
+ return this.serverSendResponse({
+ status: 'success'
+ }, serverResponse);
+ } else {
+ return this.currentPage.waitState('default', function () {
+ if (self.currentPage.statusCode === null && self.currentPage.status === 'fail') {
+ return self.owner.serverSendError(new Poltergeist.StatusFailError, serverResponse);
+ } else {
+ return self.serverSendResponse({
+ status: self.currentPage.status
+ }, serverResponse);
+ }
+ });
+ }
+ };
+
+ /**
+ * Puts the control of the browser inside the IFRAME given by name
+ * @param serverResponse
+ * @param name
+ * @param timeout
+ * @return {*}
+ */
+ Browser.prototype.push_frame = function (serverResponse, name, timeout) {
+ var _ref;
+ var self = this;
+
+ if (timeout == null) {
+ timeout = new Date().getTime() + 2000;
+ }
+
+ //TODO: WTF, else if after a if with return COMMON
+ if (_ref = this.frameUrl(name), __indexOf.call(this.currentPage.blockedUrls(), _ref) >= 0) {
+ return this.serverSendResponse(true, serverResponse);
+ } else if (this.currentPage.pushFrame(name)) {
+ if (this.currentPage.currentUrl() === 'about:blank') {
+ this.currentPage.state = 'awaiting_frame_load';
+ return this.currentPage.waitState('default', function () {
+ return self.serverSendResponse(true, serverResponse);
+ });
+ } else {
+ return this.serverSendResponse(true, serverResponse);
+ }
+ } else {
+ if (new Date().getTime() < timeout) {
+ return setTimeout((function () {
+ return self.push_frame(serverResponse, name, timeout);
+ }), 50);
+ } else {
+ return this.owner.serverSendError(new Poltergeist.FrameNotFound(name), serverResponse);
+ }
+ }
+ };
+
+ /**
+ * Injects a javascript into the current page
+ * @param serverResponse
+ * @param extension
+ * @return {*}
+ */
+ Browser.prototype.add_extension = function (serverResponse, extension) {
+ //TODO: error control when the injection was not possible
+ this.currentPage.injectExtension(extension);
+ return this.serverSendResponse('success', serverResponse);
+ };
+
+ /**
+ * Returns the url we are currently in
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.current_url = function (serverResponse) {
+ return this.serverSendResponse(this.currentPage.currentUrl(), serverResponse);
+ };
+
+ /**
+ * Returns the current page window name
+ * @param serverResponse
+ * @returns {*}
+ */
+ Browser.prototype.window_name = function (serverResponse) {
+ return this.serverSendResponse(this.currentPage.windowName(), serverResponse);
+ };
+
+ /**
+ * Returns the status code associated to the page
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.status_code = function (serverResponse) {
+ if (this.currentPage.statusCode === undefined || this.currentPage.statusCode === null) {
+ return this.owner.serverSendError(new Poltergeist.StatusFailError("status_code_error"), serverResponse);
+ }
+ return this.serverSendResponse(this.currentPage.statusCode, serverResponse);
+ };
+
+ /**
+ * Returns the source code of the active frame, useful for when inside an IFRAME
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.body = function (serverResponse) {
+ return this.serverSendResponse(this.currentPage.content(), serverResponse);
+ };
+
+ /**
+ * Returns the source code of the page all the html
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.source = function (serverResponse) {
+ return this.serverSendResponse(this.currentPage.source, serverResponse);
+ };
+
+ /**
+ * Returns the current page title
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.title = function (serverResponse) {
+ return this.serverSendResponse(this.currentPage.title(), serverResponse);
+ };
+
+ /**
+ * Finds the elements that match a method of selection and a selector
+ * @param serverResponse
+ * @param method
+ * @param selector
+ * @return {*}
+ */
+ Browser.prototype.find = function (serverResponse, method, selector) {
+ return this.serverSendResponse({
+ page_id: this.currentPage.id,
+ ids: this.currentPage.find(method, selector)
+ }, serverResponse);
+ };
+
+ /**
+ * Find elements within a given element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param method
+ * @param selector
+ * @return {*}
+ */
+ Browser.prototype.find_within = function (serverResponse, page_id, id, method, selector) {
+ return this.serverSendResponse(this.node(page_id, id).find(method, selector), serverResponse);
+ };
+
+ /**
+ * Returns ALL the text, visible and not visible from the given element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.all_text = function (serverResponse, page_id, id) {
+ return this.serverSendResponse(this.node(page_id, id).allText(), serverResponse);
+ };
+
+ /**
+ * Returns the inner or outer html of a given id
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param type
+ * @returns Object
+ */
+ Browser.prototype.all_html = function (serverResponse, page_id, id, type) {
+ return this.serverSendResponse(this.node(page_id, id).allHTML(type), serverResponse);
+ };
+
+ /**
+ * Returns only the visible text in a given element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.visible_text = function (serverResponse, page_id, id) {
+ return this.serverSendResponse(this.node(page_id, id).visibleText(), serverResponse);
+ };
+
+ /**
+ * Deletes the text in a given element leaving it empty
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.delete_text = function (serverResponse, page_id, id) {
+ return this.serverSendResponse(this.node(page_id, id).deleteText(), serverResponse);
+ };
+
+ /**
+ * Gets the value of a given attribute in an element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param name
+ * @return {*}
+ */
+ Browser.prototype.attribute = function (serverResponse, page_id, id, name) {
+ return this.serverSendResponse(this.node(page_id, id).getAttribute(name), serverResponse);
+ };
+
+ /**
+ * Allows the possibility to set an attribute on a given element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param name
+ * @param value
+ * @returns {*}
+ */
+ Browser.prototype.set_attribute = function (serverResponse, page_id, id, name, value) {
+ return this.serverSendResponse(this.node(page_id, id).setAttribute(name, value), serverResponse);
+ };
+
+ /**
+ * Allows the possibility to remove an attribute on a given element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param name
+ * @returns {*}
+ */
+ Browser.prototype.remove_attribute = function (serverResponse, page_id, id, name) {
+ return this.serverSendResponse(this.node(page_id, id).removeAttribute(name), serverResponse);
+ };
+
+ /**
+ * Returns all the attributes of a given element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param name
+ * @return {*}
+ */
+ Browser.prototype.attributes = function (serverResponse, page_id, id, name) {
+ return this.serverSendResponse(this.node(page_id, id).getAttributes(), serverResponse);
+ };
+
+ /**
+ * Returns all the way to the document level the parents of a given element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.parents = function (serverResponse, page_id, id) {
+ return this.serverSendResponse(this.node(page_id, id).parentIds(), serverResponse);
+ };
+
+ /**
+ * Returns the element.value of an element given by its page and id
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.value = function (serverResponse, page_id, id) {
+ return this.serverSendResponse(this.node(page_id, id).value(), serverResponse);
+ };
+
+ /**
+ * Sets the element.value of an element by the given value
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param value
+ * @return {*}
+ */
+ Browser.prototype.set = function (serverResponse, page_id, id, value) {
+ this.node(page_id, id).set(value);
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Uploads a file to an input file element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param file_path
+ * @return {*}
+ */
+ Browser.prototype.select_file = function (serverResponse, page_id, id, file_path) {
+ var node = this.node(page_id, id);
+
+ this.currentPage.beforeUpload(node.id);
+ this.currentPage.uploadFile('[_poltergeist_selected]', file_path);
+ this.currentPage.afterUpload(node.id);
+
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Sets a value to the selected element (to be used in select elements)
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param value
+ * @return {*}
+ */
+ Browser.prototype.select = function (serverResponse, page_id, id, value) {
+ return this.serverSendResponse(this.node(page_id, id).select(value), serverResponse);
+ };
+
+ /**
+ * Selects an option with the given value
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param value
+ * @param multiple
+ * @return {*}
+ */
+ Browser.prototype.select_option = function (serverResponse, page_id, id, value, multiple) {
+ return this.serverSendResponse(this.node(page_id, id).select_option(value, multiple), serverResponse);
+ };
+
+ /**
+ *
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.tag_name = function (serverResponse, page_id, id) {
+ return this.serverSendResponse(this.node(page_id, id).tagName(), serverResponse);
+ };
+
+
+ /**
+ * Tells if an element is visible or not
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.visible = function (serverResponse, page_id, id) {
+ return this.serverSendResponse(this.node(page_id, id).isVisible(), serverResponse);
+ };
+
+ /**
+ * Tells if an element is disabled
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.disabled = function (serverResponse, page_id, id) {
+ return this.serverSendResponse(this.node(page_id, id).isDisabled(), serverResponse);
+ };
+
+ /**
+ * Evaluates a javascript and returns the outcome to the client
+ * This will be JSON response so your script better be returning objects that can be used
+ * in JSON.stringify
+ * @param serverResponse
+ * @param script
+ * @return {*}
+ */
+ Browser.prototype.evaluate = function (serverResponse, script) {
+ return this.serverSendResponse(this.currentPage.evaluate("function() { return " + script + " }"), serverResponse);
+ };
+
+ /**
+ * Executes a javascript and goes back to the client with true if there were no errors
+ * @param serverResponse
+ * @param script
+ * @return {*}
+ */
+ Browser.prototype.execute = function (serverResponse, script) {
+ this.currentPage.execute("function() { " + script + " }");
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * If inside a frame then we will go back to the parent
+ * Not defined behaviour if you pop and are not inside an iframe
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.pop_frame = function (serverResponse) {
+ return this.serverSendResponse(this.currentPage.popFrame(), serverResponse);
+ };
+
+ /**
+ * Gets the window handle id by a given window name
+ * @param serverResponse
+ * @param name
+ * @return {*}
+ */
+ Browser.prototype.window_handle = function (serverResponse, name) {
+ var handle, pageByWindowName;
+
+ if (name === null || typeof name == "undefined" || name.length === 0) {
+ return this.serverSendResponse(this.currentPage.handle, serverResponse);
+ }
+
+ handle = null;
+
+ //Lets search the handle by the given window name
+ var filteredPages = this.pages.filter(function (p) {
+ return !p.closed && p.windowName() === name;
+ });
+
+ //A bit of error control is always good
+ if (Array.isArray(filteredPages) && filteredPages.length >= 1) {
+ pageByWindowName = filteredPages[0];
+ } else {
+ pageByWindowName = null;
+ }
+
+ if (pageByWindowName !== null && typeof pageByWindowName != "undefined") {
+ handle = pageByWindowName.handle;
+ }
+
+ return this.serverSendResponse(handle, serverResponse);
+ };
+
+ /**
+ * Returns all the window handles of opened windows
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.window_handles = function (serverResponse) {
+ var handles, filteredPages;
+
+ filteredPages = this.pages.filter(function (p) {
+ return !p.closed;
+ });
+
+ if (filteredPages.length > 0) {
+ handles = filteredPages.map(function (p) {
+ return p.handle;
+ });
+ if (handles.length === 0) {
+ handles = null;
+ }
+ } else {
+ handles = null;
+ }
+
+ return this.serverSendResponse(handles, serverResponse);
+ };
+
+ /**
+ * Tries to switch to a window given by the handle id
+ * @param serverResponse
+ * @param handle
+ * @return {*}
+ */
+ Browser.prototype.switch_to_window = function (serverResponse, handle) {
+ var page;
+ var self = this;
+
+ page = this.getPageByHandle(handle);
+ if (page === null || typeof page == "undefined") {
+ throw new Poltergeist.NoSuchWindowError;
+ }
+
+ if (page !== this.currentPage) {
+ return page.waitState('default', function () {
+ self.currentPage = page;
+ return self.serverSendResponse(true, serverResponse);
+ });
+ }
+
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Opens a new window where we can do stuff
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.open_new_window = function (serverResponse) {
+ return this.execute(serverResponse, 'window.open()');
+ };
+
+ /**
+ * Closes the window given by handle name if possible
+ * @param serverResponse
+ * @param handle
+ * @return {*}
+ */
+ Browser.prototype.close_window = function (serverResponse, handle) {
+ var page;
+
+ page = this.getPageByHandle(handle);
+ if (page === null || typeof page == "undefined") {
+ //TODO: should we throw error since we actually could not find the window?
+ return this.serverSendResponse(false, serverResponse);
+ }
+
+ //TODO: we have to add some control here to actually asses that the release has been done
+ page.release();
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Generic mouse event on an element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param name
+ * @return {number}
+ */
+ Browser.prototype.mouse_event = function (serverResponse, page_id, id, name) {
+ var node;
+ var self = this;
+ node = this.node(page_id, id);
+ this.currentPage.state = 'mouse_event';
+ this.last_mouse_event = node.mouseEvent(name);
+ return setTimeout(function () {
+ if (self.currentPage.state === 'mouse_event') {
+ self.currentPage.state = 'default';
+ return self.serverSendResponse({
+ position: self.last_mouse_event
+ }, serverResponse);
+ } else {
+ return self.currentPage.waitState('default', function () {
+ return self.serverSendResponse({
+ position: self.last_mouse_event
+ }, serverResponse);
+ });
+ }
+ }, 5);
+ };
+
+ /**
+ * Simple click on the element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.click = function (serverResponse, page_id, id) {
+ return this.mouse_event(serverResponse, page_id, id, 'click');
+ };
+
+ /**
+ * Right click on the element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.right_click = function (serverResponse, page_id, id) {
+ return this.mouse_event(serverResponse, page_id, id, 'rightclick');
+ };
+
+ /**
+ * Double click on the element given by page and id
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.double_click = function (serverResponse, page_id, id) {
+ return this.mouse_event(serverResponse, page_id, id, 'doubleclick');
+ };
+
+ /**
+ * Executes a mousemove event on the page and given element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @return {*}
+ */
+ Browser.prototype.hover = function (serverResponse, page_id, id) {
+ return this.mouse_event(serverResponse, page_id, id, 'mousemove');
+ };
+
+ /**
+ * Triggers a mouse click event on the given coordinates
+ * @param serverResponse
+ * @param x
+ * @param y
+ * @return {*}
+ */
+ Browser.prototype.click_coordinates = function (serverResponse, x, y) {
+ var response;
+
+ this.currentPage.sendEvent('click', x, y);
+ response = {
+ click: {
+ x: x,
+ y: y
+ }
+ };
+
+ return this.serverSendResponse(response, serverResponse);
+ };
+
+ /**
+ * Drags one element into another, useful for nice javascript thingies
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param other_id
+ * @return {*}
+ */
+ Browser.prototype.drag = function (serverResponse, page_id, id, other_id) {
+ this.node(page_id, id).dragTo(this.node(page_id, other_id));
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Triggers an event on the given page and element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param event
+ * @return {*}
+ */
+ Browser.prototype.trigger = function (serverResponse, page_id, id, event) {
+ this.node(page_id, id).trigger(event);
+ return this.serverSendResponse(event, serverResponse);
+ };
+
+ /**
+ * Checks if two elements are equal on a dom level
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param other_id
+ * @return {*}
+ */
+ Browser.prototype.equals = function (serverResponse, page_id, id, other_id) {
+ return this.serverSendResponse(this.node(page_id, id).isEqual(this.node(page_id, other_id)), serverResponse);
+ };
+
+ /**
+ * Resets the current page to a clean slate
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.reset = function (serverResponse) {
+ this.resetPage();
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Scrolls to a position given by the left, top coordinates
+ * @param serverResponse
+ * @param left
+ * @param top
+ * @return {*}
+ */
+ Browser.prototype.scroll_to = function (serverResponse, left, top) {
+ this.currentPage.setScrollPosition({
+ left: left,
+ top: top
+ });
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Sends keys to an element simulating as closest as possible what a user would do
+ * when typing
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param keys
+ * @return {*}
+ */
+ Browser.prototype.send_keys = function (serverResponse, page_id, id, keys) {
+ var key, sequence, target, _i, _len;
+ target = this.node(page_id, id);
+ if (!target.containsSelection()) {
+ target.mouseEvent('click');
+ }
+ for (_i = 0, _len = keys.length; _i < _len; _i++) {
+ sequence = keys[_i];
+ key = sequence.key != null ? this.currentPage.keyCode(sequence.key) : sequence;
+ this.currentPage.sendEvent('keypress', key);
+ }
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Sends a native phantomjs key event to element
+ * @param serverResponse
+ * @param page_id
+ * @param id
+ * @param keyEvent
+ * @param key
+ * @param modifier
+ */
+ Browser.prototype.key_event = function (serverResponse, page_id, id, keyEvent, key, modifier) {
+ var keyEventModifierMap;
+ var keyEventModifier;
+ var target;
+
+ keyEventModifierMap = {
+ 'none': 0x0,
+ 'shift': 0x02000000,
+ 'ctrl': 0x04000000,
+ 'alt': 0x08000000,
+ 'meta': 0x10000000
+ };
+ keyEventModifier = keyEventModifierMap[modifier];
+
+ target = this.node(page_id, id);
+ if (!target.containsSelection()) {
+ target.mouseEvent('click');
+ }
+ target.page.sendEvent(keyEvent, key, null, null, keyEventModifier);
+
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Sends the rendered page in a base64 encoding
+ * @param serverResponse
+ * @param format
+ * @param full
+ * @param selector
+ * @return {*}
+ */
+ Browser.prototype.render_base64 = function (serverResponse, format, full, selector) {
+ var encoded_image;
+ if (selector == null) {
+ selector = null;
+ }
+ this.set_clip_rect(full, selector);
+ encoded_image = this.currentPage.renderBase64(format);
+ return this.serverSendResponse(encoded_image, serverResponse);
+ };
+
+ /**
+ * Renders the current page entirely or a given selection
+ * @param serverResponse
+ * @param path
+ * @param full
+ * @param selector
+ * @return {*}
+ */
+ Browser.prototype.render = function (serverResponse, path, full, selector) {
+ var dimensions;
+ if (selector == null) {
+ selector = null;
+ }
+ dimensions = this.set_clip_rect(full, selector);
+ this.currentPage.setScrollPosition({
+ left: 0,
+ top: 0
+ });
+ this.currentPage.render(path);
+ this.currentPage.setScrollPosition({
+ left: dimensions.left,
+ top: dimensions.top
+ });
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+
+ /**
+ * Sets the paper size, useful when printing to PDF
+ * @param serverResponse
+ * @param size
+ * @return {*}
+ */
+ Browser.prototype.set_paper_size = function (serverResponse, size) {
+ this.currentPage.setPaperSize(size);
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Sets the zoom factor on the current page
+ * @param serverResponse
+ * @param zoom_factor
+ * @return {*}
+ */
+ Browser.prototype.set_zoom_factor = function (serverResponse, zoom_factor) {
+ this.currentPage.setZoomFactor(zoom_factor);
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Resizes the browser viewport, useful when testing mobile stuff
+ * @param serverResponse
+ * @param width
+ * @param height
+ * @return {*}
+ */
+ Browser.prototype.resize = function (serverResponse, width, height) {
+ this.currentPage.setViewportSize({
+ width: width,
+ height: height
+ });
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Gets the browser viewport size
+ * Because PhantomJS is headless (nothing is shown)
+ * viewportSize effectively simulates the size of the window like in a traditional browser.
+ * @param serverResponse
+ * @param handle
+ * @return {*}
+ */
+ Browser.prototype.window_size = function (serverResponse, handle) {
+ //TODO: add support for window handles
+ return this.serverSendResponse(this.currentPage.viewportSize(), serverResponse);
+ };
+
+ /**
+ * Returns the network traffic that the current page has generated
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.network_traffic = function (serverResponse) {
+ return this.serverSendResponse(this.currentPage.networkTraffic(), serverResponse);
+ };
+
+ /**
+ * Clears the accumulated network_traffic in the current page
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.clear_network_traffic = function (serverResponse) {
+ this.currentPage.clearNetworkTraffic();
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Gets the headers of the current page
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.get_headers = function (serverResponse) {
+ return this.serverSendResponse(this.currentPage.getCustomHeaders(), serverResponse);
+ };
+
+ /**
+ * Set headers in the browser
+ * @param serverResponse
+ * @param headers
+ * @return {*}
+ */
+ Browser.prototype.set_headers = function (serverResponse, headers) {
+ if (headers['User-Agent']) {
+ this.currentPage.setUserAgent(headers['User-Agent']);
+ }
+ this.currentPage.setCustomHeaders(headers);
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Given an array of headers, adds them to the page
+ * @param serverResponse
+ * @param headers
+ * @return {*}
+ */
+ Browser.prototype.add_headers = function (serverResponse, headers) {
+ var allHeaders, name, value;
+ allHeaders = this.currentPage.getCustomHeaders();
+ for (name in headers) {
+ if (headers.hasOwnProperty(name)) {
+ value = headers[name];
+ allHeaders[name] = value;
+ }
+ }
+ return this.set_headers(serverResponse, allHeaders);
+ };
+
+ /**
+ * Adds a header to the page temporary or permanently
+ * @param serverResponse
+ * @param header
+ * @param permanent
+ * @return {*}
+ */
+ Browser.prototype.add_header = function (serverResponse, header, permanent) {
+ if (!permanent) {
+ this.currentPage.addTempHeader(header);
+ }
+ return this.add_headers(serverResponse, header);
+ };
+
+
+ /**
+ * Sends back the client the response headers sent from the browser when making
+ * the page request
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.response_headers = function (serverResponse) {
+ return this.serverSendResponse(this.currentPage.responseHeaders(), serverResponse);
+ };
+
+ /**
+ * Returns the cookies of the current page being browsed
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.cookies = function (serverResponse) {
+ return this.serverSendResponse(this.currentPage.cookies(), serverResponse);
+ };
+
+ /**
+ * Sets a cookie in the browser, the format of the cookies has to be the format it says
+ * on phantomjs documentation and as such you can set it in other domains, not on the
+ * current page
+ * @param serverResponse
+ * @param cookie
+ * @return {*}
+ */
+ Browser.prototype.set_cookie = function (serverResponse, cookie) {
+ return this.serverSendResponse(phantom.addCookie(cookie), serverResponse);
+ };
+
+ /**
+ * Remove a cookie set on the current page
+ * @param serverResponse
+ * @param name
+ * @return {*}
+ */
+ Browser.prototype.remove_cookie = function (serverResponse, name) {
+ //TODO: add error control to check if the cookie was properly deleted
+ this.currentPage.deleteCookie(name);
+ phantom.deleteCookie(name);
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Clear the cookies in the browser
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.clear_cookies = function (serverResponse) {
+ phantom.clearCookies();
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Enables / Disables the cookies on the browser
+ * @param serverResponse
+ * @param flag
+ * @return {*}
+ */
+ Browser.prototype.cookies_enabled = function (serverResponse, flag) {
+ phantom.cookiesEnabled = flag;
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * US19: DONE
+ * Sets a basic authentication credential to access a page
+ * THIS SHOULD BE USED BEFORE accessing a page
+ * @param serverResponse
+ * @param user
+ * @param password
+ * @return {*}
+ */
+ Browser.prototype.set_http_auth = function (serverResponse, user, password) {
+ this.currentPage.setHttpAuth(user, password);
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Sets the flag whether to fail on javascript errors or not.
+ * @param serverResponse
+ * @param value
+ * @return {*}
+ */
+ Browser.prototype.set_js_errors = function (serverResponse, value) {
+ this.js_errors = value;
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Sets the debug mode to boolean value
+ * @param serverResponse
+ * @param value
+ * @return {*}
+ */
+ Browser.prototype.set_debug = function (serverResponse, value) {
+ this._debug = value;
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Goes back in the history when possible
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.go_back = function (serverResponse) {
+ var self = this;
+ if (this.currentPage.canGoBack()) {
+ this.currentPage.state = 'loading';
+ this.currentPage.goBack();
+ return this.currentPage.waitState('default', function () {
+ return self.serverSendResponse(true, serverResponse);
+ });
+ } else {
+ return this.serverSendResponse(false, serverResponse);
+ }
+ };
+
+ /**
+ * Reloads the page if possible
+ * @return {*}
+ */
+ Browser.prototype.reload = function (serverResponse) {
+ var self = this;
+ this.currentPage.state = 'loading';
+ this.currentPage.reload();
+ return this.currentPage.waitState('default', function () {
+ return self.serverSendResponse(true, serverResponse);
+ });
+ };
+
+ /**
+ * Goes forward in the browser history if possible
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.go_forward = function (serverResponse) {
+ var self = this;
+ if (this.currentPage.canGoForward()) {
+ this.currentPage.state = 'loading';
+ this.currentPage.goForward();
+ return this.currentPage.waitState('default', function () {
+ return self.serverSendResponse(true, serverResponse);
+ });
+ } else {
+ return this.serverSendResponse(false, serverResponse);
+ }
+ };
+
+ /**
+ * Sets the urlBlacklist for the given urls as parameters
+ * @return {boolean}
+ */
+ Browser.prototype.set_url_blacklist = function (serverResponse, blackList) {
+ this.currentPage.urlBlacklist = Array.prototype.slice.call(blackList);
+ return this.serverSendResponse(true, serverResponse);
+ };
+
+ /**
+ * Runs a browser command and returns the response back to the client
+ * when the command has finished the execution
+ * @param command
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.serverRunCommand = function (command, serverResponse) {
+ var commandData;
+ var commandArgs;
+ var commandName;
+
+ commandName = command.name;
+ commandArgs = command.args;
+ this.currentPage.state = 'default';
+ commandData = [serverResponse].concat(commandArgs);
+
+ if (typeof this[commandName] !== "function") {
+ //We can not run such command
+ throw new Poltergeist.Error();
+ }
+
+ return this[commandName].apply(this, commandData);
+ };
+
+ /**
+ * Sends a response back to the client who made the request
+ * @param response
+ * @param serverResponse
+ * @return {*}
+ */
+ Browser.prototype.serverSendResponse = function (response, serverResponse) {
+ var errors;
+ errors = this.currentPage.errors;
+ this.currentPage.clearErrors();
+ if (errors.length > 0 && this.js_errors) {
+ return this.owner.serverSendError(new Poltergeist.JavascriptError(errors), serverResponse);
+ } else {
+ return this.owner.serverSendResponse(response, serverResponse);
+ }
+ };
+
+ return Browser;
+
+})();
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/main.js b/vendor/jcalderonzumba/gastonjs/src/Client/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..a8f2ecb6deaa9313483c545140f97475b0fdd193
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/main.js
@@ -0,0 +1,29 @@
+var Poltergeist, system, _ref, _ref1, _ref2;
+
+//Inheritance tool
+phantom.injectJs("" + phantom.libraryPath + "/Tools/inherit.js");
+
+//Poltergeist main object
+phantom.injectJs("" + phantom.libraryPath + "/poltergeist.js");
+
+//Errors that are controller in the poltergeist code
+phantom.injectJs("" + phantom.libraryPath + "/Errors/error.js");
+phantom.injectJs("" + phantom.libraryPath + "/Errors/obsolete_node.js");
+phantom.injectJs("" + phantom.libraryPath + "/Errors/invalid_selector.js");
+phantom.injectJs("" + phantom.libraryPath + "/Errors/frame_not_found.js");
+phantom.injectJs("" + phantom.libraryPath + "/Errors/mouse_event_failed.js");
+phantom.injectJs("" + phantom.libraryPath + "/Errors/javascript_error.js");
+phantom.injectJs("" + phantom.libraryPath + "/Errors/browser_error.js");
+phantom.injectJs("" + phantom.libraryPath + "/Errors/status_fail_error.js");
+phantom.injectJs("" + phantom.libraryPath + "/Errors/no_such_window_error.js");
+
+//web server to control the commands
+phantom.injectJs("" + phantom.libraryPath + "/Server/server.js");
+
+phantom.injectJs("" + phantom.libraryPath + "/web_page.js");
+phantom.injectJs("" + phantom.libraryPath + "/node.js");
+phantom.injectJs("" + phantom.libraryPath + "/browser.js");
+
+system = require('system');
+
+new Poltergeist(system.args[1], system.args[2], system.args[3]);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/node.js b/vendor/jcalderonzumba/gastonjs/src/Client/node.js
new file mode 100644
index 0000000000000000000000000000000000000000..bdf5baf23cd138ee6cdba58d64855eb2c0266889
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/node.js
@@ -0,0 +1,161 @@
+var __slice = [].slice;
+
+Poltergeist.Node = (function () {
+ var name, _fn, _i, _len, _ref;
+ var xpathStringLiteral;
+
+ Node.DELEGATES = ['allText', 'visibleText', 'getAttribute', 'value', 'set', 'checked',
+ 'setAttribute', 'isObsolete', 'removeAttribute', 'isMultiple',
+ 'select', 'tagName', 'find', 'getAttributes', 'isVisible',
+ 'position', 'trigger', 'input', 'parentId', 'parentIds', 'mouseEventTest',
+ 'scrollIntoView', 'isDOMEqual', 'isDisabled', 'deleteText', 'selectRadioValue',
+ 'containsSelection', 'allHTML', 'changed', 'getXPathForElement', 'deselectAllOptions'];
+
+ function Node(page, id) {
+ this.page = page;
+ this.id = id;
+ }
+
+ /**
+ * Returns the parent Node of this Node
+ * @return {Poltergeist.Node}
+ */
+ Node.prototype.parent = function () {
+ return new Poltergeist.Node(this.page, this.parentId());
+ };
+
+ _ref = Node.DELEGATES;
+
+ _fn = function (name) {
+ return Node.prototype[name] = function () {
+ var args = [];
+ if (arguments.length >= 1) {
+ args = __slice.call(arguments, 0)
+ }
+ return this.page.nodeCall(this.id, name, args);
+ };
+ };
+
+ //Adding all the delegates from the agent Node to this Node
+ for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+ name = _ref[_i];
+ _fn(name);
+ }
+
+ xpathStringLiteral = function (s) {
+ if (s.indexOf('"') === -1)
+ return '"' + s + '"';
+ if (s.indexOf("'") === -1)
+ return "'" + s + "'";
+ return 'concat("' + s.replace(/"/g, '",\'"\',"') + '")';
+ };
+
+ /**
+ * Gets an x,y position tailored for mouse event actions
+ * @return {{x, y}}
+ */
+ Node.prototype.mouseEventPosition = function () {
+ var middle, pos, viewport;
+
+ viewport = this.page.viewportSize();
+ pos = this.position();
+ middle = function (start, end, size) {
+ return start + ((Math.min(end, size) - start) / 2);
+ };
+
+ return {
+ x: middle(pos.left, pos.right, viewport.width),
+ y: middle(pos.top, pos.bottom, viewport.height)
+ };
+ };
+
+ /**
+ * Executes a phantomjs native mouse event
+ * @param name
+ * @return {{x, y}}
+ */
+ Node.prototype.mouseEvent = function (name) {
+ var pos, test;
+
+ this.scrollIntoView();
+ pos = this.mouseEventPosition();
+ test = this.mouseEventTest(pos.x, pos.y);
+
+ if (test.status === 'success') {
+ if (name === 'rightclick') {
+ this.page.mouseEvent('click', pos.x, pos.y, 'right');
+ this.trigger('contextmenu');
+ } else {
+ this.page.mouseEvent(name, pos.x, pos.y);
+ }
+ return pos;
+ } else {
+ throw new Poltergeist.MouseEventFailed(name, test.selector, pos);
+ }
+ };
+
+ /**
+ * Executes a mouse based drag from one node to another
+ * @param other
+ * @return {{x, y}}
+ */
+ Node.prototype.dragTo = function (other) {
+ var otherPosition, position;
+
+ this.scrollIntoView();
+ position = this.mouseEventPosition();
+ otherPosition = other.mouseEventPosition();
+ this.page.mouseEvent('mousedown', position.x, position.y);
+ return this.page.mouseEvent('mouseup', otherPosition.x, otherPosition.y);
+ };
+
+ /**
+ * Checks if one node is equal to another
+ * @param other
+ * @return {boolean}
+ */
+ Node.prototype.isEqual = function (other) {
+ return this.page === other.page && this.isDOMEqual(other.id);
+ };
+
+
+ /**
+ * The value to select
+ * @param value
+ * @param multiple
+ */
+ Node.prototype.select_option = function (value, multiple) {
+ var tagName = this.tagName().toLowerCase();
+
+ if (tagName === "select") {
+ var escapedOption = xpathStringLiteral(value);
+ // The value of an option is the normalized version of its text when it has no value attribute
+ var optionQuery = ".//option[@value = " + escapedOption + " or (not(@value) and normalize-space(.) = " + escapedOption + ")]";
+ var ids = this.find("xpath", optionQuery);
+ var polterNode = this.page.get(ids[0]);
+
+ if (multiple || !this.getAttribute('multiple')) {
+ if (!polterNode.getAttribute('selected')) {
+ polterNode.select(value);
+ this.trigger('click');
+ this.input();
+ }
+ return true;
+ }
+
+ this.deselectAllOptions();
+ polterNode.select(value);
+ this.trigger('click');
+ this.input();
+ return true;
+ } else if (tagName === "input" && this.getAttribute("type").toLowerCase() === "radio") {
+ return this.selectRadioValue(value);
+ }
+
+ throw new Poltergeist.BrowserError("The element is not a select or radio input");
+
+ };
+
+ return Node;
+
+}).call(this);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/poltergeist.js b/vendor/jcalderonzumba/gastonjs/src/Client/poltergeist.js
new file mode 100644
index 0000000000000000000000000000000000000000..20f026769e22d49974dfc0838cd94ea458fbf36f
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/poltergeist.js
@@ -0,0 +1,77 @@
+Poltergeist = (function () {
+
+ /**
+ * The MAIN class of the project
+ * @param port
+ * @param width
+ * @param height
+ * @constructor
+ */
+ function Poltergeist(port, width, height) {
+ var self;
+ this.browser = new Poltergeist.Browser(this, width, height);
+
+ this.commandServer = new Poltergeist.Server(this, port);
+ this.commandServer.start();
+
+ self = this;
+
+ phantom.onError = function (message, stack) {
+ return self.onError(message, stack);
+ };
+
+ this.running = false;
+ }
+
+ /**
+ * Tries to execute a command send by a client and returns the command response
+ * or error if something happened
+ * @param command
+ * @param serverResponse
+ * @return {boolean}
+ */
+ Poltergeist.prototype.serverRunCommand = function (command, serverResponse) {
+ var error;
+ this.running = true;
+ try {
+ return this.browser.serverRunCommand(command, serverResponse);
+ } catch (_error) {
+ error = _error;
+ if (error instanceof Poltergeist.Error) {
+ return this.serverSendError(error, serverResponse);
+ }
+ return this.serverSendError(new Poltergeist.BrowserError(error.toString(), error.stack), serverResponse);
+ }
+ };
+
+ /**
+ * Sends error back to the client
+ * @param error
+ * @param serverResponse
+ * @return {boolean}
+ */
+ Poltergeist.prototype.serverSendError = function (error, serverResponse) {
+ var errorObject;
+ errorObject = {
+ error: {
+ name: error.name || 'Generic',
+ args: error.args && error.args() || [error.toString()]
+ }
+ };
+ return this.commandServer.sendError(serverResponse, 500, errorObject);
+ };
+
+ /**
+ * Send the response back to the client
+ * @param response Data to send to the client
+ * @param serverResponse Phantomjs response object associated to the client request
+ * @return {boolean}
+ */
+ Poltergeist.prototype.serverSendResponse = function (response, serverResponse) {
+ return this.commandServer.send(serverResponse, {response: response});
+ };
+
+ return Poltergeist;
+})();
+
+window.Poltergeist = Poltergeist;
diff --git a/vendor/jcalderonzumba/gastonjs/src/Client/web_page.js b/vendor/jcalderonzumba/gastonjs/src/Client/web_page.js
new file mode 100644
index 0000000000000000000000000000000000000000..c275b03b745833bbfe6bc545dcd77b11dfb02cbd
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Client/web_page.js
@@ -0,0 +1,829 @@
+var __slice = [].slice;
+var __indexOf = [].indexOf || function (item) {
+ for (var i = 0, l = this.length; i < l; i++) {
+ if (i in this && this[i] === item) return i;
+ }
+ return -1;
+ };
+
+Poltergeist.WebPage = (function () {
+ var command, delegate, commandFunctionBind, delegateFunctionBind, i, j, commandsLength, delegatesRefLength, commandsRef, delegatesRef,
+ _this = this;
+
+ //Native or not webpage callbacks
+ WebPage.CALLBACKS = ['onAlert', 'onConsoleMessage', 'onLoadFinished', 'onInitialized', 'onLoadStarted', 'onResourceRequested',
+ 'onResourceReceived', 'onError', 'onNavigationRequested', 'onUrlChanged', 'onPageCreated', 'onClosing'];
+
+ // Delegates the execution to the phantomjs page native functions but directly available in the WebPage object
+ WebPage.DELEGATES = ['open', 'sendEvent', 'uploadFile', 'release', 'render', 'renderBase64', 'goBack', 'goForward', 'reload'];
+
+ //Commands to execute on behalf of the browser but on the current page
+ WebPage.COMMANDS = ['currentUrl', 'find', 'nodeCall', 'documentSize', 'beforeUpload', 'afterUpload', 'clearLocalStorage'];
+
+ WebPage.EXTENSIONS = [];
+
+ function WebPage(nativeWebPage) {
+ var callback, i, callBacksLength, callBacksRef;
+
+ //Lets create the native phantomjs webpage
+ if (nativeWebPage === null || typeof nativeWebPage == "undefined") {
+ this._native = require('webpage').create();
+ } else {
+ this._native = nativeWebPage;
+ }
+
+ this.id = 0;
+ this.source = null;
+ this.closed = false;
+ this.state = 'default';
+ this.urlBlacklist = [];
+ this.frames = [];
+ this.errors = [];
+ this._networkTraffic = {};
+ this._tempHeaders = {};
+ this._blockedUrls = [];
+
+ callBacksRef = WebPage.CALLBACKS;
+ for (i = 0, callBacksLength = callBacksRef.length; i < callBacksLength; i++) {
+ callback = callBacksRef[i];
+ this.bindCallback(callback);
+ }
+ }
+
+ //Bind the commands we can run from the browser to the current page
+ commandsRef = WebPage.COMMANDS;
+ commandFunctionBind = function (command) {
+ return WebPage.prototype[command] = function () {
+ var args;
+ args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+ return this.runCommand(command, args);
+ };
+ };
+ for (i = 0, commandsLength = commandsRef.length; i < commandsLength; i++) {
+ command = commandsRef[i];
+ commandFunctionBind(command);
+ }
+
+ //Delegates bind applications
+ delegatesRef = WebPage.DELEGATES;
+ delegateFunctionBind = function (delegate) {
+ return WebPage.prototype[delegate] = function () {
+ return this._native[delegate].apply(this._native, arguments);
+ };
+ };
+ for (j = 0, delegatesRefLength = delegatesRef.length; j < delegatesRefLength; j++) {
+ delegate = delegatesRef[j];
+ delegateFunctionBind(delegate);
+ }
+
+ /**
+ * This callback is invoked after the web page is created but before a URL is loaded.
+ * The callback may be used to change global objects.
+ * @return {*}
+ */
+ WebPage.prototype.onInitializedNative = function () {
+ this.id += 1;
+ this.source = null;
+ this.injectAgent();
+ this.removeTempHeaders();
+ return this.setScrollPosition({
+ left: 0,
+ top: 0
+ });
+ };
+
+ /**
+ * This callback is invoked when the WebPage object is being closed,
+ * either via page.close in the PhantomJS outer space or via window.close in the page's client-side.
+ * @return {boolean}
+ */
+ WebPage.prototype.onClosingNative = function () {
+ this.handle = null;
+ return this.closed = true;
+ };
+
+ /**
+ * This callback is invoked when there is a JavaScript console message on the web page.
+ * The callback may accept up to three arguments: the string for the message, the line number, and the source identifier.
+ * @param message
+ * @param line
+ * @param sourceId
+ * @return {boolean}
+ */
+ WebPage.prototype.onConsoleMessageNative = function (message, line, sourceId) {
+ if (message === '__DOMContentLoaded') {
+ this.source = this._native.content;
+ return false;
+ }
+ console.log(message);
+ return true;
+ };
+
+ /**
+ * This callback is invoked when the page starts the loading. There is no argument passed to the callback.
+ * @return {number}
+ */
+ WebPage.prototype.onLoadStartedNative = function () {
+ this.state = 'loading';
+ return this.requestId = this.lastRequestId;
+ };
+
+ /**
+ * This callback is invoked when the page finishes the loading.
+ * It may accept a single argument indicating the page's status: 'success' if no network errors occurred, otherwise 'fail'.
+ * @param status
+ * @return {string}
+ */
+ WebPage.prototype.onLoadFinishedNative = function (status) {
+ this.status = status;
+ this.state = 'default';
+
+ if (this.source === null || typeof this.source == "undefined") {
+ this.source = this._native.content;
+ } else {
+ this.source = this._native.content;
+ }
+
+ return this.source;
+ };
+
+ /**
+ * This callback is invoked when there is a JavaScript execution error.
+ * It is a good way to catch problems when evaluating a script in the web page context.
+ * The arguments passed to the callback are the error message and the stack trace [as an Array].
+ * @param message
+ * @param stack
+ * @return {Number}
+ */
+ WebPage.prototype.onErrorNative = function (message, stack) {
+ var stackString;
+
+ stackString = message;
+ stack.forEach(function (frame) {
+ stackString += "\n";
+ stackString += " at " + frame.file + ":" + frame.line;
+ if (frame["function"] && frame["function"] !== '') {
+ return stackString += " in " + frame["function"];
+ }
+ });
+
+ return this.errors.push({
+ message: message,
+ stack: stackString
+ });
+ };
+
+ /**
+ * This callback is invoked when the page requests a resource.
+ * The first argument to the callback is the requestData metadata object.
+ * The second argument is the networkRequest object itself.
+ * @param requestData
+ * @param networkRequest
+ * @return {*}
+ */
+ WebPage.prototype.onResourceRequestedNative = function (requestData, networkRequest) {
+ var abort;
+
+ abort = this.urlBlacklist.some(function (blacklistedUrl) {
+ return requestData.url.indexOf(blacklistedUrl) !== -1;
+ });
+
+ if (abort) {
+ if (this._blockedUrls.indexOf(requestData.url) === -1) {
+ this._blockedUrls.push(requestData.url);
+ }
+ //TODO: check this, as it raises onResourceError
+ return networkRequest.abort();
+ }
+
+ this.lastRequestId = requestData.id;
+ if (requestData.url === this.redirectURL) {
+ this.redirectURL = null;
+ this.requestId = requestData.id;
+ }
+
+ return this._networkTraffic[requestData.id] = {
+ request: requestData,
+ responseParts: []
+ };
+ };
+
+ /**
+ * This callback is invoked when a resource requested by the page is received.
+ * The only argument to the callback is the response metadata object.
+ * @param response
+ * @return {*}
+ */
+ WebPage.prototype.onResourceReceivedNative = function (response) {
+ var networkTrafficElement;
+
+ if ((networkTrafficElement = this._networkTraffic[response.id]) != null) {
+ networkTrafficElement.responseParts.push(response);
+ }
+
+ if (this.requestId === response.id) {
+ if (response.redirectURL) {
+ return this.redirectURL = response.redirectURL;
+ }
+
+ this.statusCode = response.status;
+ return this._responseHeaders = response.headers;
+ }
+ };
+
+ /**
+ * Inject the poltergeist agent into the webpage
+ * @return {Array}
+ */
+ WebPage.prototype.injectAgent = function () {
+ var extension, isAgentInjected, i, extensionsRefLength, extensionsRef, injectionResults;
+
+ isAgentInjected = this["native"]().evaluate(function () {
+ return typeof window.__poltergeist;
+ });
+
+ if (isAgentInjected === "undefined") {
+ this["native"]().injectJs("" + phantom.libraryPath + "/agent.js");
+ extensionsRef = WebPage.EXTENSIONS;
+ injectionResults = [];
+ for (i = 0, extensionsRefLength = extensionsRef.length; i < extensionsRefLength; i++) {
+ extension = extensionsRef[i];
+ injectionResults.push(this["native"]().injectJs(extension));
+ }
+ return injectionResults;
+ }
+ };
+
+ /**
+ * Injects a Javascript file extension into the
+ * @param file
+ * @return {*}
+ */
+ WebPage.prototype.injectExtension = function (file) {
+ //TODO: add error control, for example, check if file already in the extensions array, check if the file exists, etc.
+ WebPage.EXTENSIONS.push(file);
+ return this["native"]().injectJs(file);
+ };
+
+ /**
+ * Returns the native phantomjs webpage object
+ * @return {*}
+ */
+ WebPage.prototype["native"] = function () {
+ if (this.closed) {
+ throw new Poltergeist.NoSuchWindowError;
+ }
+
+ return this._native;
+ };
+
+ /**
+ * Returns the current page window name
+ * @return {*}
+ */
+ WebPage.prototype.windowName = function () {
+ return this["native"]().windowName;
+ };
+
+ /**
+ * Returns the keyCode of a given key as set in the phantomjs values
+ * @param name
+ * @return {number}
+ */
+ WebPage.prototype.keyCode = function (name) {
+ return this["native"]().event.key[name];
+ };
+
+ /**
+ * Waits for the page to reach a certain state
+ * @param state
+ * @param callback
+ * @return {*}
+ */
+ WebPage.prototype.waitState = function (state, callback) {
+ var self = this;
+ if (this.state === state) {
+ return callback.call();
+ } else {
+ return setTimeout((function () {
+ return self.waitState(state, callback);
+ }), 100);
+ }
+ };
+
+ /**
+ * Sets the browser header related to basic authentication protocol
+ * @param user
+ * @param password
+ * @return {boolean}
+ */
+ WebPage.prototype.setHttpAuth = function (user, password) {
+ var allHeaders = this.getCustomHeaders();
+
+ if (user === false || password === false) {
+ if (allHeaders.hasOwnProperty("Authorization")) {
+ delete allHeaders["Authorization"];
+ }
+ this.setCustomHeaders(allHeaders);
+ return true;
+ }
+
+ var userName = user || "";
+ var userPassword = password || "";
+
+ allHeaders["Authorization"] = "Basic " + btoa(userName + ":" + userPassword);
+ this.setCustomHeaders(allHeaders);
+ return true;
+ };
+
+ /**
+ * Returns all the network traffic associated to the rendering of this page
+ * @return {{}}
+ */
+ WebPage.prototype.networkTraffic = function () {
+ return this._networkTraffic;
+ };
+
+ /**
+ * Clears all the recorded network traffic related to the current page
+ * @return {{}}
+ */
+ WebPage.prototype.clearNetworkTraffic = function () {
+ return this._networkTraffic = {};
+ };
+
+ /**
+ * Returns the blocked urls that the page will not load
+ * @return {Array}
+ */
+ WebPage.prototype.blockedUrls = function () {
+ return this._blockedUrls;
+ };
+
+ /**
+ * Clean all the urls that should not be loaded
+ * @return {Array}
+ */
+ WebPage.prototype.clearBlockedUrls = function () {
+ return this._blockedUrls = [];
+ };
+
+ /**
+ * This property stores the content of the web page's currently active frame
+ * (which may or may not be the main frame), enclosed in an HTML/XML element.
+ * @return {string}
+ */
+ WebPage.prototype.content = function () {
+ return this["native"]().frameContent;
+ };
+
+ /**
+ * Returns the current active frame title
+ * @return {string}
+ */
+ WebPage.prototype.title = function () {
+ return this["native"]().frameTitle;
+ };
+
+ /**
+ * Returns if possible the frame url of the frame given by name
+ * @param frameName
+ * @return {string}
+ */
+ WebPage.prototype.frameUrl = function (frameName) {
+ var query;
+
+ query = function (frameName) {
+ var iframeReference;
+ if ((iframeReference = document.querySelector("iframe[name='" + frameName + "']")) != null) {
+ return iframeReference.src;
+ }
+ return void 0;
+ };
+
+ return this.evaluate(query, frameName);
+ };
+
+ /**
+ * Remove the errors caught on the page
+ * @return {Array}
+ */
+ WebPage.prototype.clearErrors = function () {
+ return this.errors = [];
+ };
+
+ /**
+ * Returns the response headers associated to this page
+ * @return {{}}
+ */
+ WebPage.prototype.responseHeaders = function () {
+ var headers;
+ headers = {};
+ this._responseHeaders.forEach(function (item) {
+ return headers[item.name] = item.value;
+ });
+ return headers;
+ };
+
+ /**
+ * Get Cookies visible to the current URL (though, for setting, use of page.addCookie is preferred).
+ * This array will be pre-populated by any existing Cookie data visible to this URL that is stored in the CookieJar, if any.
+ * @return {*}
+ */
+ WebPage.prototype.cookies = function () {
+ return this["native"]().cookies;
+ };
+
+ /**
+ * Delete any Cookies visible to the current URL with a 'name' property matching cookieName.
+ * Returns true if successfully deleted, otherwise false.
+ * @param name
+ * @return {*}
+ */
+ WebPage.prototype.deleteCookie = function (name) {
+ return this["native"]().deleteCookie(name);
+ };
+
+ /**
+ * This property gets the size of the viewport for the layout process.
+ * @return {*}
+ */
+ WebPage.prototype.viewportSize = function () {
+ return this["native"]().viewportSize;
+ };
+
+ /**
+ * This property sets the size of the viewport for the layout process.
+ * @param size
+ * @return {*}
+ */
+ WebPage.prototype.setViewportSize = function (size) {
+ return this["native"]().viewportSize = size;
+ };
+
+ /**
+ * This property specifies the scaling factor for the page.render and page.renderBase64 functions.
+ * @param zoomFactor
+ * @return {*}
+ */
+ WebPage.prototype.setZoomFactor = function (zoomFactor) {
+ return this["native"]().zoomFactor = zoomFactor;
+ };
+
+ /**
+ * This property defines the size of the web page when rendered as a PDF.
+ * See: http://phantomjs.org/api/webpage/property/paper-size.html
+ * @param size
+ * @return {*}
+ */
+ WebPage.prototype.setPaperSize = function (size) {
+ return this["native"]().paperSize = size;
+ };
+
+ /**
+ * This property gets the scroll position of the web page.
+ * @return {*}
+ */
+ WebPage.prototype.scrollPosition = function () {
+ return this["native"]().scrollPosition;
+ };
+
+ /**
+ * This property defines the scroll position of the web page.
+ * @param pos
+ * @return {*}
+ */
+ WebPage.prototype.setScrollPosition = function (pos) {
+ return this["native"]().scrollPosition = pos;
+ };
+
+
+ /**
+ * This property defines the rectangular area of the web page to be rasterized when page.render is invoked.
+ * If no clipping rectangle is set, page.render will process the entire web page.
+ * @return {*}
+ */
+ WebPage.prototype.clipRect = function () {
+ return this["native"]().clipRect;
+ };
+
+ /**
+ * This property defines the rectangular area of the web page to be rasterized when page.render is invoked.
+ * If no clipping rectangle is set, page.render will process the entire web page.
+ * @param rect
+ * @return {*}
+ */
+ WebPage.prototype.setClipRect = function (rect) {
+ return this["native"]().clipRect = rect;
+ };
+
+ /**
+ * Returns the size of an element given by a selector and its position relative to the viewport.
+ * @param selector
+ * @return {Object}
+ */
+ WebPage.prototype.elementBounds = function (selector) {
+ return this["native"]().evaluate(function (selector) {
+ return document.querySelector(selector).getBoundingClientRect();
+ }, selector);
+ };
+
+ /**
+ * Defines the user agent sent to server when the web page requests resources.
+ * @param userAgent
+ * @return {*}
+ */
+ WebPage.prototype.setUserAgent = function (userAgent) {
+ return this["native"]().settings.userAgent = userAgent;
+ };
+
+ /**
+ * Returns the additional HTTP request headers that will be sent to the server for EVERY request.
+ * @return {{}}
+ */
+ WebPage.prototype.getCustomHeaders = function () {
+ return this["native"]().customHeaders;
+ };
+
+ /**
+ * Gets the additional HTTP request headers that will be sent to the server for EVERY request.
+ * @param headers
+ * @return {*}
+ */
+ WebPage.prototype.setCustomHeaders = function (headers) {
+ return this["native"]().customHeaders = headers;
+ };
+
+ /**
+ * Adds a one time only request header, after being used it will be deleted
+ * @param header
+ * @return {Array}
+ */
+ WebPage.prototype.addTempHeader = function (header) {
+ var name, value, tempHeaderResult;
+ tempHeaderResult = [];
+ for (name in header) {
+ if (header.hasOwnProperty(name)) {
+ value = header[name];
+ tempHeaderResult.push(this._tempHeaders[name] = value);
+ }
+ }
+ return tempHeaderResult;
+ };
+
+ /**
+ * Remove the temporary headers we have set via addTempHeader
+ * @return {*}
+ */
+ WebPage.prototype.removeTempHeaders = function () {
+ var allHeaders, name, value, tempHeadersRef;
+ allHeaders = this.getCustomHeaders();
+ tempHeadersRef = this._tempHeaders;
+ for (name in tempHeadersRef) {
+ if (tempHeadersRef.hasOwnProperty(name)) {
+ value = tempHeadersRef[name];
+ delete allHeaders[name];
+ }
+ }
+
+ return this.setCustomHeaders(allHeaders);
+ };
+
+ /**
+ * If possible switch to the frame given by name
+ * @param name
+ * @return {boolean}
+ */
+ WebPage.prototype.pushFrame = function (name) {
+ if (this["native"]().switchToFrame(name)) {
+ this.frames.push(name);
+ return true;
+ }
+ return false;
+ };
+
+ /**
+ * Switch to parent frame, use with caution:
+ * popFrame assumes you are in frame, pop frame not being in a frame
+ * leaves unexpected behaviour
+ * @return {*}
+ */
+ WebPage.prototype.popFrame = function () {
+ //TODO: add some error control here, some way to check we are in a frame or not
+ this.frames.pop();
+ return this["native"]().switchToParentFrame();
+ };
+
+ /**
+ * Returns the webpage dimensions
+ * @return {{top: *, bottom: *, left: *, right: *, viewport: *, document: {height: number, width: number}}}
+ */
+ WebPage.prototype.dimensions = function () {
+ var scroll, viewport;
+ scroll = this.scrollPosition();
+ viewport = this.viewportSize();
+ return {
+ top: scroll.top,
+ bottom: scroll.top + viewport.height,
+ left: scroll.left,
+ right: scroll.left + viewport.width,
+ viewport: viewport,
+ document: this.documentSize()
+ };
+ };
+
+ /**
+ * Returns webpage dimensions that are valid
+ * @return {{top: *, bottom: *, left: *, right: *, viewport: *, document: {height: number, width: number}}}
+ */
+ WebPage.prototype.validatedDimensions = function () {
+ var dimensions, documentDimensions;
+
+ dimensions = this.dimensions();
+ documentDimensions = dimensions.document;
+
+ if (dimensions.right > documentDimensions.width) {
+ dimensions.left = Math.max(0, dimensions.left - (dimensions.right - documentDimensions.width));
+ dimensions.right = documentDimensions.width;
+ }
+
+ if (dimensions.bottom > documentDimensions.height) {
+ dimensions.top = Math.max(0, dimensions.top - (dimensions.bottom - documentDimensions.height));
+ dimensions.bottom = documentDimensions.height;
+ }
+
+ this.setScrollPosition({
+ left: dimensions.left,
+ top: dimensions.top
+ });
+
+ return dimensions;
+ };
+
+ /**
+ * Returns a Poltergeist.Node given by an id
+ * @param id
+ * @return {Poltergeist.Node}
+ */
+ WebPage.prototype.get = function (id) {
+ return new Poltergeist.Node(this, id);
+ };
+
+ /**
+ * Executes a phantomjs mouse event, for more info check: http://phantomjs.org/api/webpage/method/send-event.html
+ * @param name
+ * @param x
+ * @param y
+ * @param button
+ * @return {*}
+ */
+ WebPage.prototype.mouseEvent = function (name, x, y, button) {
+ if (button == null) {
+ button = 'left';
+ }
+ this.sendEvent('mousemove', x, y);
+ return this.sendEvent(name, x, y, button);
+ };
+
+ /**
+ * Evaluates a javascript and returns the evaluation of such script
+ * @return {*}
+ */
+ WebPage.prototype.evaluate = function () {
+ var args, fn;
+ fn = arguments[0];
+ args = [];
+
+ if (2 <= arguments.length) {
+ args = __slice.call(arguments, 1);
+ }
+
+ this.injectAgent();
+ return JSON.parse(this.sanitize(this["native"]().evaluate("function() { return PoltergeistAgent.stringify(" + (this.stringifyCall(fn, args)) + ") }")));
+ };
+
+ /**
+ * Does some string sanitation prior parsing
+ * @param potentialString
+ * @return {*}
+ */
+ WebPage.prototype.sanitize = function (potentialString) {
+ if (typeof potentialString === "string") {
+ return potentialString.replace("\n", "\\n").replace("\r", "\\r");
+ }
+
+ return potentialString;
+ };
+
+ /**
+ * Executes a script into the current page scope
+ * @param script
+ * @return {*}
+ */
+ WebPage.prototype.executeScript = function (script) {
+ return this["native"]().evaluateJavaScript(script);
+ };
+
+ /**
+ * Executes a script via phantomjs evaluation
+ * @return {*}
+ */
+ WebPage.prototype.execute = function () {
+ var args, fn;
+
+ fn = arguments[0];
+ args = [];
+
+ if (2 <= arguments.length) {
+ args = __slice.call(arguments, 1);
+ }
+
+ return this["native"]().evaluate("function() { " + (this.stringifyCall(fn, args)) + " }");
+ };
+
+ /**
+ * Helper methods to do script evaluation and execution
+ * @param fn
+ * @param args
+ * @return {string}
+ */
+ WebPage.prototype.stringifyCall = function (fn, args) {
+ if (args.length === 0) {
+ return "(" + (fn.toString()) + ")()";
+ }
+
+ return "(" + (fn.toString()) + ").apply(this, JSON.parse(" + (JSON.stringify(JSON.stringify(args))) + "))";
+ };
+
+ /**
+ * Binds callbacks to their respective Native implementations
+ * @param name
+ * @return {Function}
+ */
+ WebPage.prototype.bindCallback = function (name) {
+ var self;
+ self = this;
+
+ return this["native"]()[name] = function () {
+ var result;
+ if (self[name + 'Native'] != null) {
+ result = self[name + 'Native'].apply(self, arguments);
+ }
+ if (result !== false && (self[name] != null)) {
+ return self[name].apply(self, arguments);
+ }
+ };
+ };
+
+ /**
+ * Runs a command delegating to the PoltergeistAgent
+ * @param name
+ * @param args
+ * @return {*}
+ */
+ WebPage.prototype.runCommand = function (name, args) {
+ var method, result, selector;
+
+ result = this.evaluate(function (name, args) {
+ return window.__poltergeist.externalCall(name, args);
+ }, name, args);
+
+ if (result !== null) {
+ if (result.error != null) {
+ switch (result.error.message) {
+ case 'PoltergeistAgent.ObsoleteNode':
+ throw new Poltergeist.ObsoleteNode;
+ break;
+ case 'PoltergeistAgent.InvalidSelector':
+ method = args[0];
+ selector = args[1];
+ throw new Poltergeist.InvalidSelector(method, selector);
+ break;
+ default:
+ throw new Poltergeist.BrowserError(result.error.message, result.error.stack);
+ }
+ } else {
+ return result.value;
+ }
+ }
+ };
+
+ /**
+ * Tells if we can go back or not
+ * @return {boolean}
+ */
+ WebPage.prototype.canGoBack = function () {
+ return this["native"]().canGoBack;
+ };
+
+ /**
+ * Tells if we can go forward or not in the browser history
+ * @return {boolean}
+ */
+ WebPage.prototype.canGoForward = function () {
+ return this["native"]().canGoForward;
+ };
+
+ return WebPage;
+
+}).call(this);
diff --git a/vendor/jcalderonzumba/gastonjs/src/Cookie.php b/vendor/jcalderonzumba/gastonjs/src/Cookie.php
new file mode 100644
index 0000000000000000000000000000000000000000..d59c0f674f8fdc341341a40fa5707fb34e2429da
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Cookie.php
@@ -0,0 +1,79 @@
+<?php
+
+namespace Zumba\GastonJS;
+
+/**
+ * Class Cookie
+ * @package Zumba\GastonJS
+ */
+class Cookie {
+ /** @var array */
+ protected $attributes;
+
+ /**
+ * @param $attributes
+ */
+ public function __construct($attributes) {
+ $this->attributes = $attributes;
+ }
+
+ /**
+ * Returns the cookie name
+ * @return string
+ */
+ public function getName() {
+ return $this->attributes['name'];
+ }
+
+ /**
+ * Returns the cookie value
+ * @return string
+ */
+ public function getValue() {
+ return urldecode($this->attributes['value']);
+ }
+
+ /**
+ * Returns the cookie domain
+ * @return string
+ */
+ public function getDomain() {
+ return $this->attributes['domain'];
+ }
+
+ /**
+ * Returns the path were the cookie is valid
+ * @return string
+ */
+ public function getPath() {
+ return $this->attributes['path'];
+ }
+
+ /**
+ * Is a secure cookie?
+ * @return bool
+ */
+ public function isSecure() {
+ return isset($this->attributes['secure']);
+ }
+
+ /**
+ * Is http only cookie?
+ * @return bool
+ */
+ public function isHttpOnly() {
+ return isset($this->attributes['httponly']);
+ }
+
+ /**
+ * Returns cookie expiration time
+ * @return mixed
+ */
+ public function getExpirationTime() {
+ //TODO: return a \DateTime object
+ if (isset($this->attributes['expiry'])) {
+ return $this->attributes['expiry'];
+ }
+ return null;
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/BrowserError.php b/vendor/jcalderonzumba/gastonjs/src/Exception/BrowserError.php
new file mode 100644
index 0000000000000000000000000000000000000000..a1c4f4b12624b6833257cf81aad0de8050c93172
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/BrowserError.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+
+/**
+ * Class BrowserError
+ * @package Zumba\GastonJS\Exception
+ */
+class BrowserError extends ClientError {
+
+ /**
+ * @param array $response
+ */
+ public function __construct($response) {
+ parent::__construct($response);
+ $this->message = $this->message();
+ }
+
+ /**
+ * Gets the name of the browser error
+ * @return string
+ */
+ public function getName() {
+ return $this->response["error"]["name"];
+ }
+
+ /**
+ * @return JSErrorItem
+ */
+ public function javascriptError() {
+ //TODO: this need to be check, i don't know yet what comes in response
+ return new JSErrorItem($this->response["error"]["args"][0], $this->response["error"]["args"][1]);
+ }
+
+ /**
+ * Returns error message
+ * TODO: check how to proper implement if we have exceptions
+ * @return string
+ */
+ public function message() {
+ return "There was an error inside the PhantomJS portion of GastonJS.\nThis is probably a bug, so please report it:\n" . $this->javascriptError();
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/ClientError.php b/vendor/jcalderonzumba/gastonjs/src/Exception/ClientError.php
new file mode 100644
index 0000000000000000000000000000000000000000..06be87bc23a481cac7d13d8311c56247424cfb3d
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/ClientError.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+/**
+ * Class ClientError
+ * @package Zumba\GastonJS\Exception
+ */
+class ClientError extends \Exception {
+
+ /** @var mixed */
+ protected $response;
+
+ /**
+ * @param mixed $response
+ */
+ public function __construct($response) {
+ $this->response = $response;
+ }
+
+ /**
+ * @return mixed
+ */
+ public function getResponse() {
+ return $this->response;
+ }
+
+ /**
+ * @param mixed $response
+ */
+ public function setResponse($response) {
+ $this->response = $response;
+ }
+
+
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/DeadClient.php b/vendor/jcalderonzumba/gastonjs/src/Exception/DeadClient.php
new file mode 100644
index 0000000000000000000000000000000000000000..f4af193064afb73f4ea5761e9818e56bf62cee21
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/DeadClient.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+
+/**
+ * Class DeadClient
+ * @package Zumba\GastonJS\Exception
+ */
+class DeadClient extends \Exception {
+
+ /**
+ * @param string $message
+ * @param int $code
+ * @param \Exception $previous
+ */
+ public function __construct($message = "", $code = 0, \Exception $previous = null) {
+ $errorMsg = $message."\nPhantomjs browser server is not taking connections, most probably it has crashed\n";
+ parent::__construct($errorMsg, $code, $previous);
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/FrameNotFound.php b/vendor/jcalderonzumba/gastonjs/src/Exception/FrameNotFound.php
new file mode 100644
index 0000000000000000000000000000000000000000..56a6f9129ecc8204eb03c4e646e5d5981bc4d199
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/FrameNotFound.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+/**
+ * Class FrameNotFound
+ * @package Zumba\GastonJS\Exception
+ */
+class FrameNotFound extends ClientError {
+
+ /**
+ * @return string
+ */
+ public function getName() {
+ //TODO: check stuff here
+ return current(reset($this->response["args"]));
+ }
+
+ /**
+ * @return string
+ */
+ public function message() {
+ //TODO: check the exception message stuff
+ return "The frame " . $this->getName() . " was not not found";
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/InvalidSelector.php b/vendor/jcalderonzumba/gastonjs/src/Exception/InvalidSelector.php
new file mode 100644
index 0000000000000000000000000000000000000000..44fad4becc0b8052799e242333144929479674ae
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/InvalidSelector.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+/**
+ * Class InvalidSelector
+ * @package Zumba\GastonJS\Exception
+ */
+class InvalidSelector extends ClientError {
+ /**
+ * Gets the method of selection
+ * @return string
+ */
+ public function getMethod() {
+ return $this->response["error"]["args"][0];
+ }
+
+ /**
+ * Gets the selector related to the method
+ * @return string
+ */
+ public function getSelector() {
+ return $this->response["error"]["args"][1];
+ }
+
+ /**
+ * @return string
+ */
+ public function message() {
+ return "The browser raised a syntax error while trying to evaluate" . $this->getMethod() . " selector " . $this->getSelector();
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/JSErrorItem.php b/vendor/jcalderonzumba/gastonjs/src/Exception/JSErrorItem.php
new file mode 100644
index 0000000000000000000000000000000000000000..2fa205afdd3f96266bf81820030cc1a8a3f8e584
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/JSErrorItem.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+/**
+ * Class JSErrorItem
+ * @package Zumba\GastonJS\Exception
+ */
+class JSErrorItem {
+ /** @var mixed */
+ protected $message;
+ /** @var mixed */
+ protected $stack;
+
+ /**
+ * @param $message
+ * @param $stack
+ */
+ public function __construct($message, $stack) {
+ $this->message = $message;
+ $this->stack = $stack;
+ }
+
+ /**
+ * String representation of the class
+ * @return string
+ */
+ public function __toString() {
+ return sprintf("%s\n%s", $this->message, $this->stack);
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/JavascriptError.php b/vendor/jcalderonzumba/gastonjs/src/Exception/JavascriptError.php
new file mode 100644
index 0000000000000000000000000000000000000000..309adfb9738f4391de4e2f9b4922ac497b792c95
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/JavascriptError.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+
+/**
+ * Class JavascriptError
+ * @package Zumba\GastonJS\Exception
+ */
+class JavascriptError extends ClientError {
+
+ /**
+ * @param array $response
+ */
+ public function __construct($response) {
+ parent::__construct($response);
+ $this->message = $this->message();
+ }
+
+ /**
+ * Get the javascript errors found during the use of the phantomjs
+ * @return array
+ */
+ public function javascriptErrors() {
+ $jsErrors = array();
+ $errors = $this->response["error"]["args"][0];
+ foreach ($errors as $error) {
+ $jsErrors[] = new JSErrorItem($error["message"], $error["stack"]);
+ }
+ return $jsErrors;
+ }
+
+ /**
+ * Returns the javascript errors found
+ * @return string
+ */
+ public function message() {
+ $error = "One or more errors were raised in the Javascript code on the page.
+ If you don't care about these errors, you can ignore them by
+ setting js_errors: false in your Poltergeist configuration (see documentation for details).";
+ //TODO: add javascript errors
+ $jsErrors = $this->javascriptErrors();
+ foreach($jsErrors as $jsError){
+ $error = "$error\n$jsError";
+ }
+ return $error;
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/MouseEventFailed.php b/vendor/jcalderonzumba/gastonjs/src/Exception/MouseEventFailed.php
new file mode 100644
index 0000000000000000000000000000000000000000..abd72d3a4773e9a59e34e007a504337d26cf1c56
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/MouseEventFailed.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+/**
+ * Class MouseEventFailed
+ * @package Zumba\GastonJS\Exception
+ */
+class MouseEventFailed extends NodeError {
+
+ /**
+ * Gets the name of the event
+ * @return string
+ */
+ public function getName() {
+ return $this->response["args"][0];
+ }
+
+ /**
+ * Selector of the element to act with the mouse
+ * @return string
+ */
+ public function getSelector() {
+ return $this->response["args"][1];
+ }
+
+ /**
+ * Returns the position where the click was done
+ * @return array
+ */
+ public function getPosition() {
+ $position = array();
+ $position[0] = $this->response["args"][1]['x'];
+ $position[1] = $this->response["args"][2]['y'];
+ return $position;
+ }
+
+ /**
+ * @return string
+ */
+ public function message() {
+ $name = $this->getName();
+ $position = implode(",", $this->getPosition());
+ return "Firing a $name at co-ordinates [$position] failed. Poltergeist detected
+ another element with CSS selector '#{selector}' at this position.
+ It may be overlapping the element you are trying to interact with.
+ If you don't care about overlapping elements, try using node.trigger('$name').";
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/NoSuchWindowError.php b/vendor/jcalderonzumba/gastonjs/src/Exception/NoSuchWindowError.php
new file mode 100644
index 0000000000000000000000000000000000000000..45388d16c7eac8c3bf8f8d56a66f0b6ffbdd9c8f
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/NoSuchWindowError.php
@@ -0,0 +1,10 @@
+<?php
+namespace Zumba\GastonJS\Exception;
+
+
+/**
+ * Class NoSuchWindowError
+ * @package Zumba\GastonJS\Exception
+ */
+class NoSuchWindowError extends ClientError {
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/NodeError.php b/vendor/jcalderonzumba/gastonjs/src/Exception/NodeError.php
new file mode 100644
index 0000000000000000000000000000000000000000..4b399cf3740009145493982fa8daedb5cca7eb68
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/NodeError.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+/**
+ * Class NodeError
+ * @package Zumba\GastonJS\Exception
+ */
+class NodeError extends ClientError {
+ protected $node;
+
+ /**
+ * @param mixed $node
+ * @param mixed $response
+ */
+ public function __construct($node, $response) {
+ $this->node = $node;
+ parent::__construct($response);
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/ObsoleteNode.php b/vendor/jcalderonzumba/gastonjs/src/Exception/ObsoleteNode.php
new file mode 100644
index 0000000000000000000000000000000000000000..a0cdb1795e8f800aa2bdb485a5b02181fa48a90f
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/ObsoleteNode.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+/**
+ * Class ObsoleteNode
+ * @package Zumba\GastonJS\Exception
+ */
+class ObsoleteNode extends ClientError {
+
+ /**
+ * @param array $response
+ */
+ public function __construct($response) {
+ parent::__construct($response);
+ $this->message = $this->message();
+ }
+
+ /**
+ * @return string
+ */
+ public function message() {
+ return "The element you are trying to interact with is either not part of the DOM, or is
+ not currently visible on the page (perhaps display: none is set).
+ It's possible the element has been replaced by another element and you meant to interact with
+ the new element. If so you need to do a new 'find' in order to get a reference to the
+ new element.";
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/StatusFailError.php b/vendor/jcalderonzumba/gastonjs/src/Exception/StatusFailError.php
new file mode 100644
index 0000000000000000000000000000000000000000..fd90eefecdf561962c648be00a2ed6c9dd502b1a
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/StatusFailError.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+
+/**
+ * Class StatusFailError
+ * @package Zumba\GastonJS\Exception
+ */
+class StatusFailError extends ClientError {
+ /**
+ * @return string
+ */
+ public function message() {
+ return "Request failed to reach server, check DNS and/or server status";
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/Exception/TimeoutError.php b/vendor/jcalderonzumba/gastonjs/src/Exception/TimeoutError.php
new file mode 100644
index 0000000000000000000000000000000000000000..6366ffae89a67bd714aed6908846e2e22b882c4d
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/Exception/TimeoutError.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Zumba\GastonJS\Exception;
+
+/**
+ * Class TimeoutError
+ * @package Zumba\GastonJS\Exception
+ */
+class TimeoutError extends \Exception {
+
+ /**
+ * @param string $message
+ */
+ public function __construct($message) {
+ $errorMessage = "Timed out waiting for response to {$message}. It's possible that this happened
+ because something took a very long time(for example a page load was slow).
+ If so, setting the Poltergeist :timeout option to a higher value will help
+ (see the docs for details). If increasing the timeout does not help, this is
+ probably a bug in Poltergeist - please report it to the issue tracker.";
+ parent::__construct($errorMessage);
+ }
+
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/NetworkTraffic/Request.php b/vendor/jcalderonzumba/gastonjs/src/NetworkTraffic/Request.php
new file mode 100644
index 0000000000000000000000000000000000000000..e6f9893abe2536a5d122c5eebf93ec1d3cce2ec3
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/NetworkTraffic/Request.php
@@ -0,0 +1,95 @@
+<?php
+
+namespace Zumba\GastonJS\NetworkTraffic;
+
+/**
+ * Class Request
+ * @package Zumba\GastonJS\NetworkTraffic
+ */
+class Request {
+ /** @var array */
+ protected $data;
+ /** @var array */
+ protected $responseParts;
+
+
+ /**
+ * @param array $data
+ * @param array $responseParts
+ */
+ public function __construct($data, $responseParts = null) {
+ $this->data = $data;
+ $this->responseParts = $this->createResponseParts($responseParts);
+ }
+
+ /**
+ * Creates an array of Response objects from a given response array
+ * @param $responseParts
+ * @return array
+ */
+ protected function createResponseParts($responseParts) {
+ if ($responseParts === null) {
+ return array();
+ }
+ $responses = array();
+ foreach ($responseParts as $responsePart) {
+ $responses[] = new Response($responsePart);
+ }
+ return $responses;
+ }
+
+ /**
+ * @return array
+ */
+ public function getResponseParts() {
+ return $this->responseParts;
+ }
+
+ /**
+ * @param array $responseParts
+ */
+ public function setResponseParts($responseParts) {
+ $this->responseParts = $responseParts;
+ }
+
+ /**
+ * Returns the url where the request is going to be made
+ * @return string
+ */
+ public function getUrl() {
+ //TODO: add isset maybe?
+ return $this->data['url'];
+ }
+
+ /**
+ * Returns the request method
+ * @return string
+ */
+ public function getMethod() {
+ return $this->data['method'];
+ }
+
+ /**
+ * Gets the request headers
+ * @return array
+ */
+ public function getHeaders() {
+ //TODO: Check if the data is actually an array, else make it array and see implications
+ return $this->data['headers'];
+ }
+
+ /**
+ * Returns if exists the request time
+ * @return \DateTime
+ */
+ public function getTime() {
+ if (isset($this->data['time'])) {
+ $requestTime = new \DateTime();
+ //TODO: fix the microseconds to miliseconds
+ $requestTime->createFromFormat("Y-m-dTH:i:s.uZ", $this->data["time"]);
+ return $requestTime;
+ }
+ return null;
+ }
+
+}
diff --git a/vendor/jcalderonzumba/gastonjs/src/NetworkTraffic/Response.php b/vendor/jcalderonzumba/gastonjs/src/NetworkTraffic/Response.php
new file mode 100644
index 0000000000000000000000000000000000000000..37edc4250fcf049d053ce78b06371ef0d8baf6ff
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/src/NetworkTraffic/Response.php
@@ -0,0 +1,97 @@
+<?php
+namespace Zumba\GastonJS\NetworkTraffic;
+
+/**
+ * Class Response
+ * @package Zumba\GastonJS\NetworkTraffic
+ */
+class Response {
+ /** @var array */
+ protected $data;
+
+ /**
+ * @param $data
+ */
+ public function __construct($data) {
+ $this->data = $data;
+ }
+
+ /**
+ * Gets Response url
+ * @return string
+ */
+ public function getUrl() {
+ return $this->data['url'];
+ }
+
+ /**
+ * Gets the response status code
+ * @return int
+ */
+ public function getStatus() {
+ return intval($this->data['status']);
+ }
+
+ /**
+ * Gets the status text of the response
+ * @return string
+ */
+ public function getStatusText() {
+ return $this->data['statusText'];
+ }
+
+ /**
+ * Gets the response headers
+ * @return array
+ */
+ public function getHeaders() {
+ return $this->data['headers'];
+ }
+
+ /**
+ * Get redirect url if response is a redirect
+ * @return string
+ */
+ public function getRedirectUrl() {
+ if (isset($this->data['redirectUrl']) && !empty($this->data['redirectUrl'])) {
+ return $this->data['redirectUrl'];
+ }
+ return null;
+ }
+
+ /**
+ * Returns the size of the response body
+ * @return int
+ */
+ public function getBodySize() {
+ if (isset($this->data['bodySize'])) {
+ return intval($this->data['bodySize']);
+ }
+ return 0;
+ }
+
+ /**
+ * Returns the content type of the response
+ * @return string
+ */
+ public function getContentType() {
+ if (isset($this->data['contentType'])) {
+ return $this->data['contentType'];
+ }
+ return null;
+ }
+
+ /**
+ * Returns if exists the response time
+ * @return \DateTime
+ */
+ public function getTime() {
+ if (isset($this->data['time'])) {
+ $requestTime = new \DateTime();
+ //TODO: fix the microseconds to miliseconds
+ $requestTime->createFromFormat("Y-m-dTH:i:s.uZ", $this->data["time"]);
+ return $requestTime;
+ }
+ return null;
+ }
+}
diff --git a/vendor/jcalderonzumba/gastonjs/unit_tests.xml b/vendor/jcalderonzumba/gastonjs/unit_tests.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5473787bf6ba2780fbec741d591e60f71a2ec62e
--- /dev/null
+++ b/vendor/jcalderonzumba/gastonjs/unit_tests.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit bootstrap="./tests/unit/bootstrap.php"
+ backupGlobals="false"
+ backupStaticAttributes="false"
+ colors="true"
+ convertErrorsToExceptions="true"
+ convertNoticesToExceptions="true"
+ convertWarningsToExceptions="true"
+ processIsolation="false"
+ stopOnFailure="true"
+ syntaxCheck="false">
+ <testsuites>
+ <testsuite>
+ <directory>tests/unit</directory>
+ </testsuite>
+ </testsuites>
+ <filter>
+ <whitelist>
+ <directory suffix=".php">src</directory>
+ <exclude>
+ <directory suffix="Trait.php">src/</directory>
+ </exclude>
+ </whitelist>
+ </filter>
+</phpunit>