watir 6.0.0.beta5 → 6.0.0

data/lib/watir/extensions/select_text.rb

@@ -3,7 +3,7 @@ Watir::Atoms.load :selectText
 module Watir
   class Element
     def select_text(str)
-      assert_exists
+      wait_for_exists
       execute_atom :selectText, @element, str
     end
   end # Element

data/lib/watir/legacy_wait.rb

@@ -0,0 +1,126 @@
+require 'forwardable'
+
+# TODO - remove this file for future release
+module Watir
+
+  class BaseDecorator
+    def initialize(element, timeout, message = nil)
+      @element = element
+      @timeout = timeout
+      @message = message
+    end
+
+    def respond_to?(*args)
+      @element.respond_to?(*args)
+    end
+
+    def method_missing(m, *args, &block)
+      unless @element.respond_to?(m)
+        raise NoMethodError, "undefined method `#{m}' for #{@element.inspect}:#{@element.class}"
+      end
+
+      Watir::Wait.until(@timeout, @message) { wait_until }
+
+      @element.__send__(m, *args, &block)
+    end
+  end
+
+  #
+  # Wraps an Element so that any subsequent method calls are
+  # put on hold until the element is present (exists and is visible) on the page.
+  #
+
+  class WhenPresentDecorator < BaseDecorator
+    def present?
+      Watir::Wait.until(@timeout, @message) { wait_until }
+      true
+    rescue Watir::Wait::TimeoutError
+      false
+    end
+
+    private
+
+    def wait_until
+      @element.present?
+    end
+  end # WhenPresentDecorator
+
+  #
+  # Wraps an Element so that any subsequent method calls are
+  # put on hold until the element is enabled (exists and is enabled) on the page.
+  #
+
+  class WhenEnabledDecorator < BaseDecorator
+
+    private
+
+    def wait_until
+      @element.enabled?
+    end
+  end # WhenEnabledDecorator
+
+  #
+  # Convenience methods for things that eventually become present.
+  #
+  # Includers should implement a public #present? and a (possibly private) #selector_string method.
+  #
+
+  module EventuallyPresent
+    #
+    # Waits until the element is present.
+    #
+    # @example
+    #   browser.text_field(name: "new_user_first_name").when_present.click
+    #   browser.text_field(name: "new_user_first_name").when_present { |field| field.set "Watir" }
+    #   browser.text_field(name: "new_user_first_name").when_present(60).text
+    #
+    # @param [Fixnum] timeout seconds to wait before timing out
+    #
+    # @see Watir::Wait
+    # @see Watir::Element#present?
+    #
+
+    def when_present(timeout = nil)
+      warning = '#when_present has been deprecated and is unlikely to be needed; '
+      warning << 'replace this with #wait_until_present if a wait is still needed'
+      warn warning
+
+      timeout ||= Watir.default_timeout
+      message = "waiting for #{selector_string} to become present"
+
+      if block_given?
+        Watir::Wait.until(timeout, message) { present? }
+        yield self
+      else
+        WhenPresentDecorator.new(self, timeout, message)
+      end
+    end
+
+    #
+    # Waits until the element is enabled.
+    #
+    # @example
+    #   browser.button(name: "new_user_button_2").when_enabled.click
+    #
+    # @param [Fixnum] timeout seconds to wait before timing out
+    #
+    # @see Watir::Wait
+    # @see Watir::Element#enabled?
+    #
+
+    def when_enabled(timeout = nil)
+      warn '#when_enabled has been deprecated and is unlikely to be needed'
+
+      timeout ||= Watir.default_timeout
+      message = "waiting for #{selector_string} to become enabled"
+
+      if block_given?
+        Watir::Wait.until(timeout, message) { enabled? }
+        yield self
+      else
+        WhenEnabledDecorator.new(self, timeout, message)
+      end
+    end
+
+  end # EventuallyPresent
+end # Watir

data/lib/watir/locators/text_field/locator.rb

@@ -32,9 +32,6 @@ module Watir
           element = super
 
           if element && !Watir::TextField::NON_TEXT_TYPES.include?(element.attribute(:type))
-            if element.tag_name.downcase == 'textarea'
-              warn "Locating textareas with '#text_field' is deprecated. Please, use '#textarea' method instead."
-            end
             element
           end
         end

data/lib/watir/locators/text_field/selector_builder.rb

@@ -7,14 +7,11 @@ module Watir
 
           selectors.delete(:tag_name)
 
-          textarea_attr_exp = xpath_builder.attribute_expression(:textarea, selectors)
           input_attr_exp = xpath_builder.attribute_expression(:input, selectors)
 
           xpath = ".//input[(not(@type) or (#{negative_type_expr}))"
           xpath << " and #{input_attr_exp}" unless input_attr_exp.empty?
-          xpath << "] "
-          xpath << "| .//textarea"
-          xpath << "[#{textarea_attr_exp}]" unless textarea_attr_exp.empty?
+          xpath << "]"
 
           p build_wd_selector: xpath if $DEBUG
 

data/lib/watir/locators/text_field/selector_builder/xpath.rb

