ayanko-watir-webdriver 0.1.1.1

data/lib/watir-webdriver/elements/table.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Watir
+  class Table < HTMLElement
+    include RowContainer
+
+    def hashes
+      all_rows   = rows.to_a
+      header_row = all_rows.shift or raise Exception::Error, "no rows in table"
+
+      headers = header_row.ths.map { |header_cell| header_cell.text  }
+      result = []
+
+      all_rows.each_with_index do |row, idx|
+        cells = row.cells.to_a
+        if cells.length != headers.length
+          raise Exception::Error, "row at index #{idx} has #{cells.length} cells, expected #{headers.length}"
+        end
+
+        result << headers.inject({}) { |res, header| res.merge(header => cells.shift.text) }
+      end
+
+      result
+    end
+
+    #
+    # Get the n'th row of this table.
+    #
+    # @return Watir::TableRow
+    #
+
+    def [](idx)
+      row(:index, idx)
+    end
+
+  end # Table
+end # Watir

data/lib/watir-webdriver/elements/table_cell.rb

@@ -0,0 +1,36 @@
+module Watir
+  class TableCell < HTMLElement
+    # @private
+    attr_writer :locator_class
+
+    def locator_class
+      @locator_class || super
+    end
+
+    def colspan
+      value = attribute_value :colspan
+      value ? Integer(value) : 1
+    end
+  end
+
+  class TableCellCollection < ElementCollection
+    attr_writer :locator_class
+
+    def locator_class
+      @locator_class || super
+    end
+
+    def elements
+      # we do this craziness since the xpath used will find direct child rows
+      # before any rows inside thead/tbody/tfoot...
+      elements = super
+
+      if locator_class == ChildCellLocator
+        elements = elements.sort_by { |row| row.attribute(:cellIndex).to_i }
+      end
+
+      elements
+    end
+
+  end
+end

data/lib/watir-webdriver/elements/table_row.rb

@@ -0,0 +1,45 @@
+module Watir
+  class TableRow < HTMLElement
+    include CellContainer
+
+    # @private
+    attr_writer :locator_class
+
+    #
+    # Get the n'th cell (<th> or <td>) of this row
+    #
+    # @return Watir::TableCell
+    #
+
+    def [](idx)
+      cell(:index, idx)
+    end
+
+    private
+
+    def locator_class
+      @locator_class || super
+    end
+  end # TableRow
+
+
+  class TableRowCollection < ElementCollection
+    attr_writer :locator_class
+
+    def elements
+      # we do this craziness since the xpath used will find direct child rows
+      # before any rows inside thead/tbody/tfoot...
+      elements = super
+
+      if locator_class == ChildRowLocator and @parent.kind_of? Table
+        elements = elements.sort_by { |row| row.attribute(:rowIndex).to_i }
+      end
+
+      elements
+    end
+
+    def locator_class
+      @locator_class || super
+    end
+  end # TableRowCollection
+end # Watir

data/lib/watir-webdriver/elements/table_section.rb

@@ -0,0 +1,9 @@
+module Watir
+  class TableSection < HTMLElement
+    include RowContainer
+
+    def [](idx)
+      row(:index => idx)
+    end
+  end
+end

data/lib/watir-webdriver/elements/text_field.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+module Watir
+  class TextField < Input
+
+    attributes Watir::TextArea.typed_attributes
+    remove_method :type # we want Input#type here, which was overriden by TextArea's attributes
+
+    def self.from(parent, element)
+      type = element.attribute(:type)
+
+      if TextFieldLocator::NON_TEXT_TYPES.include?(type)
+        raise TypeError, "expected type != #{type} for #{element.inspect}"
+      end
+
+      super
+    end
+
+    #
+    # Clear the element, the type in the given value.
+    #
+
+    def set(*args)
+      assert_exists
+      assert_writable
+
+      @element.clear
+      @element.send_keys(*args)
+    end
+    alias_method :value=, :set
+
+    #
+    # Append the given value to the text in the text field.
+    #
+
+    def append(*args)
+      assert_exists
+      assert_writable
+
+      @element.send_keys(*args)
+    end
+
+    #
+    # Clear the text field.
+    #
+
+    def clear
+      assert_exists
+      @element.clear
+    end
+
+    #
+    # Returns the text in the text field.
+    #
+
+    def value
+      # since 'value' is an attribute on input fields, we override this here
+      assert_exists
+      @element.value
+    end
+
+    private
+
+    def locate
+      @parent.assert_exists
+      TextFieldLocator.new(@parent.wd, @selector, self.class.attribute_list).locate
+    end
+
+    def selector_string
+      selector = @selector.dup
+      selector[:type] = '(any text type)'
+      selector[:tag_name] = "input or textarea"
+      selector.inspect
+    end
+  end
+
+  module Container
+    def text_field(*args)
+      TextField.new(self, extract_selector(args).merge(:tag_name => "input"))
+    end
+
+    def text_fields(*args)
+      TextFieldCollection.new(self, extract_selector(args).merge(:tag_name => "input"))
+    end
+  end # Container
+
+  class TextFieldCollection < InputCollection
+    private
+
+    def locator_class
+      TextFieldLocator
+    end
+
+    def element_class
+      TextField
+    end
+  end # TextFieldCollection
+end

