poltergeistFork 0.0.1

data/lib/capybara/poltergeist/client/web_page.coffee

@@ -0,0 +1,372 @@
+class Poltergeist.WebPage
+  @CALLBACKS = ['onConsoleMessage','onError',
+                'onLoadFinished', 'onInitialized', 'onLoadStarted',
+                'onResourceRequested', 'onResourceReceived', 'onResourceError',
+                'onNavigationRequested', 'onUrlChanged', 'onPageCreated',
+                'onClosing']
+
+  @DELEGATES = ['open', 'sendEvent', 'uploadFile', 'release', 'render',
+                'renderBase64', 'goBack', 'goForward']
+
+  @COMMANDS  = ['currentUrl', 'find', 'nodeCall', 'documentSize',
+                'beforeUpload', 'afterUpload', 'clearLocalStorage']
+
+  @EXTENSIONS = []
+
+  constructor: (@_native) ->
+    @_native or= require('webpage').create()
+
+    @id              = 0
+    @source          = null
+    @closed          = false
+    @state           = 'default'
+    @urlBlacklist    = []
+    @frames          = []
+    @errors          = []
+    @_networkTraffic = {}
+    @_tempHeaders    = {}
+    @_blockedUrls    = []
+
+    for callback in WebPage.CALLBACKS
+      this.bindCallback(callback)
+
+  for command in @COMMANDS
+    do (command) =>
+      this.prototype[command] =
+        (args...) -> this.runCommand(command, args)
+
+  for delegate in @DELEGATES
+    do (delegate) =>
+      this.prototype[delegate] =
+        -> @_native[delegate].apply(@_native, arguments)
+
+  onInitializedNative: ->
+    @id += 1
+    @source = null
+    @injectAgent()
+    this.removeTempHeaders()
+    this.setScrollPosition(left: 0, top: 0)
+
+  onClosingNative: ->
+    @handle = null
+    @closed = true
+
+  onConsoleMessageNative: (message) ->
+    if message == '__DOMContentLoaded'
+      @source = @_native.content
+      false
+    else
+      console.log(message)
+
+  onLoadStartedNative: ->
+    @state = 'loading'
+    @requestId = @lastRequestId
+
+  onLoadFinishedNative: (@status) ->
+    @state = 'default'
+    @source or= @_native.content
+
+  onErrorNative: (message, stack) ->
+    stackString = message
+
+    stack.forEach (frame) ->
+      stackString += "\n"
+      stackString += "    at #{frame.file}:#{frame.line}"
+      stackString += " in #{frame.function}" if frame.function && frame.function != ''
+
+    @errors.push(message: message, stack: stackString)
+    return true
+
+  onResourceRequestedNative: (request, net) ->
+    abort = @urlBlacklist.some (blacklisted_url) ->
+      request.url.indexOf(blacklisted_url) != -1
+
+    if abort
+      @_blockedUrls.push request.url unless request.url in @_blockedUrls
+      net.abort()
+    else
+      @lastRequestId = request.id
+
+      if @normalizeURL(request.url) == @redirectURL
+        @redirectURL = null
+        @requestId   = request.id
+
+      @_networkTraffic[request.id] = {
+        request:       request,
+        responseParts: []
+        error: null
+      }
+    return true
+
+  onResourceReceivedNative: (response) ->
+    @_networkTraffic[response.id]?.responseParts.push(response)
+
+    if @requestId == response.id
+      if response.redirectURL
+        @redirectURL = @normalizeURL(response.redirectURL)
+      else
+        @statusCode = response.status
+        @_responseHeaders = response.headers
+    return true
+
+  onResourceErrorNative: (errorResponse) ->
+    @_networkTraffic[errorResponse.id]?.error = errorResponse
+    return true
+
+  injectAgent: ->
+    if this.native().evaluate(-> typeof __poltergeist) == "undefined"
+      this.native().injectJs "#{phantom.libraryPath}/agent.js"
+      for extension in WebPage.EXTENSIONS
+        this.native().injectJs extension
+      return true
+    return false
+
+  injectExtension: (file) ->
+    WebPage.EXTENSIONS.push file
+    this.native().injectJs file
+
+  native: ->
+    if @closed
+      throw new Poltergeist.NoSuchWindowError
+    else
+      @_native
+
+  windowName: ->
+    this.native().windowName
+
+  keyCode: (name) ->
+    this.native().event.key[name]
+
+  keyModifierCode: (names) ->
+    modifiers = this.native().event.modifier
+    names = names.split(',').map ((name) -> modifiers[name])
+    names[0] | names[1] # return codes for 1 or 2 modifiers
+
+  keyModifierKeys: (names) ->
+    names.split(',').map (name) =>
+      this.keyCode(name.charAt(0).toUpperCase() + name.substring(1))
+
+  waitState: (state, callback) ->
+    if @state == state
+      callback.call()
+    else
+      setTimeout (=> @waitState(state, callback)), 100
+
+  setHttpAuth: (user, password) ->
+    this.native().settings.userName = user
+    this.native().settings.password = password
+    return true
+
+  networkTraffic: ->
+    @_networkTraffic
+
+  clearNetworkTraffic: ->
+    @_networkTraffic = {}
+    return true
+
+  blockedUrls: ->
+    @_blockedUrls
+
+  clearBlockedUrls: ->
+    @_blockedUrls = []
+    return true
+
+  content: ->
+    this.native().frameContent
+
+  title: ->
+    this.native().frameTitle
+
+  frameUrl: (frameNameOrId) ->
+    query = (frameNameOrId) ->
+      document.querySelector("iframe[name='#{frameNameOrId}'], iframe[id='#{frameNameOrId}']")?.src
+    this.evaluate(query, frameNameOrId)
+
+  clearErrors: ->
+    @errors = []
+    return true
+
+  responseHeaders: ->
+    headers = {}
+    @_responseHeaders.forEach (item) ->
+      headers[item.name] = item.value
+    headers
+
+  cookies: ->
+    this.native().cookies
+
+  deleteCookie: (name) ->
+    this.native().deleteCookie(name)
+
+  viewportSize: ->
+    this.native().viewportSize
+
+  setViewportSize: (size) ->
+    this.native().viewportSize = size
+
+  setZoomFactor: (zoom_factor) ->
+    this.native().zoomFactor = zoom_factor
+
+  setPaperSize: (size) ->
+    this.native().paperSize = size
+
+  scrollPosition: ->
+    this.native().scrollPosition
+
+  setScrollPosition: (pos) ->
+    this.native().scrollPosition = pos
+
+  clipRect: ->
+    this.native().clipRect
+
+  setClipRect: (rect) ->
+    this.native().clipRect = rect
+
+  elementBounds: (selector) ->
+    this.native().evaluate(
+      (selector) ->
+        document.querySelector(selector).getBoundingClientRect()
+      , selector
+    )
+
+  setUserAgent: (userAgent) ->
+    this.native().settings.userAgent = userAgent
+
+  getCustomHeaders: ->
+    this.native().customHeaders
+
+  setCustomHeaders: (headers) ->
+    this.native().customHeaders = headers
+
+  addTempHeader: (header) ->
+    for name, value of header
+      @_tempHeaders[name] = value
+    @_tempHeaders
+
+  removeTempHeaders: ->
+    allHeaders = this.getCustomHeaders()
+    for name, value of @_tempHeaders
+      delete allHeaders[name]
+    this.setCustomHeaders(allHeaders)
+
+  pushFrame: (name) ->
+    if this.native().switchToFrame(name)
+      @frames.push(name)
+      return true
+    else
+      frame_no = this.native().evaluate(
+        (frame_name) ->
+          frames = document.querySelectorAll("iframe, frame")
+          (idx for f, idx in frames when f?['name'] == frame_name or f?['id'] == frame_name)[0]
+        , name)
+      if frame_no? and this.native().switchToFrame(frame_no)
+        @frames.push(name)
+        return true
+      else
+        return false
+
+  popFrame: ->
+    @frames.pop()
+    this.native().switchToParentFrame()
+
+  dimensions: ->
+    scroll   = this.scrollPosition()
+    viewport = this.viewportSize()
+
+    top:    scroll.top,  bottom: scroll.top  + viewport.height,
+    left:   scroll.left, right:  scroll.left + viewport.width,
+    viewport: viewport
+    document: this.documentSize()
+
+  # A work around for http://code.google.com/p/phantomjs/issues/detail?id=277
+  validatedDimensions: ->
+    dimensions = this.dimensions()
+    document   = dimensions.document
+
+    if dimensions.right > document.width
+      dimensions.left  = Math.max(0, dimensions.left - (dimensions.right - document.width))
+      dimensions.right = document.width
+
+    if dimensions.bottom > document.height
+      dimensions.top    = Math.max(0, dimensions.top - (dimensions.bottom - document.height))
+      dimensions.bottom = document.height
+
+    this.setScrollPosition(left: dimensions.left, top: dimensions.top)
+
+    dimensions
+
+  get: (id) ->
+    new Poltergeist.Node(this, id)
+
+  # Before each mouse event we make sure that the mouse is moved to where the
+  # event will take place. This deals with e.g. :hover changes.
+  mouseEvent: (name, x, y, button = 'left') ->
+    this.sendEvent('mousemove', x, y)
+    this.sendEvent(name, x, y, button)
+
+  evaluate: (fn, args...) ->
+    this.injectAgent()
+    JSON.parse this.sanitize(this.native().evaluate("function() { return PoltergeistAgent.stringify(#{this.stringifyCall(fn, args)}) }"))
+
+  sanitize: (potential_string) ->
+    if typeof(potential_string) == "string"
+      # JSON doesn't like \r or \n in strings unless escaped
+      potential_string.replace("\n","\\n").replace("\r","\\r")
+    else
+      potential_string
+
+  execute: (fn, args...) ->
+    this.native().evaluate("function() { #{this.stringifyCall(fn, args)} }")
+
+  stringifyCall: (fn, args) ->
+    if args.length == 0
+      "(#{fn.toString()})()"
+    else
+      # The JSON.stringify happens twice because the second time we are essentially
+      # escaping the string.
+      "(#{fn.toString()}).apply(this, PoltergeistAgent.JSON.parse(#{JSON.stringify(JSON.stringify(args))}))"
+
+  # For some reason phantomjs seems to have trouble with doing 'fat arrow' binding here,
+  # hence the 'that' closure.
+  bindCallback: (name) ->
+    that = this
+    this.native()[name] = ->
+      if that[name + 'Native']? # For internal callbacks
+        result = that[name + 'Native'].apply(that, arguments)
+
+      if result != false && that[name]? # For externally set callbacks
+        that[name].apply(that, arguments)
+    return true
+
+  # Any error raised here or inside the evaluate will get reported to
+  # phantom.onError. If result is null, that means there was an error
+  # inside the agent.
+  runCommand: (name, args) ->
+    result = this.evaluate(
+      (name, args) -> __poltergeist.externalCall(name, args),
+      name, args
+    )
+
+    if result != null
+      if result.error?
+        switch result.error.message
+          when 'PoltergeistAgent.ObsoleteNode'
+            throw new Poltergeist.ObsoleteNode
+          when 'PoltergeistAgent.InvalidSelector'
+            [method, selector] = args
+            throw new Poltergeist.InvalidSelector(method, selector)
+          else
+            throw new Poltergeist.BrowserError(result.error.message, result.error.stack)
+      else
+        result.value
+
+  canGoBack: ->
+    this.native().canGoBack
+
+  canGoForward: ->
+    this.native().canGoForward
+
+  normalizeURL: (url) ->
+    parser = document.createElement('a')
+    parser.href = url
+    return parser.href

