browserstack-webdriver 0.0.1

data/lib/selenium/webdriver/support/abstract_event_listener.rb

@@ -0,0 +1,28 @@
+module Selenium
+  module WebDriver
+    module Support
+
+      class AbstractEventListener
+        def before_navigate_to(url, driver) end
+        def after_navigate_to(url, driver) end
+        def before_navigate_back(driver) end
+        def after_navigate_back(driver) end
+        def before_navigate_forward(driver) end
+        def after_navigate_forward(driver) end
+        def before_find(by, what, driver) end
+        def after_find(by, what, driver) end
+        def before_click(element, driver) end
+        def after_click(element, driver) end
+        def before_change_value_of(element, driver) end
+        def after_change_value_of(element, driver) end
+        def before_execute_script(script, driver) end
+        def after_execute_script(script, driver) end
+        def before_quit(driver) end
+        def after_quit(driver) end
+        def before_close(driver) end
+        def after_close(driver) end
+      end
+
+    end
+  end
+end

data/lib/selenium/webdriver/support/block_event_listener.rb

@@ -0,0 +1,17 @@
+module Selenium
+  module WebDriver
+    module Support
+
+      class BlockEventListener
+        def initialize(callback)
+          @callback = callback
+        end
+
+        def method_missing(meth, *args, &blk)
+          @callback.call meth, *args
+        end
+      end
+
+    end
+  end
+end

data/lib/selenium/webdriver/support/color.rb

@@ -0,0 +1,110 @@
+module Selenium
+  module WebDriver
+    module Support
+      class Color
+        RGB_PATTERN      = /^\s*rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)\s*$/
+        RGB_PCT_PATTERN  = /^\s*rgb\(\s*(\d{1,3}|\d{1,2}\.\d+)%\s*,\s*(\d{1,3}|\d{1,2}\.\d+)%\s*,\s*(\d{1,3}|\d{1,2}\.\d+)%\s*\)\s*$/
+        RGBA_PATTERN     = /^\s*rgba\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(0|1|0\.\d+)\s*\)\s*$/
+        RGBA_PCT_PATTERN = /^\s*rgba\(\s*(\d{1,3}|\d{1,2}\.\d+)%\s*,\s*(\d{1,3}|\d{1,2}\.\d+)%\s*,\s*(\d{1,3}|\d{1,2}\.\d+)%\s*,\s*(0|1|0\.\d+)\s*\)\s*$/
+        HEX_PATTERN      = /#([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})/ # \p{XDigit} or \h only works on Ruby 1.9
+        HEX3_PATTERN     = /#([A-Fa-f0-9])([A-Fa-f0-9])([A-Fa-f0-9])/ # \p{XDigit} or \h only works on Ruby 1.9
+        HSL_PATTERN      = /^\s*hsl\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*\)\s*$/
+        HSLA_PATTERN     = /^\s*hsla\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*,\s*(0|1|0\.\d+)\s*\)\s*$/
+
+        attr_reader :red, :green, :blue, :alpha
+
+        def self.from_string(str)
+          case str
+          when RGB_PATTERN
+            new $1, $2, $3
+          when RGB_PCT_PATTERN
+            new(*[$1, $2, $3].map { |e| Float(e) / 100 * 255 })
+          when RGBA_PATTERN
+            new $1, $2, $3, $4
+          when RGBA_PCT_PATTERN
+            new(*[$1, $2, $3].map { |e| Float(e) / 100 * 255 } << $4)
+          when HEX_PATTERN
+            new(*[$1, $2, $3].map { |e| e.to_i(16) })
+          when HEX3_PATTERN
+            new(*[$1, $2, $3].map { |e| (e * 2).to_i(16) })
+          when HSL_PATTERN, HSLA_PATTERN
+            from_hsl($1, $2, $3, $4)
+          else
+            raise ArgumentError, "could not convert #{str.inspect} into color"
+          end
+        end
+
+        def self.from_hsl(h, s, l, a)
+          h = Float(h) / 360
+          s = Float(s) / 100
+          l = Float(l) / 100
+          a = Float(a || 1)
+
+          if s == 0
+            r = l
+            g = r
+            b = r
+          else
+            luminocity2 = (l < 0.5) ? l * (1 + s) : l + s - l * s
+            luminocity1 = 2 * l - luminocity2
+
+            hue_to_rgb = lambda do |lum1, lum2, hue|
+              hue += 1 if hue < 0.0
+              hue -= 1 if hue > 1.0
+
+              if hue < 1.0 / 6.0
+                 (lum1 + (lum2 - lum1) * 6.0 * hue)
+              elsif  hue < 1.0 / 2.0
+                 lum2
+              elsif hue < 2.0 / 3.0
+                lum1 + (lum2 - lum1) * ((2.0 / 3.0) - hue) * 6.0
+              else
+                lum1
+              end
+            end
+
+            r = hue_to_rgb.call(luminocity1, luminocity2, h + 1.0 / 3.0)
+            g = hue_to_rgb.call(luminocity1, luminocity2, h)
+            b = hue_to_rgb.call(luminocity1, luminocity2, h - 1.0 / 3.0)
+          end
+
+          new r * 256, g * 256, b * 256, a
+        end
+
+
+        def initialize(red, green, blue, alpha = 1)
+          @red   = Integer(red)
+          @green = Integer(green)
+          @blue  = Integer(blue)
+          @alpha = Float(alpha)
+        end
+
+        def ==(other)
+          return true if equal?(other)
+          return false unless other.kind_of?(self.class)
+
+          [red, green, blue, alpha] == [other.red, other.green, other.blue, other.alpha]
+        end
+        alias_method :eql?, :==
+
+        def hash
+          [red, green, blue, alpha].hash ^ self.class.hash
+        end
+
+        def rgb
+          "rgb(#{red}, #{green}, #{blue})"
+        end
+
+        def rgba
+          a = alpha == 1 ? '1' : alpha
+          "rgba(#{red}, #{green}, #{blue}, #{a})"
+        end
+
+        def hex
+          "#%02x%02x%02x" % [red, green, blue]
+        end
+
+      end
+    end
+  end
+end

