apparition 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9aa4f4946fd5bbdd57c5547b6dd179c2c9f91737e4810bc331ac7155b9efb542
+  data.tar.gz: 8bdbca6fc6c5598a8827627f10b4dc9dfbbe94df5b57ea006a80d13a8bf4402a
+SHA512:
+  metadata.gz: 47c7ddf86e36760c0d26c64e59a157d5e32871e106977dd166acceeca7cd3b07e27131d02e6ec1487d74cba6cdebad8831ea6b6a2e79fcf4d00dbe53fd02be70
+  data.tar.gz: 50d6f7f64911974d0f17687500a2059efba3ccd3f609f5c96f7fb09ba37a193f77d537c13c50b3fbf7a27d033ea3c0b591ee33023a991870637f211db5705ed3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2019 Thomas Walpole
+
+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.

data/README.md

@@ -0,0 +1,251 @@
+# Apparition - A Chrome driver for Capybara #
+
+[![Build Status](https://secure.travis-ci.org/twalpole/apparition.svg)](http://travis-ci.org/twalpole/apparition)
+
+Apparition is a driver for [Capybara](https://github.com/jnicklas/capybara). It allows you to
+run your Capybara tests in the Chrome browser via CDP (no selenium or chromedriver needed) in a headless or
+headed configuration. It started as a fork of Poltergeist and attempts to maintain as much compatibility
+with the Poltergeist API as possible, with the thought to add a capybara-webkit compatibility wrapper at some future point in time.
+
+## Getting help ##
+
+Questions should be posted [on Stack
+Overflow, using the 'capybara' tag](http://stackoverflow.com/questions/tagged/capybara) and mentioning
+you are using the apparition driver.
+
+Bug reports should be posted [on GitHub](https://github.com/twalpole/apparition/issues) (and be sure
+to read the bug reporting guidance below).
+
+## Installation ##
+
+Add either
+
+``` ruby
+gem 'apparition'
+```
+
+or
+
+``` ruby
+gem apparition', github: 'twalpole/apparition'
+```
+
+to your Gemfile and run `bundle install`.
+
+In your test setup add:
+
+``` ruby
+require 'capybara/apparition'
+Capybara.javascript_driver = :apparition
+```
+
+If you were previously using the `:rack_test` driver, be aware that your app will now run in a separate thread and this can have
+consequences for transactional tests. [See the Capybara README for more detail](https://github.com/teamcapybara/capybara/blob/master/README.md#transactions-and-database-setup).
+
+## What's supported? ##
+
+Apparition supports all Capybara features, and the following extended features:
+
+* `page.status_code`
+* `page.response_headers`
+* `page.driver.render_base64(format, options)`
+* `page.driver.scroll_to(left, top)`
+* `page.driver.basic_authorize(user, password)`
+* `page.driver.set_proxy(ip, port, type, user, password)`
+* cookie handling
+* extra headers
+
+There are some additional features:
+
+### Taking screenshots with some extensions ###
+
+You can grab screenshots of the page at any point by calling
+`save_screenshot('/path/to/file.png')`.
+
+By default, only the viewport will be rendered (the part of the page that is in
+view). To render the entire page, use `save_screenshot('/path/to/file.png',
+full: true)`.
+
+You also have an ability to render selected element. Pass option `selector` with
+any valid CSS element selector to make a screenshot bounded by that element
+`save_screenshot('/path/to/file.png', selector: '#id')`.
+
+If the desired image format is not identifiable from the filename passed you can
+also pass in a `format:` option with accepable values being `:png` or `:jpeg`
+
+If, for some reason, you need a base64 encoded screenshot you can simply call
+`render_base64` which will return your encoded image. Additional options are the
+same as for `save_screenshot`.
+
+### Clicking precise coordinates ###
+
+Sometimes its desirable to click a very specific area of the screen. You can accomplish this with
+`page.driver.click(x, y)`, where x and y are the screen coordinates.
+
+### Manipulating request headers ###
+
+You can manipulate HTTP request headers with these methods:
+
+``` ruby
+page.driver.headers # => {}
+page.driver.headers = { "User-Agent" => "Apparition" }
+page.driver.add_headers("Referer" => "https://example.com")
+page.driver.headers # => { "User-Agent" => "Apparition", "Referer" => "https://example.com" }
+```
+
+Notice that `headers=` will overwrite already set headers. You should use
+`add_headers` if you want to add a few more. These headers will apply to all
+subsequent HTTP requests (including requests for assets, AJAX, etc). They will
+be automatically cleared at the end of the test. You have ability to set headers
+only for the initial request:
+
+``` ruby
+page.driver.headers = { "User-Agent" => "Apparition" }
+page.driver.add_header("Referer", "http://example.com", permanent: false)
+page.driver.headers # => { "User-Agent" => "Apparition", "Referer" => "http://example.com" }
+visit(login_path)
+page.driver.headers # => { "User-Agent" => "Apparition" }
+```
+
+This way your temporary headers will be sent only for the initial request, and related 30x redirects. All
+subsequent request will only contain your permanent headers. If the temporary
+headers should not be sent on related 30x redirects, specify `permanent: :no_redirect`.
+
+### Inspecting network traffic ###
+
+You can inspect the network traffic (i.e. what resources have been
+loaded) on the current page by calling `page.driver.network_traffic`.
+This returns an array of request objects. A request object has a
+`response_parts` method containing data about the response chunks.
+
+You can inspect requests that were blocked by a whitelist or blacklist
+by calling `page.driver.network_traffic(:blocked)`. This returns an array of
+request objects. The `response_parts` portion of these requests will always
+be empty.
+
+Please note that network traffic is not cleared when you visit new page.
+You can manually clear the network traffic by calling `page.driver.clear_network_traffic`
+or `page.driver.reset`
+
+### Manipulating cookies ###
+
+The following methods are used to inspect and manipulate cookies:
+
+* `page.driver.cookies` - a hash of cookies accessible to the current
+  page. The keys are cookie names. The values are `Cookie` objects, with
+  the following methods: `name`, `value`, `domain`, `path`, `secure?`,
+  `httponly?`, `samesite`, `expires`.
+* `page.driver.set_cookie(name, value, options = {})` - set a cookie.
+  The options hash can take the following keys: `:domain`, `:path`,
+  `:secure`, `:httponly`, `:samesite`, `:expires`. `:expires` should be a
+  `Time` object.
+* `page.driver.remove_cookie(name)` - remove a cookie
+* `page.driver.clear_cookies` - clear all cookies
+
+## Customization ##
+
+You can customize the way that Capybara sets up Apparition via the following code in your
+test setup:
+
+``` ruby
+Capybara.register_driver :apparition do |app|
+  Capybara::Apparition::Driver.new(app, options)
+end
+```
+
+`options` is a hash of options. The following options are supported:
+
+*   `:headless` (Boolean) - When false, run the browser visibly
+*   `:debug` (Boolean) - When true, debug output is logged to `STDERR`.
+*   `:logger` (Object responding to `puts`) - When present, debug output is written to this object
+*   `:browser_logger` (`IO` object) - Where the `STDOUT` from Chromium is written to. This is
+    where your `console.log` statements will show up. Default: `STDOUT`
+*   `:timeout` (Numeric) - The number of seconds we'll wait for a response
+    when communicating with Chrome. Default is 30.
+*   `:inspector` (Boolean, String) - See 'Remote Debugging', above.
+*   `:js_errors` (Boolean) - When false, JavaScript errors do not get re-raised in Ruby.
+*   `:window_size` (Array) - The dimensions of the browser window in which to test, expressed
+    as a 2-element array, e.g. [1024, 768]. Default: [1024, 768]
+*   `:screen_size` (Array) - The dimensions the window size will be set to when Window#maximize is called in headless mode.  Expressed
+    as a 2-element array, e.g. [1600, 1200]. Default: [1366, 768]
+*   `:extensions` (Array) - An array of JS files to be preloaded into
+    the browser. Useful for faking or mocking APIs.
+*   `:url_blacklist` (Array) - Default session url blacklist - expressed as an array of strings to match against requested URLs.
+*   `:url_whitelist` (Array) - Default session url whitelist - expressed as an array of strings to match against requested URLs.
+*   `:browser_options` (Hash) - Extra command line options to pass to Chrome when starting
+
+### URL Blacklisting & Whitelisting ###
+Apparition supports URL blacklisting, which allows you
+to prevent scripts from running on designated domains:
+
+```ruby
+page.driver.browser.url_blacklist = ['http://www.example.com']
+```
+
+and also URL whitelisting, which allows scripts to only run
+on designated domains:
+
+```ruby
+page.driver.browser.url_whitelist = ['http://www.example.com']
+```
+
+If you are experiencing slower run times, consider creating a
+URL whitelist of domains that are essential or a blacklist of
+domains that are not essential, such as ad networks or analytics,
+to your testing environment.
+
+
+### Timing problems ###
+
+Sometimes tests pass and fail sporadically. This is often because there
+is some problem synchronising events properly. It's often
+straightforward to verify this by adding `sleep` statements into your
+test to allow sufficient time for the page to settle.
+
+If you have these types of problems, read through the [Capybara
+documentation on asynchronous
+JavaScript](https://github.com/jnicklas/capybara#asynchronous-javascript-ajax-and-friends)
+which explains the tools that Capybara provides for dealing with this.
+
+### Filing a bug ###
+
+If you can provide specific steps to reproduce your problem, or have
+specific information that might help track down the problem, then please file a bug on Github.
+
+Include as much information as possible. For example:
+
+* Specific steps to reproduce where possible (failing tests are even
+  better)
+* The output obtained from running Apparition with `:debug` turned on
+* Screenshots
+* Stack traces if there are any Ruby on JavaScript exceptions generated
+* The Apparition, Capybara, and Chrome version numbers used
+* The operating system name and version used
+
+## Changes ##
+
+Version history and a list of next-release features and fixes can be found in
+the [changelog](CHANGELOG.md).
+
+## License ##
+
+Copyright (c) 2019 Thomas Walpole
+
+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.

data/lib/capybara/apparition.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'capybara'
+
+module Capybara
+  module Apparition
+    require 'capybara/apparition/utility'
+    require 'capybara/apparition/driver'
+    require 'capybara/apparition/browser'
+    require 'capybara/apparition/node'
+    require 'capybara/apparition/inspector'
+    require 'capybara/apparition/network_traffic'
+    require 'capybara/apparition/errors'
+    require 'capybara/apparition/cookie'
+  end
+end
+
+Capybara.register_driver :apparition do |app|
+  Capybara::Apparition::Driver.new(app)
+end

data/lib/capybara/apparition/browser.rb

@@ -0,0 +1,532 @@
+# frozen_string_literal: true
+
+require 'capybara/apparition/errors'
+require 'capybara/apparition/command'
+require 'capybara/apparition/dev_tools_protocol/target_manager'
+require 'capybara/apparition/page'
+require 'json'
+require 'time'
+
+module Capybara::Apparition
+  class Browser
+    attr_reader :client, :logger, :paper_size
+
+    def initialize(client, logger = nil)
+      @client = client
+      @logger = logger
+      @current_page_handle = nil
+      @targets = Capybara::Apparition::DevToolsProtocol::TargetManager.new
+      @context_id = nil
+      @js_errors = true
+
+      initialize_handlers
+
+      command('Target.setDiscoverTargets', discover: true)
+      while @current_page_handle.nil?
+        puts 'waiting for target...'
+        sleep 0.1
+      end
+    end
+
+    def restart
+      puts 'handle client restart'
+      # client.restart
+
+      self.debug = @debug if defined?(@debug)
+      self.js_errors = @js_errors if defined?(@js_errors)
+      self.extensions = @extensions if @extensions
+    end
+
+    def visit(url)
+      current_page.visit url
+    end
+
+    def current_url
+      current_page.current_url
+    end
+
+    def status_code
+      current_page.status_code
+    end
+
+    def body
+      current_page.content
+    end
+
+    def source
+      # Is this still useful?
+      # command 'source'
+    end
+
+    def title
+      # Updated info doesn't have correct title when changed programmatically
+      # current_target.title
+      current_page.title
+    end
+
+    def frame_title
+      current_page.frame_title
+    end
+
+    def frame_url
+      current_page.frame_url
+    end
+
+    def find(method, selector)
+      current_page.find(method, selector)
+    end
+
+    def click_coordinates(x, y)
+      current_page.click_at(x, y)
+    end
+
+    def evaluate(script, *args)
+      current_page.evaluate(script, *args)
+    end
+
+    def evaluate_async(script, wait_time, *args)
+      current_page.evaluate_async(script, wait_time, *args)
+    end
+
+    def execute(script, *args)
+      current_page.execute(script, *args)
+    end
+
+    def switch_to_frame(frame)
+      case frame
+      when Capybara::Node::Base
+        current_page.push_frame(frame)
+      when :parent
+        current_page.pop_frame
+      when :top
+        current_page.pop_frame(top: true)
+      end
+    end
+
+    def window_handle
+      @current_page_handle
+    end
+
+    def window_handles
+      @targets.window_handles
+    end
+
+    def switch_to_window(handle)
+      target = @targets.get(handle)
+      raise NoSuchWindowError unless target&.page
+
+      target.page.wait_for_loaded
+      @current_page_handle = handle
+    end
+
+    def open_new_window
+      context_id = @context_id || current_target.info['browserContextId']
+      info = command('Target.createTarget', url: 'about:blank', browserContextId: context_id)
+      target_id = info['targetId']
+      target = DevToolsProtocol::Target.new(self, info.merge('type' => 'page', 'inherit' => current_page))
+      target.page # Ensure page object construction happens
+      @targets.add(target_id, target)
+      target_id
+    end
+
+    def close_window(handle)
+      @targets.delete(handle)
+      @current_page_handle = nil if @current_page_handle == handle
+      command('Target.closeTarget', targetId: handle)
+    end
+
+    def within_window(locator)
+      original = window_handle
+      handle = find_window_handle(locator)
+      switch_to_window(handle)
+      yield
+    ensure
+      switch_to_window(original)
+    end
+
+    def reset
+      command('Target.disposeBrowserContext', browserContextId: @context_id) if @context_id
+
+      @context_id = command('Target.createBrowserContext')['browserContextId']
+      target_id = command('Target.createTarget', url: 'about:blank', browserContextId: @context_id)['targetId']
+
+      start = Time.now
+      until @targets.get(target_id)&.page&.usable?
+        if Time.now - start > 5
+          puts 'Timedout waiting for reset'
+          # byebug
+          raise TimeoutError.new('reset')
+        end
+        sleep 0.01
+      end
+      @current_page_handle = target_id
+      true
+    end
+
+    def scroll_to(left, top)
+      current_page.scroll_to(left, top)
+    end
+
+    def render(path, options = {})
+      options[:format] ||= File.extname(path).downcase[1..-1]
+      check_render_options!(options)
+      options[:full] = !!options[:full]
+      img_data = current_page.render(options)
+      File.open(path, 'wb') { |f| f.write(Base64.decode64(img_data)) }
+    end
+
+    def render_base64(_format, options = {})
+      check_render_options!(options)
+      options[:full] = !!options[:full]
+      current_page.render(options)
+    end
+
+    # def set_zoom_factor(zoom_factor)
+    #   TODO: implement if needed
+    #   command 'set_zoom_factor', zoom_factor
+    # end
+
+    def set_paper_size(size)
+      @paper_size = size
+    end
+
+    def resize(width, height, screen: nil)
+      current_page.set_viewport width: width, height: height, screen: screen
+    end
+
+    def fullscreen
+      current_page.fullscreen
+    end
+
+    def maximize
+      current_page.maximize
+    end
+
+    def network_traffic(type = nil)
+      case type
+      when :blocked
+        current_page.network_traffic.select(&:blocked?)
+      else
+        current_page.network_traffic
+      end
+    end
+
+    def clear_network_traffic
+      current_page.clear_network_traffic
+    end
+
+    def set_proxy(ip, port, type, user, password)
+      args = [ip, port, type]
+      args << user if user
+      args << password if password
+      # TODO: Implement via CDP if possible
+      # command('set_proxy', *args)
+    end
+
+    def equals(page_id, id, other_id)
+      # TODO: Implement if still needed
+      # command('equals', page_id, id, other_id)
+    end
+
+    def get_headers
+      current_page.extra_headers
+    end
+
+    def set_headers(headers)
+      @targets.pages.each do |page|
+        page.perm_headers = headers
+        page.temp_headers = {}
+        page.temp_no_redirect_headers = {}
+        page.update_headers
+      end
+    end
+
+    def add_headers(headers)
+      current_page.perm_headers.merge! headers
+      current_page.update_headers
+    end
+
+    def add_header(header, permanent: true, **_options)
+      if permanent == true
+        @targets.pages.each do |page|
+          page.perm_headers.merge! header
+          page.update_headers
+        end
+      else
+        if permanent.to_s == 'no_redirect'
+          current_page.temp_no_redirect_headers.merge! header
+        else
+          current_page.temp_headers.merge! header
+        end
+        current_page.update_headers
+      end
+    end
+
+    def response_headers
+      current_page.response_headers
+    end
+
+    def cookies
+      current_page.command('Network.getCookies')['cookies'].each_with_object({}) do |c, h|
+        h[c['name']] = Cookie.new(c)
+      end
+    end
+
+    def set_cookie(cookie)
+      if cookie[:expires]
+        # cookie[:expires] = cookie[:expires].to_i * 1000
+        cookie[:expires] = cookie[:expires].to_i
+      end
+
+      current_page.command('Network.setCookie', cookie)
+    end
+
+    def remove_cookie(name)
+      current_page.command('Network.deleteCookies', name: name, url: current_url)
+    end
+
+    def clear_cookies
+      current_page.command('Network.clearBrowserCookies')
+    end
+
+    def cookies_enabled=(flag)
+      current_page.command('Emulation.setDocumentCookieDisabled', disabled: !flag)
+    end
+
+    def set_http_auth(user = nil, password = nil)
+      current_page.credentials = if user.nil? && password.nil?
+        nil
+      else
+        { username: user, password: password }
+      end
+    end
+
+    attr_accessor :js_errors
+
+    def extensions=(filenames)
+      @extensions = filenames
+      Array(filenames).each do |name|
+        begin
+          current_page.command('Page.addScriptToEvaluateOnNewDocument', source: File.read(name))
+        rescue Errno::ENOENT
+          raise ::Capybara::Apparition::BrowserError.new('name' => "Unable to load extension: #{name}", 'args' => nil)
+        end
+      end
+    end
+
+    def url_whitelist=(whitelist)
+      current_page&.url_whitelist = whitelist
+    end
+
+    def url_blacklist=(blacklist)
+      current_page&.url_blacklist = blacklist
+    end
+
+    attr_writer :debug
+
+    def clear_memory_cache
+      current_page.command('Network.clearBrowserCache')
+    end
+
+    def command(name, params = {})
+      cmd = Command.new(name, params)
+      log cmd.message
+
+      response = client.send_cmd(name, params, async: false)
+      log response
+
+      response || raise(Capybara::Apparition::ObsoleteNode.new(nil, nil))
+    rescue DeadClient
+      restart
+      raise
+    end
+
+    def command_for_session(session_id, name, params, async: false)
+      cmd = Command.new(name, params)
+      log cmd.message
+
+      response = client.send_cmd_to_session(session_id, name, params, async: async)
+      log response
+
+      response
+    rescue DeadClient
+      restart
+      raise
+    end
+
+    def go_back
+      current_page.go_back
+    end
+
+    def go_forward
+      current_page.go_forward
+    end
+
+    def refresh
+      current_page.refresh
+    end
+
+    def accept_alert
+      current_page.add_modal(alert: true)
+    end
+
+    def accept_confirm
+      current_page.add_modal(confirm: true)
+    end
+
+    def dismiss_confirm
+      current_page.add_modal(confirm: false)
+    end
+
+    #
+    # press "OK" with text (response) or default value
+    #
+    def accept_prompt(response)
+      current_page.add_modal(prompt: response)
+    end
+
+    #
+    # press "Cancel"
+    #
+    def dismiss_prompt
+      current_page.add_modal(prompt: false)
+    end
+
+    def modal_message
+      current_page.modal_messages.shift
+    end
+
+    def current_page
+      current_target.page
+    end
+
+  private
+
+    def current_target
+      @targets.get(@current_page_handle) || begin
+        puts "No current page: #{@current_page_handle}"
+        @current_page_handle = nil
+        raise NoSuchWindowError
+      end
+    end
+
+    def log(message)
+      logger&.puts message
+    end
+
+    def check_render_options!(options)
+      options[:format] = :jpeg if options[:format].to_s == 'jpg'
+      return unless options[:full] && options.key?(:selector)
+
+      warn "Ignoring :selector in #render since :full => true was given at #{caller(1..1)}"
+      options.delete(:selector)
+    end
+
+    def find_window_handle(locator)
+      return locator if window_handles.include? locator
+
+      window_handles.each do |handle|
+        switch_to_window(handle)
+        return handle if evaluate('window.name') == locator
+      end
+      raise NoSuchWindowError
+    end
+
+    KEY_ALIASES = {
+      command: :Meta,
+      equals: :Equal,
+      control: :Control,
+      ctrl: :Control,
+      multiply: 'numpad*',
+      add: 'numpad+',
+      divide: 'numpad/',
+      subtract: 'numpad-',
+      decimal: 'numpad.',
+      left: 'ArrowLeft',
+      right: 'ArrowRight',
+      down: 'ArrowDown',
+      up: 'ArrowUp'
+    }.freeze
+
+    def normalize_keys(keys)
+      keys.map do |key_desc|
+        case key_desc
+        when Array
+          # [:Shift, "s"] => { modifier: "shift", keys: "S" }
+          # [:Shift, "string"] => { modifier: "shift", keys: "STRING" }
+          # [:Ctrl, :Left] => { modifier: "ctrl", key: 'Left' }
+          # [:Ctrl, :Shift, :Left] => { modifier: "ctrl,shift", key: 'Left' }
+          # [:Ctrl, :Left, :Left] => { modifier: "ctrl", key: [:Left, :Left] }
+          keys_chunks = key_desc.chunk do |k|
+            k.is_a?(Symbol) && %w[shift ctrl control alt meta command].include?(k.to_s.downcase)
+          end
+          modifiers = modifiers_from_chunks(keys_chunks)
+          letters = normalize_keys(_keys.next[1].map { |k| k.is_a?(String) ? k.upcase : k })
+          { modifier: modifiers, keys: letters }
+        when Symbol
+          symbol_to_desc(key_desc)
+        when String
+          key_desc # Plain string, nothing to do
+        end
+      end
+    end
+
+    def modifiers_from_chunks(chunks)
+      if chunks.peek[0]
+        chunks.next[1].map do |k|
+          k = k.to_s.downcase
+          k = 'control' if k == 'ctrl'
+          k = 'meta' if k == 'command'
+          k
+        end.join(',')
+      else
+        ''
+      end
+    end
+
+    def symbol_to_desc(symbol)
+      if symbol == :space
+        res = ' '
+      else
+        key = KEY_ALIASES.fetch(symbol.downcase, symbol)
+        if (match = key.to_s.match(/numpad(.)/))
+          res = { keys: match[1], modifier: 'keypad' }
+        elsif !/^[A-Z]/.match?(key)
+          key = key.to_s.split('_').map(&:capitalize).join
+        end
+      end
+      res || { key: key }
+    end
+
+    def initialize_handlers
+      @client.on 'Target.targetCreated' do |info|
+        puts "Target Created Info: #{info}" if ENV['DEBUG']
+        target_info = info['targetInfo']
+        if !@targets.target?(target_info['targetId'])
+          @targets.add(target_info['targetId'], DevToolsProtocol::Target.new(self, target_info))
+          puts "**** Target Added #{info}" if ENV['DEBUG']
+        elsif ENV['DEBUG']
+          puts "Target already existed #{info}"
+        end
+        @current_page_handle ||= target_info['targetId'] if target_info['type'] == 'page'
+      end
+
+      @client.on 'Target.targetDestroyed' do |info|
+        puts "**** Target Destroyed Info: #{info}" if ENV['DEBUG']
+        @targets.delete(info['targetId'])
+      end
+
+      @client.on 'Target.targetInfoChanged' do |info|
+        puts "**** Target Info Changed: #{info}" if ENV['DEBUG']
+        target_info = info['targetInfo']
+        target = @targets.get(target_info['targetId'])
+        if target
+          target.info.merge!(target_info)
+        else
+          puts '****No target for the info change- creating****' if ENV['DEBUG']
+          @targets.add(target_info['targetId'], DevToolsProtocol::Target.new(self, target_info))
+        end
+      end
+    end
+  end
+end