selenium-webdriver 2.13.0 → 2.14.0

data/lib/selenium/webdriver/firefox/profile.rb

@@ -89,7 +89,7 @@ module Selenium
               raise ArgumentError, "preference values must be plain strings: #{key.inspect} => #{value.inspect}"
             end
 
-            value = value.to_json
+            value = MultiJson.encode(value)
           when TrueClass, FalseClass, Integer, Float
             value = value.to_s
           else

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

@@ -1,6 +1,10 @@
 module Selenium
   module WebDriver
     module IPhone
+      #
+      # @api private
+      #
+
       class Bridge < Remote::Bridge
 
         DEFAULT_URL = "http://#{Platform.localhost}:3001/hub/"

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

@@ -85,7 +85,15 @@ module Selenium
 
           def iphone(opts = {})
             new({
-              :browser_name       => "iphone",
+              :browser_name       => "iPhone",
+              :platform           => :mac,
+              :javascript_enabled => true
+            }.merge(opts))
+          end
+
+          def ipad(opts = {})
+            new({
+              :browser_name       => "iPad",
               :platform           => :mac,
               :javascript_enabled => true
             }.merge(opts))
@@ -206,7 +214,7 @@ module Selenium
         end
 
         def to_json(*args)
-          as_json.to_json(*args)
+          MultiJson.encode as_json
         end
 
         def ==(other)

data/lib/selenium/webdriver/remote/http/common.rb

@@ -23,7 +23,7 @@ module Selenium
             headers  = DEFAULT_HEADERS.dup
 
             if command_hash
-              payload                   = command_hash.to_json
+              payload                   = MultiJson.encode(command_hash)
               headers["Content-Type"]   = "#{CONTENT_TYPE}; charset=utf-8"
               headers["Content-Length"] = payload.bytesize.to_s if [:post, :put].include?(verb)
 
@@ -55,7 +55,7 @@ module Selenium
 
             if content_type.include? CONTENT_TYPE
               raise Error::WebDriverError, "empty body: #{content_type.inspect} (#{code})\n#{body}" if body.empty?
-              Response.new(code, JSON.parse(body))
+              Response.new(code, MultiJson.decode(body))
             elsif code == 204
               Response.new(code)
             else

data/lib/selenium/webdriver/support.rb

@@ -1,3 +1,4 @@
 require 'selenium/webdriver/support/event_firing_bridge'
 require 'selenium/webdriver/support/abstract_event_listener'
-require 'selenium/webdriver/support/block_event_listener'
+require 'selenium/webdriver/support/block_event_listener'
+require 'selenium/webdriver/support/select'

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

@@ -3,6 +3,10 @@ module Selenium
     module Support
       class Select
 
+        #
+        # @param [Element] element The select element to use
+        #
+
         def initialize(element)
           tag_name = element.tag_name
 
@@ -17,6 +21,8 @@ module Selenium
         #
         # Does this select element support selecting multiple options?
         #
+        # @return [Boolean]
+        #
 
         def multiple?
           @multi
@@ -25,14 +31,18 @@ module Selenium
         #
         # Get all options for this select element
         #
+        # @return [Array<Element>]
+        #
 
         def options
-          @element.find_elements :tag_name => "option"
+          @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? }
@@ -41,6 +51,9 @@ module Selenium
         #
         # 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? }
@@ -50,253 +63,231 @@ module Selenium
         #
         # 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(how, what)
+        def select_by(how, what)
           case how
-          when :text, :index, :value
-            raise NotImplementedError
+          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
 