data/lib/selenium/webdriver/support/event_firing_bridge.rb

@@ -0,0 +1,112 @@
+module Selenium
+  module WebDriver
+    module Support
+
+      #
+      # @api private
+      #
+
+      class EventFiringBridge
+        def initialize(delegate, listener)
+          @delegate = delegate
+
+          if listener.respond_to? :call
+            @listener = BlockEventListener.new(listener)
+          else
+            @listener = listener
+          end
+        end
+
+        def get(url)
+          dispatch(:navigate_to, url, driver) {
+            @delegate.get(url)
+          }
+        end
+
+        def goForward
+          dispatch(:navigate_forward, driver) {
+            @delegate.goForward
+          }
+        end
+
+        def goBack
+          dispatch(:navigate_back, driver) {
+            @delegate.goBack
+          }
+        end
+
+        def clickElement(ref)
+          dispatch(:click, create_element(ref), driver) {
+            @delegate.clickElement(ref)
+          }
+        end
+
+        def clearElement(ref)
+          dispatch(:change_value_of, create_element(ref), driver) {
+            @delegate.clearElement(ref)
+          }
+        end
+
+        def sendKeysToElement(ref, keys)
+          dispatch(:change_value_of, create_element(ref), driver) {
+            @delegate.sendKeysToElement(ref, keys)
+          }
+        end
+
+        def find_element_by(how, what, parent = nil)
+          e = dispatch(:find, how, what, driver) {
+            @delegate.find_element_by how, what, parent
+          }
+
+          Element.new self, e.ref
+        end
+
+        def find_elements_by(how, what, parent = nil)
+          es = dispatch(:find, how, what, driver) {
+            @delegate.find_elements_by(how, what, parent)
+          }
+
+          es.map { |e| Element.new self, e.ref }
+        end
+
+        def executeScript(script, *args)
+          dispatch(:execute_script, script, driver) {
+            @delegate.executeScript(script, *args)
+          }
+        end
+
+        def quit
+          dispatch(:quit, driver) { @delegate.quit }
+        end
+
+        def close
+          dispatch(:close, driver) { @delegate.close }
+        end
+
+        private
+
+        def create_element(ref)
+          # hmm. we're not passing self here to not fire events for potential calls made by the listener
+          Element.new @delegate, ref
+        end
+
+        def driver
+          @driver ||= Driver.new(self)
+        end
+
+        def dispatch(name, *args, &blk)
+          @listener.__send__("before_#{name}", *args)
+          returned = yield
+          @listener.__send__("after_#{name}", *args)
+
+          returned
+        end
+
+        def method_missing(meth, *args, &blk)
+          @delegate.__send__(meth, *args, &blk)
+        end
+      end # EventFiringBridge
+
+    end # Support
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/support/select.rb

