watir-webdriver 0.0.1.dev

data/lib/watir-webdriver/browser.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+module Watir
+  class Browser
+    include Container
+
+    attr_reader :driver
+    alias_method :wd, :driver # ensures duck typing with BaseElement
+
+    class << self
+      def start(url, browser = :firefox)
+        b = new(browser)
+        b.goto url
+
+        b
+      end
+    end
+
+    def initialize(browser, *args)
+      case browser
+      when Symbol, String
+        @driver = Selenium::WebDriver.for browser.to_sym, *args
+      when Selenium::WebDriver::Driver
+        @driver = browser
+      else
+        raise ArugmentError, "expected Symbol or Selenium::WebDriver::Driver, got #{browser.class}"
+      end
+
+      @error_checkers = []
+    end
+
+    def inspect
+      '#<%s:0x%x url=%s title=%s>' % [self.class, hash*2, url.inspect, title.inspect]
+    end
+
+    def goto(uri)
+      uri = "http://#{uri}" unless uri.include?("://")
+
+      @driver.navigate.to uri
+      run_checkers
+
+      url
+    end
+
+    def back
+      @driver.navigate.back
+    end
+
+    def forward
+      @driver.navigate.forward
+    end
+
+    def url
+      @driver.current_url
+    end
+
+    def title
+      @driver.title
+    end
+
+    def quit
+      @driver.quit
+    end
+
+    def close
+      @driver.quit
+    end
+    alias_method :quit, :close # TODO: close vs quit
+
+    def clear_cookies
+      @driver.manage.delete_all_cookies
+    end
+
+    def text
+      # TODO: do this properly
+      if @driver.bridge.browser == :firefox
+        browserbot 'getVisibleText'
+      else
+        @driver.find_element(:tag_name, "body").text
+      end
+    end
+
+    def html
+      @driver.page_source
+    end
+
+    def refresh
+      execute_script 'location.reload(true)'
+    end
+
+    def exist?
+      true
+    end
+
+    def status
+      execute_script "return window.status;"
+    end
+
+    def execute_script(script, *args)
+      args.map! { |e| e.kind_of?(Watir::BaseElement) ? e.element : e }
+      @driver.execute_script(script, *args)
+    end
+
+    def add_checker(checker = nil, &block)
+      if block_given?
+        @error_checkers << block
+      elsif Proc === checker
+        @error_checkers << checker
+      else
+        raise ArgumentError, "argument must be a Proc or block"
+      end
+    end
+
+    def disable_checker(checker)
+      @error_checkers.delete(checker)
+    end
+
+    def run_checkers
+      @error_checkers.each { |e| e[self] }
+    end
+
+    #
+    # @api private
+    #
+
+    def assert_exists
+      true # TODO: assert browser is open
+    end
+
+  end # Browser
+end # Watir

data/lib/watir-webdriver/browserbot.js

@@ -0,0 +1,34 @@
+// 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);
+            element.dispatchEvent(evt);
+        }
+    },
+
+    getVisibleText : function() {
+        var selection = getSelection();
+        var range = document.createRange();
+        range.selectNodeContents(document.documentElement);
+        selection.addRange(range);
+        return selection.toString();
+    }
+};

data/lib/watir-webdriver/collections/buttons_collection.rb

@@ -0,0 +1,13 @@
+module Watir
+  class ButtonsCollection < ElementCollection
+
+    def elements
+      @elements ||= ButtonLocator.new(
+        @parent.wd,
+        @element_class.default_selector,
+        @element_class.attribute_list
+      ).locate_all
+    end
+
+  end # ButtonsCollection
+end # Watir

data/lib/watir-webdriver/collections/element_collection.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module Watir
+  class ElementCollection
+    include Enumerable
+
+    def initialize(parent, element_class)
+      @parent, @element_class = parent, element_class
+    end
+
+    def each(&blk)
+      to_a.each(&blk)
+    end
+
+    def length
+      to_a.length
+    end
+    alias_method :size, :length
+
+    def [](idx)
+      to_a[idx] || @element_class.new(@parent, :index, idx)
+    end
+
+    def first
+      to_a[0] || @element_class.new(@parent, :index, 0)
+    end
+
+    def last
+      to_a[-1] || @element_class.new(@parent, :index, -1)
+    end
+
+    def to_a
+      # TODO: optimize - lazily @element_class instance
+      @to_a ||= elements.map { |e| @element_class.new(@parent, :element, e) }
+    end
+
+    def elements
+      @elements ||= ElementLocator.new(
+        @parent.wd,
+        @element_class.default_selector,
+        @element_class.attribute_list
+      ).locate_all
+    end
+
+  end # ElementCollection
+end # Watir

