watir 7.0.0.beta1 → 7.0.0.beta5

data/spec/watirspec/elements/span_spec.rb

@@ -100,18 +100,16 @@ describe 'Span' do
   end
 
   # Other
-  not_compliant_on :headless do
-    describe '#click' do
-      it 'fires events' do
-        expect(browser.span(class: 'footer').text).to_not include('Javascript')
-        browser.span(class: 'footer').click
-        expect(browser.span(class: 'footer').text).to include('Javascript')
-      end
-
-      it "raises UnknownObjectException if the span doesn't exist" do
-        expect { browser.span(id: 'no_such_id').click }.to raise_unknown_object_exception
-        expect { browser.span(title: 'no_such_title').click }.to raise_unknown_object_exception
-      end
+  describe '#click', except: {headless: true} do
+    it 'fires events' do
+      expect(browser.span(class: 'footer').text).to_not include('Javascript')
+      browser.span(class: 'footer').click
+      expect(browser.span(class: 'footer').text).to include('Javascript')
+    end
+
+    it "raises UnknownObjectException if the span doesn't exist" do
+      expect { browser.span(id: 'no_such_id').click }.to raise_unknown_object_exception
+      expect { browser.span(title: 'no_such_title').click }.to raise_unknown_object_exception
     end
   end
 end

data/spec/watirspec/elements/table_nesting_spec.rb

@@ -5,48 +5,45 @@ describe 'Table' do
     browser.goto(WatirSpec.url_for('nested_tables.html'))
   end
 
-  # not a selenium bug - IE seems unable to deal with the invalid nesting
-  not_compliant_on :internet_explorer do
-    it 'returns the correct number of rows under a table element' do
-      tables = browser.div(id: 'table-rows-test').tables(id: /^tbl/)
-      expect(tables.length).to be > 0
-
-      tables.each do |table|
-        expected      = Integer(table.data_row_count)
-        actual        = table.rows.length
-        browser_count = Integer(table.data_browser_count)
-
-        msg = "expected #{expected} rows, got #{actual} for table id=#{table.id}, browser reported: #{browser_count}"
-        expect(actual).to eql(expected), msg
-      end
+  it 'returns the correct number of rows under a table element' do
+    tables = browser.div(id: 'table-rows-test').tables(id: /^tbl/)
+    expect(tables.length).to be > 0
+
+    tables.each do |table|
+      expected = Integer(table.data_row_count)
+      actual = table.rows.length
+      browser_count = Integer(table.data_browser_count)
+
+      msg = "expected #{expected} rows, got #{actual} for table id=#{table.id}, browser reported: #{browser_count}"
+      expect(actual).to eql(expected), msg
     end
+  end
 
-    it 'returns the correct number of cells under a row' do
-      rows = browser.div(id: 'row-cells-test').trs(id: /^row/)
-      expect(rows.length).to be > 0
+  it 'returns the correct number of cells under a row' do
+    rows = browser.div(id: 'row-cells-test').trs(id: /^row/)
+    expect(rows.length).to be > 0
 
-      rows.each do |row|
-        expected      = Integer(row.data_cell_count)
-        actual        = row.cells.length
-        browser_count = Integer(row.data_browser_count)
+    rows.each do |row|
+      expected = Integer(row.data_cell_count)
+      actual = row.cells.length
+      browser_count = Integer(row.data_browser_count)
 
-        msg = "expected #{expected} cells, got #{actual} for row id=#{row.id}, browser reported: #{browser_count}"
-        expect(actual).to eql(expected), msg
-      end
+      msg = "expected #{expected} cells, got #{actual} for row id=#{row.id}, browser reported: #{browser_count}"
+      expect(actual).to eql(expected), msg
     end
+  end
 
-    it 'returns the correct number of rows under a table section' do
-      tbodies = browser.table(id: 'tbody-rows-test').tbodys(id: /^body/)
-      expect(tbodies.length).to be > 0
+  it 'returns the correct number of rows under a table section' do
+    tbodies = browser.table(id: 'tbody-rows-test').tbodys(id: /^body/)
+    expect(tbodies.length).to be > 0
 
-      tbodies.each do |tbody|
-        expected      = Integer(tbody.data_rows_count)
-        actual        = tbody.rows.count
-        browser_count = Integer(tbody.data_browser_count)
+    tbodies.each do |tbody|
+      expected = Integer(tbody.data_rows_count)
+      actual = tbody.rows.count
+      browser_count = Integer(tbody.data_browser_count)
 
-        msg = "expected #{expected} rows, got #{actual} for tbody id=#{tbody.id}, browser reported: #{browser_count}"
-        expect(actual).to eql(expected), msg
-      end
+      msg = "expected #{expected} rows, got #{actual} for tbody id=#{tbody.id}, browser reported: #{browser_count}"
+      expect(actual).to eql(expected), msg
     end
   end
 end