data/lib/watir-webdriver/exception.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Watir
+  module Exception
+    class Error < StandardError; end
+
+    # TODO: rename Object -> Element?
+    class UnknownObjectException < Error; end
+    class ObjectDisabledException < Error; end
+    class ObjectReadOnlyException < Error; end
+    class NoValueFoundException < Error; end
+    class MissingWayOfFindingObjectException < Error; end
+    class UnknownCellException < Error; end
+    class NoMatchingWindowFoundException < Error; end
+    class NoStatusBarException < Error; end
+    class NavigationException < Error; end
+    class UnknownFrameException < Error; end
+    class UnknownRowException < Error; end
+
+  end # Exception
+end # Watir

data/lib/watir-webdriver/extensions/alerts.rb

@@ -0,0 +1,69 @@
+module Watir
+
+  #
+  # Module provided by optional require:
+  #
+  #   require "watir-webdriver/extensions/alerts"
+  #
+
+  module AlertHelper
+
+    #
+    # Overwrite window.alert()
+    #
+    # This method is provided by an optional require - API is subject to change.
+    #
+    # @example
+    #   browser.alert do
+    #     browser.button(:value => "Alert").click
+    #   end #=> "the alert message"
+    #
+
+    def alert(&blk)
+      execute_script "window.alert = function(msg) { window.__lastWatirAlert = msg; }"
+      yield
+      execute_script "return window.__lastWatirAlert"
+    end
+
+    #
+    # Overwrite window.confirm()
+    #
+    # This method is provided by an optional require - API is subject to change.
+    #
+    # @example
+    #   browser.confirm(true) do
+    #     browser.button(:value => "Confirm").click
+    #   end #=> "the confirm message"
+
+    def confirm(bool, &blk)
+      execute_script "window.confirm = function(msg) { window.__lastWatirConfirm = msg; return #{!!bool} }"
+      yield
+      execute_script "return window.__lastWatirConfirm"
+    end
+
+    #
+    # Overwrite window.prompt()
+    #
+    # This method is provided by an optional require - API is subject to change.
+    #
+    # @example
+    #   browser.prompt("hello") do
+    #     browser.button(:value => "Prompt").click
+    #   end #=> { :message => "foo", :default => "bar" }
+    #
+
+    def prompt(answer, &blk)
+      execute_script "window.prompt = function(text, value) { window.__lastWatirPrompt = { message: text, default: value }; return #{answer.to_json}; }"
+      yield
+      result = execute_script "return window.__lastWatirPrompt"
+
+      result && result.dup.each_key { |k| result[k.to_sym] = result.delete(k)}
+      result
+    end
+  end
+
+  class Browser
+    include AlertHelper
+  end
+
+end

data/lib/watir-webdriver/extensions/cookies.rb

@@ -0,0 +1,39 @@
+module Watir
+  class Browser
+
+    def clear_all_cookies
+      @driver.manage.clear_cookies
+    end
+
+  end
+end
+
+
+module Selenium
+  module WebDriver
+
+    class Options
+      def clear_cookies
+        @bridge.clearCookies
+      end
+    end
+
+    module Remote
+      class Bridge
+        def clearCookies
+          execute :clearCookies
+        end
+
+        command :clearCookies, :delete, "session/:session_id/cookies"
+      end
+    end
+
+     module Firefox
+      class Profile
+        remove_const :WEBDRIVER_EXTENSION_PATH
+        WEBDRIVER_EXTENSION_PATH = File.expand_path('../firefox/webdriver.xpi', __FILE__)
+      end
+     end
+
+  end
+end

data/lib/watir-webdriver/extensions/nokogiri.rb

@@ -0,0 +1,14 @@
+require "nokogiri"
+
+module Watir
+  class Browser
+
+    def text
+      doc = Nokogiri::HTML(body(:index => 0).html)
+      doc.css("script").remove # encoding bug in older libxml?
+
+      doc.inner_text
+    end
+
+  end
+end