data/lib/watir-webdriver/collections/table_rows_collection.rb

@@ -0,0 +1,14 @@
+module Watir
+  class TrsCollection < ElementCollection
+
+    def elements
+      return super unless @parent.kind_of?(Watir::Table)
+      @elements ||= TableRowLocator.new(
+        @parent.wd,
+        @element_class.default_selector,
+        @element_class.attribute_list
+      ).locate_all
+    end
+
+  end # ButtonsCollection
+end # Watir

data/lib/watir-webdriver/collections/text_fields_collection.rb

@@ -0,0 +1,13 @@
+module Watir
+  class TextFieldsCollection < ElementCollection
+
+    def elements
+      @elements ||= TextFieldLocator.new(
+        @parent.wd,
+        @element_class.default_selector,
+        @element_class.attribute_list
+      ).locate_all
+    end
+
+  end # ButtonsCollection
+end # Watir

data/lib/watir-webdriver/container.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Watir
+  module Container
+    class << self
+      def add(method, &blk)
+        define_method(method, &blk)
+      end
+    end
+
+    include XpathSupport
+
+    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
+
+  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/elements/button.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Watir
+  class Button < HTMLElement
+
+    # add the attributes from <input>
+    attributes Watir::Input.typed_attributes
+
+    def locate
+      ButtonLocator.new(@parent.wd, @selector, self.class.attribute_list).locate
+    end
+
+    def text
+      assert_exists
+      case @element.tag_name
+      when 'input'
+        value
+      when 'button'
+        text
+      end
+    end
+
+    def enabled?
+      !disabled?
+    end
+
+  end
+end

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Watir
+  class CheckBox < Input
+    include SharedRadioCheckbox
+
+    identifier :type => 'checkbox'
+
+    container_method  :checkbox
+    collection_method :checkboxes
+
+    def set(bool = true)
+      assert_exists
+      assert_enabled
+
+      if @element.selected?
+        @element.click unless bool
+      else
+        @element.click if bool
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Watir
+  class FileField < Input
+    identifier :type => 'file'
+
+    container_method  :file_field
+    collection_method :file_fields
+
+    def set(value)
+      assert_exists
+      @element.send_keys value
+    end
+
+    def value
+      # since 'value' is an attribute on input fields, we override this here
+      assert_exists
+      @element.value
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Watir
+  class Form
+
+    def submit
+      assert_exists
+      @element.submit
+    end
+
+  end # Form
+end # Watir

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

