selenium-webdriver 2.53.4 → 3.8.0

data/lib/selenium/webdriver/ie/driver.rb

@@ -0,0 +1,90 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Selenium
+  module WebDriver
+    module IE
+
+      #
+      # Driver implementation for Internet Explorer supporting
+      # both OSS and W3C dialects of JSON wire protocol.
+      # @api private
+      #
+
+      class Driver < WebDriver::Driver
+        include DriverExtensions::TakesScreenshot
+
+        def initialize(opts = {})
+          opts[:desired_capabilities] = create_capabilities(opts)
+
+          unless opts.key?(:url)
+            driver_path = opts.delete(:driver_path) || IE.driver_path
+            driver_opts = opts.delete(:driver_opts) || {}
+            port = opts.delete(:port) || Service::DEFAULT_PORT
+
+            @service = Service.new(driver_path, port, driver_opts)
+            @service.start
+            opts[:url] = @service.uri
+          end
+
+          listener = opts.delete(:listener)
+          @bridge = Remote::Bridge.handshake(opts)
+          super(@bridge, listener: listener)
+        end
+
+        def browser
+          :internet_explorer
+        end
+
+        def quit
+          super
+        ensure
+          @service.stop if @service
+        end
+
+        private
+
+        def create_capabilities(opts)
+          caps = opts.delete(:desired_capabilities) { Remote::Capabilities.internet_explorer }
+          options = opts.delete(:options) { Options.new }
+
+          if opts.delete(:introduce_flakiness_by_ignoring_security_domains)
+            WebDriver.logger.deprecate ':introduce_flakiness_by_ignoring_security_domains',
+                                       'Selenium::WebDriver::IE::Options#ignore_protected_mode_settings='
+            options.ignore_protected_mode_settings = true
+          end
+
+          native_events = opts.delete(:native_events)
+          unless native_events.nil?
+            WebDriver.logger.deprecate ':native_events', 'Selenium::WebDriver::IE::Options#native_events='
+            options.native_events = native_events
+          end
+
+          # Backward compatibility with older IEDriverServer versions
+          caps[:ignore_protected_mode_settings] = options.ignore_protected_mode_settings
+          caps[:native_events] = options.native_events
+
+          options = options.as_json
+          caps.merge!(options) unless options.empty?
+
+          caps
+        end
+
+      end # Driver
+    end # IE
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/ie/options.rb

