watir-webdriver 0.7.0 → 0.8.0

data/lib/watir-webdriver/window.rb

@@ -8,7 +8,7 @@ module Watir
 
       if selector.empty?
         @handle = current_window
-      elsif selector.has_key? :handle
+      elsif selector.key? :handle
         @handle = selector.delete :handle
       else
         unless selector.keys.all? { |k| [:title, :url, :index].include? k }
@@ -116,7 +116,7 @@ module Watir
     # Returns true if two windows are equal.
     #
     # @example
-    #   browser.window(:index => 0) == browser.window(:index => 1)
+    #   browser.window(index: 0) == browser.window(index: 1)
     #   #=> false
     #
     # @param [Window] other
@@ -183,8 +183,8 @@ module Watir
     # Switches to given window and executes block, then switches back.
     #
     # @example
-    #   browser.window(:title => "closeable window").use do
-    #     browser.a(:id => "close").click
+    #   browser.window(title: "closeable window").use do
+    #     browser.a(id: "close").click
     #   end
     #
 
@@ -210,7 +210,7 @@ module Watir
     def locate
       if @selector.empty?
         nil
-      elsif @selector.has_key?(:index)
+      elsif @selector.key?(:index)
         @driver.window_handles[Integer(@selector[:index])]
       else
         @driver.window_handles.find { |wh| matches?(wh) }

data/lib/watir-webdriver/xpath_support.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 module Watir
   module XpathSupport
 

data/spec/always_locate_spec.rb

@@ -4,11 +4,11 @@ describe 'Watir' do
   describe '#always_locate?' do
 
     before do
-      browser.goto WatirSpec.url_for('removed_element.html', :needs_server => true)
+      browser.goto WatirSpec.url_for('removed_element.html', needs_server: true)
     end
 
     it 'determines whether #exist? returns false for stale element' do
-      element = browser.div(:id => "text")
+      element = browser.div(id: "text")
       expect(element.exists?).to be true
 
       browser.refresh
@@ -17,7 +17,7 @@ describe 'Watir' do
     end
 
     it 'allows using cached elements regardless of setting, when element is not stale' do
-      element = browser.div(:id => "text")
+      element = browser.div(id: "text")
       expect(element.exists?).to be true
 
       # exception raised if element is re-looked up
@@ -27,7 +27,7 @@ describe 'Watir' do
     end
 
     it 'determines whether an exception is raised when taking an action on a stale element' do
-      element = browser.div(:id => "text")
+      element = browser.div(id: "text")
       expect(element.exists?).to be true
 
       browser.refresh

data/spec/browser_spec.rb

@@ -51,12 +51,12 @@ describe Watir::Browser do
       browser.goto WatirSpec.url_for "forms_with_input_elements.html"
 
       browser.send_keys "hello"
-      expect(browser.text_field(:id => "new_user_first_name").value).to eq "hello"
+      expect(browser.text_field(id: "new_user_first_name").value).to eq "hello"
     end
 
     it "sends keys to a frame" do
       browser.goto WatirSpec.url_for "frames.html"
-      tf = browser.frame.text_field(:id => "senderElement")
+      tf = browser.frame.text_field(id: "senderElement")
       tf.clear
 
       browser.frame.send_keys "hello"
@@ -70,7 +70,7 @@ describe Watir::Browser do
     b.goto WatirSpec.url_for "definition_lists.html"
     b.close
 
-    expect { b.dl(:id => "experience-list").id }.to raise_error(Watir::Exception::Error, "browser was closed")
+    expect { b.dl(id: "experience-list").id }.to raise_error(Watir::Exception::Error, "browser was closed")
   end
 
   describe "#wait_while" do

data/spec/click_spec.rb

@@ -3,14 +3,21 @@ require File.expand_path('../watirspec/spec_helper', __FILE__)
 describe Watir::Element do
   describe "#click" do
     before {
-      browser.goto WatirSpec.url_for('clicks.html', :needs_server => true)
+      browser.goto WatirSpec.url_for('clicks.html', needs_server: true)
     }
 