@@ -0,0 +1,941 @@
+# Autogenerated from the HTML5 specification. Edits may be lost.
+module Watir
+  class HTMLElement < BaseElement
+    attributes(:string_map => ([:dataset]), :string => ([:innerhtml, :outerhtml, :id, :title, :lang, :dir, :class_name, :item_type, :item_id, :item_ref, :item_value, :access_key, :access_key_label, :content_editable, :spellcheck, :command_type, :label, :icon]), :properties_collection => ([:properties]), :int => ([:tab_index]), :html_element => ([:context_menu]), :function => ([:onabort, :onblur, :oncanplay, :oncanplaythrough, :onchange, :onclick, :oncontextmenu, :ondblclick, :ondrag, :ondragend, :ondragenter, :ondragleave, :ondragover, :ondragstart, :ondrop, :ondurationchange, :onemptied, :onended, :onerror, :onfocus, :onformchange, :onforminput, :oninput, :oninvalid, :onkeydown, :onkeypress, :onkeyup, :onload, :onloadeddata, :onloadedmetadata, :onloadstart, :onmousedown, :onmousemove, :onmouseout, :onmouseover, :onmouseup, :onmousewheel, :onpause, :onplay, :onplaying, :onprogress, :onratechange, :onreadystatechange, :onscroll, :onseeked, :onseeking, :onselect, :onshow, :onstalled, :onsubmit, :onsuspend, :ontimeupdate, :onvolumechange, :onwaiting]), :style => ([:style]), :bool => ([:item_scope, :hidden, :draggable, :is_content_editable, :disabled, :checked]), :token_list => ([:class_list, :item_prop]))
+  end
+
+  class TableCell < HTMLElement
+    attributes(:string => ([:headers]), :int => ([:col_span, :row_span, :cell_index]))
+  end
+
+  class Mod < HTMLElement
+    attributes(:string => ([:cite, :date_time]))
+  end
+
+  class Meta < HTMLElement
+    identifier(:tag_name => "meta")
+
+    container_method(:meta)
+
+    collection_method(:metas)
+
+    attributes(:string => ([:name, :http_equiv, :content]))
+  end
+
+  class Input < HTMLElement
+    identifier(:tag_name => "input")
+
+    container_method(:input)
+
+    collection_method(:inputs)
+
+    attributes(:string => ([:accept, :alt, :form_action, :form_enctype, :form_method, :form_target, :height, :max, :min, :name, :pattern, :placeholder, :src, :step, :type, :default_value, :value, :width, :validity, :validation_message]), :int => ([:max_length, :size, :selection_start, :selection_end]), :float => ([:value_as_number]), :date => ([:value_as_date]), :html_element => ([:form, :list, :selected_option]), :list => ([:files, :labels]), :bool => ([:autocomplete, :autofocus, :default_checked, :checked, :disabled, :form_no_validate, :indeterminate, :multiple, :read_only, :required, :will_validate]))
+  end
+
+  class TableHeaderCell < TableCell
+    identifier(:tag_name => "th")
+
+    container_method(:th)
+
+    collection_method(:ths)
+
+    attributes(:string => ([:scope]))
+  end
+
+  class DataList < HTMLElement
+    identifier(:tag_name => "datalist")
+
+    container_method(:datalist)
+
+    collection_method(:datalists)
+
+    attributes(:html_collection => ([:options]))
+  end
+
+  class Object < HTMLElement
+    identifier(:tag_name => "object")
+
+    container_method(:object)
+
+    collection_method(:objects)
+
+    attributes(:string => ([:data, :type, :name, :use_map, :width, :height, :content_window, :validity, :validation_message]), :document => ([:content_document]), :html_element => ([:form]), :bool => ([:will_validate]))
+  end
+
+  class DList < HTMLElement
+    identifier(:tag_name => "dl")
+
+    container_method(:dl)
+
+    collection_method(:dls)
+
+    # do nothing
+  end
+
+  class LI < HTMLElement
+    identifier(:tag_name => "li")
+
+    container_method(:li)
+
+    collection_method(:lis)
+
+    attributes(:int => ([:value]))
+  end
+
+  class HR < HTMLElement
+    identifier(:tag_name => "hr")
+
+    container_method(:hr)
+
+    collection_method(:hrs)
+
+    # do nothing
+  end
+
+  class Button < HTMLElement
+    identifier(:tag_name => "button")
+
+    container_method(:button)
+
+    collection_method(:buttons)
+
+    attributes(:string => ([:form_action, :form_enctype, :form_method, :form_no_validate, :form_target, :name, :type, :value, :validity, :validation_message]), :html_element => ([:form]), :list => ([:labels]), :bool => ([:autofocus, :disabled, :will_validate]))
+  end
+
+  class TableRow < HTMLElement
+    identifier(:tag_name => "tr")
+
+    container_method(:tr)
+
+    collection_method(:trs)
+
+    attributes(:int => ([:row_index, :section_row_index]), :html_collection => ([:cells]))
+  end
+
+  class TableSection < HTMLElement
+    identifier(:tag_name => "tbody")
+
+    container_method(:tbody)
+
+    collection_method(:tbodys)
+
+    attributes(:html_collection => ([:rows]))
+  end
+
+  class Area < HTMLElement
+    identifier(:tag_name => "area")
+
+    container_method(:area)
+
+    collection_method(:areas)
+
+    attributes(:string => ([:alt, :coords, :shape, :href, :target, :ping, :rel, :media, :hreflang, :type, :protocol, :host, :hostname, :port, :pathname, :search, :hash]), :token_list => ([:rel_list]))
+  end
+
+  class Anchor < HTMLElement
+    identifier(:tag_name => "a")
+
+    container_method(:a)
+
+    collection_method(:as)
+
+    attributes(:string => ([:href, :target, :ping, :rel, :media, :hreflang, :type, :protocol, :host, :hostname, :port, :pathname, :search, :hash]), :token_list => ([:rel_list]))
+  end
+
+  class Pre < HTMLElement
+    identifier(:tag_name => "pre")
+
+    container_method(:pre)
+
+    collection_method(:pres)
+
+    # do nothing
+  end
+
+  class Details < HTMLElement
+    identifier(:tag_name => "details")
+
+    container_method(:details)
+
+    collection_method(:details)
+
+    attributes(:bool => ([:open]))
+  end
+
+  class OptGroup < HTMLElement
+    identifier(:tag_name => "optgroup")
+
+    container_method(:optgroup)
+
+    collection_method(:optgroups)
+
+    attributes(:string => ([:label]), :bool => ([:disabled]))
+  end
+
+  class TableCol < HTMLElement
+    identifier(:tag_name => "colgroup")
+
+    container_method(:colgroup)
+
+    collection_method(:colgroups)
+
+    attributes(:int => ([:span]))
+  end
+
+  class Embed < HTMLElement
+    identifier(:tag_name => "embed")
+
+    container_method(:embed)
+
+    collection_method(:embeds)
+
+    attributes(:string => ([:src, :type, :width, :height]))
+  end
+
+  # class Link < HTMLElement
+  #   identifier(:tag_name => "link")
+  #
+  #   container_method(:link)
+  #
+  #   collection_method(:links)
+  #
+  #   attributes(:string => ([:href, :rel, :media, :hreflang, :type, :sizes]), :bool => ([:disabled]), :token_list => ([:rel_list]))
+  # end
+
+
+
+  class Html < HTMLElement
+    identifier(:tag_name => "html")
+
+    container_method(:html)
+
+    collection_method(:htmls)
+
+    # do nothing
+  end
+
+  class Option < HTMLElement
+    identifier(:tag_name => "option")
+
+    container_method(:option)
+
+    collection_method(:options)
+
+    attributes(:string => ([:label, :value, :text]), :int => ([:index]), :html_element => ([:form]), :bool => ([:disabled, :default_selected, :selected]))
+  end
+
+  class Legend < HTMLElement
+    identifier(:tag_name => "legend")
+
+    container_method(:legend)
+
+    collection_method(:legends)
+
+    attributes(:html_element => ([:form]))
+  end
+
+  class Form < HTMLElement
+    identifier(:tag_name => "form")
+
+    container_method(:form)
+
+    collection_method(:forms)
+
+    attributes(:string => ([:accept_charset, :action, :enctype, :method, :name, :target]), :int => ([:length]), :html_collection => ([:elements]), :bool => ([:autocomplete, :no_validate]))
+  end
+
+  class Param < HTMLElement
+    identifier(:tag_name => "param")
+
+    container_method(:param)
+
+    collection_method(:params)
+
+    attributes(:string => ([:name, :value]))
+  end
+
+  class IFrame < HTMLElement
+    identifier(:tag_name => "iframe")
+
+    container_method(:iframe)
+
+    collection_method(:iframes)
+
+    attributes(:string => ([:src, :name, :sandbox, :width, :height, :content_window]), :document => ([:content_document]), :bool => ([:seamless]))
+  end
+
+  class Image < HTMLElement
+    identifier(:tag_name => "img")
+
+    container_method(:image)
+
+    collection_method(:images)
+
+    attributes(:string => ([:alt, :src, :use_map]), :int => ([:width, :height, :natural_width, :natural_height]), :bool => ([:is_map, :complete]))
+  end
+
+  class Progress < HTMLElement
+    identifier(:tag_name => "progress")
+
+    container_method(:progress)
+
+    collection_method(:progress)
+
+    attributes(:float => ([:value, :max, :position]))
+  end
+
+  class Time < HTMLElement
+    identifier(:tag_name => "time")
+
+    container_method(:time)
+
+    collection_method(:times)
+
+    attributes(:string => ([:date_time]), :date => ([:value_as_date]), :bool => ([:pub_date]))
+  end
+
+  class UList < HTMLElement
+    identifier(:tag_name => "ul")
+
+    container_method(:ul)
+
+    collection_method(:uls)
+
+    # do nothing
+  end
+
+  class Quote < HTMLElement
+    identifier(:tag_name => "blockquote")
+
+    container_method(:blockquote)
+
+    collection_method(:blockquotes)
+
+    attributes(:string => ([:cite]))
+  end
+
+  class Style < HTMLElement
+    identifier(:tag_name => "style")
+
+    container_method(:style)
+
+    collection_method(:styles)
+
+    attributes(:string => ([:media, :type]), :bool => ([:disabled, :scoped]))
+  end
+
+
+
+  class Output < HTMLElement
+    identifier(:tag_name => "output")
+
+    container_method(:output)
+
+    collection_method(:outputs)
+
+    attributes(:string => ([:html_for, :name, :type, :default_value, :value, :validity, :validation_message]), :html_element => ([:form]), :bool => ([:will_validate]))
+  end
+
+  class TableCaption < HTMLElement
+    identifier(:tag_name => "caption")
+
+    container_method(:caption)
+
+    collection_method(:captions)
+
+    # do nothing
+  end
+
+  class Table < HTMLElement
+    identifier(:tag_name => "table")
+
+    container_method(:table)
+
+    collection_method(:tables)
+
+    attributes(:string => ([:summary]), :html_element => ([:caption, :t_head, :t_foot]), :html_collection => ([:t_bodies, :rows]))
+  end
+
+  class Paragraph < HTMLElement
+    identifier(:tag_name => "p")
+
+    container_method(:p)
+
+    collection_method(:ps)
+
+    # do nothing
+  end
+
+  class Body < HTMLElement
+    identifier(:tag_name => "body")
+
+    container_method(:body)
+
+    collection_method(:bodys)
+
+    attributes(:function => ([:onafterprint, :onbeforeprint, :onbeforeunload, :onblur, :onerror, :onfocus, :onhashchange, :onload, :onmessage, :onoffline, :ononline, :onpopstate, :onpagehide, :onpageshow, :onredo, :onresize, :onstorage, :onundo, :onunload]))
+  end
+
+  class Head < HTMLElement
+    identifier(:tag_name => "head")
+
+    container_method(:head)
+
+    collection_method(:heads)
+
+    # do nothing
+  end
+
+  class Map < HTMLElement
+    identifier(:tag_name => "map")
+
+    container_method(:map)
+
+    collection_method(:maps)
+
+    attributes(:string => ([:name]), :html_collection => ([:areas, :images]))
+  end
+
+  class Div < HTMLElement
+    identifier(:tag_name => "div")
+
+    container_method(:div)
+
+    collection_method(:divs)
+
+    # do nothing
+  end
+
+  class TextArea < HTMLElement
+    identifier(:tag_name => "textarea")
+
+    container_method(:textarea)
+
+    collection_method(:textareas)
+
+    attributes(:string => ([:name, :placeholder, :wrap, :type, :default_value, :value, :validity, :validation_message]), :int => ([:cols, :max_length, :rows, :text_length, :selection_start, :selection_end]), :html_element => ([:form]), :list => ([:labels]), :bool => ([:autofocus, :disabled, :read_only, :required, :will_validate]))
+  end
+
+  class TableDataCell < TableCell
+    identifier(:tag_name => "td")
+
+    container_method(:td)
+
+    collection_method(:tds)
+
+    # do nothing
+  end
+
+  class Canvas < HTMLElement
+    identifier(:tag_name => "canvas")
+
+    container_method(:canvas)
+
+    collection_method(:canvas)
+
+    attributes(:int => ([:width, :height]))
+  end
+
+  class BR < HTMLElement
+    identifier(:tag_name => "br")
+
+    container_method(:br)
+
+    collection_method(:brs)
+
+    # do nothing
+  end
+
+  class Title < HTMLElement
+    identifier(:tag_name => "title")
+
+    container_method(:title)
+
+    collection_method(:titles)
+
+    attributes(:string => ([:text]))
+  end
+
+  class Meter < HTMLElement
+    identifier(:tag_name => "meter")
+
+    container_method(:meter)
+
+    collection_method(:meters)
+
+    attributes(:float => ([:value, :min, :max, :low, :high, :optimum]))
+  end
+
+  class Heading < HTMLElement
+    identifier(:tag_name => "h1")
+
+    container_method(:h1)
+
+    collection_method(:h1s)
+
+    # do nothing
+  end
+
+  class Base < HTMLElement
+    identifier(:tag_name => "base")
+
+    container_method(:base)
+
+    collection_method(:bases)
+
+    attributes(:string => ([:href, :target]))
+  end
+
+  class Unknown < HTMLElement
+    identifier(:tag_name => "unknown")
+
+    container_method(:unknown)
+
+    collection_method(:unknowns)
+
+    # do nothing
+  end
+
+  class Select < HTMLElement
+    identifier(:tag_name => "select")
+
+    container_method(:select)
+
+    collection_method(:selects)
+
+    attributes(:string => ([:name, :type, :value, :validity, :validation_message]), :int => ([:size, :length, :selected_index]), :html_element => ([:form]), :list => ([:labels]), :html_collection => ([:options, :selected_options]), :bool => ([:autofocus, :disabled, :multiple, :will_validate]))
+  end
+
+  class Label < HTMLElement
+    identifier(:tag_name => "label")
+
+    container_method(:label)
+
+    collection_method(:labels)
+
+    attributes(:string => ([:html_for]), :html_element => ([:form, :control]))
+  end
+
+  class Keygen < HTMLElement
+    identifier(:tag_name => "keygen")
+
+    container_method(:keygen)
+
+    collection_method(:keygens)
+
+    attributes(:string => ([:challenge, :keytype, :name, :type, :validity, :validation_message]), :html_element => ([:form]), :list => ([:labels]), :bool => ([:autofocus, :disabled, :will_validate]))
+  end
+
+  class FieldSet < HTMLElement
+    identifier(:tag_name => "fieldset")
+
+    container_method(:fieldset)
+
+    collection_method(:fieldsets)
+
+    attributes(:string => ([:name, :type, :validity, :validation_message]), :html_element => ([:form]), :html_collection => ([:elements]), :bool => ([:disabled, :will_validate]))
+  end
+
+  class Source < HTMLElement
+    identifier(:tag_name => "source")
+
+    container_method(:source)
+
+    collection_method(:sources)
+
+    attributes(:string => ([:src, :type, :media]))
+  end
+
+  class Span < HTMLElement
+    identifier(:tag_name => "span")
+
+    container_method(:span)
+
+    collection_method(:spans)
+
+    # do nothing
+  end
+
+  class OList < HTMLElement
+    identifier(:tag_name => "ol")
+
+    container_method(:ol)
+
+    collection_method(:ols)
+
+    attributes(:int => ([:start]), :bool => ([:reversed]))
+  end
+end# from extras:
+
+# Autogenerated from the HTML5 specification. Edits may be lost.
+module Watir
+  class Thead < TableSection
+    identifier(:tag_name => "thead")
+
+    container_method(:thead)
+
+    collection_method(:theads)
+
+    # do nothing
+  end
+
+  class Dd < HTMLElement
+    identifier(:tag_name => "dd")
+
+    container_method(:dd)
+
+    collection_method(:dds)
+
+    # do nothing
+  end
+
+  class Address < HTMLElement
+    identifier(:tag_name => "address")
+
+    container_method(:address)
+
+    collection_method(:address)
+
+    # do nothing
+  end
+
+  class Nav < HTMLElement
+    identifier(:tag_name => "nav")
+
+    container_method(:nav)
+
+    collection_method(:navs)
+
+    # do nothing
+  end
+
+  class TFoot < TableSection
+    identifier(:tag_name => "tfoot")
+
+    container_method(:tfoot)
+
+    collection_method(:tfoots)
+
+    # do nothing
+  end
+
+  class Sub < HTMLElement
+    identifier(:tag_name => "sub")
+
+    container_method(:sub)
+
+    collection_method(:subs)
+
+    # do nothing
+  end
+
+  class Sup < HTMLElement
+    identifier(:tag_name => "sup")
+
+    container_method(:sup)
+
+    collection_method(:sups)
+
+    # do nothing
+  end
+
+  class Bdo < HTMLElement
+    identifier(:tag_name => "bdo")
+
+    container_method(:bdo)
+
+    collection_method(:bdos)
+
+    # do nothing
+  end
+
+  class Rp < HTMLElement
+    identifier(:tag_name => "rp")
+
+    container_method(:rp)
+
+    collection_method(:rps)
+
+    # do nothing
+  end
+
+  class Rt < HTMLElement
+    identifier(:tag_name => "rt")
+
+    container_method(:rt)
+
+    collection_method(:rts)
+
+    # do nothing
+  end
+
+  class Mark < HTMLElement
+    identifier(:tag_name => "mark")
+
+    container_method(:mark)
+
+    collection_method(:marks)
+
+    # do nothing
+  end
+
+  class Kbd < HTMLElement
+    identifier(:tag_name => "kbd")
+
+    container_method(:kbd)
+
+    collection_method(:kbds)
+
+    # do nothing
+  end
+
+  class Dfn < HTMLElement
+    identifier(:tag_name => "dfn")
+
+    container_method(:dfn)
+
+    collection_method(:dfns)
+
+    # do nothing
+  end
+
+  class Cite < HTMLElement
+    identifier(:tag_name => "cite")
+
+    container_method(:cite)
+
+    collection_method(:cites)
+
+    # do nothing
+  end
+
+  class Ins < Mod
+    identifier(:tag_name => "ins")
+
+    container_method(:ins)
+
+    collection_method(:ins)
+
+    # do nothing
+  end
+
+  class B < HTMLElement
+    identifier(:tag_name => "b")
+
+    container_method(:b)
+
+    collection_method(:bs)
+
+    # do nothing
+  end
+
+  class Noscript < HTMLElement
+    identifier(:tag_name => "noscript")
+
+    container_method(:noscript)
+
+    collection_method(:noscripts)
+
+    # do nothing
+  end
+
+  class Figure < HTMLElement
+    identifier(:tag_name => "figure")
+
+    container_method(:figure)
+
+    collection_method(:figures)
+
+    # do nothing
+  end
+
+  class Code < HTMLElement
+    identifier(:tag_name => "code")
+
+    container_method(:code)
+
+    collection_method(:codes)
+
+    # do nothing
+  end
+
+  class Q < Quote
+    identifier(:tag_name => "q")
+
+    container_method(:q)
+
+    collection_method(:qs)
+
+    # do nothing
+  end
+
+  class Strong < HTMLElement
+    identifier(:tag_name => "strong")
+
+    container_method(:strong)
+
+    collection_method(:strongs)
+
+    # do nothing
+  end
+
+  class Header < HTMLElement
+    identifier(:tag_name => "header")
+
+    container_method(:header)
+
+    collection_method(:headers)
+
+    # do nothing
+  end
+
+  class Hgroup < HTMLElement
+    identifier(:tag_name => "hgroup")
+
+    container_method(:hgroup)
+
+    collection_method(:hgroups)
+
+    # do nothing
+  end
+
+  class Aside < HTMLElement
+    identifier(:tag_name => "aside")
+
+    container_method(:aside)
+
+    collection_method(:asides)
+
+    # do nothing
+  end
+
+  class Samp < HTMLElement
+    identifier(:tag_name => "samp")
+
+    container_method(:samp)
+
+    collection_method(:samps)
+
+    # do nothing
+  end
+
+  class Section < HTMLElement
+    identifier(:tag_name => "section")
+
+    container_method(:section)
+
+    collection_method(:sections)
+
+    # do nothing
+  end
+
+  class Dt < HTMLElement
+    identifier(:tag_name => "dt")
+
+    container_method(:dt)
+
+    collection_method(:dts)
+
+    # do nothing
+  end
+
+  class Col < TableCol
+    identifier(:tag_name => "col")
+
+    container_method(:col)
+
+    collection_method(:cols)
+
+    # do nothing
+  end
+
+  class I < HTMLElement
+    identifier(:tag_name => "i")
+
+    container_method(:i)
+
+    collection_method(:is)
+
+    # do nothing
+  end
+
+  class Var < HTMLElement
+    identifier(:tag_name => "var")
+
+    container_method(:var)
+
+    collection_method(:vars)
+
+    # do nothing
+  end
+
+  class Abbr < HTMLElement
+    identifier(:tag_name => "abbr")
+
+    container_method(:abbr)
+
+    collection_method(:abbrs)
+
+    # do nothing
+  end
+
+  class Small < HTMLElement
+    identifier(:tag_name => "small")
+
+    container_method(:small)
+
+    collection_method(:smalls)
+
+    # do nothing
+  end
+
+  class Footer < HTMLElement
+    identifier(:tag_name => "footer")
+
+    container_method(:footer)
+
+    collection_method(:footers)
+
+    # do nothing
+  end
+
+  class Ruby < HTMLElement
+    identifier(:tag_name => "ruby")
+
+    container_method(:ruby)
+
+    collection_method(:rubys)
+
+    # do nothing
+  end
+
+  class Article < HTMLElement
+    identifier(:tag_name => "article")
+
+    container_method(:article)
+
+    collection_method(:articles)
+
+    # do nothing
+  end
+
+  class Del < Mod
+    identifier(:tag_name => "del")
+
+    container_method(:del)
+
+    collection_method(:dels)
+
+    # do nothing
+  end
+
+  class Em < HTMLElement
+    identifier(:tag_name => "em")
+
+    container_method(:em)
+
+    collection_method(:ems)
+
+    # do nothing
+  end
+end