watir 5.0.0 → 6.0.0.beta1

data/lib/watir/user_editable.rb

@@ -0,0 +1,38 @@
+module Watir
+  module UserEditable
+
+    #
+    # Clear the element, the type in the given value.
+    #
+    # @param [String, Symbol] *args
+    #
+
+    def set(*args)
+      clear
+      element_call { @element.send_keys(*args) }
+    end
+    alias_method :value=, :set
+
+    #
+    # Appends the given value to the text in the text field.
+    #
+    # @param [String, Symbol] *args
+    #
+
+    def append(*args)
+      send_keys(*args)
+    end
+    alias_method :<<, :append
+
+    #
+    # Clears the text field.
+    #
+
+    def clear
+      assert_exists
+      assert_writable
+      element_call { @element.clear }
+    end
+
+  end # UserEditable
+end # Watir

data/lib/watir/version.rb

@@ -1,3 +1,3 @@
-module Watir
-  BUNDLE_VERSION = '5.0.0'
-end
+module Watir
+  VERSION = '0.9.9'
+end

data/lib/watir/wait.rb

@@ -0,0 +1,250 @@
+require 'forwardable'
+require 'watir/wait/timer'
+
+module Watir
+  module Wait
+
+    class TimeoutError < StandardError ; end
+
+    INTERVAL = 0.1
+
+
+    class << self
+
+      #
+      # @!attribute timer
+      #   Access Watir timer implementation in use.
+      #   @see Timer
+      #   @return [#wait]
+      #
+
+      attr_writer :timer
+
+      def timer
+        @timer ||= Timer.new
+      end
+
+      #
+      # Waits until the block evaluates to true or times out.
+      #
+      # @example
+      #   Watir::Wait.until { browser.text_field(name: "new_user_first_name").visible? }
+      #
+      # @param [Fixnum] timeout How long to wait in seconds
+      # @param [String] message Message to raise if timeout is exceeded
+      # @raise [TimeoutError] if timeout is exceeded
+      #
+
+      def until(timeout = nil, message = nil)
+        timeout ||= Watir.default_timeout
+        run_with_timer(timeout) do
+          result = yield(self)
+          return result if result
+        end
+        raise TimeoutError, message_for(timeout, message)
+      end
+
+      #
+      # Wait while the block evaluates to true or times out.
+      #
+      # @example
+      #   Watir::Wait.while { browser.text_field(name: "abrakadbra").present? }
+      #
+      # @param [Fixnum] timeout How long to wait in seconds
+      # @param [String] message Message to raise if timeout is exceeded
+      # @raise [TimeoutError] if timeout is exceeded
+      #
+
+      def while(timeout = nil, message = nil)
+        timeout ||= Watir.default_timeout
+        run_with_timer(timeout) { return unless yield(self) }
+        raise TimeoutError, message_for(timeout, message)
+      end
+
+      private
+
+      def message_for(timeout, message)
+        err = "timed out after #{timeout} seconds"
+        err << ", #{message}" if message
+
+        err
+      end
+
+      def run_with_timer(timeout, &block)
+        if timeout == 0
+          block.call
+        else
+          timer.wait(timeout) do
+            block.call
+            sleep INTERVAL
+          end
+        end
+      end
+
+    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 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)
+      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)
+      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
+
+    #
+    # Waits until the element is present.
+    #
+    # @example
+    #   browser.text_field(name: "new_user_first_name").wait_until_present
+    #
+    # @param [Fixnum] timeout seconds to wait before timing out
+    #
+    # @see Watir::Wait
+    # @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? }
+    end
+
+    #
+    # Waits while the element is present.
+    #
+    # @example
+    #   browser.text_field(name: "abrakadbra").wait_while_present
+    #
+    # @param [Fixnum] timeout seconds to wait before timing out
+    #
+    # @see Watir::Wait
+    # @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? }
+    rescue Selenium::WebDriver::Error::StaleElementReferenceError
+      # it's not present
+    end
+
+  end # EventuallyPresent
+end # Watir

data/lib/watir/wait/timer.rb

@@ -0,0 +1,19 @@
+module Watir
+  module Wait
+    class Timer
+
+      #
+      # Executes given block until it returns true or exceeds timeout.
+      # @param [Fixnum] timeout
+      # @yield block
+      # @api private
+      #
+
+      def wait(timeout, &block)
+        end_time = ::Time.now + timeout
+        yield(block) until ::Time.now > end_time
+      end
+
+    end # Timer
+  end # Wait
+end # Watir

data/lib/watir/window.rb