data/lib/watir-webdriver/extensions/performance.rb

@@ -0,0 +1,54 @@
+require "ostruct"
+
+module Watir
+
+  # Adds helper for window.performance to Watir::Browser.
+  #
+  # This module is provided by an optional require:
+  #
+  #   require "watir-webdriver/extensions/performance"
+  #
+  # @see http://dev.w3.org/2006/webapi/WebTiming/
+  #
+
+  module PerformanceHelper
+
+    def performance
+      data = driver.execute_script("return window.performance || window.webkitPerformance || window.mozPerformance || window.msPerformance;")
+      data && Performance.new(data)
+    end
+
+    class Performance
+      attr_reader :timing, :navigation, :memory
+
+      def initialize(data)
+        @timing     = rubify data['timing'] || {}
+        @navigation = rubify data['navigation'] || {}
+        @memory     = rubify data['memory'] || {}
+      end
+
+      private
+
+      def rubify(hash)
+        result = {}
+
+        hash.each do |k, v|
+          if k =~ /^[A-Z_]+$/
+            k = k.downcase
+          elsif k =~ /(start|end)$/i && Fixnum === v
+            v = ::Time.at(v / 1000)
+          end
+
+          result[k.snake_case] = v
+        end
+
+        OpenStruct.new(result)
+      end
+
+    end # Performance
+  end # PerformanceHelper
+
+  class Browser
+    include PerformanceHelper
+  end
+end # Watir

data/lib/watir-webdriver/extensions/wait.rb

@@ -0,0 +1,141 @@
+# encoding: utf-8
+module Watir
+
+  #
+  # Module provided by optional require:
+  #
+  #   require "watir-webdriver/extensions/wait"
+  #
+
+  module Wait
+    module_function
+
+    class TimeoutError < StandardError
+    end
+
+    #
+    # Wait until the block evaluates to true or times out.
+    #
+
+    def until(timeout = 30, &block)
+      end_time = ::Time.now + timeout
+
+      until ::Time.now > end_time
+        result = yield(self)
+        return result if result
+        sleep 0.5
+      end
+
+      raise TimeoutError, "timed out after #{timeout} seconds"
+    end
+
+    #
+    # Wait while the block evaluates to true or times out.
+    #
+
+    def while(timeout = 30, &block)
+      end_time = ::Time.now + timeout
+
+      until ::Time.now > end_time
+        return unless yield(self)
+        sleep 0.5
+      end
+
+      raise TimeoutError, "timed out after #{timeout} seconds"
+    end
+
+  end # Wait
+
+  #
+  # 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
+    def initialize(element, timeout)
+      @element = element
+      @timeout = timeout
+    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) { @element.present? }
+
+      @element.__send__(m, *args, &block)
+    end
+  end # WhenPresentDecorator
+
+  class Element
+
+    #
+    # Returns true if the element exists and is visible on the page
+    #
+    # This method is provided by an optional require.
+    # @see Watir::Wait
+    #
+
+    def present?
+      exists? && visible?
+    end
+
+    #
+    # Waits until the element is present.
+    #
+    # This method is provided by an optional require.
+    # @see Watir::Wait
+    #
+    # Example:
+    #   browser.button(:id, 'foo').when_present.click
+    #   browser.div(:id, 'bar').when_present { |div| ... }
+    #   browser.p(:id, 'baz').when_present(60).text
+    #
+    # @param [Integer] timeout seconds to wait before timing out
+    #
+
+    def when_present(timeout = 30)
+      if block_given?
+        Watir::Wait.until(timeout) { self.present? }
+        yield self
+      else
+        WhenPresentDecorator.new(self, timeout)
+      end
+    end
+
+    #
+    # Waits until the element is present.
+    #
+    # This method is provided by an optional require.
+    #
+    # @param [Integer] timeout seconds to wait before timing out
+    #
+    # @see Watir::Wait
+    # @see Watir::Element#present?
+    #
+
+    def wait_until_present(timeout = 30)
+      Watir::Wait.until(timeout) { self.present? }
+    end
+
+    #
+    # Waits while the element is present.
+    #
+    # This method is provided by an optional require.
+    #
+    # @param [Integer] timeout seconds to wait before timing out
+    #
+    # @see Watir::Wait
+    # @see Watir::Element#present?
+    #
+
+    def wait_while_present(timeout = 30)
+      Watir::Wait.while(timeout) { self.present? }
+    rescue Selenium::WebDriver::Error::ObsoleteElementError
+      # it's not present
+    end
+  end # Element
+
+
+end # Watir