data/spec/watirspec/elements/table_spec.rb

@@ -36,19 +36,17 @@ describe 'Table' do
   end
 
   # Other
-  bug 'Safari does not strip text', :safari do
-    describe '#strings' do
-      it 'returns a two-dimensional array representation of the table' do
-        expect(browser.table(id: 'inner').strings).to eq [
-          ['Table 2, Row 1, Cell 1',
-           'Table 2, Row 1, Cell 2']
-        ]
-        expect(browser.table(id: 'outer').strings).to eq [
-          ['Table 1, Row 1, Cell 1', 'Table 1, Row 1, Cell 2'],
-          ['Table 1, Row 2, Cell 1', "Table 1, Row 2, Cell 2\nTable 2, Row 1, Cell 1 Table 2, Row 1, Cell 2"],
-          ['Table 1, Row 3, Cell 1', 'Table 1, Row 3, Cell 2']
-        ]
-      end
+  describe '#strings', except: {browser: :safari, reason: 'Safari does not strip text'} do
+    it 'returns a two-dimensional array representation of the table' do
+      expect(browser.table(id: 'inner').strings).to eq [
+        ['Table 2, Row 1, Cell 1',
+         'Table 2, Row 1, Cell 2']
+      ]
+      expect(browser.table(id: 'outer').strings).to eq [
+        ['Table 1, Row 1, Cell 1', 'Table 1, Row 1, Cell 2'],
+        ['Table 1, Row 2, Cell 1', "Table 1, Row 2, Cell 2\nTable 2, Row 1, Cell 1 Table 2, Row 1, Cell 2"],
+        ['Table 1, Row 3, Cell 1', 'Table 1, Row 3, Cell 2']
+      ]
     end
   end
 

data/spec/watirspec/elements/tbody_spec.rb

@@ -44,19 +44,17 @@ describe 'TableBody' do
     end
   end
 
-  bug 'Safari does not strip text', :safari do
-    describe '#[]' do
-      it 'returns the row at the given index (page context)' do
-        expect(browser.tbody(id: 'first')[0].text).to eq 'March 2008'
-        expect(browser.tbody(id: 'first')[1][0].text).to eq 'Gregory House'
-        expect(browser.tbody(id: 'first')[2][0].text).to eq 'Hugh Laurie'
-      end
+  describe '#[]', except: {browser: :safari, reason: 'Safari does not strip text'} do
+    it 'returns the row at the given index (page context)' do
+      expect(browser.tbody(id: 'first')[0].text).to eq 'March 2008'
+      expect(browser.tbody(id: 'first')[1][0].text).to eq 'Gregory House'
+      expect(browser.tbody(id: 'first')[2][0].text).to eq 'Hugh Laurie'
+    end
 
-      it 'returns the row at the given index (table context)' do
-        expect(browser.table(index: 0).tbody(id: 'first')[0].text).to eq 'March 2008'
-        expect(browser.table(index: 0).tbody(id: 'first')[1][0].text).to eq 'Gregory House'
-        expect(browser.table(index: 0).tbody(id: 'first')[2][0].text).to eq 'Hugh Laurie'
-      end
+    it 'returns the row at the given index (table context)' do
+      expect(browser.table(index: 0).tbody(id: 'first')[0].text).to eq 'March 2008'
+      expect(browser.table(index: 0).tbody(id: 'first')[1][0].text).to eq 'Gregory House'
+      expect(browser.table(index: 0).tbody(id: 'first')[2][0].text).to eq 'Hugh Laurie'
     end
   end
 

data/spec/watirspec/elements/td_spec.rb

@@ -42,12 +42,10 @@ describe 'TableCell' do
   end
 
   # Attribute methods
-  bug 'Safari does not strip text', :safari do
-    describe '#text' do
-      it 'returns the text inside the table cell' do
-        expect(browser.td(id: 't1_r2_c1').text).to eq 'Table 1, Row 2, Cell 1'
-        expect(browser.td(id: 't2_r1_c1').text).to eq 'Table 2, Row 1, Cell 1'
-      end
+  describe '#text', except: {browser: :safari, reason: 'Safari does not strip text'} do
+    it 'returns the text inside the table cell' do
+      expect(browser.td(id: 't1_r2_c1').text).to eq 'Table 1, Row 2, Cell 1'
+      expect(browser.td(id: 't2_r1_c1').text).to eq 'Table 2, Row 1, Cell 1'
     end
   end
 

data/spec/watirspec/elements/text_field_spec.rb

