ayanko-watir-webdriver 0.1.1.1

data/lib/watir-webdriver/browserbot.js

@@ -0,0 +1,49 @@
+// stolen from injectableSelenium.js in WebDriver
+var browserbot = {
+
+    triggerEvent: function(element, eventType, canBubble, controlKeyDown, altKeyDown, shiftKeyDown, metaKeyDown) {
+        canBubble = (typeof(canBubble) == undefined) ? true: canBubble;
+        if (element.fireEvent && element.ownerDocument && element.ownerDocument.createEventObject) {
+            // IE
+            var evt = this.createEventObject(element, controlKeyDown, altKeyDown, shiftKeyDown, metaKeyDown);
+            element.fireEvent('on' + eventType, evt);
+        } else {
+            var evt = document.createEvent('HTMLEvents');
+
+            try {
+                evt.shiftKey = shiftKeyDown;
+                evt.metaKey = metaKeyDown;
+                evt.altKey = altKeyDown;
+                evt.ctrlKey = controlKeyDown;
+            } catch(e) {
+                // Nothing sane to do
+                }
+
+            evt.initEvent(eventType, canBubble, true);
+            return element.dispatchEvent(evt);
+        }
+    },
+
+    getVisibleText: function() {
+        var selection = getSelection();
+        var range = document.createRange();
+        range.selectNodeContents(document.documentElement);
+        selection.addRange(range);
+        var string = selection.toString();
+        selection.removeAllRanges();
+
+        return string;
+    },
+
+    getOuterHTML: function(element) {
+        if (element.outerHTML) {
+            return element.outerHTML;
+        } else if (typeof(XMLSerializer) != undefined) {
+            return new XMLSerializer().serializeToString(element);
+        } else {
+            throw "can't get outerHTML in this browser";
+        }
+    }
+
+
+};

data/lib/watir-webdriver/cell_container.rb

@@ -0,0 +1,19 @@
+module Watir
+  module CellContainer
+
+    def cell(*args)
+      cell = TableCell.new(self, extract_selector(args).merge(:tag_name => /^(th|td)$/))
+      cell.locator_class = ChildCellLocator
+
+      cell
+    end
+
+    def cells(*args)
+      cells = TableCellCollection.new(self, extract_selector(args).merge(:tag_name => /^(th|td)$/))
+      cells.locator_class = ChildCellLocator
+
+      cells
+    end
+
+  end
+end

data/lib/watir-webdriver/container.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+module Watir
+  module Container
+    include XpathSupport
+
+    def element(*args)
+      HTMLElement.new(self, extract_selector(args))
+    end
+
+    def elements(*args)
+      HTMLElementCollection.new(self, extract_selector(args))
+    end
+
+    private
+
+    def browserbot(function_name, *arguments)
+      script = browserbot_script + "return browserbot.#{function_name}.apply(browserbot, arguments);"
+      driver.execute_script(script, *arguments)
+    end
+
+    def browserbot_script
+      @browserbot_script ||= File.read("#{File.dirname(__FILE__)}/browserbot.js")
+    end
+
+    def extract_selector(selectors)
+      case selectors.size
+      when 2
+        return { selectors[0] => selectors[1] }
+      when 1
+        obj = selectors.first
+        return obj if obj.kind_of? Hash
+      when 0
+        return {}
+      end
+
+      raise ArgumentError, "expected Hash or (:how, 'what'), got #{selectors.inspect}"
+    end
+
+  end # Container
+end # Watir

data/lib/watir-webdriver/core_ext/string.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+class String
+  #
+  # Convert from camel case to snake case
+  #
+  #     'FooBar'.snake_case # => "foo_bar"
+  #
+
+  def snake_case
+    gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
+  end
+
+  #
+  # Convert from snake case to camel case
+  #
+  #     'foo_bar'.camel_case # => "FooBar"
+  #
+
+  def camel_case
+   split('_').map { |e| e.capitalize }.join
+  end
+end

data/lib/watir-webdriver/element_collection.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+module Watir
+
+  #
+  # Base class for element collections.
+  #
+
+  class ElementCollection
+    include Enumerable
+
+    def initialize(parent, selector)
+      @parent   = parent
+      @selector = selector
+    end
+
+    #
+    # @yieldparam [Watir::Element] element Iterate through the elements in this collection.
+    #
+
+    def each(&blk)
+      to_a.each(&blk)
+    end
+
+    #
+    # @return [Fixnum] The number of elements in this collection.
+    #
+
+    def length
+      elements.length
+    end
+    alias_method :size, :length
+
+    #
+    # Get the element at the given index.
+    # Note that this is 0-indexed and not compatible with older Watir implementations.
+    #
+    # Also note that because of Watir's lazy loading, this will return an Element
+    # instance even if the index is out of bounds.
+    #
+    # @param [Fixnum] n Index of wanted element, 0-indexed
+    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
+    #
+
+
+    def [](idx)
+      to_a[idx] || element_class.new(@parent, :index => idx)
+    end
+
+    #
+    # First element of this collection
+    #
+    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
+    #
+
+    def first
+      self[0]
+    end
+
+    #
+    # Last element of the collection
+    #
+    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
+    #
+
+    def last
+      self[-1]
+    end
+
+    #
+    # This collection as an Array
+    #
+    # @return [Array<Watir::Element>]
+    #
+
+    def to_a
+      # TODO: optimize - lazy element_class instance?
+      @to_a ||= elements.map { |e| element_class.new(@parent, :element => e) }
+    end
+
+    private
+
+    def elements
+      @elements ||= locator_class.new(
+        @parent.wd,
+        @selector,
+        element_class.attribute_list
+      ).locate_all
+    end
+
+    # overridable by subclasses
+    def locator_class
+      ElementLocator
+    end
+
+  end # ElementCollection
+end # Watir

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