@@ -0,0 +1,136 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Selenium
+  module WebDriver
+    module IE
+      class Options
+        KEY = 'se:ieOptions'.freeze
+        SCROLL_TOP = 0
+        SCROLL_BOTTOM = 1
+        CAPABILITIES = {
+          browser_attach_timeout: 'browserAttachTimeout',
+          element_scroll_behavior: 'elementScrollBehavior',
+          full_page_screenshot: 'ie.enableFullPageScreenshot',
+          ensure_clean_session: 'ie.ensureCleanSession',
+          file_upload_dialog_timeout: 'ie.fileUploadDialogTimeout',
+          force_create_process_api: 'ie.forceCreateProcessApi',
+          force_shell_windows_api: 'ie.forceShellWindowsApi',
+          ignore_protected_mode_settings: 'ignoreProtectedModeSettings',
+          ignore_zoom_level: 'ignoreZoomSetting',
+          initial_browser_url: 'initialBrowserUrl',
+          native_events: 'nativeEvents',
+          persistent_hover: 'enablePersistentHover',
+          require_window_focus: 'requireWindowFocus',
+          use_per_process_proxy: 'ie.usePerProcessProxy',
+          validate_cookie_document_type: 'ie.validateCookieDocumentType'
+        }.freeze
+
+        CAPABILITIES.each_key do |key|
+          define_method key do
+            @options[key]
+          end
+
+          define_method "#{key}=" do |value|
+            @options[key] = value
+          end
+        end
+
+        attr_reader :args, :options
+
+        #
+        # Create a new Options instance
+        #
+        # @example
+        #   options = Selenium::WebDriver::IE::Options.new(args: ['--host=127.0.0.1'])
+        #   driver = Selenium::WebDriver.for(:ie, options: options)
+        #
+        # @example
+        #   options = Selenium::WebDriver::IE::Options.new
+        #   options.element_scroll_behavior = Selenium::WebDriver::IE::Options::SCROLL_BOTTOM
+        #   driver = Selenium::WebDriver.for(:ie, options: options)
+        #
+        # @param [Hash] opts the pre-defined options
+        # @option opts [Array<String>] args
+        # @option opts [Integer] browser_attach_timeout
+        # @option opts [Integer] element_scroll_behavior Either SCROLL_TOP or SCROLL_BOTTOM
+        # @option opts [Boolean] full_page_screenshot
+        # @option opts [Boolean] ensure_clean_session
+        # @option opts [Integer] file_upload_dialog_timeout
+        # @option opts [Boolean] force_create_process_api
+        # @option opts [Boolean] force_shell_windows_api
+        # @option opts [Boolean] ignore_protected_mode_settings
+        # @option opts [Boolean] ignore_zoom_level
+        # @option opts [String] initial_browser_url
+        # @option opts [Boolean] native_events
+        # @option opts [Boolean] persistent_hover
+        # @option opts [Boolean] require_window_focus
+        # @option opts [Boolean] use_per_process_proxy
+        # @option opts [Boolean] validate_cookie_document_type
+        #
+
+        def initialize(**opts)
+          @args = opts.delete(:args) || []
+          @options = opts
+          @options[:native_events] ||= true
+        end
+
+        #
+        # Add a command-line argument to use when starting Internet Explorer.
+        #
+        # @param [String] arg The command-line argument to add
+        #
+
+        def add_argument(arg)
+          @args << arg
+        end
+
+        #
+        # Add a new option not yet handled by these bindings.
+        #
+        # @example
+        #   options = Selenium::WebDriver::IE::Options.new
+        #   options.add_option(:foo, 'bar')
+        #
+        # @param [String, Symbol] name Name of the option
+        # @param [Boolean, String, Integer] value Value of the option
+        #
+
+        def add_option(name, value)
+          @options[name] = value
+        end
+
+        #
+        # @api private
+        #
+
+        def as_json(*)
+          opts = {}
+
+          CAPABILITIES.each do |capability_alias, capability_name|
+            capability_value = @options.delete(capability_alias)
+            opts[capability_name] = capability_value unless capability_value.nil?
+          end
+          opts['ie.browserCommandLineSwitches'] = @args.join(' ') if @args.any?
+          opts.merge!(@options)
+
+          {KEY => opts}
+        end
+      end # Options
+    end # IE
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/ie/service.rb

@@ -0,0 +1,58 @@
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Selenium
+  module WebDriver
+    module IE
+      #
+      # @api private
+      #
+
+      class Service < WebDriver::Service
+        DEFAULT_PORT = 5555
+        @executable = 'IEDriverServer'.freeze
+        @missing_text = <<-ERROR.gsub(/\n +| {2,}/, ' ').freeze
+          Unable to find IEDriverServer. Please download the server from
+          http://selenium-release.storage.googleapis.com/index.html and place it somewhere on your PATH.
+          More info at https://github.com/SeleniumHQ/selenium/wiki/InternetExplorerDriver.
+        ERROR
+
+        private
+
+        def start_process
+          @process = build_process(@executable_path, "--port=#{@port}", *@extra_args)
+          @process.start
+        end
+
+        def cannot_connect_error_text
+          "unable to connect to IE server #{@host}:#{@port}"
+        end
+
+        def extract_service_args(driver_opts)
+          driver_args = super
+          driver_args << "--log-level=#{driver_opts.delete(:log_level).to_s.upcase}" if driver_opts.key?(:log_level)
+          driver_args << "--log-file=#{driver_opts.delete(:log_file)}" if driver_opts.key?(:log_file)
+          driver_args << "--implementation=#{driver_opts.delete(:implementation).to_s.upcase}" if driver_opts.key?(:implementation)
+          driver_args << "--host=#{driver_opts.delete(:host)}" if driver_opts.key?(:host)
+          driver_args << "--extract_path=#{driver_opts.delete(:extract_path)}" if driver_opts.key?(:extract_path)
+          driver_args << "--silent" if driver_opts[:silent] == true
+          driver_args
+        end
+      end # Server
+    end # IE
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/remote.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-#
 # Licensed to the Software Freedom Conservancy (SFC) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -19,23 +17,17 @@
 
 require 'uri'
 
-require 'selenium/webdriver/remote/capabilities'
-require 'selenium/webdriver/remote/w3c_capabilities'
 require 'selenium/webdriver/remote/bridge'