-    let(:clicker) { browser.element(:id => "click-logger") }
-    let(:log)     { browser.element(:id => "log").ps.map { |e| e.text } }
+    let(:clicker) { browser.element(id: "click-logger") }
+    let(:log)     { browser.element(id: "log").ps.map { |e| e.text } }
+
+    bug "https://github.com/watir/watir-webdriver/issues/343", :webdriver do
+      it "clicks an element with text in nested text node using text selector" do
+        browser.element(text: "Can You Click This?").click
+        expect(browser.element(text: "You Clicked It!")).to exist
+      end
+    end
 
     # TODO: make guards more flexible, in reality this currently only works on linux with native events
-    compliant_on [:webdriver, :firefox, :native_events] do
+    compliant_on %i(webdriver firefox native_events) do
       it "should perform a click with no modifier keys" do
         clicker.click
         expect(log).to eq ["shift=false alt=false"]

data/spec/container_spec.rb

@@ -11,11 +11,11 @@ describe Watir::Container do
     end
 
     it "converts 2-arg selector into a hash" do
-      expect(@container.public_extract_selector([:how, 'what'])).to eq Hash[:how => 'what']
+      expect(@container.public_extract_selector([:how, 'what'])).to eq Hash[how: 'what']
     end
 
     it "returns the hash given" do
-      expect(@container.public_extract_selector([:how => "what"])).to eq Hash[:how => "what"]
+      expect(@container.public_extract_selector([how: "what"])).to eq Hash[how: "what"]
     end
 
     it "returns an empty hash if given no args" do

data/spec/element_locator_spec.rb

@@ -7,7 +7,7 @@ describe Watir::ElementLocator do
     describe "by delegating to webdriver" do
       WEBDRIVER_SELECTORS.each do |loc|
         it "delegates to webdriver's #{loc} locator" do
-          expect_one(loc, "bar").and_return(element(:tag_name => "div"))
+          expect_one(loc, "bar").and_return(element(tag_name: "div"))
           locate_one loc => "bar"
         end
       end
@@ -21,8 +21,8 @@ describe Watir::ElementLocator do
           expect_one :xpath, ".//div[@title='foo']"
         end
 
-        locate_one :tag_name => "div",
-                   :title    => "foo"
+        locate_one tag_name: "div",
+                   title: "foo"
       end
 
       it "handles selector with no tag name and and a single attribute" do
@@ -32,7 +32,7 @@ describe Watir::ElementLocator do
           expect_one :xpath, ".//*[@title='foo']"
         end
 
-        locate_one :title => "foo"
+        locate_one title: "foo"
       end
 
       it "handles single quotes in the attribute string" do
