watir-webdriver 0.0.1.dev5 → 0.0.1.dev6

data/Rakefile

@@ -11,11 +11,13 @@ begin
     gem.homepage    = "http://github.com/jarib/watir-webdriver"
     gem.authors     = ["Jari Bakken"]
 
-    gem.add_dependency "selenium-webdriver"
+    gem.add_dependency "selenium-webdriver", '>= 0.0.18'
 
     gem.add_development_dependency "rspec"
     gem.add_development_dependency "webidl"
-    gem.add_development_dependency "sinatra"
+    gem.add_development_dependency "sinatra", ">= 1.0"
+    gem.add_development_dependency "sinatra", ">= 1.0"
+    gem.add_development_dependency "activesupport", ">= 2.3.5" # for pluralization during code generation
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -39,32 +41,22 @@ task :spec => :check_dependencies
 
 namespace :html5 do
   IDL_PATH    = "support/html5/html5.idl"
-  EXTRAS_PATH = "support/html5/html5_extras.idl"
   SPEC_URI    = "http://dev.w3.org/html5/spec/Overview.html" # TODO: use http://www.whatwg.org/specs/web-apps/current-work/source
 
+  desc "Print IDL parts from #{SPEC_URI}"
   task :extract do
-    require 'support/html5/idl_extractor'
-
-    idl = IdlExtractor.new(SPEC_URI)
-    idl.write_idl_to IDL_PATH
-    idl.write_extras_to "#{EXTRAS_PATH}.txt"
-
-    puts "\n\n"
-    puts "Some HTML elements does not have an interface declaration defined in the spec."
-    puts "You will need to create the IDL by hand and remove the .txt extension from #{EXTRAS_PATH}.txt before running the html5:generate task."
-    puts "We're also adding an extended attribute to specify TagName - you may need to look through #{IDL_PATH} to make sure the syntax is correct."
+    require "nokogiri"
+    require "open-uri"
+    doc = Nokogiri.HTML(open(SPEC_URI))
+    puts doc.search("//pre[@class='idl']").map {  |e| e.inner_text }.join("\n\n")
   end
 
   desc 'Re-enerate the base Watir element classes from the spec '
   task :generate do
     require "support/html5/watir_visitor"
-    raise Errno::ENOENT, EXTRAS_PATH unless File.exist?(EXTRAS_PATH)
 
     code = WatirVisitor.generate_from(IDL_PATH)
-    code << "# from extras: \n\n"
-    code << WatirVisitor.generate_from(EXTRAS_PATH)
-
-    old_file = "lib/watir/elements/generated.rb"
+    old_file = "lib/watir-webdriver/elements/generated.rb"
 
     File.open("#{old_file}.new", "w") { |file| file << code }
     if File.exist?(old_file)
@@ -98,7 +90,9 @@ task :default => :spec
 begin
   require 'yard'
   require 'support/yard_handlers'
-  YARD::Rake::YardocTask.new
+  YARD::Rake::YardocTask.new do |task|
+    task.options = %w[--debug] # this is pretty slow, so nice with some output
+  end
 rescue LoadError
   task :yard do
     abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"

data/VERSION

@@ -1 +1 @@
-0.0.1.dev5
+0.0.1.dev6

data/lib/watir-webdriver.rb

@@ -21,7 +21,7 @@ module Watir
     end
 
     def element_class_for(tag_name)
-      tag_to_class[tag_name] || raise(Exception::Error, "no class found for #{tag_name.inspect}")
+      tag_to_class[tag_name] || HTMLElement
     end
   end
 
@@ -35,6 +35,7 @@ require "watir-webdriver/elements/button"
 require "watir-webdriver/collections/buttons_collection"
 require "watir-webdriver/elements/checkbox"
 require "watir-webdriver/elements/file_field"
+require "watir-webdriver/elements/font"
 require "watir-webdriver/elements/headings"
 require "watir-webdriver/elements/image"
 require "watir-webdriver/elements/link"
@@ -71,3 +72,4 @@ end # Watir
 # undefine deprecated methods to use them for Element attributes
 Object.send :undef_method, :id   if Object.method_defined? "id"
 Object.send :undef_method, :type if Object.method_defined? "type"
+

data/lib/watir-webdriver/base_element.rb

@@ -6,11 +6,22 @@ module Watir
     include Container
     include Selenium
 
+    IGNORED_ATTRIBUTES = [:text, :hash]
+
     class << self
       attr_writer :default_selector
 
-      def inherited(klass)
-        klass.default_selector = default_selector.dup
+      def typed_attributes
+        @typed_attributes ||= Hash.new { |hash, type| hash[type] = []  }
+      end
+
+      def attribute_list
+        @attribute_list ||= (
+          list = typed_attributes.values.flatten
+          list += ancestors[1..-1].map do |e|
+            e.attribute_list if e.respond_to?(:attribute_list)
+          end.compact.flatten
+        ).uniq
       end
 
       def attributes(attribute_map = nil)