@@ -6,8 +6,6 @@ module Watir
           def lhs_for(building, key)
             if building == :input && key == :text
               "@value"
-            elsif building == :textarea && key == :value
-              "text()"
             else
               super
             end

data/lib/watir/locators/text_field/validator.rb

@@ -2,16 +2,8 @@ module Watir
   module Locators
     class TextField
       class Validator < Element::Validator
-        VALID_TEXT_FIELD_TAGS = %w[input textarea]
-
         def validate(element, selector)
-          element_tag_name = element.tag_name.downcase
-
-          if element.tag_name.downcase == 'textarea'
-            warn "Locating textareas with '#text_field' is deprecated. Please, use '#textarea' method instead."
-          end
-          return unless VALID_TEXT_FIELD_TAGS.include?(element_tag_name)
-
+          return unless element.tag_name.downcase == 'input'
           element
         end
       end

data/lib/watir/row_container.rb

@@ -24,7 +24,7 @@ module Watir
     #
 
     def strings
-      assert_exists
+      wait_for_exists
 
       rows.inject [] do |res, row|
         res << row.cells.map(&:text)

data/lib/watir/user_editable.rb

@@ -8,8 +8,10 @@ module Watir
     #
 
     def set(*args)
-      clear
-      element_call { @element.send_keys(*args) }
+      element_call(:wait_for_writable) do
+        @element.clear
+        @element.send_keys(*args)
+      end
     end
     alias_method :value=, :set
 
@@ -29,9 +31,9 @@ module Watir
     #
 
     def clear
-      assert_exists
-      assert_writable
-      element_call { @element.clear }
+      element_call(:wait_for_writable) do
+        @element.clear
+      end
     end
 
   end # UserEditable

data/lib/watir/wait.rb

@@ -1,4 +1,3 @@
-require 'forwardable'
 require 'watir/wait/timer'
 
 module Watir
@@ -32,13 +31,19 @@ module Watir
       #
       # @param [Fixnum] timeout How long to wait in seconds
       # @param [String] message Message to raise if timeout is exceeded
+      # @param [Object, NilClass] object Object to evaluate block against
       # @raise [TimeoutError] if timeout is exceeded
       #
 
-      def until(timeout = nil, message = nil)
+      def until(deprecated_timeout = nil, deprecated_message = nil, timeout: nil, message: nil, object: nil)
+        if deprecated_message || deprecated_timeout
+          warn "Instead of passing arguments into Wait#until method, use keywords"
+          timeout = deprecated_timeout
+          message = deprecated_message
+        end
         timeout ||= Watir.default_timeout
         run_with_timer(timeout) do
-          result = yield(self)
+          result = yield(object)
           return result if result
         end
         raise TimeoutError, message_for(timeout, message)
@@ -52,12 +57,18 @@ module Watir
       #
       # @param [Fixnum] timeout How long to wait in seconds
       # @param [String] message Message to raise if timeout is exceeded
+      # @param [Object, NilClass] object Object to evaluate block against
       # @raise [TimeoutError] if timeout is exceeded
       #
 
-      def while(timeout = nil, message = nil)
+      def while(deprecated_timeout = nil, deprecated_message = nil, timeout: nil, message: nil, object: nil)
+        if deprecated_message || deprecated_timeout
+          warn "Instead of passing arguments into Wait#while method, use keywords"
+          timeout = deprecated_timeout
+          message = deprecated_message
+        end
         timeout ||= Watir.default_timeout
-        run_with_timer(timeout) { return unless yield(self) }
+        run_with_timer(timeout) { return unless yield(object) }
         raise TimeoutError, message_for(timeout, message)
       end
 
@@ -71,7 +82,7 @@ module Watir
       end
 
       def run_with_timer(timeout, &block)
-        if timeout == 0
+        if timeout.zero?
           block.call
         else
           timer.wait(timeout) do
@@ -84,128 +95,52 @@ module Watir
     end # self
   end # Wait
 
-  module Waitable
-    def wait_until(*args, &blk)
-      Wait.until(*args, &blk)
-    end
-
-    def wait_while(*args, &blk)
-      Wait.while(*args, &blk)
-    end
-  end
-
-  class BaseDecorator
-
-    def initialize(element, timeout, message = nil)
-      @element = element
-      @timeout = timeout
-      @message = message
-    end
-
-    def respond_to?(*args)
-      @element.respond_to?(*args)
-    end
-
-    def method_missing(m, *args, &block)
-      unless @element.respond_to?(m)
-        raise NoMethodError, "undefined method `#{m}' for #{@element.inspect}:#{@element.class}"
-      end
-
-      Watir::Wait.until(@timeout, @message) { wait_until }
-
-      @element.__send__(m, *args, &block)
-    end
-  end
-
-  #
-  # Wraps an Element so that any subsequent method calls are
-  # put on hold until the element is present (exists and is visible) on the page.
-  #
-
-  class WhenPresentDecorator < BaseDecorator
-    def present?
-      Watir::Wait.until(@timeout, @message) { wait_until }
-      true
-    rescue Watir::Wait::TimeoutError
-      false
-    end
-
-    private
-
-    def wait_until
-      @element.present?
-    end
-  end # WhenPresentDecorator
-
-  #
-  # Wraps an Element so that any subsequent method calls are
-  # put on hold until the element is enabled (exists and is enabled) on the page.
-  #
-
-  class WhenEnabledDecorator < BaseDecorator
-
-    private
-
-    def wait_until
-      @element.enabled?
-    end
-  end # WhenEnabledDecorator
 