data/lib/capybara/poltergeist/command.rb

@@ -0,0 +1,17 @@
+require 'securerandom'
+
+module Capybara::Poltergeist
+  class Command
+    attr_reader :id
+
+    def initialize(name, *args)
+      @id = SecureRandom.uuid
+      @name = name
+      @args = args
+    end
+
+    def message
+      JSON.dump({ 'id' => @id, 'name' => @name, 'args' => @args })
+    end
+  end
+end

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,394 @@
+require 'uri'
+
+module Capybara::Poltergeist
+  class Driver < Capybara::Driver::Base
+    DEFAULT_TIMEOUT = 30
+
+    attr_reader :app, :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] || []
+
+      # PhantomJS defaults to only using SSLv3, which since POODLE (Oct 2014)
+      # many sites have dropped from their supported protocols (eg PayPal,
+      # Braintree).
+      list += ["--ssl-protocol=any"] unless list.grep(/ssl-protocol/).any?
+
+      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 current_window_handle
+      browser.window_handle
+    end
+
+    def window_handles
+      browser.window_handles
+    end
+
+    def close_window(handle)
+      browser.close_window(handle)
+    end
+
+    def open_new_window
+      browser.open_new_window
+    end
+
+    def switch_to_window(handle)
+      browser.switch_to_window(handle)
+    end
+
+    def within_window(name, &block)
+      browser.within_window(name, &block)
+    end
+
+    def no_such_window_error
+      NoSuchWindowError
+    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 set_screen_size(s_width,s_height)
+      browser.set_screen_size(s_width, s_width)
+    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 resize_window_to(handle, width, height)
+      within_window(handle) do
+        resize(width, height)
+      end
+    end
+
+    def window_size(handle)
+      within_window(handle) do
+        evaluate_script('[window.innerWidth, window.innerHeight]')
+      end
+    end
+
+    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
+          URI.parse(Capybara.app_host || '').host || "127.0.0.1"
+        end
+      end
+
+      browser.set_cookie(options)
+    end
+
+    def remove_cookie(name)
+      browser.remove_cookie(name)
+    end
+
+    def clear_cookies
+      browser.clear_cookies
+    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]
+        # Fall back to default scheme
+        scheme = URI.parse(browser.current_url).scheme rescue nil
+        scheme = 'http' if scheme != 'https'
+        inspector.open(scheme)
+        pause
+      else
+        raise Error, "To use the remote debugging, you have to launch the driver " \
+                     "with `:inspector => true` configuration option"
+      end
+    end
+
+    def pause
+      # STDIN is not necessarily connected to a keyboard. It might even be closed.
+      # So we need a method other than keypress to continue.
+
+      # In jRuby - STDIN returns immediately from select
+      # see https://github.com/jruby/jruby/issues/1783
+      read, write = IO.pipe
+      Thread.new { IO.copy_stream(STDIN, write); write.close }
+
+      STDERR.puts "Poltergeist execution paused. Press enter (or run 'kill -CONT #{Process.pid}') to continue."
+
+      signal = false
+      old_trap = trap('SIGCONT') { signal = true; STDERR.puts "\nSignal SIGCONT received" }
+      keyboard = IO.select([read], nil, nil, 1) until keyboard || signal # wait for data on STDIN or signal SIGCONT received
+
+      begin
+        input = read.read_nonblock(80) # clear out the read buffer
+        puts unless input && input =~ /\n\z/
+      rescue EOFError, IO::WaitReadable # Ignore problems reading from STDIN.
+      end unless signal
+
+      trap('SIGCONT', old_trap) # Restore the previuos signal handler, if there was one.
+
+      STDERR.puts 'Continuing'
+    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
+
+    def accept_modal(type, options = {})
+      case type
+      when :confirm
+        browser.accept_confirm
+      when :prompt
+        browser.accept_prompt options[:with]
+      end
+
+      yield if block_given?
+
+      find_modal(options)
+    end
+
+    def dismiss_modal(type, options = {})
+      case type
+      when :confirm
+        browser.dismiss_confirm
+      when :prompt
+        browser.dismiss_prompt
+      end
+
+      yield if block_given?
+      find_modal(options)
+    end
+
+    private
+
+    def find_modal(options)
+      start_time    = Time.now
+      timeout_sec   = options[:wait] || begin Capybara.default_max_wait_time rescue Capybara.default_wait_time end
+      expect_text   = options[:text]
+      not_found_msg = 'Unable to find modal dialog'
+      not_found_msg += " with #{expect_text}" if expect_text
+
+      begin
+        modal_text = browser.modal_message
+        raise Capybara::ModalNotFound if modal_text.nil?
+        raise Capybara::ModalNotFound if (expect_text && (modal_text != expect_text))
+      rescue Capybara::ModalNotFound => e
+        raise e, not_found_msg if (Time.now - start_time) >= timeout_sec
+        sleep(0.05)
+        retry
+      end
+      modal_text
+    end
+  end
+end