@@ -21,10 +32,24 @@ module Watir
         add_attributes attribute_map
 
         attribute_map.each do |type, attribs|
-          attribs.each { |name| define_attribute(type, name) }
+          attribs.each do |name|
+            # we don't want to override methods like :text or :hash
+            next if IGNORED_ATTRIBUTES.include?(name)
+            define_attribute(type, name)
+          end
         end
       end
 
+      def default_selector
+        @default_selector ||= {}
+      end
+
+      private
+
+      def inherited(klass)
+        klass.default_selector = default_selector.dup
+      end
+
       def define_attribute(type, name)
         method_name    = method_name_for(type, name)
         attribute_name = attribute_for_method(name)
@@ -72,9 +97,12 @@ module Watir
       end
 
       def collection_method(name)
+        constant_name = "#{name.to_s.camel_case}Collection"
+        return if Watir.const_defined?(constant_name)
+
         element_class = self
         klass = Watir.const_set(
-          "#{name.to_s.camel_case}Collection",
+          constant_name,
           Class.new(ElementCollection)
         )
 
@@ -89,33 +117,14 @@ module Watir
         end
       end
 
-      def typed_attributes
-        @typed_attributes ||= Hash.new { |hash, type| hash[type] = []  }
-      end
-
       def identifier(selector)
         Watir.tag_to_class[selector[:tag_name]] = self
         default_selector.merge! selector
       end
 
-      def default_selector
-        @default_selector ||= {}
-      end
-
-      def attribute_list
-        @attribute_list ||= begin
-          list = typed_attributes.values.flatten
-          list += ancestors[1..-1].map do |e|
-            e.attribute_list if e.respond_to?(:attribute_list)
-          end.compact.flatten
-        end
-      end
-
       def method_name_for(type, attribute)
         # TODO: rethink this - this list could get pretty long...
         name = case attribute
-               when :hash
-                 'hash_attribute'
                when :html_for
                  'for'
                when :col_span
@@ -135,8 +144,6 @@ module Watir
         case method.to_sym
         when :class_name
           'class'
-        when :hash_attribute
-          'hash'
         when :html_for
           'for'
         when :read_only
@@ -326,8 +333,7 @@ module Watir
 
     def rescue_no_match(returned = "", &blk)
       yield
-    rescue WebDriver::Error::WebDriverError => e # webdriver needs a MissingAttributeError or similar
-      raise unless e.message == "No match"
+    rescue WebDriver::Error::ElementNotEnabledError
       returned
     end
 

data/lib/watir-webdriver/browser.rb

@@ -18,7 +18,7 @@ module Watir
     #
     # Create a Watir::Browser instance
     #
-    # @param [:firefox, :ie, :chrome, :remote] browser
+    # @param [:firefox, :ie, :chrome, :remote, Selenium::WebDriver] browser
     # @param args Passed to the underlying driver
     #
 
@@ -29,7 +29,7 @@ module Watir
       when Selenium::WebDriver::Driver
         @driver = browser
       else
-        raise ArugmentError, "expected Symbol or Selenium::WebDriver::Driver, got #{browser.class}"
+        raise ArgumentError, "expected Symbol or Selenium::WebDriver::Driver, got #{browser.class}"
       end
 
       @error_checkers = []
@@ -71,10 +71,6 @@ module Watir
       @driver.title
     end
 
-    def quit
-      @driver.quit
-    end
-
     def close
       @driver.quit
     end

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

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Watir
+  class Font < HTMLElement
+    identifier        :tag_name => 'font'
+    container_method  :font
+    collection_method :fonts
+
+    attributes :string => [:color, :face], :int => [:size]
+  end
+end
+

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

@@ -1,941 +1,1346 @@
 # 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]))
+    attributes(:token_list => ([:class_list]), :string => ([:innerhtml, :outerhtml, :id, :title, :lang, :dir, :class_name, :access_key, :access_key_label, :content_editable, :spellcheck, :command_type, :label, :icon]), :string_map => ([:dataset]), :style => ([:style]), :html_element => ([:context_menu]), :bool => ([:hidden, :draggable, :is_content_editable, :disabled, :checked]), :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]), :int => ([:tab_index]))
   end
-
-  class TableCell < HTMLElement
-    attributes(:string => ([:headers]), :int => ([:col_span, :row_span, :cell_index]))
+  
+  class Html < HTMLElement
+    identifier(:tag_name => "html")
+    
+    container_method(:html)
+    
+    collection_method(:htmls)
+    
+    # do nothing
   end