-  #
-  # Convenience methods for things that eventually become present.
-  #
-  # Includers should implement a public #present? and a (possibly private) #selector_string method.
-  #
+  module Waitable
 
-  module EventuallyPresent
     #
-    # Waits until the element is present.
+    # Waits until the condition is true.
     #
     # @example
-    #   browser.text_field(name: "new_user_first_name").when_present.click
-    #   browser.text_field(name: "new_user_first_name").when_present { |field| field.set "Watir" }
-    #   browser.text_field(name: "new_user_first_name").when_present(60).text
+    #   browser.wait_until(timeout: 2) do |browser|
+    #     browser.windows.size == 1
+    #   end
     #
-    # @param [Fixnum] timeout seconds to wait before timing out
+    # @example
+    #   browser.text_field(name: "new_user_first_name").wait_until(&:present?).click
+    #   browser.text_field(name: "new_user_first_name").wait_until(message: 'foo') { |field| field.present? }
+    #   browser.text_field(name: "new_user_first_name").wait_until(timeout: 60, &:present?)
     #
-    # @see Watir::Wait
-    # @see Watir::Element#present?
+    # @param [Fixnum] timeout seconds to wait before timing out
+    # @param [String] message error message for when times out
     #
 
-    def when_present(timeout = nil)
-      timeout ||= Watir.default_timeout
-      message = "waiting for #{selector_string} to become present"
+    def wait_until(timeout: nil, message: nil, &blk)
+      message ||= "waiting for true condition on #{selector_string}"
+      Wait.until(timeout: timeout, message: message, object: self, &blk)
 
-      if block_given?
-        Watir::Wait.until(timeout, message) { present? }
-        yield self
-      else
-        WhenPresentDecorator.new(self, timeout, message)
-      end
+      self
     end
 
     #
-    # Waits until the element is enabled.
+    # Waits while the condition is true.
     #
     # @example
-    #   browser.button(name: "new_user_button_2").when_enabled.click
+    #   browser.wait_while(timeout: 2) do |browser|
+    #     !browser.exists?
+    #   end
     #
-    # @param [Fixnum] timeout seconds to wait before timing out
+    # @todo add element example
     #
-    # @see Watir::Wait
-    # @see Watir::Element#enabled?
+    # @param [Fixnum] timeout seconds to wait before timing out
+    # @param [String] message error message for when times out
     #
 
-    def when_enabled(timeout = nil)
-      timeout ||= Watir.default_timeout
-      message = "waiting for #{selector_string} to become enabled"
+    def wait_while(timeout: nil, message: nil, &blk)
+      message ||= "waiting for false condition on #{selector_string}"
+      Wait.while(timeout: timeout, message: message, object: self, &blk)
 
-      if block_given?
-        Watir::Wait.until(timeout, message) { enabled? }
-        yield self
-      else
-        WhenEnabledDecorator.new(self, timeout, message)
-      end
+      self
     end
 
     #
@@ -220,10 +155,12 @@ module Watir
     # @see Watir::Element#present?
     #
 
-    def wait_until_present(timeout = nil)
-      timeout ||= Watir.default_timeout
-      message = "waiting for #{selector_string} to become present"
-      Watir::Wait.until(timeout, message) { present? }
+    def wait_until_present(deprecated_timeout = nil, timeout: nil)
+      if deprecated_timeout
+        warn "Instead of passing arguments into #wait_until_present method, use keywords"
+        timeout = deprecated_timeout
+      end
+      wait_until(timeout: timeout, &:present?)
     end
 
     #
@@ -238,29 +175,13 @@ module Watir
     # @see Watir::Element#present?
     #
 
-    def wait_while_present(timeout = nil)
-      timeout ||= Watir.default_timeout
-      message = "waiting for #{selector_string} to disappear"
-      Watir::Wait.while(timeout, message) { present? }
-    end
-
-    #
-    # Waits until the element is stale.
-    #
-    # @example
-    #   browser.text_field(name: "abrakadbra").wait_until_stale
-    #
-    # @param [Fixnum] timeout seconds to wait before timing out
-    #
-    # @see Watir::Wait
-    # @see Watir::Element#stale?
-    #
-
-    def wait_until_stale(timeout = nil)
-      timeout ||= Watir.default_timeout
-      message = "waiting for #{selector_string} to become stale"
-      Watir::Wait.until(timeout, message) { stale? }
+    def wait_while_present(deprecated_timeout = nil, timeout: nil)
+      if deprecated_timeout
+        warn "Instead of passing arguments into #wait_while_present method, use keywords"
+        timeout = deprecated_timeout
+      end
+      wait_while(timeout: timeout, &:present?)
     end
 
-  end # EventuallyPresent
+  end # Waitable
 end # Watir