@@ -26,18 +26,16 @@ describe 'TextField' do
       expect(browser.text_field(label: 'With hidden text')).to exist
       expect(browser.text_field(label: 'With text')).not_to exist
 
-      # These will work after text is deprecated for visible_text
-      # expect(browser.text_field(label: /With hidden text/)).to exist
-      # expect(browser.text_field(label: /With text/)).not_to exist
-    end
-
-    bug 'Safari is not filtering out hidden text', :safari do
-      it 'returns true in spite of hidden text' do
-        expect(browser.text_field(visible_label: 'With hidden text')).not_to exist
-        expect(browser.text_field(visible_label: 'With text')).to exist
-        expect(browser.text_field(visible_label: /With text/)).to exist
-        expect(browser.text_field(visible_label: /With hidden text/)).not_to exist
-      end
+      expect(browser.text_field(label: /With hidden text/)).to exist
+      expect(browser.text_field(label: /With text/)).not_to exist
+    end
+
+    it 'returns true in spite of hidden text',
+       except: {browser: :safari, reason: 'Safari is not filtering out hidden text'} do
+      expect(browser.text_field(visible_label: 'With hidden text')).not_to exist
+      expect(browser.text_field(visible_label: 'With text')).to exist
+      expect(browser.text_field(visible_label: /With text/)).to exist
+      expect(browser.text_field(visible_label: /With hidden text/)).not_to exist
     end
 
     it 'locates value of text_field using text locators' do

data/spec/watirspec/elements/tr_spec.rb

@@ -29,14 +29,12 @@ describe 'TableRow' do
     end
   end
 
-  bug 'Safari does not strip text', :safari do
-    describe '#[]' do
-      let(:table) { browser.table(id: 'outer') }
+  describe '#[]', except: {browser: :safari, reason: 'Safari does not strip text'} do
+    let(:table) { browser.table(id: 'outer') }
 
-      it 'returns the nth cell of the row' do
-        expect(table[0][0].text).to eq 'Table 1, Row 1, Cell 1'
-        expect(table[2][0].text).to eq 'Table 1, Row 3, Cell 1'
-      end
+    it 'returns the nth cell of the row' do
+      expect(table[0][0].text).to eq 'Table 1, Row 1, Cell 1'
+      expect(table[2][0].text).to eq 'Table 1, Row 3, Cell 1'
     end
   end
 

data/spec/watirspec/support/rspec_matchers.rb

@@ -1,5 +1,5 @@
 if defined?(RSpec)
-  DEPRECATION_WARNINGS = %i[use_capabilities].freeze
+  DEPRECATION_WARNINGS = %i[timeouts].freeze
 
   DEPRECATION_WARNINGS.each do |deprecation|
     RSpec::Matchers.define "have_deprecated_#{deprecation}" do

data/spec/watirspec/user_editable_spec.rb

@@ -5,34 +5,32 @@ describe Watir::UserEditable do
     browser.goto(WatirSpec.url_for('forms_with_input_elements.html'))
   end
 
-  bug 'incorrectly clears first', :safari do
-    describe '#append' do
-      it 'appends the text to the text field' do
-        browser.text_field(name: 'new_user_occupation').append(' Append This')
-        expect(browser.text_field(name: 'new_user_occupation').value).to eq 'Developer Append This'
-      end
-
-      it 'appends multi-byte characters' do
-        browser.text_field(name: 'new_user_occupation').append(' ijij')
-        expect(browser.text_field(name: 'new_user_occupation').value).to eq 'Developer ijij'
-      end
-
-      it 'raises NotImplementedError if the object is content editable element' do
-        msg = '#append method is not supported with contenteditable element'
-        expect { browser.div(id: 'contenteditable').append('bar') }.to raise_exception(NotImplementedError, msg)
-      end
-
-      it 'raises ObjectReadOnlyException if the object is read only' do
-        expect { browser.text_field(id: 'new_user_code').append('Append This') }.to raise_object_read_only_exception
-      end
-
-      it 'raises ObjectDisabledException if the object is disabled' do
-        expect { browser.text_field(name: 'new_user_species').append('Append This') }.to raise_object_disabled_exception
-      end
-
-      it "raises UnknownObjectException if the object doesn't exist" do
-        expect { browser.text_field(name: 'no_such_name').append('Append This') }.to raise_unknown_object_exception
-      end
+  describe '#append' do
+    it 'appends the text to the text field', except: {browser: :safari, reason: 'incorrectly clears first'} do
+      browser.text_field(name: 'new_user_occupation').append(' Append This')
+      expect(browser.text_field(name: 'new_user_occupation').value).to eq 'Developer Append This'
+    end
+
+    it 'appends multi-byte characters', except: {browser: :safari, reason: 'incorrectly clears first'} do
+      browser.text_field(name: 'new_user_occupation').append(' ijij')
+      expect(browser.text_field(name: 'new_user_occupation').value).to eq 'Developer ijij'
+    end
+
+    it 'raises NotImplementedError if the object is content editable element' do
+      msg = '#append method is not supported with contenteditable element'
+      expect { browser.div(id: 'contenteditable').append('bar') }.to raise_exception(NotImplementedError, msg)
+    end
+
+    it 'raises ObjectReadOnlyException if the object is read only' do
+      expect { browser.text_field(id: 'new_user_code').append('Append This') }.to raise_object_read_only_exception
+    end
+
+    it 'raises ObjectDisabledException if the object is disabled' do
+      expect { browser.text_field(name: 'new_user_species').append('Append This') }.to raise_object_disabled_exception
+    end
+
+    it "raises UnknownObjectException if the object doesn't exist" do
+      expect { browser.text_field(name: 'no_such_name').append('Append This') }.to raise_unknown_object_exception
     end
   end
 