-
-  class Mod < HTMLElement
-    attributes(:string => ([:cite, :date_time]))
+  
+  class Head < HTMLElement
+    identifier(:tag_name => "head")
+    
+    container_method(:head)
+    
+    collection_method(:heads)
+    
+    # do nothing
+  end
+  
+  class Title < HTMLElement
+    identifier(:tag_name => "title")
+    
+    container_method(:title)
+    
+    collection_method(:titles)
+    
+    attributes(:string => ([:text]))
+  end
+  
+  class Base < HTMLElement
+    identifier(:tag_name => "base")
+    
+    container_method(:base)
+    
+    collection_method(:bases)
+    
+    attributes(:string => ([:href, :target]))
   end
-
+  
+  # class Link < HTMLElement
+  #   identifier(:tag_name => "link")
+  #   
+  #   container_method(:link)
+  #   
+  #   collection_method(:links)
+  #   
+  #   attributes(:token_list => ([:rel_list, :sizes]), :string => ([:href, :rel, :media, :hreflang, :type]), :bool => ([:disabled]))
+  # 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]))
+  
+  class Style < HTMLElement
+    identifier(:tag_name => "style")
+    
+    container_method(:style)
+    
+    collection_method(:styles)
+    
+    attributes(:string => ([:media, :type]), :bool => ([:disabled, :scoped]))
   end
-
-  class DataList < HTMLElement
-    identifier(:tag_name => "datalist")
-
-    container_method(:datalist)
-
-    collection_method(:datalists)
-
-    attributes(:html_collection => ([:options]))
+  
+  class Script < HTMLElement
+    identifier(:tag_name => "script")
+    
+    container_method(:script)
+    
+    collection_method(:scripts)
+    
+    attributes(:string => ([:src, :type, :charset, :text]), :bool => ([:async, :defer]))
+  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 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)
-
+  
+  class Heading < HTMLElement
+    identifier(:tag_name => "h1")
+    
+    container_method(:h1)
+    
+    collection_method(:h1s)
+    
     # do nothing
   end
-
-  class LI < HTMLElement
-    identifier(:tag_name => "li")
-
-    container_method(:li)
-
-    collection_method(:lis)
-
-    attributes(:int => ([:value]))
+  
+  class Paragraph < HTMLElement
+    identifier(:tag_name => "p")
+    
+    container_method(:p)
+    
+    collection_method(:ps)
+    
+    # do nothing
   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]))
+  
+  class Pre < HTMLElement
+    identifier(:tag_name => "pre")
+    
+    container_method(:pre)
+    
+    collection_method(:pres)
+    
+    # do nothing
   end
-
-  class TableRow < HTMLElement
-    identifier(:tag_name => "tr")
-
-    container_method(:tr)
-
-    collection_method(:trs)
-
-    attributes(:int => ([:row_index, :section_row_index]), :html_collection => ([:cells]))
+  
+  class Quote < HTMLElement
+    identifier(:tag_name => "blockquote")
+    
+    container_method(:blockquote)
+    
+    collection_method(:blockquotes)
+    
+    attributes(:string => ([:cite]))
   end
-
-  class TableSection < HTMLElement
-    identifier(:tag_name => "tbody")
-
-    container_method(:tbody)
-
-    collection_method(:tbodys)
-
-    attributes(:html_collection => ([:rows]))
+  
+  class OList < HTMLElement
+    identifier(:tag_name => "ol")
+    
+    container_method(:ol)
+    
+    collection_method(:ols)
+    
+    attributes(:bool => ([:reversed]), :int => ([:start]))
   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]))
+  
+  class UList < HTMLElement
+    identifier(:tag_name => "ul")
+    
+    container_method(:ul)
+    
+    collection_method(:uls)
+    
+    # do nothing
+  end
+  
+  class LI < HTMLElement
+    identifier(:tag_name => "li")
+    
+    container_method(:li)
+    
+    collection_method(:lis)
+    
+    attributes(:int => ([:value]))
+  end
+  
+  class DList < HTMLElement
+    identifier(:tag_name => "dl")
+    
+    container_method(:dl)
+    
+    collection_method(:dls)
+    
+    # do nothing
+  end
+  
+  class Div < HTMLElement
+    identifier(:tag_name => "div")
+    
+    container_method(:div)
+    
+    collection_method(:divs)
+    
+    # do nothing
   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]))
+    
+    attributes(:token_list => ([:rel_list]), :string => ([:href, :target, :rel, :media, :hreflang, :type, :text, :protocol, :host, :hostname, :port, :pathname, :search, :hash]))
   end
-
-  class Pre < HTMLElement
-    identifier(:tag_name => "pre")
-
-    container_method(:pre)
-
-    collection_method(:pres)
-
+  
+  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 Span < HTMLElement
+    identifier(:tag_name => "span")
+    
+    container_method(:span)
+    
+    collection_method(:spans)
+    
     # do nothing
   end