@@ -0,0 +1,244 @@
+module Watir
+  class Window
+    include EventuallyPresent
+
+    def initialize(driver, selector)
+      @driver = driver
+      @selector = selector
+
+      if selector.empty?
+        @handle = current_window
+      elsif selector.key? :handle
+        @handle = selector.delete :handle
+      else
+        unless selector.keys.all? { |k| [:title, :url, :index].include? k }
+          raise ArgumentError, "invalid window selector: #{selector.inspect}"
+        end
+      end
+    end
+
+    def inspect
+      '#<%s:0x%x located=%s>' % [self.class, hash*2, !!@handle]
+    end
+
+    #
+    # Returns window size.
+    #
+    # @example
+    #   size = browser.window.size
+    #   [size.width, size.height] #=> [1600, 1200]
+    #
+
+    def size
+      size = nil
+      use { size = @driver.manage.window.size }
+
+      size
+    end
+
+    #
+    # Returns window position.
+    #
+    # @example
+    #   position = browser.window.position
+    #   [position.x, position.y] #=> [92, 76]
+    #
+
+    def position
+      pos = nil
+      use { pos = @driver.manage.window.position }
+
+      pos
+    end
+
+    #
+    # Resizes window to given width and height.
+    #
+    # @example
+    #   browser.window.resize_to 1600, 1200
+    #
+    # @param [Fixnum] width
+    # @param [Fixnum] height
+    #
+
+    def resize_to(width, height)
+      dimension = Selenium::WebDriver::Dimension.new(Integer(width), Integer(height))
+      use { @driver.manage.window.size = dimension }
+
+      dimension
+    end
+
+    #
+    # Moves window to given x and y coordinates.
+    #
+    # @example
+    #   browser.window.move_to 300, 200
+    #
+    # @param [Fixnum] x
+    # @param [Fixnum] y
+    #
+
+    def move_to(x, y)
+      point = Selenium::WebDriver::Point.new(Integer(x), Integer(y))
+      use { @driver.manage.window.position = point }
+
+      point
+    end
+
+    #
+    # Maximizes window.
+    #
+    # @example
+    #   browser.window.maximize
+    #
+
+    def maximize
+      use { @driver.manage.window.maximize }
+    end
+
+    #
+    # Returns true if window exists.
+    #
+    # @return [Boolean]
+    #
+
+    def exists?
+      assert_exists
+      true
+    rescue Exception::NoMatchingWindowFoundException
+      false
+    end
+
+    alias_method :present?, :exists?
+    alias_method :exist?, :exists?
+
+    #
+    # Returns true if two windows are equal.
+    #
+    # @example
+    #   browser.window(index: 0) == browser.window(index: 1)
+    #   #=> false
+    #
+    # @param [Window] other
+    #
+
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+
+      handle == other.handle
+    end
+    alias_method :eql?, :==
+
+    def hash
+      handle.hash ^ self.class.hash
+    end
+
+    #
+    # Returns true if window is current.
+    #
+    # @example
+    #   browser.window.current?
+    #   #=> true
+    #
+
+    def current?
+      current_window == handle
+    end
+
+    #
+    # Closes window.
+    #
+
+    def close
+      use { @driver.close }
+    end
+
+    #
+    # Returns window title.
+    #
+    # @return [String]
+    #
+
+    def title
+      title = nil
+      use { title = @driver.title }
+
+      title
+    end
+
+    #
+    # Returns window URL.
+    #
+    # @return [String]
+    #
+
+    def url
+      url = nil
+      use { url = @driver.current_url }
+
+      url
+    end
+
+    #
+    # Switches to given window and executes block, then switches back.
+    #
+    # @example
+    #   browser.window(title: "closeable window").use do
+    #     browser.a(id: "close").click
+    #   end
+    #
+
+    def use(&blk)
+      assert_exists
+      @driver.switch_to.window(handle, &blk)
+      self
+    end
+
+    protected
+
+    def handle
+      @handle ||= locate
+    end
+
+    private
+
+    # Referenced in EventuallyPresent
+    def selector_string
+      @selector.inspect
+    end
+
+    def locate
+      if @selector.empty?
+        nil
+      elsif @selector.key?(:index)
+        @driver.window_handles[Integer(@selector[:index])]
+      else
+        @driver.window_handles.find { |wh| matches?(wh) }
+      end
+    end
+
+    def assert_exists
+      raise(Exception::NoMatchingWindowFoundException, @selector.inspect) unless @driver.window_handles.include?(handle)
+    end
+
+    # return a handle to the currently active window if it is still open; otherwise nil
+    def current_window
+      @driver.window_handle
+    rescue Selenium::WebDriver::Error::NoSuchWindowError
+      nil
+    end
+
+    def matches?(handle)
+      @driver.switch_to.window(handle) {
+        matches_title = @selector[:title].nil? || @selector[:title] === @driver.title
+        matches_url   = @selector[:url].nil? || @selector[:url] === @driver.current_url
+
+        matches_title && matches_url
+      }
+    rescue Selenium::WebDriver::Error::NoSuchWindowError, Selenium::WebDriver::Error::NoSuchDriverError
+      # the window may disappear while we're iterating.
+      false
+    end
+
+  end # Window
+end # Watir