-require 'selenium/webdriver/remote/w3c_bridge'
-require 'selenium/webdriver/remote/server_error'
+require 'selenium/webdriver/remote/driver'
 require 'selenium/webdriver/remote/response'
-require 'selenium/webdriver/remote/commands'
-require 'selenium/webdriver/remote/w3c_commands'
+require 'selenium/webdriver/remote/server_error'
 require 'selenium/webdriver/remote/http/common'
 require 'selenium/webdriver/remote/http/default'
 
-module Selenium
-  module WebDriver
-
-    # @api private
-    module Remote
+require 'selenium/webdriver/remote/capabilities'
+require 'selenium/webdriver/remote/oss/bridge'
+require 'selenium/webdriver/remote/oss/commands'
 
-    end # Remote
-  end # WebDriver
-end # Selenium
+require 'selenium/webdriver/remote/w3c/bridge'
+require 'selenium/webdriver/remote/w3c/capabilities'
+require 'selenium/webdriver/remote/w3c/commands'

data/lib/selenium/webdriver/remote/bridge.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-#
 # Licensed to the Software Freedom Conservancy (SFC) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -20,624 +18,141 @@
 module Selenium
   module WebDriver
     module Remote
-
-      #
-      # Low level bridge to the remote server, through which the rest of the API works.
-      #
-      # @api private
-      #
-
       class Bridge
+        include Atoms
         include BridgeHelper
 
-        COMMANDS = {}
+        PORT = 4444
+        COMMANDS = {
+          new_session: [:post, 'session'.freeze]
+        }.freeze
+
+        attr_accessor :context, :http, :file_detector
+        attr_reader :capabilities, :dialect
 
         #
-        # Defines a wrapper method for a command, which ultimately calls #execute.
+        # Implements protocol handshake which:
         #
-        # @param name [Symbol]
-        #   name of the resulting method
-        # @param url [String]
-        #   a URL template, which can include some arguments, much like the definitions on the server.
-        #   the :session_id parameter is implicitly handled, but the remainder will become required method arguments.
-        # @param verb [Symbol]
-        #   the appropriate http verb, such as :get, :post, or :delete
+        #   1. Creates session with driver.
+        #   2. Sniffs response.
+        #   3. Based on the response, understands which dialect we should use.
         #
+        # @return [OSS:Bridge, W3C::Bridge]
+        #
+        def self.handshake(**opts)
+          desired_capabilities = opts.delete(:desired_capabilities)
 
-        def self.command(name, verb, url)
-          COMMANDS[name] = [verb, url.freeze]
-        end
+          if desired_capabilities.is_a?(Symbol)
+            unless Remote::Capabilities.respond_to?(desired_capabilities)
+              raise Error::WebDriverError, "invalid desired capability: #{desired_capabilities.inspect}"
+            end
+            desired_capabilities = Remote::Capabilities.__send__(desired_capabilities)
+          end
 
-        attr_accessor :context, :http, :file_detector
-        attr_reader :capabilities
+          bridge = new(opts)
+          capabilities = bridge.create_session(desired_capabilities)
+
+          case bridge.dialect
+          when :oss
+            Remote::OSS::Bridge.new(capabilities, bridge.session_id, opts)
+          when :w3c
+            Remote::W3C::Bridge.new(capabilities, bridge.session_id, opts)
+          else
+            raise WebDriverError, 'cannot understand dialect'
+          end
+        end
 
         #
-        # Initializes the bridge with the given server URL.
-        #
-        # @param url         [String] url for the remote server
-        # @param http_client [Object] an HTTP client instance that implements the same protocol as Http::Default
-        # @param desired_capabilities [Capabilities] an instance of Remote::Capabilities describing the capabilities you want
+        # Initializes the bridge with the given server URL
+        # @param [Hash] opts options for the driver
+        # @option opts [String] :url url for the remote server
+        # @option opts [Object] :http_client an HTTP client instance that implements the same protocol as Http::Default
+        # @option opts [Capabilities] :desired_capabilities an instance of Remote::Capabilities describing the capabilities you want
+        # @api private
         #
 
         def initialize(opts = {})
           opts = opts.dup