-
-  class Details < HTMLElement
-    identifier(:tag_name => "details")
-
-    container_method(:details)
-
-    collection_method(:details)
-
-    attributes(:bool => ([:open]))
+  
+  class BR < HTMLElement
+    identifier(:tag_name => "br")
+    
+    container_method(:br)
+    
+    collection_method(:brs)
+    
+    # do nothing
   end
-
-  class OptGroup < HTMLElement
-    identifier(:tag_name => "optgroup")
-
-    container_method(:optgroup)
-
-    collection_method(:optgroups)
-
-    attributes(:string => ([:label]), :bool => ([:disabled]))
+  
+  class Mod < HTMLElement
+    attributes(:string => ([:cite, :date_time]))
   end
-
-  class TableCol < HTMLElement
-    identifier(:tag_name => "colgroup")
-
-    container_method(:colgroup)
-
-    collection_method(:colgroups)
-
-    attributes(:int => ([:span]))
+  
+  class Image < HTMLElement
+    identifier(:tag_name => "img")
+    
+    container_method(:image)
+    
+    collection_method(:images)
+    
+    attributes(:string => ([:alt, :src, :use_map]), :bool => ([:is_map, :complete]), :int => ([:width, :height, :natural_width, :natural_height]))
   end
-
+  
+  class IFrame < HTMLElement
+    identifier(:tag_name => "iframe")
+    
+    container_method(:iframe)
+    
+    collection_method(:iframes)
+    
+    attributes(:token_list => ([:sandbox]), :string => ([:src, :srcdoc, :name, :width, :height, :content_window]), :document => ([:content_document]), :bool => ([:seamless]))
+  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 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]), :html_element => ([:form]), :bool => ([:will_validate]), :document => ([:content_document]))
+  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]))
+  
+  class Media < HTMLElement
+    attributes(:string => ([:error, :src, :current_src, :preload, :buffered, :played, :seekable]), :float => ([:current_time, :start_time, :duration, :default_playback_rate, :playback_rate, :volume]), :bool => ([:seeking, :paused, :ended, :autoplay, :loop, :controls, :muted]), :int => ([:network_state, :ready_state]))
+  end
+  
+  class Video < Media
+    identifier(:tag_name => "video")
+    
+    container_method(:video)
+    
+    collection_method(:videos)
+    
+    attributes(:string => ([:width, :height, :poster]), :int => ([:video_width, :video_height]))
+  end
+  
+  class Audio < Media
+    identifier(:tag_name => "audio")
+    
+    container_method(:audio)
+    
+    collection_method(:audios)
+    
+    # do nothing
   end
-
-  class Progress < HTMLElement
-    identifier(:tag_name => "progress")
-
-    container_method(:progress)
-
-    collection_method(:progress)
-
-    attributes(:float => ([:value, :max, :position]))
+  
+  class Source < HTMLElement
+    identifier(:tag_name => "source")
+    
+    container_method(:source)
+    
+    collection_method(:sources)
+    
+    attributes(:string => ([:src, :type, :media]))
   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]))
+  
+  class Canvas < HTMLElement
+    identifier(:tag_name => "canvas")
+    
+    container_method(:canvas)
+    
+    collection_method(:canvases)
+    
+    attributes(:int => ([:width, :height]))
   end
-
-  class UList < HTMLElement
-    identifier(:tag_name => "ul")
-
-    container_method(:ul)
-
-    collection_method(:uls)
-
-    # do nothing
+  
+  class Map < HTMLElement
+    identifier(:tag_name => "map")
+    
+    container_method(:map)
+    
+    collection_method(:maps)
+    
+    attributes(:string => ([:name]), :html_collection => ([:areas, :images]))
   end
-
-  class Quote < HTMLElement
-    identifier(:tag_name => "blockquote")
-
-    container_method(:blockquote)
-
-    collection_method(:blockquotes)
-
-    attributes(:string => ([:cite]))
+  
+  class Area < HTMLElement
+    attributes(:token_list => ([:rel_list]), :string => ([:alt, :coords, :shape, :href, :target, :rel, :media, :hreflang, :type, :protocol, :host, :hostname, :port, :pathname, :search, :hash]))
   end
-
-  class Style < HTMLElement
-    identifier(:tag_name => "style")
-
-    container_method(:style)
-
-    collection_method(:styles)
-
-    attributes(:string => ([:media, :type]), :bool => ([:disabled, :scoped]))
+  
+  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 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]))
+  
+  class TableCol < HTMLElement
+    identifier(:tag_name => "colgroup")
+    
+    container_method(:colgroup)
+    
+    collection_method(:colgroups)
+    
+    attributes(:int => ([:span]))
   end