@@ -0,0 +1,75 @@
+# encoding: utf-8
+module Watir
+
+  #
+  # Class representing button elements.
+  #
+  # This class covers both <button> and <input type="submit|reset|image|button" /> elements.
+  #
+
+  class Button < HTMLElement
+
+    # add the attributes from <input>
+    attributes Watir::Input.typed_attributes
+
+    VALID_TYPES = %w[button reset submit image]
+
+    def self.from(parent, element)
+      if element.tag_name == "button" ||
+         element.tag_name == "input" && VALID_TYPES.include?(element.attribute(:type))
+        Button.new(parent, :element => element)
+      else
+        raise TypeError, "expected button or input[@type=#{VALID_TYPES.join("|")}] for #{element.inspect}"
+      end
+    end
+
+    #
+    # Returns the text of the button.
+    #
+    # For input elements, returns the "value" attribute.
+    # For button elements, returns the inner text.
+    #
+
+    def text
+      assert_exists
+      case @element.tag_name
+      when 'input'
+        @element.attribute(:value)
+      when 'button'
+        @element.text
+      else
+        raise Exception::Error, "unknown tag name for button: #{@element.tag_name}"
+      end
+    end
+
+    #
+    # Returns true if this element is enabled
+    #
+    # @return [Boolean]
+    #
+
+    def enabled?
+      !disabled?
+    end
+
+    private
+
+    def locate
+      @parent.assert_exists
+      ButtonLocator.new(@parent.wd, @selector, self.class.attribute_list).locate
+    end
+
+  end # Button
+
+  class ButtonCollection < ElementCollection
+    private
+
+    def locator_class
+      ButtonLocator
+    end
+
+    def element_class
+      Button
+    end
+  end # ButtonsCollection
+end # Watir

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

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module Watir
+  class CheckBox < Input
+
+    def self.from(parent, element)
+      if element.attribute(:type) != "checkbox"
+        raise TypeError, "expected type=checkbox for #{element.inspect}"
+      end
+
+      super
+    end
+
+    #
+    # Set this checkbox to the given value
+    #
+    # Example:
+    #
+    #   checkbox.set?        #=> false
+    #   checkbox.set
+    #   checkbox.set?        #=> true
+    #   checkbox.set(false)
+    #   checkbox.set?        #=> false
+    #
+
+    def set(bool = true)
+      assert_exists
+      assert_enabled
+
+      if @element.selected?
+        @element.click unless bool
+      else
+        @element.click if bool
+      end
+    end
+
+    #
+    # returns true if the element is checked
+    # @return [Boolean]
+    #
+
+    def set?
+      assert_exists
+      @element.selected?
+    end
+
+    #
+    # Unset this checkbox.
+    #
+    # Same as +set(false)+
+    #
+
+    def clear
+      set false
+    end
+  end # CheckBox
+
+  module Container
+    def checkbox(*args)
+      CheckBox.new(self, extract_selector(args).merge(:tag_name => "input", :type => "checkbox"))
+    end
+
+    def checkboxes(*args)
+      CheckBoxCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "checkbox"))
+    end
+  end # Container
+
+  class CheckBoxCollection < InputCollection
+    def element_class
+      CheckBox
+    end
+  end # CheckBoxCollection
+end

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