-
-          http_client          = opts.delete(:http_client) { Http::Default.new }
-          desired_capabilities = opts.delete(:desired_capabilities) { Capabilities.firefox }
-          url                  = opts.delete(:url) { "http://#{Platform.localhost}:4444/wd/hub" }
+          http_client = opts.delete(:http_client) { Http::Default.new }
+          url = opts.delete(:url) { "http://#{Platform.localhost}:#{PORT}/wd/hub" }
 
           unless opts.empty?
             raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
           end
 
-          if desired_capabilities.kind_of?(Symbol)
-            unless Capabilities.respond_to?(desired_capabilities)
-              raise Error::WebDriverError, "invalid desired capability: #{desired_capabilities.inspect}"
-            end
-
-            desired_capabilities = Capabilities.send(desired_capabilities)
-          end
-
-          uri = url.kind_of?(URI) ? url : URI.parse(url)
-          uri.path += "/" unless uri.path =~ /\/$/
+          uri = url.is_a?(URI) ? url : URI.parse(url)
+          uri.path += '/' unless uri.path =~ %r{\/$}
 
           http_client.server_url = uri
 
-          @http          = http_client
-          @capabilities  = create_session(desired_capabilities)
-
+          @http = http_client
           @file_detector = nil
         end
 
-        def browser
-          @browser ||= (
-            name = @capabilities.browser_name
-            name ? name.gsub(" ", "_").to_sym : 'unknown'
-          )
-        end
-
-        def driver_extensions
-          [
-            DriverExtensions::HasInputDevices,
-            DriverExtensions::UploadsFiles,
-            DriverExtensions::TakesScreenshot,
-            DriverExtensions::HasSessionId,
-            DriverExtensions::Rotatable,
-            DriverExtensions::HasTouchScreen,
-            DriverExtensions::HasLocation,
-            DriverExtensions::HasNetworkConnection,
-            DriverExtensions::HasRemoteStatus,
-            DriverExtensions::HasWebStorage
-          ]
-        end
-
         #
-        # Returns the current session ID.
+        # Creates session handling both OSS and W3C dialects.
         #
 
-        def session_id
-          @session_id || raise(Error::WebDriverError, "no current session exists")
-        end
-
         def create_session(desired_capabilities)
-          resp = raw_execute :newSession, {}, :desiredCapabilities => desired_capabilities
-          @session_id = resp['sessionId'] or raise Error::WebDriverError, 'no sessionId in returned payload'
-
-          Capabilities.json_create resp['value']
-        end
-
-        def status
-          execute :status
-        end
-
-        def get(url)
-          execute :get, {}, :url => url
-        end
-
-        def getCapabilities
-          Capabilities.json_create execute(:getCapabilities)
-        end
-
-        def setImplicitWaitTimeout(milliseconds)
-          execute :implicitlyWait, {}, :ms => milliseconds
-        end
-
-        def setScriptTimeout(milliseconds)
-          execute :setScriptTimeout, {}, :ms => milliseconds
-        end
-
-        def setTimeout(type, milliseconds)
-          execute :setTimeout, {}, :type => type, :ms => milliseconds
-        end
-
-        #
-        # alerts
-        #
-
-        def acceptAlert
-          execute :acceptAlert
-        end
-
-        def dismissAlert
-          execute :dismissAlert
-        end
-
-        def setAlertValue(keys)
-          execute :setAlertValue, {}, :text => keys.to_s
-        end
-
-        def getAlertText
-          execute :getAlertText
-        end
-        
-        def setAuthentication(credentials)
-          execute :setAuthentication, {}, credentials
-        end
-
-        #
-        # navigation
-        #
-
-        def goBack
-          execute :goBack
-        end
-
-        def goForward
-          execute :goForward
-        end
-
-        def getCurrentUrl
-          execute :getCurrentUrl
-        end
-
-        def getTitle
-          execute :getTitle
-        end
+          response = execute(:new_session, {}, merged_capabilities(desired_capabilities))
 
