phantomjs-binaries 1.8.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in phantomjs-binaries.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    phantomjs-binaries (1.5.0)
+      sys-uname (= 0.9.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ffi (1.0.11)
+    sys-uname (0.9.0)
+      ffi (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  phantomjs-binaries!

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/bootstrap.js

@@ -0,0 +1,342 @@
+/*!
+ * Casper is a navigation utility for PhantomJS.
+ *
+ * Documentation: http://casperjs.org/
+ * Repository:    http://github.com/n1k0/casperjs
+ *
+ * Copyright (c) 2011-2012 Nicolas Perriault
+ *
+ * Part of source code is Copyright Joyent, Inc. and other Node contributors.
+ *
+ * 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.
+ *
+ */
+
+/*global console phantom require*/
+/*jshint maxstatements:30 maxcomplexity:10*/
+
+if (!phantom) {
+    console.error('CasperJS needs to be executed in a PhantomJS environment http://phantomjs.org/');
+    phantom.exit(1);
+}
+
+if (phantom.version.major === 1 && phantom.version.minor < 7) {
+    console.error('CasperJS needs at least PhantomJS v1.7 or later.');
+    phantom.exit(1);
+} else {
+    bootstrap(window);
+}
+
+// Polyfills
+if (typeof Function.prototype.bind !== "function") {
+    Function.prototype.bind = function(scope) {
+        "use strict";
+        var _function = this;
+        return function() {
+            return _function.apply(scope, arguments);
+        };
+    };
+}
+
+/**
+ * CasperJS ships with its own implementation of CommonJS' require() because
+ * PhantomJS' native one doesn't allow to specify supplementary, alternative
+ * lookup directories to fetch modules from.
+ *
+ */
+function patchRequire(require, requireDirs) {
+    "use strict";
+    require('webserver'); // force generation of phantomjs' require.cache for the webserver module
+    var fs = require('fs');
+    var phantomBuiltins = ['fs', 'webpage', 'system', 'webserver'];
+    var phantomRequire = phantom.__orig__require = require;
+    var requireCache = {};
+    function possiblePaths(path, requireDir) {
+        var dir, paths = [];
+        if (path[0] === '.') {
+            paths.push.apply(paths, [
+                fs.absolute(path),
+                fs.absolute(fs.pathJoin(requireDir, path))
+            ]);
+        } else if (path[0] === '/') {
+            paths.push(path);
+        } else {
+            dir = fs.absolute(requireDir);
+            while (dir !== '' && dir.lastIndexOf(':') !== dir.length - 1) {
+                paths.push(fs.pathJoin(dir, 'modules', path));
+                // nodejs compatibility
+                paths.push(fs.pathJoin(dir, 'node_modules', path));
+                dir = fs.dirname(dir);
+            }
+            paths.push(fs.pathJoin(requireDir, 'lib', path));
+            paths.push(fs.pathJoin(requireDir, 'modules', path));
+        }
+        return paths;
+    }
+    var patchedRequire = function _require(path) {
+        var i, paths = [],
+            fileGuesses = [],
+            file,
+            module = {
+                exports: {}
+            };
+        if (phantomBuiltins.indexOf(path) !== -1) {
+            return phantomRequire(path);
+        }
+        requireDirs.forEach(function(requireDir) {
+            paths = paths.concat(possiblePaths(path, requireDir));
+        });
+        paths.forEach(function _forEach(testPath) {
+            fileGuesses.push.apply(fileGuesses, [
+                testPath,
+                testPath + '.js',
+                testPath + '.json',
+                testPath + '.coffee',
+                fs.pathJoin(testPath, 'index.js'),
+                fs.pathJoin(testPath, 'index.json'),
+                fs.pathJoin(testPath, 'index.coffee'),
+                fs.pathJoin(testPath, 'lib', fs.basename(testPath) + '.js'),
+                fs.pathJoin(testPath, 'lib', fs.basename(testPath) + '.json'),
+                fs.pathJoin(testPath, 'lib', fs.basename(testPath) + '.coffee')
+            ]);
+        });
+        file = null;
+        for (i = 0; i < fileGuesses.length && !file; ++i) {
+            if (fs.isFile(fileGuesses[i])) {
+                file = fileGuesses[i];
+            }
+        }
+        if (!file) {
+            throw new window.CasperError("CasperJS couldn't find module " + path);
+        }
+        if (file in requireCache) {
+            return requireCache[file].exports;
+        }
+        if (/\.json/i.test(file)) {
+            var parsed = JSON.parse(fs.read(file));
+            requireCache[file] = parsed;
+            return parsed;
+        }
+        var scriptCode = (function getScriptCode(file) {
+            var scriptCode = fs.read(file);
+            if (/\.coffee$/i.test(file)) {
+                /*global CoffeeScript*/
+                scriptCode = CoffeeScript.compile(scriptCode);
+            }
+            return scriptCode;
+        })(file);
+        var fn = new Function('__file__', 'require', 'module', 'exports', scriptCode);
+        try {
+            fn(file, _require, module, module.exports);
+        } catch (e) {
+            var error = new window.CasperError('__mod_error(' + path + ':' + e.line + '):: ' + e);
+            error.file = file;
+            error.line = e.line;
+            error.stack = e.stack;
+            error.stackArray = JSON.parse(JSON.stringify(e.stackArray));
+            if (error.stackArray.length > 0) {
+                error.stackArray[0].sourceURL = file;
+            }
+            throw error;
+        }
+        requireCache[file] = module;
+        return module.exports;
+    };
+    patchedRequire.patched = true;
+    return patchedRequire;
+}
+
+function bootstrap(global) {
+    "use strict";
+    var phantomArgs = require('system').args;
+
+    /**
+     * Hooks in default phantomjs error handler to print a hint when a possible
+     * casperjs command misuse is detected.
+     *
+     */
+    phantom.onError = function onPhantomError(msg, trace) {
+        phantom.defaultErrorHandler.apply(phantom, arguments);
+        if (msg.indexOf("ReferenceError: Can't find variable: casper") === 0) {
+            console.error('Hint: you may want to use the `casperjs test` command.');
+        }
+    };
+
+    /**
+     * Loads and initialize the CasperJS environment.
+     */
+    phantom.loadCasper = function loadCasper() {
+        // Patching fs
+        // TODO: watch for these methods being implemented in official fs module
+        var fs = (function _fs(fs) {
+            if (!fs.hasOwnProperty('basename')) {
+                fs.basename = function basename(path) {
+                    return path.replace(/.*\//, '');
+                };
+            }
+            if (!fs.hasOwnProperty('dirname')) {
+                fs.dirname = function dirname(path) {
+                    return path.replace(/\\/g, '/').replace(/\/[^\/]*$/, '');
+                };
+            }
+            if (!fs.hasOwnProperty('isWindows')) {
+                fs.isWindows = function isWindows() {
+                    var testPath = arguments[0] || this.workingDirectory;
+                    return (/^[a-z]{1,2}:/i).test(testPath) || testPath.indexOf("\\\\") === 0;
+                };
+            }
+            if (!fs.hasOwnProperty('pathJoin')) {
+                fs.pathJoin = function pathJoin() {
+                    return Array.prototype.join.call(arguments, this.separator);
+                };
+            }
+            return fs;
+        })(require('fs'));
+
+        // casper root path
+        if (!phantom.casperPath) {
+            try {
+                phantom.casperPath = phantom.args.map(function _map(i) {
+                    var match = i.match(/^--casper-path=(.*)/);
+                    if (match) {
+                        return fs.absolute(match[1]);
+                    }
+                }).filter(function _filter(path) {
+                    return fs.isDirectory(path);
+                }).pop();
+            } catch (e) {}
+        }
+
+        if (!phantom.casperPath) {
+            console.error("Couldn't find nor compute phantom.casperPath, exiting.");
+            phantom.exit(1);
+        }
+
+        // Embedded, up-to-date, validatable & controlable CoffeeScript
+        phantom.injectJs(fs.pathJoin(phantom.casperPath, 'modules', 'vendors', 'coffee-script.js'));
+
+        // custom global CasperError
+        global.CasperError = function CasperError(msg) {
+            Error.call(this);
+            this.message = msg;
+            this.name = 'CasperError';
+        };
+
+        // standard Error prototype inheritance
+        global.CasperError.prototype = Object.getPrototypeOf(new Error());
+
+        // CasperJS version, extracted from package.json - see http://semver.org/
+        phantom.casperVersion = (function getVersion(path) {
+            var parts, patchPart, pkg, pkgFile;
+            var fs = require('fs');
+            pkgFile = fs.absolute(fs.pathJoin(path, 'package.json'));
+            if (!fs.exists(pkgFile)) {
+                throw new global.CasperError('Cannot find package.json at ' + pkgFile);
+            }
+            try {
+                pkg = JSON.parse(require('fs').read(pkgFile));
+            } catch (e) {
+                throw new global.CasperError('Cannot read package file contents: ' + e);
+            }
+            parts  = pkg.version.trim().split(".");
+            if (parts.length < 3) {
+                throw new global.CasperError("Invalid version number");
+            }
+            patchPart = parts[2].split('-');
+            return {
+                major: ~~parts[0]       || 0,
+                minor: ~~parts[1]       || 0,
+                patch: ~~patchPart[0]   || 0,
+                ident: patchPart[1]     || "",
+                toString: function toString() {
+                    var version = [this.major, this.minor, this.patch].join('.');
+                    if (this.ident) {
+                        version = [version, this.ident].join('-');
+                    }
+                    return version;
+                }
+            };
+        })(phantom.casperPath);
+
+        // patch require
+        global.require = patchRequire(global.require, [phantom.casperPath, fs.workingDirectory]);
+
+        // casper cli args
+        phantom.casperArgs = global.require('cli').parse(phantom.args);
+
+        // loaded status
+        phantom.casperLoaded = true;
+    };
+
+    /**
+     * Initializes the CasperJS Command Line Interface.
+     */
+    phantom.initCasperCli = function initCasperCli() {
+        var fs = require("fs");
+        var baseTestsPath = fs.pathJoin(phantom.casperPath, 'tests');
+
+        if (!!phantom.casperArgs.options.version) {
+            console.log(phantom.casperVersion.toString());
+            return phantom.exit();
+        } else if (phantom.casperArgs.get(0) === "test") {
+            phantom.casperScript = fs.absolute(fs.pathJoin(baseTestsPath, 'run.js'));
+            phantom.casperTest = true;
+            phantom.casperArgs.drop("test");
+        } else if (phantom.casperArgs.get(0) === "selftest") {
+            phantom.casperScript = fs.absolute(fs.pathJoin(baseTestsPath, 'run.js'));
+            phantom.casperSelfTest = phantom.casperTest = true;
+            phantom.casperArgs.options.includes = fs.pathJoin(baseTestsPath, 'selftest.js');
+            if (phantom.casperArgs.args.length <= 1) {
+                phantom.casperArgs.args.push(fs.pathJoin(baseTestsPath, 'suites'));
+            }
+            phantom.casperArgs.drop("selftest");
+        } else if (phantom.casperArgs.args.length === 0 || !!phantom.casperArgs.options.help) {
+            var phantomVersion = [phantom.version.major, phantom.version.minor, phantom.version.patch].join('.');
+            var f = require("utils").format;
+            console.log(f('CasperJS version %s at %s, using PhantomJS version %s',
+                        phantom.casperVersion.toString(),
+                        phantom.casperPath, phantomVersion));
+            console.log(fs.read(fs.pathJoin(phantom.casperPath, 'bin', 'usage.txt')));
+            return phantom.exit(0);
+        }
+
+        if (!phantom.casperScript) {
+            phantom.casperScript = phantom.casperArgs.get(0);
+        }
+
+        if (!fs.isFile(phantom.casperScript)) {
+            console.error('Unable to open file: ' + phantom.casperScript);
+            return phantom.exit(1);
+        }
+
+        // filter out the called script name from casper args
+        phantom.casperArgs.drop(phantom.casperScript);
+
+        // passed casperjs script execution
+        phantom.injectJs(phantom.casperScript);
+    };
+
+    if (!phantom.casperLoaded) {
+        phantom.loadCasper();
+    }
+
+    if (true === phantom.casperArgs.get('cli')) {
+        phantom.initCasperCli();
+    }
+}

data/bin/casperjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# Ruby Wrapper for CasperJs
+# by hannyu
+
+def resolve(file_path)
+    while File.symlink?(file_path) do
+        file_path = File.readlink(file_path)
+    end
+    file_path
+end
+
+CASPER_PATH = File.dirname(File.dirname(File.expand_path(resolve(__FILE__))))
+
+PHANTOMJS_NATIVE_ARGS = [
+    '--cookies-file',
+    '--config',
+    '--debug',
+    '--disk-cache',
+    '--ignore-ssl-errors',
+    '--load-images',
+    '--load-plugins',
+    '--local-storage-path',
+    '--local-storage-quota',
+    '--local-to-remote-url-access',
+    '--max-disk-cache-size',
+    '--output-encoding',
+    '--proxy',
+    '--proxy-auth',
+    '--proxy-type',
+    '--remote-debugger-port',
+    '--remote-debugger-autorun',
+    '--script-encoding',
+    '--web-security',
+]
+
+CASPER_ARGS = []
+PHANTOMJS_ARGS = []
+ARGV.each do |arg|
+    is_found = false
+    PHANTOMJS_NATIVE_ARGS.each do |pna|
+        if arg.start_with? pna
+            PHANTOMJS_ARGS << arg
+            is_found = true
+            break
+        end
+    end
+    CASPER_ARGS << arg if not is_found
+end
+
+CASPER_COMMAND = []
+CASPER_COMMAND << (ENV["PHANTOMJS_EXECUTABLE"] || "phantomjs")
+CASPER_COMMAND.concat PHANTOMJS_ARGS
+CASPER_COMMAND << File.join(CASPER_PATH, "bin", "bootstrap.js")
+CASPER_COMMAND << "--casper-path=#{CASPER_PATH}"
+CASPER_COMMAND << "--cli"
+CASPER_COMMAND.concat CASPER_ARGS
+
+exec CASPER_COMMAND.join(" ")

data/bin/phantomjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'sys/uname'
+include Sys
+
+$:.push File.expand_path("../../lib", __FILE__)
+require "phantomjs-binaries/version"
+
+machine  = Uname.machine
+platform = Uname.sysname.downcase
+version  = Phantomjs::Binaries::VERSION
+platform_binary = File.expand_path(File.join(File.dirname(__FILE__), "phantomjs-#{version}-#{platform}-#{machine}"))
+exec platform_binary, *ARGV

data/bin/usage.txt

@@ -0,0 +1,11 @@
+
+Usage: casperjs [options] script.[js|coffee] [script argument [script argument ...]]
+       casperjs [options] test [test path [test path ...]]
+       casperjs [options] selftest
+
+Options:
+
+--help      Prints this help
+--version   Prints out CasperJS version
+
+Read the docs http://casperjs.org/

data/lib/phantomjs-binaries/version.rb

@@ -0,0 +1,5 @@
+module Phantomjs
+  module Binaries
+    VERSION = "1.8.0"
+  end
+end

data/lib/phantomjs-binaries.rb

@@ -0,0 +1,7 @@
+require "phantomjs-binaries/version"
+
+module Phantomjs
+  module Binaries
+    # Your code goes here...
+  end
+end