@@ -0,0 +1,265 @@
+# encoding: utf-8
+
+module Watir
+
+  #
+  # Base class for HTML elements.
+  #
+
+  class Element
+    include Exception
+    include Container
+    include Selenium
+    extend AttributeHelper
+
+    def initialize(parent, selector)
+      @parent   = parent
+      @selector = selector
+
+      unless @selector.kind_of? Hash
+        raise ArgumentError, "invalid argument: #{selector.inspect}"
+      end
+
+      if @selector.has_key?(:element)
+        @element = @selector[:element]
+      end
+    end
+
+    def exists?
+      assert_exists
+      true
+    rescue UnknownObjectException, UnknownFrameException
+      false
+    end
+    alias_method :exist?, :exists?
+
+    def inspect
+      if @selector.has_key?(:element)
+        '#<%s:0x%x located=%s selector=%s>' % [self.class, hash*2, !!@element, '{:element=>(webdriver element)}']
+      else
+        '#<%s:0x%x located=%s selector=%s>' % [self.class, hash*2, !!@element, selector_string]
+      end
+    end
+
+    def ==(other)
+      return false unless other.kind_of? self.class
+
+      assert_exists
+      @element == other.element
+    end
+    alias_method :eql?, :==
+
+    def hash
+      @element ? @element.hash : super
+    end
+
+    def text
+      assert_exists
+      @element.text
+    end
+
+    def tag_name
+      assert_exists
+      @element.tag_name
+    end
+
+    def click
+      assert_exists
+      assert_enabled
+      @element.click
+      run_checkers
+    end
+
+    def double_click
+      assert_exists
+      raise NotImplementedError, "need support in WebDriver"
+
+      @element.double_click
+      run_checkers
+    end
+
+    def right_click
+      assert_exists
+      raise NotImplementedError, "need support in WebDriver"
+
+      @element.right_click
+      run_checkers
+    end
+
+    def flash
+      original_color = style("backgroundColor")
+
+      10.times do |n|
+        color = (n % 2 == 0) ? "red" : original_color
+        driver.execute_script("arguments[0].style.backgroundColor = '#{color}'", @element)
+      end
+    end
+
+    def value
+      assert_exists
+
+      begin
+        @element.value || ''
+      rescue WebDriver::Error::ElementNotEnabledError
+        ""
+      end
+    end
+
+    def attribute_value(attribute_name)
+      assert_exists
+      @element.attribute attribute_name
+    end
+
+    def html
+      assert_exists
+      browserbot('getOuterHTML', @element).strip
+    end
+
+    def send_keys(*args)
+      assert_exists
+      @element.send_keys(*args)
+    end
+
+    #
+    # Note: Firefox queues focus events until the window actually has focus.
+    #
+    # See http://code.google.com/p/selenium/issues/detail?id=157
+    #
+
+    def focus
+      assert_exists
+      driver.execute_script "return arguments[0].focus()", @element
+    end
+
+    def fire_event(event_name, bubble = false)
+      assert_exists
+      event_name = event_name.to_s.sub(/^on/, '')
+      browserbot('triggerEvent', @element, event_name, bubble)
+    end
+
+    def parent
+      assert_exists
+
+      e = driver.execute_script "return arguments[0].parentNode", @element
+
+      if e.kind_of?(WebDriver::Element)
+        Watir.element_class_for(e.tag_name).new(@parent, :element => e)
+      end
+    end
+
+    def driver
+      @parent.driver
+    end
+
+    def element
+      assert_exists
+      @element
+    end
+    alias_method :wd, :element # ensures duck typing with Browser
+
+    def visible?
+      assert_exists
+      @element.displayed?
+    end
+
+    def style(property = nil)
+      if property
+        assert_exists
+        @element.style property
+      else
+        attribute_value("style") || ''
+      end
+    end
+
+    def run_checkers
+      @parent.run_checkers
+    end
+
+    #
+    # Cast this Element instance to a more specific subtype.
+    #
+    # Example:
+    #
+    #   browser.element(:xpath => "//input[@type='submit']").to_subtype #=> #<Watir::Button>
+    #
+
+    def to_subtype
+      elem = element()
+      tag_name = elem.tag_name
+
+      klass = nil
+
+      if tag_name == "input"
+        klass = case elem.attribute(:type)
+          when *Button::VALID_TYPES
+            Button
+          when 'checkbox'
+            CheckBox
+          when 'radio'
+            Radio
+          when 'file'
+            FileField
+          else
+            TextField
+          end
+      else
+        klass = Watir.element_class_for(tag_name)
+      end
+
+      klass.new(@parent, :element => elem)
+    end
+
+  protected
+
+    def assert_exists
+      @element ||= locate
+
+      unless @element
+        raise UnknownObjectException, "unable to locate element, using #{selector_string}"
+      end
+    end
+
+    def browser
+      @parent.browser
+    end
+
+    def locate
+      @parent.assert_exists
+      locator_class.new(@parent.wd, @selector, self.class.attribute_list).locate
+    end
+
+  private
+
+    def locator_class
+      ElementLocator
+    end
+
+    def selector_string
+      @selector.inspect
+    end
+
+    def attribute?(attribute)
+      assert_exists
+      driver.execute_script "return !!arguments[0].getAttributeNode(arguments[1]);", @element, attribute.to_s.downcase
+    end
+
+    def assert_enabled
+      raise ObjectDisabledException, "object is disabled #{selector_string}" unless @element.enabled?
+    end
+
+    def assert_writable
+      assert_enabled
+      raise ObjectReadOnlyException if respond_to?(:readonly?) && readonly?
+    end
+
+    def method_missing(meth, *args, &blk)
+      method = meth.to_s
+      if method =~ /^data_(.+)$/
+        attribute_value(method.gsub(/_/, '-'), *args)
+      else
+        super
+      end
+    end
+
+  end # Element
+end # Watir