-
-  class Paragraph < HTMLElement
-    identifier(:tag_name => "p")
-
-    container_method(:p)
-
-    collection_method(:ps)
-
-    # do nothing
+  
+  class TableSection < HTMLElement
+    identifier(:tag_name => "tbody")
+    
+    container_method(:tbody)
+    
+    collection_method(:tbodys)
+    
+    attributes(:html_collection => ([:rows]))
   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]))
+  
+  class TableRow < HTMLElement
+    identifier(:tag_name => "tr")
+    
+    container_method(:tr)
+    
+    collection_method(:trs)
+    
+    attributes(:html_collection => ([:cells]), :int => ([:row_index, :section_row_index]))
   end
-
-  class Head < HTMLElement
-    identifier(:tag_name => "head")
-
-    container_method(:head)
-
-    collection_method(:heads)
-
+  
+  class TableCell < HTMLElement
+    identifier(:tag_name => "td")
+    
+    container_method(:td)
+    
+    collection_method(:tds)
+    
+    attributes(:string => ([:abbr, :align, :axis, :bg_color, :ch, :ch_off, :height, :v_align, :width]), :bool => ([:no_wrap]))
+  end
+  
+  class TableDataCell < TableCell
+    identifier(:tag_name => "td")
+    
+    container_method(:td)
+    
+    collection_method(:tds)
+    
     # do nothing
   end
-
-  class Map < HTMLElement
-    identifier(:tag_name => "map")
-
-    container_method(:map)
-
-    collection_method(:maps)
-
-    attributes(:string => ([:name]), :html_collection => ([:areas, :images]))
+  
+  class TableHeaderCell < TableCell
+    identifier(:tag_name => "th")
+    
+    container_method(:th)
+    
+    collection_method(:ths)
+    
+    attributes(:string => ([:scope]))
   end
-
-  class Div < HTMLElement
-    identifier(:tag_name => "div")
-
-    container_method(:div)
-
-    collection_method(:divs)
-
-    # do nothing
+  
+  class TableCell < HTMLElement
+    attributes(:token_list => ([:headers]), :int => ([:col_span, :row_span, :cell_index]))
+  end
+  
+  class Form < HTMLElement
+    identifier(:tag_name => "form")
+    
+    container_method(:form)
+    
+    collection_method(:forms)
+    
+    attributes(:string => ([:accept_charset, :action, :autocomplete, :enctype, :method, :name, :target]), :bool => ([:no_validate]), :html_collection => ([:elements]), :int => ([:length]))
+  end
+  
+  class FieldSet < HTMLElement
+    identifier(:tag_name => "fieldset")
+    
+    container_method(:fieldset)
+    
+    collection_method(:fieldsets)
+    
+    attributes(:string => ([:name, :type, :validity, :validation_message]), :html_element => ([:form]), :bool => ([:disabled, :will_validate]), :html_collection => ([:elements]))
+  end
+  
+  class Legend < HTMLElement
+    identifier(:tag_name => "legend")
+    
+    container_method(:legend)
+    
+    collection_method(:legends)
+    
+    attributes(:html_element => ([:form]))
   end
-
+  
+  class Label < HTMLElement
+    identifier(:tag_name => "label")
+    
+    container_method(:label)
+    
+    collection_method(:labels)
+    
+    attributes(:string => ([:html_for]), :html_element => ([:form, :control]))
+  end
+  
+  class Input < HTMLElement
+    identifier(:tag_name => "input")
+    
+    container_method(:input)
+    
+    collection_method(:inputs)
+    
+    attributes(:string => ([:accept, :alt, :autocomplete, :form_action, :form_enctype, :form_method, :form_target, :height, :max, :min, :name, :pattern, :placeholder, :src, :step, :type, :default_value, :value, :width, :validity, :validation_message]), :date => ([:value_as_date]), :float => ([:value_as_number]), :list => ([:files, :labels]), :html_element => ([:form, :list, :selected_option]), :bool => ([:autofocus, :default_checked, :checked, :disabled, :form_no_validate, :indeterminate, :multiple, :read_only, :required, :will_validate]), :int => ([:max_length, :size, :selection_start, :selection_end]))
+  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]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :will_validate]))
+  end
+  
+  class Select < HTMLElement
+    identifier(:tag_name => "select")
+    
+    container_method(:select)
+    
+    collection_method(:selects)
+    
+    attributes(:string => ([:name, :type, :value, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :multiple, :will_validate]), :html_collection => ([:options, :selected_options]), :int => ([:size, :length, :selected_index]))
+  end
+  
+  class DataList < HTMLElement
+    identifier(:tag_name => "datalist")
+    
+    container_method(:datalist)
+    
+    collection_method(:datalists)
+    
+    attributes(:html_collection => ([:options]))
+  end
+  
+  class OptGroup < HTMLElement
+    identifier(:tag_name => "optgroup")
+    
+    container_method(:optgroup)
+    
+    collection_method(:optgroups)
+    
+    attributes(:string => ([:label]), :bool => ([:disabled]))
+  end
+  
+  class Option < HTMLElement
+    identifier(:tag_name => "option")
+    
+    container_method(:option)
+    
+    collection_method(:options)
+    
+    attributes(:string => ([:label, :value, :text]), :html_element => ([:form]), :bool => ([:disabled, :default_selected, :selected]), :int => ([:index]))
+  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]))
+    
+    attributes(:string => ([:name, :placeholder, :wrap, :type, :default_value, :value, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :read_only, :required, :will_validate]), :int => ([:cols, :max_length, :rows, :text_length, :selection_start, :selection_end]))
   end
