poltergeist-cj 1.5.2

data/lib/capybara/poltergeist/cookie.rb

@@ -0,0 +1,35 @@
+module Capybara::Poltergeist
+  class Cookie
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def name
+      @attributes['name']
+    end
+
+    def value
+      @attributes['value']
+    end
+
+    def domain
+      @attributes['domain']
+    end
+
+    def path
+      @attributes['path']
+    end
+
+    def secure?
+      @attributes['secure']
+    end
+
+    def httponly?
+      @attributes['httponly']
+    end
+
+    def expires
+      Time.at @attributes['expiry'] if @attributes['expiry']
+    end
+  end
+end

data/lib/capybara/poltergeist/driver.rb

@@ -0,0 +1,278 @@
+require 'uri'
+
+module Capybara::Poltergeist
+  class Driver < Capybara::Driver::Base
+    DEFAULT_TIMEOUT = 30
+
+    attr_reader :app, :server, :client, :browser, :options
+
+    def initialize(app, options = {})
+      @app       = app
+      @options   = options
+      @browser   = nil
+      @inspector = nil
+      @server    = nil
+      @client    = nil
+      @started   = false
+    end
+
+    def needs_server?
+      true
+    end
+
+    def browser
+      @browser ||= begin
+        browser = Browser.new(server, client, logger)
+        browser.js_errors  = options[:js_errors] if options.key?(:js_errors)
+        browser.extensions = options.fetch(:extensions, [])
+        browser.debug      = true if options[:debug]
+        browser
+      end
+    end
+
+    def inspector
+      @inspector ||= options[:inspector] && Inspector.new(options[:inspector])
+    end
+
+    def server
+      @server ||= Server.new(options[:port], options.fetch(:timeout) { DEFAULT_TIMEOUT })
+    end
+
+    def client
+      @client ||= Client.start(server,
+        :path              => options[:phantomjs],
+        :window_size       => options[:window_size],
+        :phantomjs_options => phantomjs_options,
+        :phantomjs_logger  => phantomjs_logger
+      )
+    end
+
+    def phantomjs_options
+      list = options[:phantomjs_options] || []
+      list += ["--remote-debugger-port=#{inspector.port}", "--remote-debugger-autorun=yes"] if inspector
+      list
+    end
+
+    def client_pid
+      client.pid
+    end
+
+    def timeout
+      server.timeout
+    end
+
+    def timeout=(sec)
+      server.timeout = sec
+    end
+
+    def restart
+      browser.restart
+    end
+
+    def quit
+      server.stop
+      client.stop
+    end
+
+    # logger should be an object that responds to puts, or nil
+    def logger
+      options[:logger] || (options[:debug] && STDERR)
+    end
+
+    # logger should be an object that behaves like IO or nil
+    def phantomjs_logger
+      options.fetch(:phantomjs_logger, nil)
+    end
+
+    def visit(url)
+      @started = true
+      browser.visit(url)
+    end
+
+    def current_url
+      browser.current_url
+    end
+
+    def status_code
+      browser.status_code
+    end
+
+    def html
+      browser.body
+    end
+    alias_method :body, :html
+
+    def source
+      browser.source.to_s
+    end
+
+    def title
+      browser.title
+    end
+
+    def find(method, selector)
+      browser.find(method, selector).map { |page_id, id| Capybara::Poltergeist::Node.new(self, page_id, id) }
+    end
+
+    def find_xpath(selector)
+      find :xpath, selector
+    end
+
+    def find_css(selector)
+      find :css, selector
+    end
+
+    def click(x, y)
+      browser.click_coordinates(x, y)
+    end
+
+    def evaluate_script(script)
+      browser.evaluate(script)
+    end
+
+    def execute_script(script)
+      browser.execute(script)
+      nil
+    end
+
+    def within_frame(name, &block)
+      browser.within_frame(name, &block)
+    end
+
+    def within_window(name, &block)
+      browser.within_window(name, &block)
+    end
+
+    def window_handles
+      browser.window_handles
+    end
+
+    def reset!
+      browser.reset
+      @started = false
+    end
+
+    def save_screenshot(path, options = {})
+      browser.render(path, options)
+    end
+    alias_method :render, :save_screenshot
+
+    def render_base64(format = :png, options = {})
+      browser.render_base64(format, options)
+    end
+
+    def paper_size=(size = {})
+      browser.set_paper_size(size)
+    end
+
+    def zoom_factor=(zoom_factor)
+      browser.set_zoom_factor(zoom_factor)
+    end
+
+    def resize(width, height)
+      browser.resize(width, height)
+    end
+    alias_method :resize_window, :resize
+
+    def scroll_to(left, top)
+      browser.scroll_to(left, top)
+    end
+
+    def network_traffic
+      browser.network_traffic
+    end
+
+    def clear_network_traffic
+      browser.clear_network_traffic
+    end
+
+    def headers
+      browser.get_headers
+    end
+
+    def headers=(headers)
+      browser.set_headers(headers)
+    end
+
+    def add_headers(headers)
+      browser.add_headers(headers)
+    end
+
+    def add_header(name, value, options = {})
+      permanent = options.fetch(:permanent, true)
+      browser.add_header({ name => value }, permanent)
+    end
+
+    def response_headers
+      browser.response_headers
+    end
+
+    def cookies
+      browser.cookies
+    end
+
+    def set_cookie(name, value, options = {})
+      options[:name]  ||= name
+      options[:value] ||= value
+      options[:domain] ||= begin
+        if @started
+          URI.parse(browser.current_url).host
+        else
+          Capybara.app_host || "127.0.0.1"
+        end
+      end
+
+      browser.set_cookie(options)
+    end
+
+    def remove_cookie(name)
+      browser.remove_cookie(name)
+    end
+
+    def cookies_enabled=(flag)
+      browser.cookies_enabled = flag
+    end
+
+    # * PhantomJS with set settings doesn't send `Authorize` on POST request
+    # * With manually set header PhantomJS makes next request with
+    # `Authorization: Basic Og==` header when settings are empty and the
+    # response was `401 Unauthorized` (which means Base64.encode64(':')).
+    # Combining both methods to reach proper behavior.
+    def basic_authorize(user, password)
+      browser.set_http_auth(user, password)
+      credentials = ["#{user}:#{password}"].pack('m*').strip
+      add_header('Authorization', "Basic #{credentials}")
+    end
+
+    def debug
+      if @options[:inspector]
+        inspector.open
+        pause
+      else
+        raise Error, "To use the remote debugging, you have to launch the driver " \
+                     "with `:inspector => true` configuration option"
+      end
+    end
+
+    def pause
+      STDERR.puts "Poltergeist execution paused. Press enter to continue."
+      STDIN.gets
+    end
+
+    def wait?
+      true
+    end
+
+    def invalid_element_errors
+      [Capybara::Poltergeist::ObsoleteNode, Capybara::Poltergeist::MouseEventFailed]
+    end
+
+    def go_back
+      browser.go_back
+    end
+
+    def go_forward
+      browser.go_forward
+    end
+  end
+end