@@ -42,7 +42,7 @@ describe Watir::ElementLocator do
           expect_one :xpath, %{.//*[@title=concat('foo and ',"'",'bar',"'",'')]}
         end
 
-        locate_one :title => "foo and 'bar'"
+        locate_one title: "foo and 'bar'"
       end
 
       it "handles selector with tag name and multiple attributes" do
@@ -73,15 +73,15 @@ describe Watir::ElementLocator do
     describe "with special cased selectors" do
       it "normalizes space for :text" do
         expect_one :xpath, ".//div[normalize-space()='foo']"
-        locate_one :tag_name => "div",
-                   :text     => "foo"
+        locate_one tag_name: "div",
+                   text: "foo"
       end
 
       it "translates :caption to :text" do
         expect_one :xpath, ".//div[normalize-space()='foo']"
 
-        locate_one :tag_name => "div",
-                   :caption  => "foo"
+        locate_one tag_name: "div",
+                   caption: "foo"
       end
 
       it "translates :class_name to :class" do
@@ -91,8 +91,8 @@ describe Watir::ElementLocator do
           expect_one :xpath, ".//div[contains(concat(' ', @class, ' '), ' foo ')]"
         end
 
-        locate_one :tag_name   => "div",
-                   :class_name => "foo"
+        locate_one tag_name: "div",
+                   class_name: "foo"
       end
 
       it "handles data-* attributes" do
@@ -102,8 +102,8 @@ describe Watir::ElementLocator do
           expect_one :xpath, ".//div[@data-name='foo']"
         end
 
-        locate_one :tag_name  => "div",
-                   :data_name => "foo"
+        locate_one tag_name: "div",
+                   data_name: "foo"
       end
 
       it "handles aria-* attributes" do
@@ -113,8 +113,8 @@ describe Watir::ElementLocator do
           expect_one :xpath, ".//div[@aria-label='foo']"
         end
 
-        locate_one :tag_name  => "div",
-                   :aria_label => "foo"
+        locate_one tag_name: "div",
+                   aria_label: "foo"
       end
 
       it "normalizes space for the :href attribute" do
@@ -125,8 +125,8 @@ describe Watir::ElementLocator do
         end
 
         selector = {
-          :tag_name => "a",
-          :href     => "foo"
+          tag_name: "a",
+          href: "foo"
         }
 
         locate_one selector, Watir::Anchor.attributes
@@ -160,7 +160,7 @@ describe Watir::ElementLocator do
       it "uses label attribute if it is valid for element" do
         expect_one :xpath, ".//option[@label='foo']"
 
-        selector = { :tag_name => "option", :label => "foo" }
+        selector = { tag_name: "option", label: "foo" }
         locate_one selector, Watir::Option.attributes
       end
 
@@ -172,8 +172,8 @@ describe Watir::ElementLocator do
         end
 
         selector = {
-          :tag_name   => "meta",
-          :http_equiv => "foo"
+          tag_name: "meta",
+          http_equiv: "foo"
         }
 
         locate_one selector, Watir::Meta.attributes
@@ -185,35 +185,35 @@ describe Watir::ElementLocator do
     describe "with regexp selectors" do
       it "handles selector with tag name and a single regexp attribute" do
         elements = [
-          element(:tag_name => "div", :attributes => { :class => "foo" }),
-          element(:tag_name => "div", :attributes => { :class => "foob"})
+          element(tag_name: "div", attributes: { class: "foo" }),
+          element(tag_name: "div", attributes: { class: "foob"})
         ]
 
         if Watir.prefer_css?
           expect_all(:css, "div").and_return(elements)
         else
-          expect_all(:xpath, ".//div").and_return(elements)
+          expect_all(:xpath, "(.//div)[contains(@class, 'oob')]").and_return(elements)
         end
 
-        expect(locate_one(:tag_name => "div", :class => /oob/)).to eq elements[1]
+        expect(locate_one(tag_name: "div", class: /oob/)).to eq elements[1]
       end
 
       it "handles :tag_name, :index and a single regexp attribute" do
         elements = [
-          element(:tag_name => "div", :attributes => { :class => "foo" }),
-          element(:tag_name => "div", :attributes => { :class => "foo" })
+          element(tag_name: "div", attributes: { class: "foo" }),
+          element(tag_name: "div", attributes: { class: "foo" })
         ]
 
         if Watir.prefer_css?
           expect_all(:css, "div").and_return(elements)
         else
-          expect_all(:xpath, ".//div").and_return(elements)
+          expect_all(:xpath, "(.//div)[contains(@class, 'foo')]").and_return(elements)
         end
 
         selector = {
-          :tag_name => "div",
-          :class    => /foo/,
-          :index    => 1
+          tag_name: "div",
+          class: /foo/,
+          index: 1
         }
 
         expect(locate_one(selector)).to eq elements[1]
@@ -221,15 +221,15 @@ describe Watir::ElementLocator do
 
       it "handles :xpath and :index selectors" do
         elements = [
-          element(:tag_name => "div", :attributes => { :class => "foo" }),
-          element(:tag_name => "div", :attributes => { :class => "foo" })
+          element(tag_name: "div", attributes: { class: "foo" }),
+          element(tag_name: "div", attributes: { class: "foo" })
         ]
 
         expect_all(:xpath, './/div[@class="foo"]').and_return(elements)
 
         selector = {
-          :xpath => './/div[@class="foo"]',
-          :index => 1
+          xpath: './/div[@class="foo"]',
+          index: 1
         }
 
         expect(locate_one(selector)).to eq elements[1]
@@ -237,15 +237,15 @@ describe Watir::ElementLocator do
 
       it "handles :css and :index selectors" do
         elements = [
-          element(:tag_name => "div", :attributes => { :class => "foo" }),
-          element(:tag_name => "div", :attributes => { :class => "foo" })
+          element(tag_name: "div", attributes: { class: "foo" }),
+          element(tag_name: "div", attributes: { class: "foo" })
         ]
 
         expect_all(:css, 'div[class="foo"]').and_return(elements)
 
         selector = {
-          :css   => 'div[class="foo"]',
-          :index => 1
+          css: 'div[class="foo"]',
+          index: 1
         }
 
         expect(locate_one(selector)).to eq elements[1]
@@ -253,21 +253,20 @@ describe Watir::ElementLocator do
 
       it "handles mix of string and regexp attributes" do
         elements = [
-          element(:tag_name => "div", :attributes => { :dir => "foo", :title => "bar" }),
-          element(:tag_name => "div", :attributes => { :dir => "foo", :title => "baz" })
+          element(tag_name: "div", attributes: { dir: "foo", title: "bar" }),
+          element(tag_name: "div", attributes: { dir: "foo", title: "baz" })
         ]
 
         if Watir.prefer_css?
           expect_all(:css, 'div[dir="foo"]').and_return(elements)
         else
-          expect_all(:xpath, ".//div[@dir='foo']").and_return(elements)
+          expect_all(:xpath, "(.//div[@dir='foo'])[contains(@title, 'baz')]").and_return(elements)
         end
 
-
         selector = {
-          :tag_name => "div",
-          :dir      => "foo",
-          :title    => /baz/
+          tag_name: "div",
+          dir: "foo",
+          title: /baz/
         }
 
         expect(locate_one(selector)).to eq elements[1]
@@ -275,20 +274,20 @@ describe Watir::ElementLocator do
 
       it "handles data-* attributes with regexp" do
         elements = [
-          element(:tag_name => "div", :attributes => { :'data-automation-id' => "foo" }),
-          element(:tag_name => "div", :attributes => { :'data-automation-id' => "bar" })
+          element(tag_name: "div", attributes: { :'data-automation-id' => "foo" }),
+          element(tag_name: "div", attributes: { :'data-automation-id' => "bar" })
         ]
 
         if Watir.prefer_css?
           expect_all(:css, 'div').and_return(elements)
         else
-          expect_all(:xpath, ".//div").and_return(elements)
+          expect_all(:xpath, "(.//div)[contains(@data-automation-id, 'bar')]").and_return(elements)
         end
 
 
         selector = {
-          :tag_name => "div",
-          :data_automation_id => /bar/
+          tag_name: "div",
+          data_automation_id: /bar/
         }
 
         expect(locate_one(selector)).to eq elements[1]
@@ -296,10 +295,10 @@ describe Watir::ElementLocator do
 
       it "handles :label => /regexp/ selector" do
         label_elements = [
-          element(:tag_name => "label", :text => "foo", :attributes => { :for => "bar"}),
-          element(:tag_name => "label", :text => "foob", :attributes => { :for => "baz"})
+          element(tag_name: "label", text: "foo", attributes: { for: "bar"}),
+          element(tag_name: "label", text: "foob", attributes: { for: "baz"})
         ]
-        div_elements = [element(:tag_name => "div")]
+        div_elements = [element(tag_name: "div")]
 
         expect_all(:tag_name, "label").ordered.and_return(label_elements)
 
@@ -309,21 +308,20 @@ describe Watir::ElementLocator do
           expect_all(:xpath, ".//div[@id='baz']").ordered.and_return(div_elements)
         end
 
-        expect(locate_one(:tag_name => "div", :label => /oob/)).to eq div_elements.first
+        expect(locate_one(tag_name: "div", label: /oob/)).to eq div_elements.first
       end
 
       it "returns nil when no label matching the regexp is found" do
         expect_all(:tag_name, "label").and_return([])
-        expect(locate_one(:tag_name => "div", :label => /foo/)).to be_nil
+        expect(locate_one(tag_name: "div", label: /foo/)).to be_nil
       end
-
     end
 
     it "finds all if :index is given" do
       # or could we use XPath indeces reliably instead?
       elements = [
-        element(:tag_name => "div"),
-        element(:tag_name => "div")
+        element(tag_name: "div"),
+        element(tag_name: "div")
       ]
 
       if Watir.prefer_css?
@@ -333,20 +331,20 @@ describe Watir::ElementLocator do
       end
 
       selector = {
-        :tag_name => "div",
-        :dir      => "foo",
-        :index    => 1
+        tag_name: "div",
+        dir: "foo",
+        index: 1
       }
 
       expect(locate_one(selector)).to eq elements[1]
     end
 
     it "returns nil if found element didn't match the selector tag_name" do
-      expect_one(:xpath, "//div").and_return(element(:tag_name => "div"))
+      expect_one(:xpath, "//div").and_return(element(tag_name: "div"))
 
       selector = {
-        :tag_name => "input",
-        :xpath    => "//div"
+        tag_name: "input",
+        xpath: "//div"
       }
 
       expect(locate_one(selector, Watir::Input.attributes)).to be_nil
@@ -354,17 +352,17 @@ describe Watir::ElementLocator do
 
     describe "errors" do
       it "raises a TypeError if :index is not a Fixnum" do
-        expect { locate_one(:tag_name => "div", :index => "bar") }.to \
+        expect { locate_one(tag_name: "div", index: "bar") }.to \
         raise_error(TypeError, %[expected Fixnum, got "bar":String])
       end
 
       it "raises a TypeError if selector value is not a String or Regexp" do
-        expect { locate_one(:tag_name => 123) }.to \
+        expect { locate_one(tag_name: 123) }.to \
         raise_error(TypeError, %[expected one of [String, Regexp], got 123:Fixnum])
       end
 
       it "raises a MissingWayOfFindingObjectException if the attribute is not valid" do
-        bad_selector = {:tag_name => "input", :href => "foo"}
+        bad_selector = {tag_name: "input", href: "foo"}
         valid_attributes = Watir::Input.attributes
 
         expect { locate_one(bad_selector, valid_attributes) }.to \
@@ -377,7 +375,7 @@ describe Watir::ElementLocator do
     describe "by delegating to webdriver" do
       WEBDRIVER_SELECTORS.each do |loc|
         it "delegates to webdriver's #{loc} locator" do
-          expect_all(loc, "bar").and_return([element(:tag_name => "div")])
+          expect_all(loc, "bar").and_return([element(tag_name: "div")])
           locate_all(loc => "bar")
         end
       end
@@ -403,8 +401,8 @@ describe Watir::ElementLocator do
           expect_all :xpath, ".//div[@dir='foo']"
         end
 
-        locate_all :tag_name => "div",
-                   :dir      => "foo"
+        locate_all tag_name: "div",
+                   dir: "foo"
       end
 
       it "handles selector with tag name and multiple attributes" do
@@ -423,47 +421,110 @@ describe Watir::ElementLocator do
     describe "with regexp selectors" do
       it "handles selector with tag name and a single regexp attribute" do
         elements = [
-          element(:tag_name => "div", :attributes => { :class => "foo" }),
-          element(:tag_name => "div", :attributes => { :class => "foob"}),
-          element(:tag_name => "div", :attributes => { :class => "doob"}),
-          element(:tag_name => "div", :attributes => { :class => "noob"})
+          element(tag_name: "div", attributes: { class: "foo" }),
+          element(tag_name: "div", attributes: { class: "foob"}),
+          element(tag_name: "div", attributes: { class: "doob"}),
+          element(tag_name: "div", attributes: { class: "noob"})
         ]
 
         if Watir.prefer_css?
           expect_all(:css, "div").and_return(elements)
         else
-          expect_all(:xpath, ".//div").and_return(elements)
+          expect_all(:xpath, "(.//div)[contains(@class, 'oob')]").and_return(elements)
         end
 
-        expect(locate_all(:tag_name => "div", :class => /oob/)).to eq elements.last(3)
+        expect(locate_all(tag_name: "div", class: /oob/)).to eq elements.last(3)
       end
 
       it "handles mix of string and regexp attributes" do
         elements = [
-          element(:tag_name => "div", :attributes => { :dir => "foo", :title => "bar" }),
-          element(:tag_name => "div", :attributes => { :dir => "foo", :title => "baz" }),
-          element(:tag_name => "div", :attributes => { :dir => "foo", :title => "bazt"})
+          element(tag_name: "div", attributes: { dir: "foo", title: "bar" }),
+          element(tag_name: "div", attributes: { dir: "foo", title: "baz" }),
+          element(tag_name: "div", attributes: { dir: "foo", title: "bazt"})
         ]
 
         if Watir.prefer_css?
           expect_all(:css, 'div[dir="foo"]').and_return(elements)
         else
-          expect_all(:xpath, ".//div[@dir='foo']").and_return(elements)
+          expect_all(:xpath, "(.//div[@dir='foo'])[contains(@title, 'baz')]").and_return(elements)
         end
 
         selector = {
-          :tag_name => "div",
-          :dir      => "foo",
-          :title    => /baz/
+          tag_name: "div",
+          dir: "foo",
+          title: /baz/
         }
 
         expect(locate_all(selector)).to eq elements.last(2)
       end
+
+      context "and xpath" do
+        before do
+          expect(Watir).to receive(:prefer_css?).and_return(false)
+        end
+
+        it "converts a leading run of regexp literals to a contains() expression" do
+          elements = [
+            element(tag_name: "div", attributes: { class: "foo" }),
+            element(tag_name: "div", attributes: { class: "foob" }),
+            element(tag_name: "div", attributes: { class: "bar" })
+          ]
+
+          expect_all(:xpath, "(.//div)[contains(@class, 'fo')]").and_return(elements.first(2))
+
+          expect(locate_one(tag_name: "div", class: /fo.b$/)).to eq elements[1]
+        end
+
+        it "converts a trailing run of regexp literals to a contains() expression" do
+          elements = [
+            element(tag_name: "div", attributes: { class: "foo" }),
+            element(tag_name: "div", attributes: { class: "foob" })
+          ]
+
+          expect_all(:xpath, "(.//div)[contains(@class, 'b')]").and_return(elements.last(1))
+
+          expect(locate_one(tag_name: "div", class: /^fo.b/)).to eq elements[1]
+        end
+
+        it "converts a leading and a trailing run of regexp literals to a contains() expression" do
+          elements = [
+            element(tag_name: "div", attributes: { class: "foo" }),
+            element(tag_name: "div", attributes: { class: "foob" })
+          ]
+
+          expect_all(:xpath, "(.//div)[contains(@class, 'fo') and contains(@class, 'b')]").
+            and_return(elements.last(1))
+
+          expect(locate_one(tag_name: "div", class: /fo.b/)).to eq elements[1]
+        end
+
+        it "does not try to convert case insensitive expressions" do
+          elements = [
+            element(tag_name: "div", attributes: { class: "foo" }),
+            element(tag_name: "div", attributes: { class: "foob"})
+          ]
+
+          expect_all(:xpath, ".//div").and_return(elements.last(1))
+
+          expect(locate_one(tag_name: "div", class: /FOOB/i)).to eq elements[1]
+        end
+
+        it "does not try to convert expressions containing '|'" do
+          elements = [
+            element(tag_name: "div", attributes: { class: "foo" }),
+            element(tag_name: "div", attributes: { class: "foob"})
+          ]
+
+          expect_all(:xpath, ".//div").and_return(elements.last(1))
+
+          expect(locate_one(tag_name: "div", class: /x|b/)).to eq elements[1]
+        end
+      end
     end
 
     describe "errors" do
       it "raises ArgumentError if :index is given" do
-        expect { locate_all(:tag_name => "div", :index => 1) }.to \
+        expect { locate_all(tag_name: "div", index: 1) }.to \
         raise_error(ArgumentError, "can't locate all elements by :index")
       end
     end