-
-  class TableDataCell < TableCell
-    identifier(:tag_name => "td")
-
-    container_method(:td)
-
-    collection_method(:tds)
-
-    # do nothing
+  
+  class Keygen < HTMLElement
+    identifier(:tag_name => "keygen")
+    
+    container_method(:keygen)
+    
+    collection_method(:keygens)
+    
+    attributes(:string => ([:challenge, :keytype, :name, :type, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :will_validate]))
   end
-
-  class Canvas < HTMLElement
-    identifier(:tag_name => "canvas")
-
-    container_method(:canvas)
-
-    collection_method(:canvas)
-
-    attributes(:int => ([:width, :height]))
+  
+  class Output < HTMLElement
+    identifier(:tag_name => "output")
+    
+    container_method(:output)
+    
+    collection_method(:outputs)
+    
+    attributes(:token_list => ([:html_for]), :string => ([:name, :type, :default_value, :value, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:will_validate]))
+  end
+  
+  class Progress < HTMLElement
+    identifier(:tag_name => "progress")
+    
+    container_method(:progress)
+    
+    collection_method(:progresses)
+    
+    attributes(:list => ([:labels]), :float => ([:value, :max, :position]), :html_element => ([:form]))
+  end
+  
+  class Meter < HTMLElement
+    identifier(:tag_name => "meter")
+    
+    container_method(:meter)
+    
+    collection_method(:meters)
+    
+    attributes(:list => ([:labels]), :float => ([:value, :min, :max, :low, :high, :optimum]), :html_element => ([:form]))
+  end
+  
+  class Details < HTMLElement
+    identifier(:tag_name => "details")
+    
+    container_method(:details)
+    
+    collection_method(:details)
+    
+    attributes(:bool => ([:open]))
+  end
+  
+  class Command < HTMLElement
+    identifier(:tag_name => "command")
+    
+    container_method(:command)
+    
+    collection_method(:commands)
+    
+    attributes(:string => ([:type, :label, :icon, :radiogroup]), :bool => ([:disabled, :checked]))
+  end
+  
+  class Menu < HTMLElement
+    identifier(:tag_name => "menu")
+    
+    container_method(:menu)
+    
+    collection_method(:menus)
+    
+    attributes(:string => ([:type, :label]))
+  end
+  
+  class Applet < HTMLElement
+    identifier(:tag_name => "applet")
+    
+    container_method(:applet)
+    
+    collection_method(:applets)
+    
+    attributes(:string => ([:align, :alt, :archive, :code, :code_base, :height, :name, :object, :width]), :int => ([:hspace, :vspace]))
+  end
+  
+  class Marquee < HTMLElement
+    identifier(:tag_name => "marquee")
+    
+    container_method(:marquee)
+    
+    collection_method(:marquees)
+    
+    attributes(:string => ([:behavior, :bg_color, :direction, :height, :true_speed, :width]), :function => ([:onbounce, :onfinish, :onstart]), :int => ([:hspace, :loop, :scroll_amount, :scroll_delay, :vspace]))
+  end
+  
+  class FrameSet < HTMLElement
+    identifier(:tag_name => "farmeset")
+    
+    container_method(:farmeset)
+    
+    collection_method(:farmesets)
+    
+    attributes(:string => ([:cols, :rows]), :function => ([:onafterprint, :onbeforeprint, :onbeforeunload, :onblur, :onerror, :onfocus, :onhashchange, :onload, :onmessage, :onoffline, :ononline, :onpagehide, :onpageshow, :onpopstate, :onredo, :onresize, :onstorage, :onundo, :onunload]))
+  end
+  
+  class Frame < HTMLElement
+    identifier(:tag_name => "frame")
+    
+    container_method(:frame)
+    
+    collection_method(:frames)
+    
+    attributes(:string => ([:frame_border, :long_desc, :margin_height, :margin_width, :name, :scrolling, :src]), :document => ([:content_document]), :bool => ([:no_resize]))
+  end
+  
+  class Anchor < HTMLElement
+    identifier(:tag_name => "a")
+    
+    container_method(:a)
+    
+    collection_method(:as)
+    
+    attributes(:string => ([:coords, :charset, :name, :rev, :shape]))
   end