data/lib/capybara/poltergeist/errors.rb

@@ -0,0 +1,178 @@
+module Capybara
+  module Poltergeist
+    class Error < StandardError
+    end
+
+    class ClientError < Error
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+    end
+
+    class JSErrorItem
+      attr_reader :message, :stack
+
+      def initialize(message, stack)
+        @message = message
+        @stack   = stack
+      end
+
+      def to_s
+        [message, stack].join("\n")
+      end
+    end
+
+    class BrowserError < ClientError
+      def name
+        response['name']
+      end
+
+      def javascript_error
+        JSErrorItem.new(*response['args'])
+      end
+
+      def message
+        "There was an error inside the PhantomJS portion of Poltergeist. " \
+          "This is probably a bug, so please report it. " \
+          "\n\n#{javascript_error}"
+      end
+    end
+
+    class JavascriptError < ClientError
+      def javascript_errors
+        response['args'].first.map { |data| JSErrorItem.new(data['message'], data['stack']) }
+      end
+
+      def message
+        "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)." \
+          "\n\n#{javascript_errors.map(&:to_s).join("\n")}"
+      end
+    end
+
+    class StatusFailError < ClientError
+      def message
+        "Request failed to reach server, check DNS and/or server status"
+      end
+    end
+
+    class FrameNotFound < ClientError
+      def name
+        response['args'].first
+      end
+
+      def message
+        "The frame '#{name}' was not found."
+      end
+    end
+
+    class InvalidSelector < ClientError
+      def method
+        response['args'][0]
+      end
+
+      def selector
+        response['args'][1]
+      end
+
+      def message
+        "The browser raised a syntax error while trying to evaluate " \
+          "#{method} selector #{selector.inspect}"
+      end
+    end
+
+    class NodeError < ClientError
+      attr_reader :node
+
+      def initialize(node, response)
+        @node = node
+        super(response)
+      end
+    end
+
+    class ObsoleteNode < NodeError
+      def message
+        "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."
+      end
+    end
+
+    class MouseEventFailed < NodeError
+      def name
+        response['args'][0]
+      end
+
+      def selector
+        response['args'][1]
+      end
+
+      def position
+        [response['args'][2]['x'], response['args'][2]['y']]
+      end
+
+      def message
+        "Firing a #{name} at co-ordinates [#{position.join(', ')}] 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}')."
+      end
+    end
+
+    class TimeoutError < Error
+      def initialize(message)
+        @message = message
+      end
+
+      def message
+        "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."
+      end
+    end
+
+    class DeadClient < Error
+      def initialize(message)
+        @message = message
+      end
+
+      def message
+        "PhantomJS client died while processing #{@message}"
+      end
+    end
+
+    class PhantomJSTooOld < Error
+      def self.===(other)
+        if Cliver::Dependency::VersionMismatch === other
+          warn "#{name} exception has been deprecated in favor of using the " +
+               "cliver gem for command-line dependency detection. Please " +
+               "handle Cliver::Dependency::VersionMismatch instead."
+          true
+        else
+          super
+        end
+      end
+    end
+
+    class PhantomJSFailed < Error
+      def self.===(other)
+        if Cliver::Dependency::NotMet === other
+          warn "#{name} exception has been deprecated in favor of using the " +
+               "cliver gem for command-line dependency detection. Please " +
+               "handle Cliver::Dependency::NotMet instead."
+          true
+        else
+          super
+        end
+      end
+    end
+  end
+end