-        def getPageSource
-          execute :getPageSource
-        end
-
-        def switchToWindow(name)
-          execute :switchToWindow, {}, :name => name
-        end
-
-        def switchToFrame(id)
-          execute :switchToFrame, {}, :id => id
-        end
-
-        def switchToParentFrame
-          execute :switchToParentFrame
-        end
-
-        def switchToDefaultContent
-          execute :switchToFrame, {}, :id => nil
-        end
-
-        QUIT_ERRORS = [IOError]
-
-        def quit
-          execute :quit
-          http.close
-        rescue *QUIT_ERRORS
-        end
-
-        def close
-          execute :close
-        end
-
-        def refresh
-          execute :refresh
-        end
-
-        #
-        # window handling
-        #
-
-        def getWindowHandles
-          execute :getWindowHandles
-        end
-
-        def getCurrentWindowHandle
-          execute :getCurrentWindowHandle
-        end
-
-        def setWindowSize(width, height, handle = :current)
-          execute :setWindowSize, {:window_handle => handle},
-                                   :width  => width,
-                                   :height => height
-        end
-
-        def maximizeWindow(handle = :current)
-          execute :maximizeWindow, :window_handle => handle
-        end
-
-        def getWindowSize(handle = :current)
-          data = execute :getWindowSize, :window_handle => handle
-
-          Dimension.new data['width'], data['height']
-        end
-
-        def setWindowPosition(x, y, handle = :current)
-          execute :setWindowPosition, {:window_handle => handle},
-                                       :x => x, :y => y
-        end
-
-        def getWindowPosition(handle = :current)
-          data = execute :getWindowPosition, :window_handle => handle
-
-          Point.new data['x'], data['y']
-        end
+          @session_id = response['sessionId']
+          oss_status = response['status']
+          value = response['value']
 
-        def getScreenshot
-          execute :screenshot
-        end
-
-        #
-        # HTML 5
-        #
-
-        def getLocalStorageItem(key)
-          execute :getLocalStorageItem, :key => key
-        end
-
-        def removeLocalStorageItem(key)
-          execute :removeLocalStorageItem, :key => key
-        end
-
-        def getLocalStorageKeys
-          execute :getLocalStorageKeys
-        end
-
-        def setLocalStorageItem(key, value)
-          execute :setLocalStorageItem, {}, :key => key, :value => value
-        end
-
-        def clearLocalStorage
-          execute :clearLocalStorage
-        end
-
-        def getLocalStorageSize
-          execute :getLocalStorageSize
-        end
-
-        def getSessionStorageItem(key)
-          execute :getSessionStorageItem, :key => key
-        end
+          if value.is_a?(Hash)
+            @session_id = value['sessionId'] if value.key?('sessionId')
 
-        def removeSessionStorageItem(key)
-          execute :removeSessionStorageItem, :key => key
-        end
-
-        def getSessionStorageKeys
-          execute :getSessionStorageKeys
-        end
-
-        def setSessionStorageItem(key, value)
-          execute :setSessionStorageItem, {}, :key => key, :value => value
-        end
-
-        def clearSessionStorage
-          execute :clearSessionStorage
-        end
-
-        def getSessionStorageSize
-          execute :getSessionStorageSize
-        end
-
-        def getLocation
-          obj = execute(:getLocation) || {} # android returns null
-          Location.new obj['latitude'], obj['longitude'], obj['altitude']
-        end
-
-        def setLocation(lat, lon, alt)
-          loc = {:latitude => lat, :longitude => lon, :altitude => alt}
-          execute :setLocation, {}, :location => loc
-        end
-
-        def getNetworkConnection
-          execute :getNetworkConnection
-        end
-
-        def setNetworkConnection(type)
-          execute :setNetworkConnection, {}, :parameters => {:type => type}
-        end
-
-        #
-        # javascript execution
-        #
-
-        def executeScript(script, *args)
-          assert_javascript_enabled
-
-          result = execute :executeScript, {}, :script => script, :args => args
-          unwrap_script_result result
-        end
-
-        def executeAsyncScript(script, *args)
-          assert_javascript_enabled
-
-          result = execute :executeAsyncScript, {}, :script => script, :args => args
-          unwrap_script_result result
-        end
-
-        #
-        # cookies
-        #
-
-        def addCookie(cookie)
-          execute :addCookie, {}, :cookie => cookie
-        end
-
-        def deleteCookie(name)
-          execute :deleteCookie, :name => name
-        end
-
-        def getAllCookies
-          execute :getCookies
-        end
-
-        def deleteAllCookies
-          execute :deleteAllCookies
-        end
-
-        #
-        # actions
-        #
-
-        def clickElement(element)
-          execute :clickElement, :id => element
-        end
-
-        def click
-          execute :click, {}, :button => 0
-        end
-
-        def doubleClick
-          execute :doubleClick
-        end
-
-        def contextClick
-          execute :click, {}, :button => 2
-        end
-
-        def mouseDown
-          execute :mouseDown
-        end
-
-        def mouseUp
-          execute :mouseUp
-        end
-
-        def mouseMoveTo(element, x = nil, y = nil)
-          params = { :element => element }
-
-          if x && y
-            params.merge! :xoffset => x, :yoffset => y
-          end
-
-          execute :mouseMoveTo, {}, params
-        end
-
-        def sendKeysToActiveElement(key)
-          execute :sendKeysToActiveElement, {}, :value => key
-        end
-
-        def sendKeysToElement(element, keys)
-          if @file_detector && local_file = @file_detector.call(keys)
-            keys = upload(local_file)
+            if value.key?('capabilities')
+              value = value['capabilities']
+            elsif value.key?('value')
+              value = value['value']
+            end
           end
 