-        # /**
-        #  * Select all options that display text matching the argument. That is, when given "Bar" this
-        #  * would select an option like:
-        #  *
-        #  * &lt;option value="foo"&gt;Bar&lt;/option&gt;
-        #  *
-        #  * @param text The visible text to match against
-        #  */
-        # public void selectByVisibleText(String text) {
-        #   // try to find the option via XPATH ...
-        #   List<WebElement> options =
-        #       element.findElements(By.xpath(".//option[normalize-space(.) = " + escapeQuotes(text) + "]"));
-        #
-        #   boolean matched = false;
-        #   for (WebElement option : options) {
-        #     setSelected(option);
-        #     if (!isMultiple()) {
-        #       return;
-        #     }
-        #     matched = true;
-        #   }
-        #
-        #   if (options.isEmpty() && text.contains(" ")) {
-        #     String subStringWithoutSpace = getLongestSubstringWithoutSpace(text);
-        #     List<WebElement> candidates;
-        #     if ("".equals(subStringWithoutSpace)) {
-        #       // hmm, text is either empty or contains only spaces - get all options ...
-        #       candidates = element.findElements(By.tagName("option"));
-        #     } else {
-        #       // get candidates via XPATH ...
-        #       candidates =
-        #           element.findElements(By.xpath(".//option[contains(., " +
-        #               escapeQuotes(subStringWithoutSpace) + ")]"));
-        #     }
-        #     for (WebElement option : candidates) {
-        #       if (text.equals(option.getText())) {
-        #         setSelected(option);
-        #         if (!isMultiple()) {
-        #           return;
-        #         }
-        #         matched = true;
-        #       }
-        #     }
-        #   }
-        #
-        #   if (!matched) {
-        #     throw new NoSuchElementException("Cannot locate element with text: " + text);
-        #   }
-        # }
-        #
-        # private String getLongestSubstringWithoutSpace(String s) {
-        #   String result = "";
-        #   StringTokenizer st = new StringTokenizer(s, " ");
-        #   while (st.hasMoreTokens()) {
-        #     String t = st.nextToken();
-        #     if (t.length() > result.length()) {
-        #       result = t;
-        #     }
-        #   }
-        #   return result;
-        # }
-        #
-        # /**
-        #  * Select the option at the given index. This is done by examing the "index" attribute of an
-        #  * element, and not merely by counting.
-        #  *
-        #  * @param index The option at this index will be selected
-        #  */
-        # public void selectByIndex(int index) {
-        #   String match = String.valueOf(index);
-        #
-        #   boolean matched = false;
-        #   for (WebElement option : getOptions()) {
-        #     if (match.equals(option.getAttribute("index"))) {
-        #       setSelected(option);
-        #       if (!isMultiple()) {
-        #         return;
-        #       }
-        #       matched = true;
-        #     }
-        #   }
-        #   if (!matched) {
-        #     throw new NoSuchElementException("Cannot locate option with index: " + index);
-        #   }
-        # }
-        #
-        # /**
-        #  * Select all options that have a value matching the argument. That is, when given "foo" this
-        #  * would select an option like:
-        #  *
-        #  * &lt;option value="foo"&gt;Bar&lt;/option&gt;
-        #  *
-        #  * @param value The value to match against
-        #  */
-        # public void selectByValue(String value) {
-        #   StringBuilder builder = new StringBuilder(".//option[@value = ");
-        #   builder.append(escapeQuotes(value));
-        #   builder.append("]");
-        #   List<WebElement> options = element.findElements(By.xpath(builder.toString()));
-        #
-        #   boolean matched = false;
-        #   for (WebElement option : options) {
-        #     setSelected(option);
-        #     if (!isMultiple()) {
-        #       return;
-        #     }
-        #     matched = true;
-        #   }
-        #
-        #   if (!matched) {
-        #     throw new NoSuchElementException("Cannot locate option with value: " + value);
-        #   }
-        # }
-        #
-
-        #
-        # Clear all selected entries. Only valid if the element supports multiple selections.
+        #
+        # 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
-        
-        #
-        # Deselect options by visible text, index or value.
-        # 
-        
-        def deselect(how, what)
-          case how
-          when :value, :index, :text
-            raise NotImplementedError
-          else
-            raise ArgumentError, "can't deselect options by #{how.inspect}"
+
+        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
-        
-        
-        #
-        # /**
-        #  * Deselect all options that have a value matching the argument. That is, when given "foo" this
-        #  * would deselect an option like:
-        #  *
-        #  * &lt;option value="foo"&gt;Bar&lt;/option&gt;
-        #  *
-        #  * @param value The value to match against
-        #  */
-        # public void deselectByValue(String value) {
-        #   StringBuilder builder = new StringBuilder(".//option[@value = ");
-        #   builder.append(escapeQuotes(value));
-        #   builder.append("]");
-        #   List<WebElement> options = element.findElements(By.xpath(builder.toString()));
-        #   for (WebElement option : options) {
-        #     if (option.isSelected()) {
-        #       option.click();
-        #     }
-        #   }
-        # }
-        #
-        # /**
-        #  * Deselect the option at the given index. This is done by examing the "index" attribute of an
-        #  * element, and not merely by counting.
-        #  *
-        #  * @param index The option at this index will be deselected
-        #  */
-        # public void deselectByIndex(int index) {
-        #   String match = String.valueOf(index);
-        #
-        #   for (WebElement option : getOptions()) {
-        #     if (match.equals(option.getAttribute("index")) && option.isSelected()) {
-        #       option.click();
-        #     }
-        #   }
-        # }
-        #
-        # /**
-        #  * Deselect all options that display text matching the argument. That is, when given "Bar" this
-        #  * would deselect an option like:
-        #  *
-        #  * &lt;option value="foo"&gt;Bar&lt;/option&gt;
-        #  *
-        #  * @param text The visible text to match against
-        #  */
-        # public void deselectByVisibleText(String text) {
-        #   StringBuilder builder = new StringBuilder(".//option[normalize-space(.) = ");
-        #   builder.append(escapeQuotes(text));
-        #   builder.append("]");
-        #   List<WebElement> options = element.findElements(By.xpath(builder.toString()));
-        #   for (WebElement option : options) {
-        #     if (option.isSelected()) {
-        #       option.click();
-        #     }
-        #   }
-        # }
-        #
-        # protected String escapeQuotes(String toEscape) {
-        #   // Convert strings with both quotes and ticks into: foo'"bar -> concat("foo'", '"', "bar")
-        #   if (toEscape.indexOf("\"") > -1 && toEscape.indexOf("'") > -1) {
-        #     boolean quoteIsLast = false;
-        #     if (toEscape.indexOf("\"") == toEscape.length() - 1) {
-        #       quoteIsLast = true;
-        #     }
-        #     String[] substrings = toEscape.split("\"");
-        #
-        #     StringBuilder quoted = new StringBuilder("concat(");
-        #     for (int i = 0; i < substrings.length; i++) {
-        #       quoted.append("\"").append(substrings[i]).append("\"");
-        #       quoted
-        #           .append(((i == substrings.length - 1) ? (quoteIsLast ? ", '\"')" : ")") : ", '\"', "));
-        #     }
-        #     return quoted.toString();
-        #   }
-        #
-        #   // Escape string with just a quote into being single quoted: f"oo -> 'f"oo'
-        #   if (toEscape.indexOf("\"") > -1) {
-        #     return String.format("'%s'", toEscape);
-        #   }
-        #
-        #   // Otherwise return the quoted string
-        #   return String.format("\"%s\"", toEscape);
-        # }
-        #
-        
+
+        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(opt)
-          opt.click unless opt.selected?
+
+        def select_option(option)
+          option.click unless option.selected?
+        end
+
+        def deselect_option(option)
+          option.click if option.selected?
         end
-        
-        def deselect_option(opt)
-          opt.click if opt.selected?
+
+        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
 
-      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