-
+  
+  class Area < HTMLElement
+    identifier(:tag_name => "area")
+    
+    container_method(:area)
+    
+    collection_method(:areas)
+    
+    attributes(:bool => ([:no_href]))
+  end
+  
+  class BaseFont < HTMLElement
+    identifier(:tag_name => "basefont")
+    
+    container_method(:basefont)
+    
+    collection_method(:basefonts)
+    
+    attributes(:string => ([:color, :face]), :int => ([:size]))
+  end
+  
+  class Body < HTMLElement
+    identifier(:tag_name => "body")
+    
+    container_method(:body)
+    
+    collection_method(:bodys)
+    
+    attributes(:string => ([:text, :bg_color, :background, :link, :v_link, :a_link]))
+  end
+  
   class BR < HTMLElement
     identifier(:tag_name => "br")
-
+    
     container_method(:br)
-
+    
     collection_method(:brs)
-
-    # do nothing
+    
+    attributes(:string => ([:clear]))
   end
-
-  class Title < HTMLElement
-    identifier(:tag_name => "title")
-
-    container_method(:title)
-
-    collection_method(:titles)
-
-    attributes(:string => ([:text]))
+  
+  class TableCaption < HTMLElement
+    identifier(:tag_name => "caption")
+    
+    container_method(:caption)
+    
+    collection_method(:captions)
+    
+    attributes(:string => ([:align]))
   end
-
-  class Meter < HTMLElement
-    identifier(:tag_name => "meter")
-
-    container_method(:meter)
-
-    collection_method(:meters)
-
-    attributes(:float => ([:value, :min, :max, :low, :high, :optimum]))
+  
+  class TableCol < HTMLElement
+    identifier(:tag_name => "col")
+    
+    container_method(:col)
+    
+    collection_method(:cols)
+    
+    attributes(:string => ([:align, :ch, :ch_off, :v_align, :width]))
+  end
+  
+  class Directory < HTMLElement
+    attributes(:bool => ([:compact]))
+  end
+  
+  class Div < HTMLElement
+    identifier(:tag_name => "div")
+    
+    container_method(:div)
+    
+    collection_method(:divs)
+    
+    attributes(:string => ([:align]))
+  end
+  
+  class DList < HTMLElement
+    identifier(:tag_name => "dl")
+    
+    container_method(:dl)
+    
+    collection_method(:dls)
+    
+    attributes(:bool => ([:compact]))
   end
-
+  
+  class Embed < HTMLElement
+    identifier(:tag_name => "embed")
+    
+    container_method(:embed)
+    
+    collection_method(:embeds)
+    
+    attributes(:string => ([:align, :name]))
+  end
+  
+  class Font < HTMLElement
+    identifier(:tag_name => "font")
+    
+    container_method(:font)
+    
+    collection_method(:fonts)
+    
+    attributes(:string => ([:color, :face, :size]))
+  end
+  
   class Heading < HTMLElement
     identifier(:tag_name => "h1")
-
+    
     container_method(:h1)
-
+    
     collection_method(:h1s)
-
-    # do nothing
+    
+    attributes(:string => ([:align]))
   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
+  
+  class HR < HTMLElement
+    identifier(:tag_name => "hr")
+    
+    container_method(:hr)
+    
+    collection_method(:hrs)
+    
+    attributes(:string => ([:align, :color, :size, :width]), :bool => ([:no_shade]))
   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]))
+  
+  class Html < HTMLElement
+    identifier(:tag_name => "html")
+    
+    container_method(:html)
+    
+    collection_method(:htmls)
+    
+    attributes(:string => ([:version]))
   end
-
-  class Label < HTMLElement
-    identifier(:tag_name => "label")
-
-    container_method(:label)
-
-    collection_method(:labels)
-
-    attributes(:string => ([:html_for]), :html_element => ([:form, :control]))
+  
+  class IFrame < HTMLElement
+    identifier(:tag_name => "iframe")
+    
+    container_method(:iframe)
+    
+    collection_method(:iframes)
+    
+    attributes(:string => ([:align, :frame_border, :long_desc, :margin_height, :margin_width, :scrolling]))
   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]))
+  
+  class Image < HTMLElement
+    identifier(:tag_name => "img")
+    
+    container_method(:image)
+    
+    collection_method(:images)
+    
+    attributes(:string => ([:name, :align, :border, :long_desc]), :int => ([:hspace, :vspace]))
   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]))