data/spec/watirspec/wait_spec.rb

@@ -1,352 +1,349 @@
 require 'watirspec_helper'
 
-compliant_on :relaxed_locate do
-  describe Watir do
-    before do
-      browser.goto WatirSpec.url_for('wait.html')
-    end
+describe Watir do
+  before do
+    browser.goto WatirSpec.url_for('wait.html')
+  end
 
-    describe '#default_timeout' do
-      context 'when no timeout is specified' do
-        it 'is used by Wait#until' do
-          expect { Watir::Wait.until { false } }.to wait_and_raise_timeout_exception(timeout: 1)
-        end
+  describe '#default_timeout' do
+    context 'when no timeout is specified' do
+      it 'is used by Wait#until' do
+        expect { Watir::Wait.until { false } }.to wait_and_raise_timeout_exception(timeout: 1)
+      end
 
-        it 'is used by Wait#while' do
-          expect { Watir::Wait.while { true } }.to wait_and_raise_timeout_exception(timeout: 1)
-        end
+      it 'is used by Wait#while' do
+        expect { Watir::Wait.while { true } }.to wait_and_raise_timeout_exception(timeout: 1)
+      end
 
-        it 'ensures all checks happen once even if time has expired' do
-          Watir.default_timeout = -1
-          expect { browser.link.click }.to_not raise_exception
-        ensure
-          Watir.default_timeout = 30
-        end
+      it 'ensures all checks happen once even if time has expired' do
+        Watir.default_timeout = -1
+        expect { browser.link.click }.to_not raise_exception
+      ensure
+        Watir.default_timeout = 5
       end
     end
   end
+end
+
+describe Watir::Element do
+  before do
+    browser.goto WatirSpec.url_for('wait.html')
+  end
 
-  describe Watir::Element do
-    before do
-      browser.goto WatirSpec.url_for('wait.html')
+  describe '#wait_until' do
+    it 'returns element for additional actions' do
+      element = browser.div(id: 'foo')
+      expect(element.wait_until(&:exist?)).to eq element
     end
 
-    describe '#wait_until' do
-      it 'returns element for additional actions' do
-        element = browser.div(id: 'foo')
-        expect(element.wait_until(&:exist?)).to eq element
-      end
+    it 'accepts self in block' do
+      element = browser.div(id: 'bar')
+      browser.a(id: 'show_bar').click
+      expect { element.wait_until { |el| el.text == 'bar' } }.to_not raise_exception
+    end
+
+    it 'accepts any values in block' do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until { true } }.to_not raise_exception
+    end
+
+    it 'accepts just a timeout parameter' do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until(timeout: 0) { true } }.to_not raise_exception
+    end
+
+    it 'accepts just a message parameter' do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until(message: 'no') { true } }.to_not raise_exception
+    end
+
+    it 'accepts just an interval parameter' do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until(interval: 0.1) { true } }.to_not raise_exception
+    end
+
+    context 'accepts keywords instead of block' do
+      before { browser.refresh }
 
-      it 'accepts self in block' do
+      it 'accepts text keyword' do
         element = browser.div(id: 'bar')
         browser.a(id: 'show_bar').click
-        expect { element.wait_until { |el| el.text == 'bar' } }.to_not raise_exception
+        expect { element.wait_until(text: 'bar') }.to_not raise_exception
       end
 
-      it 'accepts any values in block' do
+      it 'accepts regular expression value' do
         element = browser.div(id: 'bar')
-        expect { element.wait_until { true } }.to_not raise_exception
+        browser.a(id: 'show_bar').click
+        expect { element.wait_until(style: /block/) }.to_not raise_exception
       end
 
-      it 'accepts just a timeout parameter' do
+      it 'accepts multiple keywords' do
         element = browser.div(id: 'bar')