-          execute :sendKeysToElement, {:id => element}, {:value => Array(keys)}
-        end
-
-        def upload(local_file)
-          unless File.file?(local_file)
-            raise Error::WebDriverError, "you may only upload files: #{local_file.inspect}"
+          unless @session_id
+            raise Error::WebDriverError, 'no sessionId in returned payload'
           end
 
-          execute :uploadFile, {}, :file => Zipper.zip_file(local_file)
-        end
-
-        def clearElement(element)
-          execute :clearElement, :id => element
-        end
-
-        def submitElement(element)
-          execute :submitElement, :id => element
-        end
-
-        def dragElement(element, right_by, down_by)
-          execute :dragElement, {:id => element}, :x => right_by, :y => down_by
-        end
-
-        def touchSingleTap(element)
-          execute :touchSingleTap, {}, :element => element
-        end
-
-        def touchDoubleTap(element)
-          execute :touchDoubleTap, {}, :element => element
-        end
-
-        def touchLongPress(element)
-          execute :touchLongPress, {}, :element => element
-        end
-
-        def touchDown(x, y)
-          execute :touchDown, {}, :x => x, :y => y
-        end
-
-        def touchUp(x, y)
-          execute :touchUp, {}, :x => x, :y => y
-        end
-
-        def touchMove(x, y)
-          execute :touchMove, {}, :x => x, :y => y
-        end
-
-        def touchScroll(element, x, y)
-          if element
-            execute :touchScroll, {}, :element => element,
-                                      :xoffset => x,
-                                      :yoffset => y
+          if oss_status
+            WebDriver.logger.info 'Detected OSS dialect.'
+            @dialect = :oss
+            Capabilities.json_create(value)
           else
-            execute :touchScroll, {}, :xoffset => x, :yoffset => y
+            WebDriver.logger.info 'Detected W3C dialect.'
+            @dialect = :w3c
+            W3C::Capabilities.json_create(value)
           end
         end
 
-        def touchFlick(xspeed, yspeed)
-          execute :touchFlick, {}, :xspeed => xspeed, :yspeed => yspeed
-        end
-
-        def touchElementFlick(element, right_by, down_by, speed)
-          execute :touchFlick, {}, :element => element,
-                                   :xoffset => right_by,
-                                   :yoffset => down_by,
-                                   :speed   => speed
-
-        end
-
-        def setScreenOrientation(orientation)
-          execute :setScreenOrientation, {}, :orientation => orientation
-        end
-
-        def getScreenOrientation
-          execute :getScreenOrientation
-        end
-
-        #
-        # logs
-        #
-
-        def getAvailableLogTypes
-          types = execute :getAvailableLogTypes
-          Array(types).map { |e| e.to_sym }
-        end
-
-        def getLog(type)
-          data = execute :getLog, {}, :type => type.to_s
-
-          Array(data).map do |l|
-            begin
-              LogEntry.new l.fetch('level', 'UNKNOWN'), l.fetch('timestamp'), l.fetch('message')
-            rescue KeyError
-              next
-            end
-          end
-        end
-
-        #
-        # element properties
         #