+  
+  class Input < HTMLElement
+    identifier(:tag_name => "input")
+    
+    container_method(:input)
+    
+    collection_method(:inputs)
+    
+    attributes(:string => ([:align, :use_map]))
   end
-
-  class Source < HTMLElement
-    identifier(:tag_name => "source")
-
-    container_method(:source)
-
-    collection_method(:sources)
-
-    attributes(:string => ([:src, :type, :media]))
+  
+  class Legend < HTMLElement
+    identifier(:tag_name => "legend")
+    
+    container_method(:legend)
+    
+    collection_method(:legends)
+    
+    attributes(:string => ([:align]))
   end
-
-  class Span < HTMLElement
-    identifier(:tag_name => "span")
-
-    container_method(:span)
-
-    collection_method(:spans)
-
-    # do nothing
+  
+  class LI < HTMLElement
+    identifier(:tag_name => "li")
+    
+    container_method(:li)
+    
+    collection_method(:lis)
+    
+    attributes(:string => ([:type]))
   end
-
+  
+  # class Link < HTMLElement
+  #   identifier(:tag_name => "link")
+  #   
+  #   container_method(:link)
+  #   
+  #   collection_method(:links)
+  #   
+  #   attributes(:string => ([:charset, :rev, :target]))
+  # end
+  
+  class Menu < HTMLElement
+    identifier(:tag_name => "menu")
+    
+    container_method(:menu)
+    
+    collection_method(:menus)
+    
+    attributes(:bool => ([:compact]))
+  end
+  
+  class Meta < HTMLElement
+    identifier(:tag_name => "meta")
+    
+    container_method(:meta)
+    
+    collection_method(:metas)
+    
+    attributes(:string => ([:scheme]))
+  end
+  
+  class Object < HTMLElement
+    identifier(:tag_name => "object")
+    
+    container_method(:object)
+    
+    collection_method(:objects)
+    
+    attributes(:string => ([:align, :archive, :border, :code, :code_base, :code_type, :standby]), :bool => ([:declare]), :int => ([:hspace, :vspace]))
+  end
+  
   class OList < HTMLElement
     identifier(:tag_name => "ol")
-
+    
     container_method(:ol)
-
+    
     collection_method(:ols)
-
-    attributes(:int => ([:start]), :bool => ([:reversed]))
+    
+    attributes(:string => ([:type]), :bool => ([:compact]))
   end
-end# from extras:
-
-# Autogenerated from the HTML5 specification. Edits may be lost.
-module Watir
+  
+  class Paragraph < HTMLElement
+    identifier(:tag_name => "p")
+    
+    container_method(:p)
+    
+    collection_method(:ps)
+    
+    attributes(:string => ([:align]))
+  end
+  
+  class Param < HTMLElement
+    identifier(:tag_name => "param")
+    
+    container_method(:param)
+    
+    collection_method(:params)
+    
+    attributes(:string => ([:type, :value_type]))
+  end
+  
+  class Pre < HTMLElement
+    identifier(:tag_name => "pre")
+    
+    container_method(:pre)
+    
+    collection_method(:pres)
+    
+    attributes(:int => ([:width]))
+  end
+  
+  class Script < HTMLElement
+    identifier(:tag_name => "script")
+    
+    container_method(:script)
+    
+    collection_method(:scripts)
+    
+    attributes(:string => ([:event, :html_for]))
+  end
+  
+  class Table < HTMLElement
+    identifier(:tag_name => "table")
+    
+    container_method(:table)
+    
+    collection_method(:tables)
+    
+    attributes(:string => ([:align, :bg_color, :border, :cell_padding, :cell_spacing, :frame, :rules, :width]))
+  end
+  
+  class TableSection < HTMLElement
+    identifier(:tag_name => "tbody")
+    
+    container_method(:tbody)
+    
+    collection_method(:tbodys)
+    
+    attributes(:string => ([:align, :ch, :ch_off, :v_align]))
+  end
+  
+  class TableRow < HTMLElement
+    identifier(:tag_name => "tr")
+    
+    container_method(:tr)
+    
+    collection_method(:trs)
+    
+    attributes(:string => ([:align, :bg_color, :ch, :ch_off, :v_align]))
+  end
+  
+  class UList < HTMLElement
+    identifier(:tag_name => "ul")
+    
+    container_method(:ul)
+    
+    collection_method(:uls)
+    
+    attributes(:string => ([:type]), :bool => ([:compact]))
+  end
+  
   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)
-
+    
+    collection_method(:addresses)
+    
     # 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)
-
+    
+    collection_method(:inses)
+    
     # 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)
-
+    
+    collection_method(:rubies)
+    
     # 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