-        expect { element.wait_until(timeout: 0) { true } }.to_not raise_exception
+        browser.a(id: 'show_bar').click
+        expect { element.wait_until(text: 'bar', style: /block/) }.to_not raise_exception
       end
 
-      it 'accepts just a message parameter' do
+      it 'accepts custom keyword' do
         element = browser.div(id: 'bar')
-        expect { element.wait_until(message: 'no') { true } }.to_not raise_exception
+        browser.a(id: 'show_bar').click
+        expect { element.wait_until(custom: 'bar') }.to_not raise_exception
       end
 
-      it 'accepts just an interval parameter' do
+      it 'times out when single keyword not met' do
         element = browser.div(id: 'bar')
-        expect { element.wait_until(interval: 0.1) { true } }.to_not raise_exception
+        expect { element.wait_until(id: 'foo') }.to raise_timeout_exception
       end
 
-      context 'accepts keywords instead of block' do
-        before { browser.refresh }
-
-        it 'accepts text keyword' do
-          element = browser.div(id: 'bar')
-          browser.a(id: 'show_bar').click
-          expect { element.wait_until(text: 'bar') }.to_not raise_exception
-        end
+      it 'times out when one of multiple keywords not met' do
+        element = browser.div(id: 'bar')
+        expect { element.wait_until(id: 'bar', text: 'foo') }.to raise_timeout_exception
+      end
 
-        it 'accepts regular expression value' do
-          element = browser.div(id: 'bar')
-          browser.a(id: 'show_bar').click
-          expect { element.wait_until(style: /block/) }.to_not raise_exception
-        end
+      it 'times out when a custom keywords not met' do
+        element = browser.div(id: 'bar')
+        expect { element.wait_until(custom: 'foo') }.to raise_timeout_exception
+      end
+    end
+  end
 
-        it 'accepts multiple keywords' do
-          element = browser.div(id: 'bar')
-          browser.a(id: 'show_bar').click
-          expect { element.wait_until(text: 'bar', style: /block/) }.to_not raise_exception
-        end
+  describe '#wait_while' do
+    it 'returns element for additional actions' do
+      element = browser.div(id: 'foo')
+      browser.a(id: 'hide_foo').click
+      expect(element.wait_while(&:present?)).to eq element
+    end
 
-        it 'accepts custom keyword' do
-          element = browser.div(id: 'bar')
-          browser.a(id: 'show_bar').click
-          expect { element.wait_until(custom: 'bar') }.to_not raise_exception
-        end
+    it 'accepts any values in block' do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while { false } }.to_not raise_exception
+    end
 
-        it 'times out when single keyword not met' do
-          element = browser.div(id: 'bar')
-          expect { element.wait_until(id: 'foo') }.to raise_timeout_exception
-        end
+    it 'accepts just a timeout parameter' do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while(timeout: 0) { false } }.to_not raise_exception
+    end
 
-        it 'times out when one of multiple keywords not met' do
-          element = browser.div(id: 'bar')
-          expect { element.wait_until(id: 'bar', text: 'foo') }.to raise_timeout_exception
-        end
+    it 'accepts just a message parameter' do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while(message: 'no') { false } }.to_not raise_exception
+    end
 
-        it 'times out when a custom keywords not met' do
-          element = browser.div(id: 'bar')
-          expect { element.wait_until(custom: 'foo') }.to raise_timeout_exception
-        end
-      end
+    it 'accepts just an interval parameter' do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while(interval: 0.1) { false } }.to_not raise_exception
     end
 
-    describe '#wait_while' do
-      it 'returns element for additional actions' do
+    context 'accepts keywords instead of block' do
+      it 'accepts text keyword', except: {browser: :safari,
+                                          reason: 'Safari does not recognize date type'} do
         element = browser.div(id: 'foo')
         browser.a(id: 'hide_foo').click
-        expect(element.wait_while(&:present?)).to eq element
+        expect { element.wait_while(text: 'foo') }.to_not raise_exception
       end
 
-      it 'accepts any values in block' do
+      it 'accepts regular expression value' do
         element = browser.div(id: 'foo')
-        expect { element.wait_while { false } }.to_not raise_exception
+        browser.a(id: 'hide_foo').click
+        expect { element.wait_while(style: /block/) }.to_not raise_exception
       end
 
-      it 'accepts just a timeout parameter' do
+      it 'accepts multiple keywords' do
         element = browser.div(id: 'foo')
-        expect { element.wait_while(timeout: 0) { false } }.to_not raise_exception
+        browser.a(id: 'hide_foo').click
+        expect { element.wait_while(text: 'foo', style: /block/) }.to_not raise_exception
       end
 
-      it 'accepts just a message parameter' do
+      it 'accepts custom attributes' do
         element = browser.div(id: 'foo')