@@ -0,0 +1,293 @@
+module Selenium
+  module WebDriver
+    module Support
+      class Select
+
+        #
+        # @param [Element] element The select element to use
+        #
+
+        def initialize(element)
+          tag_name = element.tag_name
+
+          unless tag_name.downcase == "select"
+            raise ArgumentError, "unexpected tag name #{tag_name.inspect}"
+          end
+
+          @element = element
+          @multi   = ![nil, "false"].include?(element.attribute(:multiple))
+        end
+
+        #
+        # Does this select element support selecting multiple options?
+        #
+        # @return [Boolean]
+        #
+
+        def multiple?
+          @multi
+        end
+
+        #
+        # Get all options for this select element
+        #
+        # @return [Array<Element>]
+        #
+
+        def options
+          @element.find_elements :tag_name, 'option'
+        end
+
+        #
+        # Get all selected options for this select element
+        #
+        # @return [Array<Element>]
+        #
+
+        def selected_options
+          options.select { |e| e.selected? }
+        end
+
+        #
+        # Get the first selected option in this select element
+        #
+        # @raise [Error::NoSuchElementError] if no options are selected
+        # @return [Element]
+        #
+
+        def first_selected_option
+          option = options.find { |e| e.selected? }
+          option or raise Error::NoSuchElementError, 'no options are selected'
+        end
+
+        #
+        # Select options by visible text, index or value.
+        #
+        # When selecting by :text, selects options that display text matching the argument. That is, when given "Bar" this
+        # would select an option like:
+        #
+        #     <option value="foo">Bar</option>
+        #
+        # When slecting by :value, selects all options that have a value matching the argument. That is, when given "foo" this
+        # would select an option like:
+        #
+        #     <option value="foo">Bar</option>
+        #
+        # When selecting by :index, selects the option at the given index. This is done by examining the "index" attribute of an
+        # element, and not merely by counting.
+        #
+        # @param [:text, :index, :value] how How to find the option
+        # @param [String] what What value to find the option by.
+        #
+
+        def select_by(how, what)
+          case how
+          when :text
+            select_by_text what
+          when :index
+            select_by_index what
+          when :value
+            select_by_value what
+          else
+            raise ArgumentError, "can't select options by #{how.inspect}"
+          end
+        end
+
+        #
+        # Deselect options by visible text, index or value.
+        #
+        # @param [:text, :index, :value] how How to find the option
+        # @param [String] what What value to find the option by.
+        #
+        # @see Select#select_by
+        #
+
+        def deselect_by(how, what)
+          case how
+          when :text
+            deselect_by_text what
+          when :value
+            deselect_by_value what
+          when :index
+            deselect_by_index what
+          else
+            raise ArgumentError, "can't deselect options by #{how.inspect}"
+          end
+        end
+
+        #
+        # Select all unselected options. Only valid if the element supports multiple selections.
+        #
+        # @raise [Error::UnsupportedOperationError] if the element does not support multiple selections.
+        #
+
+        def select_all
+          unless multiple?
+            raise Error::UnsupportedOperationError, 'you may only select all options of a multi-select'
+          end
+
+          options.each { |e| select_option e }
+        end
+
+        #
+        # Deselect all selected options. Only valid if the element supports multiple selections.
+        #
+        # @raise [Error::UnsupportedOperationError] if the element does not support multiple selections.
+        #
+
+        def deselect_all
+          unless multiple?
+            raise Error::UnsupportedOperationError, 'you may only deselect all options of a multi-select'
+          end
+
+          options.each { |e| deselect_option e }
+        end
+
+        private
+
+        def select_by_text(text)
+          opts = find_by_text text
+
+          if opts.empty?
+            raise Error::NoSuchElementError, "cannot locate element with text: #{text.inspect}"
+          end
+
+          select_options opts
+        end
+
+        def select_by_index(index)
+          opts = find_by_index index
+
+          if opts.empty?
+            raise Error::NoSuchElementError, "cannot locate element with index: #{index.inspect}"
+          end
+
+          select_options opts
+        end
+
+        def select_by_value(value)
+          opts = find_by_value value
+
+          if opts.empty?
+            raise Error::NoSuchElementError, "cannot locate option with value: #{value.inspect}"
+          end
+
+          select_options opts
+        end
+
+        def deselect_by_text(text)
+          opts = find_by_text text
+
+          if opts.empty?
+            raise Error::NoSuchElementError, "cannot locate element with text: #{text.inspect}"
+          end
+
+          deselect_options opts
+        end
+
+        def deselect_by_value(value)
+          opts = find_by_value value
+
+          if opts.empty?
+            raise Error::NoSuchElementError, "cannot locate option with value: #{value.inspect}"
+          end
+
+          deselect_options opts
+        end
+
+        def deselect_by_index(index)
+          opts = find_by_index index
+
+          if opts.empty?
+            raise Error::NoSuchElementError, "cannot locate option with index: #{index}"
+          end
+
+          deselect_options opts
+        end
+
+        private
+
+        def select_option(option)
+          option.click unless option.selected?
+        end
+
+        def deselect_option(option)
+          option.click if option.selected?
+        end
+
+        def select_options(opts)
+          if multiple?
+            opts.each { |o| select_option o }
+          else
+            select_option opts.first
+          end
+        end
+
+        def deselect_options(opts)
+          if multiple?
+            opts.each { |o| deselect_option o }
+          else
+            deselect_option opts.first
+          end
+        end
+
+        def find_by_text(text)
+          xpath = ".//option[normalize-space(.) = #{Escaper.escape text}]"
+          opts = @element.find_elements(:xpath, xpath)
+
+          if opts.empty? && text =~ /\s+/
+            longest_word = text.split(/\s+/).max_by { |item| item.length }
+
+            if longest_word.empty?
+              candidates = options
+            else
+              xpath = ".//option[contains(., #{Escaper.escape longest_word})]"
+              candidates = @element.find_elements(:xpath, xpath)
+            end
+
+            if multiple?
+              candidates.select { |option| text == option.text }
+            else
+              Array(candidates.find { |option| text == option.text })
+            end
+          else
+            opts
+          end
+        end
+
+        def find_by_index(index)
+          index = index.to_s
+          options.select { |option| option.attribute(:index) == index }
+        end
+
+        def find_by_value(value)
+          @element.find_elements(:xpath, ".//option[@value = #{Escaper.escape value}]")
+        end
+
+        #
+        # @api private
+        #
+
+        module Escaper
+          def self.escape(str)
+            if str.include?('"') && str.include?("'")
+              parts = str.split('"', -1).map { |part| %{"#{part}"} }
+
+              quoted = parts.join(%{, '"', }).
+                             gsub(/^"", |, ""$/, '')
+
+              "concat(#{quoted})"
+            elsif str.include?('"')
+              # escape string with just a quote into being single quoted: f"oo -> 'f"oo'
+              "'#{str}'"
+            else
+              # otherwise return the quoted string
+              %{"#{str}"}
+            end
+          end
+        end # Escaper
+
+      end # Select
+    end
+  end
+end