-
-        def getElementTagName(element)
-          execute :getElementTagName, :id => element
-        end
-
-        def getElementAttribute(element, name)
-          execute :getElementAttribute, :id => element, :name => name
-        end
-
-        def getElementValue(element)
-          execute :getElementValue, :id => element
-        end
-
-        def getElementText(element)
-          execute :getElementText, :id => element
-        end
-
-        def getElementLocation(element)
-          data = execute :getElementLocation, :id => element
-
-          Point.new data['x'], data['y']
-        end
-
-        def getElementLocationOnceScrolledIntoView(element)
-          data = execute :getElementLocationOnceScrolledIntoView, :id => element
-
-          Point.new data['x'], data['y']
-        end
-
-        def getElementSize(element)
-          data = execute :getElementSize, :id => element
-
-          Dimension.new data['width'], data['height']
-        end
-
-        def isElementEnabled(element)
-          execute :isElementEnabled, :id => element
-        end
-
-        def isElementSelected(element)
-          execute :isElementSelected, :id => element
-        end
-
-        def isElementDisplayed(element)
-          execute :isElementDisplayed, :id => element
-        end
-
-        def getElementValueOfCssProperty(element, prop)
-          execute :getElementValueOfCssProperty, :id => element, :property_name => prop
-        end
-
-        #
-        # finding elements
+        # Returns the current session ID.
         #
 
-        def getActiveElement
-          Element.new self, element_id_from(execute(:getActiveElement))
-        end
-        alias_method :switchToActiveElement, :getActiveElement
-
-        def find_element_by(how, what, parent = nil)
-          if parent
-            id = execute :findChildElement, {:id => parent}, {:using => how, :value => what}
-          else
-            id = execute :findElement, {}, {:using => how, :value => what}
-          end
-
-          Element.new self, element_id_from(id)
+        def session_id
+          @session_id || raise(Error::WebDriverError, 'no current session exists')
         end
 
-        def find_elements_by(how, what, parent = nil)
-          if parent
-            ids = execute :findChildElements, {:id => parent}, {:using => how, :value => what}
-          else
-            ids = execute :findElements, {}, {:using => how, :value => what}
+        def browser
+          @browser ||= begin
+            name = @capabilities.browser_name
+            name ? name.tr(' ', '_').to_sym : 'unknown'
           end
-
-          ids.map { |id| Element.new self, element_id_from(id) }
         end
 
         private
 
-        def assert_javascript_enabled
-          return if capabilities.javascript_enabled?
-          raise Error::UnsupportedOperationError, "underlying webdriver instance does not support javascript"
-        end
-
-        #
-        # executes a command on the remote server.
-        #
-        #
-        # Returns the 'value' of the returned payload
-        #
-
-        def execute(*args)
-          raw_execute(*args)['value']
-        end
-
         #
         # executes a command on the remote server.
         #
         # @return [WebDriver::Remote::Response]
         #
 
-        def raw_execute(command, opts = {}, command_hash = nil)
-          verb, path = COMMANDS[command] || raise(ArgumentError, "unknown command: #{command.inspect}")
-          path       = path.dup
+        def execute(command, opts = {}, command_hash = nil)
+          verb, path = commands(command) || raise(ArgumentError, "unknown command: #{command.inspect}")
+          path = path.dup
 
-          path[':session_id'] = @session_id if path.include?(":session_id")
+          path[':session_id'] = session_id if path.include?(':session_id')
 
           begin
             opts.each { |key, value| path[key.inspect] = escaper.escape(value.to_s) }
@@ -645,12 +160,28 @@ module Selenium
             raise ArgumentError, "#{opts.inspect} invalid for #{command.inspect}"
           end
 
-          puts "-> #{verb.to_s.upcase} #{path}" if $DEBUG
-          http.call verb, path, command_hash
+          WebDriver.logger.info("-> #{verb.to_s.upcase} #{path}")
+          http.call(verb, path, command_hash)
         end
 
         def escaper
-          @escaper ||= defined?(URI::Parser) ? URI::Parser.new : URI
+          @escaper ||= defined?(URI::Parser) ? URI::DEFAULT_PARSER : URI
+        end
+
+        def commands(command)
+          raise NotImplementedError unless command == :new_session
+          COMMANDS[command]
+        end
+
+        def merged_capabilities(oss_capabilities)
+          w3c_capabilities = W3C::Capabilities.from_oss(oss_capabilities)
+
+          {
+            desiredCapabilities: oss_capabilities,
+            capabilities: {
+              firstMatch: [w3c_capabilities]
+            }
+          }
         end
 
       end # Bridge