-        expect { element.wait_while(message: 'no') { false } }.to_not raise_exception
+        browser.a(id: 'hide_foo').click
+        expect { element.wait_while(custom: '') }.to_not raise_exception
       end
 
-      it 'accepts just an interval parameter' do
+      it 'accepts keywords and block' do
         element = browser.div(id: 'foo')
-        expect { element.wait_while(interval: 0.1) { false } }.to_not raise_exception
+        browser.a(id: 'hide_foo').click
+        expect { element.wait_while(custom: '', &:present?) }.to_not raise_exception
       end
 
-      context 'accepts keywords instead of block' do
-        bug 'Safari does not recognize date type', :safari do
-          it 'accepts text keyword' do
-            element = browser.div(id: 'foo')
-            browser.a(id: 'hide_foo').click
-            expect { element.wait_while(text: 'foo') }.to_not raise_exception
-          end
-        end
-
-        it 'accepts regular expression value' do
-          element = browser.div(id: 'foo')
-          browser.a(id: 'hide_foo').click
-          expect { element.wait_while(style: /block/) }.to_not raise_exception
-        end
-
-        it 'accepts multiple keywords' do
-          element = browser.div(id: 'foo')
-          browser.a(id: 'hide_foo').click
-          expect { element.wait_while(text: 'foo', style: /block/) }.to_not raise_exception
-        end
-
-        it 'accepts custom attributes' do
-          element = browser.div(id: 'foo')
-          browser.a(id: 'hide_foo').click
-          expect { element.wait_while(custom: '') }.to_not raise_exception
-        end
-
-        it 'accepts keywords and block' do
-          element = browser.div(id: 'foo')
-          browser.a(id: 'hide_foo').click
-          expect { element.wait_while(custom: '', &:present?) }.to_not raise_exception
-        end
-
-        it 'browser accepts keywords' do
-          expect { browser.wait_until(title: 'wait test') }.to_not raise_exception
-          expect { browser.wait_until(title: 'wrong') }.to raise_timeout_exception
-        end
-
-        it 'alert accepts keywords' do
-          browser.goto WatirSpec.url_for('alerts.html')
+      it 'browser accepts keywords' do
+        expect { browser.wait_until(title: 'wait test') }.to_not raise_exception
+        expect { browser.wait_until(title: 'wrong') }.to raise_timeout_exception
+      end
 
-          begin
-            browser.button(id: 'alert').click
-            expect { browser.alert.wait_until(text: 'ok') }.to_not raise_exception
-            expect { browser.alert.wait_until(text: 'not ok') }.to raise_timeout_exception
-          ensure
-            browser.alert.ok
-          end
-        end
+      it 'alert accepts keywords' do
+        browser.goto WatirSpec.url_for('alerts.html')
 
-        it 'window accepts keywords' do
-          expect { browser.window.wait_until(title: 'wait test') }.to_not raise_exception
-          expect { browser.window.wait_until(title: 'wrong') }.to raise_timeout_exception
+        begin
+          browser.button(id: 'alert').click
+          expect { browser.alert.wait_until(text: 'ok') }.to_not raise_exception
+          expect { browser.alert.wait_until(text: 'not ok') }.to raise_timeout_exception
+        ensure
+          browser.alert.ok
         end
+      end
 
-        it 'times out when single keyword not met' do
-          element = browser.div(id: 'foo')
-          expect { element.wait_while(id: 'foo') }.to raise_timeout_exception
-        end
+      it 'window accepts keywords' do
+        expect { browser.window.wait_until(title: 'wait test') }.to_not raise_exception
+        expect { browser.window.wait_until(title: 'wrong') }.to raise_timeout_exception
+      end
 
-        it 'times out when one of multiple keywords not met' do
-          element = browser.div(id: 'foo')
-          browser.a(id: 'hide_foo').click
-          expect { element.wait_while(id: 'foo', style: /block/) }.to raise_timeout_exception
-        end
+      it 'times out when single keyword not met' do
+        element = browser.div(id: 'foo')
+        expect { element.wait_while(id: 'foo') }.to raise_timeout_exception
+      end
 
-        it 'times out when one of custom keywords not met' do
-          element = browser.div(id: 'foo')
-          expect { element.wait_while(custom: '') }.to raise_timeout_exception
-        end
+      it 'times out when one of multiple keywords not met' do
+        element = browser.div(id: 'foo')
+        browser.a(id: 'hide_foo').click
+        expect { element.wait_while(id: 'foo', style: /block/) }.to raise_timeout_exception
       end
-    end
 
-    context 'when acting on an element that is never present' do
-      it 'raises exception after timing out' do
-        element = browser.link(id: 'not_there')
-        expect { element.click }.to wait_and_raise_unknown_object_exception
+      it 'times out when one of custom keywords not met' do
+        element = browser.div(id: 'foo')
+        expect { element.wait_while(custom: '') }.to raise_timeout_exception
       end
     end
+  end
 
-    context 'when acting on an element that is already present' do
-      it 'does not wait' do
-        expect { browser.link.click }.to execute_when_satisfied(max: 1)
-      end
+  context 'when acting on an element that is never present' do
+    it 'raises exception after timing out' do
+      element = browser.link(id: 'not_there')
+      expect { element.click }.to wait_and_raise_unknown_object_exception
     end
+  end
 
-    context 'when acting on an element that eventually becomes present' do
-      it 'waits until element is present and then takes action' do
-        expect {
-          browser.a(id: 'show_bar').click
-          browser.div(id: 'bar').click
-        }.to execute_when_satisfied(min: 1)
-        expect(browser.div(id: 'bar').text).to eq 'changed'
-      end
+  context 'when acting on an element that is already present' do
+    it 'does not wait' do
+      expect { browser.link.click }.to execute_when_satisfied(max: 1)
+    end
+  end
 
-      it 'waits until text field present and then takes action' do
-        expect {
-          browser.a(id: 'show_textfield').click
-          browser.text_field(id: 'textfield').set 'Foo'
-        }.to execute_when_satisfied(min: 1)
-      end
+  context 'when acting on an element that eventually becomes present' do
+    it 'waits until element is present and then takes action' do
+      expect {
+        browser.a(id: 'show_bar').click
+        browser.div(id: 'bar').click
+      }.to execute_when_satisfied(min: 1)
+      expect(browser.div(id: 'bar').text).to eq 'changed'
     end
 
-    context 'when acting on a read only text field' do
-      it 'waits and raises read only exception if never becomes writable' do
-        expect { browser.text_field(id: 'writable').set 'foo' }.to wait_and_raise_object_read_only_exception
-      end
+    it 'waits until text field present and then takes action' do
+      expect {
+        browser.a(id: 'show_textfield').click
+        browser.text_field(id: 'textfield').set 'Foo'
+      }.to execute_when_satisfied(min: 1)
+    end
+  end
 
-      it 'waits until writable' do
-        expect {
-          browser.a(id: 'make-writable').click
-          browser.text_field(id: 'writable').set 'foo'
-        }.to execute_when_satisfied(min: 1)
-      end
+  context 'when acting on a read only text field' do
+    it 'waits and raises read only exception if never becomes writable' do
+      expect { browser.text_field(id: 'writable').set 'foo' }.to wait_and_raise_object_read_only_exception
     end
 
-    context 'when acting on a disabled button' do
-      it 'waits and raises exception if it never becomes enabled' do
-        expect { browser.button(id: 'btn').click }.to wait_and_raise_object_disabled_exception
-      end
+    it 'waits until writable' do
+      expect {
+        browser.a(id: 'make-writable').click
+        browser.text_field(id: 'writable').set 'foo'
+      }.to execute_when_satisfied(min: 1)
+    end
+  end
 
-      it 'waits until enabled' do
-        expect {
-          browser.a(id: 'enable_btn').click
-          browser.button(id: 'btn').click
-        }.to execute_when_satisfied(min: 1)
-      end
+  context 'when acting on a disabled button' do
+    it 'waits and raises exception if it never becomes enabled' do
+      expect { browser.button(id: 'btn').click }.to wait_and_raise_object_disabled_exception
     end
 
-    context 'when acting on an element with a parent' do
-      it 'raises exception after timing out if parent never present' do
-        element = browser.link(id: 'not_there')
-        expect { element.element.click }.to wait_and_raise_unknown_object_exception
-      end
+    it 'waits until enabled' do
+      expect {
+        browser.a(id: 'enable_btn').click
+        browser.button(id: 'btn').click
+      }.to execute_when_satisfied(min: 1)
+    end
+  end
 
-      it 'raises exception after timing out when element from a collection whose parent is never present' do
-        element = browser.link(id: 'not_there')
-        expect { element.elements[2].click }.to wait_and_raise_unknown_object_exception
-      end
+  context 'when acting on an element with a parent' do
+    it 'raises exception after timing out if parent never present' do
+      element = browser.link(id: 'not_there')
+      expect { element.element.click }.to wait_and_raise_unknown_object_exception
+    end
 
-      it 'does not wait for parent element to be present when querying child element' do
-        el = browser.element(id: 'not_there').element(id: 'doesnt_matter')
-        expect { el.present? }.to execute_when_satisfied(max: 1)
-      end
+    it 'raises exception after timing out when element from a collection whose parent is never present' do
+      element = browser.link(id: 'not_there')
+      expect { element.elements[2].click }.to wait_and_raise_unknown_object_exception
     end
-  end
 
-  describe Watir::ElementCollection do
-    before do
-      browser.goto WatirSpec.url_for('wait.html')
+    it 'does not wait for parent element to be present when querying child element' do
+      el = browser.element(id: 'not_there').element(id: 'doesnt_matter')
+      expect { el.present? }.to execute_when_satisfied(max: 1)
     end
+  end
+end
 
-    describe '#wait_until' do
-      it 'returns collection' do
-        elements = browser.divs
-        expect(elements.wait_until(&:exist?)).to eq elements
-      end
+describe Watir::ElementCollection do
+  before do
+    browser.goto WatirSpec.url_for('wait.html')
+  end
 
-      it 'times out when waiting for non-empty collection' do
-        expect { browser.divs.wait_until(&:empty?) }.to raise_timeout_exception
-      end
+  describe '#wait_until' do
+    it 'returns collection' do
+      elements = browser.divs
+      expect(elements.wait_until(&:exist?)).to eq elements
+    end
 
-      it 'provides matching collection when exists' do
-        expect {
-          browser.a(id: 'add_foobar').click
-          browser.divs(id: 'foobar').wait_until(&:exists?)
-        }.to execute_when_satisfied(min: 1)
-      end
+    it 'times out when waiting for non-empty collection' do
+      expect { browser.divs.wait_until(&:empty?) }.to raise_timeout_exception
+    end
 
-      it 'accepts self in block' do
-        expect {
-          browser.a(id: 'add_foobar').click
-          browser.divs.wait_until { |els| els.size == 7 }
-        }.to execute_when_satisfied(min: 1)
-      end
+    it 'provides matching collection when exists' do
+      expect {
+        browser.a(id: 'add_foobar').click
+        browser.divs(id: 'foobar').wait_until(&:exists?)
+      }.to execute_when_satisfied(min: 1)
+    end
 
-      it 'accepts attributes to evaluate' do
-        expect {
-          browser.a(id: 'add_foobar').click
-          browser.divs.wait_until(size: 7)
-        }.to execute_when_satisfied(min: 1)
-      end
+    it 'accepts self in block' do
+      expect {
+        browser.a(id: 'add_foobar').click
+        browser.divs.wait_until { |els| els.size == 7 }
+      }.to execute_when_satisfied(min: 1)
     end
 
-    describe '#wait_while' do
-      it 'returns collection' do
-        elements = browser.divs
-        expect(elements.wait_while(&:empty?)).to eq elements
-      end
+    it 'accepts attributes to evaluate' do
+      expect {
+        browser.a(id: 'add_foobar').click
+        browser.divs.wait_until(size: 7)
+      }.to execute_when_satisfied(min: 1)
+    end
+  end
 
-      it 'times out when waiting for non-empty collection' do
-        elements = browser.divs
-        expect { elements.wait_while(&:exists?) }.to raise_timeout_exception
-      end
+  describe '#wait_while' do
+    it 'returns collection' do
+      elements = browser.divs
+      expect(elements.wait_while(&:empty?)).to eq elements
+    end
 
-      it 'provides matching collection when exists' do
-        expect {
-          browser.a(id: 'remove_foo').click
-          browser.divs(id: 'foo').wait_while(&:exists?)
-        }.to execute_when_satisfied(min: 1)
-      end
+    it 'times out when waiting for non-empty collection' do
+      elements = browser.divs
+      expect { elements.wait_while(&:exists?) }.to raise_timeout_exception
+    end
 
-      it 'accepts self in block' do
-        expect {
-          browser.a(id: 'add_foobar').click
-          browser.divs.wait_while { |els| els.size == 6 }
-        }.to execute_when_satisfied(min: 1)
-      end
+    it 'provides matching collection when exists' do
+      expect {
+        browser.a(id: 'remove_foo').click
+        browser.divs(id: 'foo').wait_while(&:exists?)
+      }.to execute_when_satisfied(min: 1)
     end
 
-    it 'waits for parent element to be present before locating' do
-      els = browser.element(id: /not|there/).elements(id: 'doesnt_matter')
-      expect { els.to_a }.to wait_and_raise_unknown_object_exception
+    it 'accepts self in block' do
+      expect {
+        browser.a(id: 'add_foobar').click
+        browser.divs.wait_while { |els| els.size == 6 }
+      }.to execute_when_satisfied(min: 1)
     end
   end
+
+  it 'waits for parent element to be present before locating' do
+    els = browser.element(id: /not|there/).elements(id: 'doesnt_matter')
+    expect { els.to_a }.to wait_and_raise_unknown_object_exception
+  end
 end