watir-webdriver 0.0.7 → 0.0.8

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    watir-webdriver (0.0.7)
+      selenium-webdriver (>= 0.0.26)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.0)
+    ffi (0.6.3)
+      rake (>= 0.8.7)
+    json_pure (1.4.6)
+    nokogiri (1.4.3.1)
+    polyglot (0.3.1)
+    rack (1.2.1)
+    rake (0.8.7)
+    rspec (1.3.0)
+    ruby2ruby (1.2.4)
+      ruby_parser (~> 2.0)
+      sexp_processor (~> 3.0)
+    ruby_parser (2.0.4)
+      sexp_processor (~> 3.0)
+    rubyzip (0.9.4)
+    selenium-webdriver (0.0.28)
+      ffi (>= 0.6.1)
+      json_pure
+      rubyzip
+    sexp_processor (3.0.4)
+    sinatra (1.0)
+      rack (>= 1.0)
+    treetop (1.4.8)
+      polyglot (>= 0.3.1)
+    webidl (0.0.5)
+      ruby2ruby
+      treetop
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (>= 2.3.5)
+  nokogiri
+  rspec
+  selenium-webdriver (>= 0.0.26)
+  sinatra (>= 1.0)
+  watir-webdriver!
+  webidl (>= 0.0.4)

data/Rakefile

@@ -11,13 +11,14 @@ begin
     gem.homepage    = "http://github.com/jarib/watir-webdriver"
     gem.authors     = ["Jari Bakken"]
 
-    gem.add_dependency "selenium-webdriver", '>= 0.0.26'
+    gem.add_dependency "selenium-webdriver", '>= 0.0.28'
 
     gem.add_development_dependency "rspec"
+    gem.add_development_dependency "yard", "~> 0.6"
     gem.add_development_dependency "webidl", ">= 0.0.4"
-    gem.add_development_dependency "sinatra", ">= 1.0"
+    gem.add_development_dependency "sinatra", "~> 1.0"
     gem.add_development_dependency "nokogiri"
-    gem.add_development_dependency "activesupport", ">= 2.3.5" # for pluralization during code generation
+    gem.add_development_dependency "activesupport", "~> 2.3.5" # for pluralization during code generation
   end
 
   Jeweler::GemcutterTasks.new
@@ -31,11 +32,25 @@ Spec::Rake::SpecTask.new(:spec) do |spec|
   spec.spec_files = FileList['spec/**/*_spec.rb']
 end
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-  spec.rcov_opts = %w[--exclude spec,ruby-debug,/Library/Ruby,.gem --include lib/watir-webdriver]
+namespace :spec do
+  Spec::Rake::SpecTask.new(:rcov) do |spec|
+    spec.libs << 'lib' << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.rcov = true
+    spec.rcov_opts = %w[--exclude spec,ruby-debug,/Library/Ruby,.gem --include lib/watir-webdriver]
+  end
+
+  desc 'Run specs for CI'
+  Spec::Rake::SpecTask.new(:ci) do |spec|
+    spec.libs << 'lib' << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.spec_opts = ["--format", "html:results/#{RUBY_PLATFORM}/#{ENV['WATIR_WEBDRIVER_BROWSER'] || 'firefox'}/spec-results.html",
+                      "--format", "progress",
+                      "--backtrace"]
+    spec.rcov = true
+    spec.rcov_opts = %w[--exclude spec,ruby-debug,/Library/Ruby,.gem --include lib/watir-webdriver]
+  end
+
 end
 
 task :spec => :check_dependencies

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/lib/watir-webdriver.rb

@@ -5,6 +5,7 @@ require "json"
 require "watir-webdriver/core_ext/string"
 require "watir-webdriver/exception"
 require "watir-webdriver/xpath_support"
+require "watir-webdriver/window_switching"
 require "watir-webdriver/container"
 require "watir-webdriver/locators/element_locator"
 require "watir-webdriver/locators/button_locator"
@@ -28,8 +29,8 @@ module Watir
 end
 
 require "watir-webdriver/attribute_helper"
-require "watir-webdriver/element"
-require "watir-webdriver/collections/element_collection"
+require "watir-webdriver/element_collection"
+require "watir-webdriver/elements/element"
 require "watir-webdriver/elements/generated"
 require "watir-webdriver/elements/frame"
 require "watir-webdriver/elements/input"
@@ -47,7 +48,6 @@ require "watir-webdriver/elements/form"
 require "watir-webdriver/elements/option"
 require "watir-webdriver/elements/table"
 require "watir-webdriver/elements/table_row"
-require "watir-webdriver/collections/table_row_collection"
 
 Watir.tag_to_class.freeze
 
@@ -65,6 +65,8 @@ 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"
+class Object
+  undef_method :id if method_defined? "id"
+  undef_method :type if method_defined? "type"
+end
 

data/lib/watir-webdriver/browser.rb

@@ -1,7 +1,13 @@
 # encoding: utf-8
 module Watir
+
+  #
+  # The main class through which you control the browser.
+  #
+
   class Browser
     include Container
+    include WindowSwitching
 
     attr_reader :driver
     alias_method :wd, :driver # ensures duck typing with Watir::Element
@@ -49,7 +55,7 @@ module Watir
     #
 
     def goto(uri)
-      uri = "http://#{uri}" unless uri.include?("://") || uri =~ /^\w+:/
+      uri = "http://#{uri}" unless uri.include?("://")
 
       @driver.navigate.to uri
       run_checkers
@@ -89,6 +95,7 @@ module Watir
     end
 
     def html
+      # use body.html instead?
       @driver.page_source
     end
 
@@ -106,7 +113,7 @@ module Watir
       returned = @driver.execute_script(script, *args)
 
       if returned.kind_of? WebDriver::Element
-        Watir.element_class_for(returned.tag_name).new(self, :element, returned)
+        Watir.element_class_for(returned.tag_name).new(self, :element => returned)
       else
         returned
       end

data/lib/watir-webdriver/browserbot.js

@@ -20,7 +20,7 @@ var browserbot = {
                 }
 
             evt.initEvent(eventType, canBubble, true);
-            element.dispatchEvent(evt);
+            return element.dispatchEvent(evt);
         }
     },
 
@@ -29,7 +29,10 @@ var browserbot = {
         var range = document.createRange();
         range.selectNodeContents(document.documentElement);
         selection.addRange(range);
-        return selection.toString();
+        var string = selection.toString();
+        selection.removeAllRanges();
+
+        return string;
     },
 
     getOuterHTML: function(element) {

data/lib/watir-webdriver/container.rb

@@ -17,18 +17,15 @@ module Watir
     def extract_selector(selectors)
       case selectors.size
       when 2
-        { selectors[0] => selectors[1] }
+        return { selectors[0] => selectors[1] }
       when 1
-        unless selectors.first.kind_of? Hash
-          raise ArgumentError, "expected Hash or (:how, 'what')"
-        end
-
-        selectors.first
+        obj = selectors.first
+        return obj if obj.kind_of? Hash
       when 0
-        {}
-      else
-        raise ArgumentError, selectors.inspect
+        return {}
       end
+
+      raise ArgumentError, "expected Hash or (:how, 'what'), got #{selectors.inspect}"
     end
 
   end # Container

data/lib/watir-webdriver/{collections/element_collection.rb → element_collection.rb}

@@ -1,5 +1,10 @@
 # encoding: utf-8
 module Watir
+
+  #
+  # Base class for element collections.
+  #
+
   class ElementCollection
     include Enumerable
 

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

@@ -15,12 +15,13 @@ module Watir
 
     def self.from(parent, element)
       if element.tag_name == "button" ||
-         element.tag_name == "input" && %w[submit reset image button].include?(element.attribute(:type))
+         element.tag_name == "input" && ButtonLocator::VALID_TYPES.include?(element.attribute(:type))
         Button.new(parent, :element => element)
       else
-        raise TypeError, "expected button or input[@type=submit|reset|image|button] for #{element.inspect}"
+        raise TypeError, "expected button or input[@type=#{ButtonLocator::VALID_TYPES.join("|")}] for #{element.inspect}"
       end
     end
+
     #
     # Returns the text of the button.
     #
@@ -32,9 +33,9 @@ module Watir
       assert_exists
       case @element.tag_name
       when 'input'
-        value
+        @element.attribute(:value)
       when 'button'
-        text
+        @element.text
       else
         raise Exception::Error, "unknown tag name for button: #{@element.tag_name}"
       end

data/lib/watir-webdriver/{element.rb → elements/element.rb}

@@ -1,12 +1,17 @@
 # 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
@@ -36,6 +41,16 @@ module Watir
       end
     end
 
+    def ==(other)
+      assert_exists
+      @element == other.element
+    end
+    alias_method :eql?, :==
+
+    def hash
+      @element ? @element.hash : super
+    end
+
     def text
       assert_exists
       @element.text
@@ -70,8 +85,8 @@ module Watir
     end
 
     def flash
-      assert_exists
-      original_color = driver.execute_script("arguments[0].style.backgroundColor", @element)
+      original_color = style("backgroundColor")
+
       10.times do |n|
         color = (n % 2 == 0) ? "red" : original_color
         driver.execute_script("arguments[0].style.backgroundColor = '#{color}'", @element)
@@ -82,7 +97,7 @@ module Watir
       assert_exists
 
       begin
-        @element.value
+        @element.value || ''
       rescue WebDriver::Error::ElementNotEnabledError
         ""
       end
@@ -150,7 +165,7 @@ module Watir
         assert_exists
         @element.style property
       else
-        attribute_value "style" || ''
+        attribute_value("style") || ''
       end
     end
 
@@ -197,5 +212,14 @@ module Watir
       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

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

@@ -12,18 +12,35 @@ module Watir
     #
     # Set the file field to the given path
     #
-    # @param [String] a value
+    # @param [String] a path
     #
+    # @raise [Errno::ENOENT] if the file doesn't exist
+    #
+
+    def set(path)
+      raise Errno::ENOENT, path unless File.exist?(path)
+      self.value = path
+    end
 
-    def set(value)
+    #
+    # Set the file field to the given path
+    #
+    # @param [String] a path
+    #
+    def value=(path)
       assert_exists
-      value.gsub!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
-      @element.send_keys value
+      path = path.gsub(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+      @element.send_keys path
     end
 
     #
     # Return the value of this field
     #
+    # In IE, the path returned depends on the "Include local directory path
+    # when uploading files to a server" security setting:
+    #
+    # @see http://msdn.microsoft.com/en-us/library/ms535128(VS.85).aspx
+    #
     # @return [String]
     #
 

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

@@ -55,7 +55,7 @@ module Watir
     end
 
     def locate_frame
-      loc = VALID_LOCATORS.find { |loc| @selector[loc] }
+      loc = VALID_LOCATORS.find { |loc| @selector.has_key? loc }
 
       unless loc
         raise MissingWayOfFindingObjectException, "can only locate frames by #{VALID_LOCATORS.inspect}"

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

@@ -20,6 +20,16 @@ module Watir
 
 
 
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -32,23 +42,39 @@ module Watir
 
 
  class HTMLElement < Element
-   attributes(:token_list => ([:class_list, :item_ref, :item_prop]), :style => ([:style]), :string_map => ([:dataset]), :string => ([:innerhtml, :outerhtml, :id, :title, :lang, :dir, :class_name, :item_type, :item_id, :item_value, :access_key, :access_key_label, :content_editable, :command_type, :label, :icon]), :properties_collection => ([:properties]), :int => ([:tab_index]), :html_element => ([:context_menu]), :function => ([:onabort, :onblur, :oncanplay, :oncanplaythrough, :onchange, :onclick, :oncontextmenu, :oncuechange, :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]), :bool => ([:item_scope, :hidden, :draggable, :is_content_editable, :spellcheck, :disabled, :checked]))
+   attributes(:string => [:innerhtml, :outerhtml, :id, :title, :lang, :dir, :class_name, :item_type, :item_id, :item_value, :access_key, :access_key_label, :content_editable, :command_type, :label, :icon], :token_list => [:class_list, :item_ref, :item_prop], :string_map => [:dataset], :bool => [:item_scope, :hidden, :draggable, :is_content_editable, :spellcheck, :disabled, :checked], :properties_collection => [:properties], :int => [:tab_index], :html_element => [:context_menu], :style => [:style], :function => [:onabort, :onblur, :oncanplay, :oncanplaythrough, :onchange, :onclick, :oncontextmenu, :oncuechange, :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])
  end
  class HTMLElementCollection < ElementCollection
    def element_class
      HTMLElement
    end
  end
+ class Font < HTMLElement
+   attributes(:string => [:color, :face, :size])
+ end
+ class FontCollection < ElementCollection
+   def element_class
+     Font
+   end
+ end
  class Directory < HTMLElement
-   attributes(:bool => ([:compact]))
+   attributes(:bool => [:compact])
  end
  class DirectoryCollection < ElementCollection
    def element_class
      Directory
    end
  end
+ class BaseFont < HTMLElement
+   attributes(:string => [:color, :face], :int => [:size])
+ end
+ class BaseFontCollection < ElementCollection
+   def element_class
+     BaseFont
+   end
+ end
  class Frame < HTMLElement
-   attributes(:string => ([:frame_border, :long_desc, :margin_height, :margin_width, :name, :scrolling, :src]), :bool => ([:no_resize]), :document => ([:content_document]))
+   attributes(:string => [:frame_border, :long_desc, :margin_height, :margin_width, :name, :scrolling, :src], :bool => [:no_resize], :document => [:content_document])
  end
  class FrameCollection < ElementCollection
    def element_class
@@ -56,23 +82,39 @@ module Watir
    end
  end
  class FrameSet < HTMLElement
-   attributes(:string => ([:cols, :rows]), :function => ([:onafterprint, :onbeforeprint, :onbeforeunload, :onblur, :onerror, :onfocus, :onhashchange, :onload, :onmessage, :onoffline, :ononline, :onpagehide, :onpageshow, :onpopstate, :onredo, :onresize, :onstorage, :onundo, :onunload]))
+   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 FrameSetCollection < ElementCollection
    def element_class
      FrameSet
    end
  end
+ class Marquee < HTMLElement
+   attributes(:string => [:behavior, :bg_color, :direction, :height, :true_speed, :width], :int => [:hspace, :loop, :scroll_amount, :scroll_delay, :vspace], :function => [:onbounce, :onfinish, :onstart])
+ end
+ class MarqueeCollection < ElementCollection
+   def element_class
+     Marquee
+   end
+ end
  class Applet < HTMLElement
-   attributes(:string => ([:align, :alt, :archive, :code, :code_base, :height, :name, :object, :width]), :int => ([:hspace, :vspace]))
+   attributes(:string => [:align, :alt, :archive, :code, :code_base, :height, :name, :object, :width], :int => [:hspace, :vspace])
  end
  class AppletCollection < ElementCollection
    def element_class
      Applet
    end
  end
+ class Device < HTMLElement
+   attributes(:string => [:type, :data])
+ end
+ class DeviceCollection < ElementCollection
+   def element_class
+     Device
+   end
+ end
  class Menu < HTMLElement
-   attributes(:string => ([:type, :label]))
+   attributes(:string => [:type, :label])
  end
  class MenuCollection < ElementCollection
    def element_class
@@ -80,19 +122,27 @@ module Watir
    end
  end
  class Menu < HTMLElement
-   attributes(:bool => ([:compact]))
+   attributes(:bool => [:compact])
  end
  # do nothing
  class Command < HTMLElement
-   attributes(:string => ([:type, :label, :icon, :radiogroup]), :bool => ([:disabled, :checked]))
+   attributes(:string => [:type, :label, :icon, :radiogroup], :bool => [:disabled, :checked])
  end
  class CommandCollection < ElementCollection
    def element_class
      Command
    end
  end
+ class Details < HTMLElement
+   attributes(:bool => [:open])
+ end
+ class DetailsCollection < ElementCollection
+   def element_class
+     Details
+   end
+ end
  class Meter < HTMLElement
-   attributes(:float => ([:value, :min, :max, :low, :high, :optimum]), :list => ([:labels]), :html_element => ([:form]))
+   attributes(:float => [:value, :min, :max, :low, :high, :optimum], :html_element => [:form], :list => [:labels])
  end
  class MeterCollection < ElementCollection
    def element_class
@@ -100,15 +150,23 @@ module Watir
    end
  end
  class Progress < HTMLElement
-   attributes(:float => ([:value, :max, :position]), :list => ([:labels]), :html_element => ([:form]))
+   attributes(:float => [:value, :max, :position], :html_element => [:form], :list => [:labels])
  end
  class ProgressCollection < ElementCollection
    def element_class
      Progress
    end
  end
+ class Output < HTMLElement
+   attributes(:token_list => [:html_for], :html_element => [:form], :string => [:name, :type, :default_value, :value, :validity, :validation_message], :bool => [:will_validate], :list => [:labels])
+ end
+ class OutputCollection < ElementCollection
+   def element_class
+     Output
+   end
+ end
  class Keygen < HTMLElement
-   attributes(:string => ([:challenge, :keytype, :name, :type, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :will_validate]))
+   attributes(:bool => [:autofocus, :disabled, :will_validate], :string => [:challenge, :keytype, :name, :type, :validity, :validation_message], :html_element => [:form], :list => [:labels])
  end
  class KeygenCollection < ElementCollection
    def element_class
@@ -116,7 +174,7 @@ module Watir
    end
  end
  class TextArea < HTMLElement
-   attributes(:string => ([:name, :placeholder, :wrap, :type, :default_value, :value, :validity, :validation_message]), :int => ([:cols, :max_length, :rows, :text_length, :selection_start, :selection_end]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :read_only, :required, :will_validate]))
+   attributes(:bool => [:autofocus, :disabled, :read_only, :required, :will_validate], :int => [:cols, :max_length, :rows, :text_length, :selection_start, :selection_end], :html_element => [:form], :string => [:name, :placeholder, :wrap, :type, :default_value, :value, :validity, :validation_message], :list => [:labels])
  end
  class TextAreaCollection < ElementCollection
    def element_class
@@ -124,23 +182,47 @@ module Watir
    end
  end
  class Option < HTMLElement
-   attributes(:string => ([:label, :value, :text]), :int => ([:index]), :html_element => ([:form]), :bool => ([:disabled, :default_selected, :selected]))
+   attributes(:bool => [:disabled, :default_selected, :selected], :html_element => [:form], :string => [:label, :value, :text], :int => [:index])
  end
  class OptionCollection < ElementCollection
    def element_class
      Option
    end
  end
+ class OptGroup < HTMLElement
+   attributes(:bool => [:disabled], :string => [:label])
+ end
+ class OptGroupCollection < ElementCollection
+   def element_class
+     OptGroup
+   end
+ end
  class DataList < HTMLElement
-   attributes(:html_collection => ([:options]))
+   attributes(:html_collection => [:options])
  end
  class DataListCollection < ElementCollection
    def element_class
      DataList
    end
  end
+ class Select < HTMLElement
+   attributes(:bool => [:autofocus, :disabled, :multiple, :required, :will_validate], :html_element => [:form], :string => [:name, :type, :value, :validity, :validation_message], :int => [:size, :length, :selected_index], :html_collection => [:options, :selected_options], :list => [:labels])
+ end
+ class SelectCollection < ElementCollection
+   def element_class
+     Select
+   end
+ end
+ class Button < HTMLElement
+   attributes(:bool => [:autofocus, :disabled, :will_validate], :html_element => [:form], :string => [:form_action, :form_enctype, :form_method, :form_no_validate, :form_target, :name, :type, :value, :validity, :validation_message], :list => [:labels])
+ end
+ class ButtonCollection < ElementCollection
+   def element_class
+     Button
+   end
+ end
  class Input < HTMLElement
-   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]), :float => ([:value_as_number]), :int => ([:max_length, :size, :selection_start, :selection_end]), :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]), :date => ([:value_as_date]))
+   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], :bool => [:autofocus, :default_checked, :checked, :disabled, :form_no_validate, :indeterminate, :multiple, :read_only, :required, :will_validate], :html_element => [:form, :list, :selected_option], :list => [:files, :labels], :int => [:max_length, :size, :selection_start, :selection_end], :date => [:value_as_date], :float => [:value_as_number])
  end
  class InputCollection < ElementCollection
    def element_class
@@ -148,11 +230,11 @@ module Watir
    end
  end
  class Input < HTMLElement
-   attributes(:string => ([:align, :use_map]))
+   attributes(:string => [:align, :use_map])
  end
  # do nothing
  class Label < HTMLElement
-   attributes(:string => ([:html_for]), :html_element => ([:form, :control]))
+   attributes(:html_element => [:form, :control], :string => [:html_for])
  end
  class LabelCollection < ElementCollection
    def element_class
@@ -160,7 +242,7 @@ module Watir
    end
  end
  class Legend < HTMLElement
-   attributes(:html_element => ([:form]))
+   attributes(:html_element => [:form])
  end
  class LegendCollection < ElementCollection
    def element_class
@@ -168,19 +250,55 @@ module Watir
    end
  end
  class Legend < HTMLElement
-   attributes(:string => ([:align]))
+   attributes(:string => [:align])
  end
  # do nothing
+ class FieldSet < HTMLElement
+   attributes(:bool => [:disabled, :will_validate], :html_element => [:form], :string => [:name, :type, :validity, :validation_message], :html_collection => [:elements])
+ end
+ class FieldSetCollection < ElementCollection
+   def element_class
+     FieldSet
+   end
+ end
  class Form < HTMLElement
-   attributes(:string => ([:accept_charset, :action, :autocomplete, :enctype, :method, :name, :target]), :int => ([:length]), :html_collection => ([:elements]), :bool => ([:no_validate]))
+   attributes(:string => [:accept_charset, :action, :autocomplete, :enctype, :method, :name, :target], :bool => [:no_validate], :html_collection => [:elements], :int => [:length])
  end
  class FormCollection < ElementCollection
    def element_class
      Form
    end
  end
+ class TableCell < HTMLElement
+   attributes(:int => [:col_span, :row_span, :cell_index], :token_list => [:headers])
+ end
+ class TableCellCollection < ElementCollection
+   def element_class
+     TableCell
+   end
+ end
+ class TableCell < HTMLElement
+   attributes(:string => [:abbr, :align, :axis, :bg_color, :ch, :ch_off, :height, :v_align, :width], :bool => [:no_wrap])
+ end
+ # do nothing
+ class TableHeaderCell < TableCell
+   attributes(:string => [:scope])
+ end
+ class TableHeaderCellCollection < ElementCollection
+   def element_class
+     TableHeaderCell
+   end
+ end
+ class TableDataCell < TableCell
+   # do nothing
+ end
+ class TableDataCellCollection < ElementCollection
+   def element_class
+     TableDataCell
+   end
+ end
  class TableRow < HTMLElement
-   attributes(:int => ([:row_index, :section_row_index]), :html_collection => ([:cells]))
+   attributes(:int => [:row_index, :section_row_index], :html_collection => [:cells])
  end
  class TableRowCollection < ElementCollection
    def element_class
@@ -188,11 +306,11 @@ module Watir
    end
  end
  class TableRow < HTMLElement
-   attributes(:string => ([:align, :bg_color, :ch, :ch_off, :v_align]))
+   attributes(:string => [:align, :bg_color, :ch, :ch_off, :v_align])
  end
  # do nothing
  class TableSection < HTMLElement
-   attributes(:html_collection => ([:rows]))
+   attributes(:html_collection => [:rows])
  end
  class TableSectionCollection < ElementCollection
    def element_class
@@ -200,11 +318,11 @@ module Watir
    end
  end
  class TableSection < HTMLElement
-   attributes(:string => ([:align, :ch, :ch_off, :v_align]))
+   attributes(:string => [:align, :ch, :ch_off, :v_align])
  end
  # do nothing
  class TableCol < HTMLElement
-   attributes(:int => ([:span]))
+   attributes(:int => [:span])
  end
  class TableColCollection < ElementCollection
    def element_class
@@ -212,11 +330,23 @@ module Watir
    end
  end
  class TableCol < HTMLElement
-   attributes(:string => ([:align, :ch, :ch_off, :v_align, :width]))
+   attributes(:string => [:align, :ch, :ch_off, :v_align, :width])
+ end
+ # do nothing
+ class TableCaption < HTMLElement
+   # do nothing
+ end
+ class TableCaptionCollection < ElementCollection
+   def element_class
+     TableCaption
+   end
+ end
+ class TableCaption < HTMLElement
+   attributes(:string => [:align])
  end
  # do nothing
  class Table < HTMLElement
-   attributes(:string => ([:summary]), :html_element => ([:caption, :t_head, :t_foot]), :html_collection => ([:t_bodies, :rows]))
+   attributes(:html_element => [:caption, :t_head, :t_foot], :html_collection => [:t_bodies, :rows], :string => [:summary])
  end
  class TableCollection < ElementCollection
    def element_class
@@ -224,19 +354,39 @@ module Watir
    end
  end
  class Table < HTMLElement
-   attributes(:string => ([:align, :bg_color, :border, :cell_padding, :cell_spacing, :frame, :rules, :width]))
+   attributes(:string => [:align, :bg_color, :border, :cell_padding, :cell_spacing, :frame, :rules, :width])
+ end
+ # do nothing
+ class Area < HTMLElement
+   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 AreaCollection < ElementCollection
+   def element_class
+     Area
+   end
+ end
+ class Area < HTMLElement
+   attributes(:bool => [:no_href])
  end
  # do nothing
  class Map < HTMLElement
-   attributes(:string => ([:name]), :html_collection => ([:areas, :images]))
+   attributes(:string => [:name], :html_collection => [:areas, :images])
  end
  class MapCollection < ElementCollection
    def element_class
      Map
    end
  end
+ class Canvas < HTMLElement
+   attributes(:int => [:width, :height])
+ end
+ class CanvasCollection < ElementCollection
+   def element_class
+     Canvas
+   end
+ end
  class Media < HTMLElement
-   attributes(:string => ([:error, :src, :current_src, :preload, :buffered, :played, :seekable, :tracks]), :float => ([:current_time, :initial_time, :duration, :default_playback_rate, :playback_rate, :volume]), :int => ([:network_state, :ready_state]), :bool => ([:seeking, :paused, :ended, :autoplay, :loop, :controls, :muted]), :date => ([:start_offset_time]))
+   attributes(:string => [:error, :src, :current_src, :preload, :buffered, :played, :seekable, :tracks], :int => [:network_state, :ready_state], :bool => [:seeking, :paused, :ended, :autoplay, :loop, :controls, :muted], :float => [:current_time, :initial_time, :duration, :default_playback_rate, :playback_rate, :volume], :date => [:start_offset_time])
  end
  class MediaCollection < ElementCollection
    def element_class
@@ -252,15 +402,23 @@ module Watir
    end
  end
  class Video < Media
-   attributes(:string => ([:width, :height, :poster]), :int => ([:video_width, :video_height]))
+   attributes(:string => [:width, :height, :poster], :int => [:video_width, :video_height])
  end
  class VideoCollection < ElementCollection
    def element_class
      Video
    end
  end
+ class Track < HTMLElement
+   attributes(:string => [:kind, :label, :src, :srclang, :track])
+ end
+ class TrackCollection < ElementCollection
+   def element_class
+     Track
+   end
+ end
  class Source < HTMLElement
-   attributes(:string => ([:src, :type, :media]))
+   attributes(:string => [:src, :type, :media])
  end
  class SourceCollection < ElementCollection
    def element_class
@@ -268,7 +426,7 @@ module Watir
    end
  end
  class Param < HTMLElement
-   attributes(:string => ([:name, :value]))
+   attributes(:string => [:name, :value])
  end
  class ParamCollection < ElementCollection
    def element_class
@@ -276,11 +434,11 @@ module Watir
    end
  end
  class Param < HTMLElement
-   attributes(:string => ([:type, :value_type]))
+   attributes(:string => [:type, :value_type])
  end
  # do nothing
  class Object < HTMLElement
-   attributes(:string => ([:data, :type, :name, :use_map, :width, :height, :content_window, :validity, :validation_message]), :html_element => ([:form]), :bool => ([:will_validate]), :document => ([:content_document]))
+   attributes(:string => [:data, :type, :name, :use_map, :width, :height, :content_window, :validity, :validation_message], :html_element => [:form], :document => [:content_document], :bool => [:will_validate])
  end
  class ObjectCollection < ElementCollection
    def element_class
@@ -288,11 +446,23 @@ module Watir
    end
  end
  class Object < HTMLElement
-   attributes(:string => ([:align, :archive, :border, :code, :code_base, :code_type, :standby]), :int => ([:hspace, :vspace]), :bool => ([:declare]))
+   attributes(:string => [:align, :archive, :border, :code, :code_base, :code_type, :standby], :bool => [:declare], :int => [:hspace, :vspace])
+ end
+ # do nothing
+ class Embed < HTMLElement
+   attributes(:string => [:src, :type, :width, :height])
+ end
+ class EmbedCollection < ElementCollection
+   def element_class
+     Embed
+   end
+ end
+ class Embed < HTMLElement
+   attributes(:string => [:align, :name])
  end
  # do nothing
  class IFrame < HTMLElement
-   attributes(:token_list => ([:sandbox]), :string => ([:src, :srcdoc, :name, :width, :height, :content_window]), :bool => ([:seamless]), :document => ([:content_document]))
+   attributes(:string => [:src, :srcdoc, :name, :width, :height, :content_window], :token_list => [:sandbox], :bool => [:seamless], :document => [:content_document])
  end
  class IFrameCollection < ElementCollection
    def element_class
@@ -300,11 +470,11 @@ module Watir
    end
  end
  class IFrame < HTMLElement
-   attributes(:string => ([:align, :frame_border, :long_desc, :margin_height, :margin_width, :scrolling]))
+   attributes(:string => [:align, :frame_border, :long_desc, :margin_height, :margin_width, :scrolling])
  end
  # do nothing
  class Image < HTMLElement
-   attributes(:string => ([:alt, :src, :use_map]), :int => ([:width, :height, :natural_width, :natural_height]), :bool => ([:is_map, :complete]))
+   attributes(:string => [:alt, :src, :use_map], :bool => [:is_map, :complete], :int => [:width, :height, :natural_width, :natural_height])
  end
  class ImageCollection < ElementCollection
    def element_class
@@ -312,11 +482,11 @@ module Watir
    end
  end
  class Image < HTMLElement
-   attributes(:string => ([:name, :align, :border, :long_desc]), :int => ([:hspace, :vspace]))
+   attributes(:string => [:name, :align, :border, :long_desc], :int => [:hspace, :vspace])
  end
  # do nothing
  class Mod < HTMLElement
-   attributes(:string => ([:cite, :date_time]))
+   attributes(:string => [:cite, :date_time])
  end
  class ModCollection < ElementCollection
    def element_class
@@ -332,7 +502,7 @@ module Watir
    end
  end
  class BR < HTMLElement
-   attributes(:string => ([:clear]))
+   attributes(:string => [:clear])
  end
  # do nothing
  class Span < HTMLElement
@@ -343,205 +513,62 @@ module Watir
      Span
    end
  end
- class Anchor < HTMLElement
-   attributes(:token_list => ([:rel_list]), :string => ([:href, :target, :ping, :rel, :media, :hreflang, :type, :text, :protocol, :host, :hostname, :port, :pathname, :search, :hash]))
+ class Time < HTMLElement
+   attributes(:string => [:date_time], :bool => [:pub_date], :date => [:value_as_date])
  end
- class AnchorCollection < ElementCollection
+ class TimeCollection < ElementCollection
    def element_class
-     Anchor
+     Time
    end
  end
  class Anchor < HTMLElement
-   attributes(:string => ([:coords, :charset, :name, :rev, :shape]))
- end
- # do nothing
- class DList < HTMLElement
-   # do nothing
+   attributes(:string => [:href, :target, :ping, :rel, :media, :hreflang, :type, :text, :protocol, :host, :hostname, :port, :pathname, :search, :hash], :token_list => [:rel_list])
  end
- class DListCollection < ElementCollection
-   def element_class
-     DList
-   end
- end
- class DList < HTMLElement
-   attributes(:bool => ([:compact]))
- end
- # do nothing
- class LI < HTMLElement
-   attributes(:int => ([:value]))
- end
- class LICollection < ElementCollection
-   def element_class
-     LI
-   end
- end
- class LI < HTMLElement
-   attributes(:string => ([:type]))
- end
- # do nothing
- class Pre < HTMLElement
-   # do nothing
- end
- class PreCollection < ElementCollection
-   def element_class
-     Pre
-   end
- end
- class Pre < HTMLElement
-   attributes(:int => ([:width]))
- end
- # do nothing
- class HR < HTMLElement
-   # do nothing
- end
- class HRCollection < ElementCollection
+ class AnchorCollection < ElementCollection
    def element_class
-     HR
+     Anchor
    end
  end
- class HR < HTMLElement
-   attributes(:string => ([:align, :color, :size, :width]), :bool => ([:no_shade]))
+ class Anchor < HTMLElement
+   attributes(:string => [:coords, :charset, :name, :rev, :shape])
  end
  # do nothing
- class Paragraph < HTMLElement
+ class Div < HTMLElement
    # do nothing
  end
- class ParagraphCollection < ElementCollection
+ class DivCollection < ElementCollection
    def element_class
-     Paragraph
+     Div
    end
  end
- class Paragraph < HTMLElement
-   attributes(:string => ([:align]))
+ class Div < HTMLElement
+   attributes(:string => [:align])
  end
  # do nothing
- class Heading < HTMLElement
+ class DList < HTMLElement
    # do nothing
  end
- class HeadingCollection < ElementCollection
-   def element_class
-     Heading
-   end
- end
- class Heading < HTMLElement
-   attributes(:string => ([:align]))
- end
- # do nothing
- class Body < HTMLElement
-   attributes(:function => ([:onafterprint, :onbeforeprint, :onbeforeunload, :onblur, :onerror, :onfocus, :onhashchange, :onload, :onmessage, :onoffline, :ononline, :onpopstate, :onpagehide, :onpageshow, :onredo, :onresize, :onstorage, :onundo, :onunload]))
- end
- class BodyCollection < ElementCollection
-   def element_class
-     Body
-   end
- end
- class Body < HTMLElement
-   attributes(:string => ([:text, :bg_color, :background, :link, :v_link, :a_link]))
- end
- # do nothing
- class Script < HTMLElement
-   attributes(:string => ([:src, :type, :charset, :text]), :bool => ([:async, :defer]))
- end
- class ScriptCollection < ElementCollection
-   def element_class
-     Script
-   end
- end
- class Script < HTMLElement
-   attributes(:string => ([:event, :html_for]))
- end
- # do nothing
- class Style < HTMLElement
-   attributes(:string => ([:media, :type]), :bool => ([:disabled, :scoped]))
- end
- class StyleCollection < ElementCollection
-   def element_class
-     Style
-   end
- end
- class Meta < HTMLElement
-   attributes(:string => ([:name, :http_equiv, :content]))
- end
- class MetaCollection < ElementCollection
+ class DListCollection < ElementCollection
    def element_class
-     Meta
+     DList
    end
  end
- class Meta < HTMLElement
-   attributes(:string => ([:scheme]))
+ class DList < HTMLElement
+   attributes(:bool => [:compact])
  end
  # do nothing
- class Base < HTMLElement
-   attributes(:string => ([:href, :target]))
- end
- class BaseCollection < ElementCollection
-   def element_class
-     Base
-   end
- end
- class Head < HTMLElement
-   # do nothing
- end
- class HeadCollection < ElementCollection
-   def element_class
-     Head
-   end
- end
-
- class Time < HTMLElement
-   attributes(:string => ([:date_time]), :bool => ([:pub_date]), :date => ([:value_as_date]))
- end
- class TimeCollection < ElementCollection
-   def element_class
-     Time
-   end
- end
-
-
-
-
- class Marquee < HTMLElement
-   attributes(:string => ([:behavior, :bg_color, :direction, :height, :true_speed, :width]), :int => ([:hspace, :loop, :scroll_amount, :scroll_delay, :vspace]), :function => ([:onbounce, :onfinish, :onstart]))
- end
- class MarqueeCollection < ElementCollection
-   def element_class
-     Marquee
-   end
- end
- class Font < HTMLElement
-   attributes(:string => ([:color, :face, :size]))
- end
- class FontCollection < ElementCollection
-   def element_class
-     Font
-   end
- end
- class TableCaption < HTMLElement
-   # do nothing
+ class LI < HTMLElement
+   attributes(:int => [:value])
  end
- class TableCaptionCollection < ElementCollection
+ class LICollection < ElementCollection
    def element_class
-     TableCaption
+     LI
    end
  end
- class TableCaption < HTMLElement
-   attributes(:string => ([:align]))
+ class LI < HTMLElement
+   attributes(:string => [:type])
  end
  # do nothing
-
-
-
-
-
-
- class Select < HTMLElement
-   attributes(:string => ([:name, :type, :value, :validity, :validation_message]), :int => ([:size, :length, :selected_index]), :list => ([:labels]), :html_element => ([:form]), :html_collection => ([:options, :selected_options]), :bool => ([:autofocus, :disabled, :multiple, :required, :will_validate]))
- end
- class SelectCollection < ElementCollection
-   def element_class
-     Select
-   end
- end
  class UList < HTMLElement
    # do nothing
  end
@@ -551,1974 +578,1947 @@ module Watir
    end
  end
  class UList < HTMLElement
-   attributes(:string => ([:type]), :bool => ([:compact]))
+   attributes(:bool => [:compact], :string => [:type])
  end
  # do nothing
-
- class OptGroup < HTMLElement
-   attributes(:string => ([:label]), :bool => ([:disabled]))
- end
- class OptGroupCollection < ElementCollection
-   def element_class
-     OptGroup
-   end
- end
- class Canvas < HTMLElement
-   attributes(:int => ([:width, :height]))
- end
- class CanvasCollection < ElementCollection
-   def element_class
-     Canvas
-   end
- end
- class TableCell < HTMLElement
-   attributes(:token_list => ([:headers]), :int => ([:col_span, :row_span, :cell_index]))
+ class OList < HTMLElement
+   attributes(:bool => [:reversed], :int => [:start])
  end
- class TableCellCollection < ElementCollection
+ class OListCollection < ElementCollection
    def element_class
-     TableCell
+     OList
    end
  end
- class TableCell < HTMLElement
-   attributes(:string => ([:abbr, :align, :axis, :bg_color, :ch, :ch_off, :height, :v_align, :width]), :bool => ([:no_wrap]))
+ class OList < HTMLElement
+   attributes(:bool => [:compact], :string => [:type])
  end
  # do nothing
- class TableHeaderCell < TableCell
-   attributes(:string => ([:scope]))
- end
- class TableHeaderCellCollection < ElementCollection
-   def element_class
-     TableHeaderCell
-   end
- end
- class TableDataCell < TableCell
-   # do nothing
- end
- class TableDataCellCollection < ElementCollection
-   def element_class
-     TableDataCell
-   end
- end
  class Quote < HTMLElement
-   attributes(:string => ([:cite]))
+   attributes(:string => [:cite])
  end
  class QuoteCollection < ElementCollection
    def element_class
      Quote
    end
  end
- class Div < HTMLElement
+ class Pre < HTMLElement
    # do nothing
  end
- class DivCollection < ElementCollection
+ class PreCollection < ElementCollection
    def element_class
-     Div
+     Pre
    end
  end
- class Div < HTMLElement
-   attributes(:string => ([:align]))
+ class Pre < HTMLElement
+   attributes(:int => [:width])
  end
  # do nothing
-
- class Device < HTMLElement
-   attributes(:string => ([:type, :data]))
- end
- class DeviceCollection < ElementCollection
-   def element_class
-     Device
-   end
- end
-
-
- class Output < HTMLElement
-   attributes(:token_list => ([:html_for]), :string => ([:name, :type, :default_value, :value, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:will_validate]))
+ class HR < HTMLElement
+   # do nothing
  end
- class OutputCollection < ElementCollection
+ class HRCollection < ElementCollection
    def element_class
-     Output
+     HR
    end
  end
- class Track < HTMLElement
-   attributes(:string => ([:kind, :label, :src, :srclang, :track]))
- end
- class TrackCollection < ElementCollection
-   def element_class
-     Track
-   end
+ class HR < HTMLElement
+   attributes(:string => [:align, :color, :size, :width], :bool => [:no_shade])
  end
-
-
- class Embed < HTMLElement
-   attributes(:string => ([:src, :type, :width, :height]))
+ # do nothing
+ class Paragraph < HTMLElement
+   # do nothing
  end
- class EmbedCollection < ElementCollection
+ class ParagraphCollection < ElementCollection
    def element_class
-     Embed
+     Paragraph
    end
  end
- class Embed < HTMLElement
-   attributes(:string => ([:align, :name]))
+ class Paragraph < HTMLElement
+   attributes(:string => [:align])
  end
  # do nothing
-
-
-
- class Area < HTMLElement
-   attributes(:token_list => ([:rel_list]), :string => ([:alt, :coords, :shape, :href, :target, :ping, :rel, :media, :hreflang, :type, :protocol, :host, :hostname, :port, :pathname, :search, :hash]))
+ class Heading < HTMLElement
+   # do nothing
  end
- class AreaCollection < ElementCollection
+ class HeadingCollection < ElementCollection
    def element_class
-     Area
+     Heading
    end
  end
- class Area < HTMLElement
-   attributes(:bool => ([:no_href]))
+ class Heading < HTMLElement
+   attributes(:string => [:align])
  end
  # do nothing
-
- class OList < HTMLElement
-   attributes(:int => ([:start]), :bool => ([:reversed]))
+ class Body < HTMLElement
+   attributes(:function => [:onafterprint, :onbeforeprint, :onbeforeunload, :onblur, :onerror, :onfocus, :onhashchange, :onload, :onmessage, :onoffline, :ononline, :onpopstate, :onpagehide, :onpageshow, :onredo, :onresize, :onstorage, :onundo, :onunload])
  end
- class OListCollection < ElementCollection
+ class BodyCollection < ElementCollection
    def element_class
-     OList
+     Body
    end
  end
- class OList < HTMLElement
-   attributes(:string => ([:type]), :bool => ([:compact]))
+ class Body < HTMLElement
+   attributes(:string => [:text, :bg_color, :background, :link, :v_link, :a_link])
  end
  # do nothing
-
- class Unknown < HTMLElement
-   # do nothing
+ class Script < HTMLElement
+   attributes(:string => [:src, :type, :charset, :text], :bool => [:async, :defer])
  end
- class UnknownCollection < ElementCollection
+ class ScriptCollection < ElementCollection
    def element_class
-     Unknown
+     Script
    end
  end
- class Button < HTMLElement
-   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]))
+ class Script < HTMLElement
+   attributes(:string => [:event, :html_for])
  end
- class ButtonCollection < ElementCollection
+ # do nothing
+ class Style < HTMLElement
+   attributes(:bool => [:disabled, :scoped], :string => [:media, :type])
+ end
+ class StyleCollection < ElementCollection
    def element_class
-     Button
+     Style
    end
  end
- class Html < HTMLElement
-   # do nothing
+ class Meta < HTMLElement
+   attributes(:string => [:name, :http_equiv, :content])
  end
- class HtmlCollection < ElementCollection
+ class MetaCollection < ElementCollection
    def element_class
-     Html
+     Meta
    end
  end
- class Html < HTMLElement
-   attributes(:string => ([:version]))
+ class Meta < HTMLElement
+   attributes(:string => [:scheme])
  end
  # do nothing
+ class Base < HTMLElement
+   attributes(:string => [:href, :target])
+ end
+ class BaseCollection < ElementCollection
+   def element_class
+     Base
+   end
+ end
  class Title < HTMLElement
-   attributes(:string => ([:text]))
+   attributes(:string => [:text])
  end
  class TitleCollection < ElementCollection
    def element_class
      Title
    end
  end
- class FieldSet < HTMLElement
-   attributes(:string => ([:name, :type, :validity, :validation_message]), :html_element => ([:form]), :html_collection => ([:elements]), :bool => ([:disabled, :will_validate]))
+ class Head < HTMLElement
+   # do nothing
  end
- class FieldSetCollection < ElementCollection
+ class HeadCollection < ElementCollection
    def element_class
-     FieldSet
+     Head
    end
  end
- class Details < HTMLElement
-   attributes(:bool => ([:open]))
+ class Html < HTMLElement
+   # do nothing
  end
- class DetailsCollection < ElementCollection
+ class HtmlCollection < ElementCollection
    def element_class
-     Details
+     Html
    end
  end
-
-
- class BaseFont < HTMLElement
-   attributes(:string => ([:color, :face]), :int => ([:size]))
+ class Html < HTMLElement
+   attributes(:string => [:version])
  end
- class BaseFontCollection < ElementCollection
+ # do nothing
+ class Unknown < HTMLElement
+   # do nothing
+ end
+ class UnknownCollection < ElementCollection
    def element_class
-     BaseFont
+     Unknown
    end
  end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
  module Container
    #
    # @return [Anchor]
    #
-   
+
    def a(*args)
      Anchor.new(self, extract_selector(args).merge(:tag_name => "a"))
    end
-   
+
    #
    # @return [AnchorCollection]
    #
-   
+
    def as(*args)
      AnchorCollection.new(self, extract_selector(args).merge(:tag_name => "a"))
    end
-   
+
    Watir.tag_to_class[:a] = Anchor
    #
    # @return [HTMLElement]
    #
-   
+
    def abbr(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "abbr"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def abbrs(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "abbr"))
    end
-   
+
    Watir.tag_to_class[:abbr] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def address(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "address"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def addresses(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "address"))
    end
-   
+
    Watir.tag_to_class[:address] = HTMLElement
    #
    # @return [Area]
    #
-   
+
    def area(*args)
      Area.new(self, extract_selector(args).merge(:tag_name => "area"))
    end
-   
+
    #
    # @return [AreaCollection]
    #
-   
+
    def areas(*args)
      AreaCollection.new(self, extract_selector(args).merge(:tag_name => "area"))
    end
-   
+
    Watir.tag_to_class[:area] = Area
    #
    # @return [HTMLElement]
    #
-   
+
    def article(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "article"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def articles(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "article"))
    end
-   
+
    Watir.tag_to_class[:article] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def aside(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "aside"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def asides(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "aside"))
    end
-   
+
    Watir.tag_to_class[:aside] = HTMLElement
    #
    # @return [Audio]
    #
-   
+
    def audio(*args)
      Audio.new(self, extract_selector(args).merge(:tag_name => "audio"))
    end
-   
+
    #
    # @return [AudioCollection]
    #
-   
+
    def audios(*args)
      AudioCollection.new(self, extract_selector(args).merge(:tag_name => "audio"))
    end
-   
+
    Watir.tag_to_class[:audio] = Audio
    #
    # @return [HTMLElement]
    #
-   
+
    def b(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "b"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def bs(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "b"))
    end
-   
+
    Watir.tag_to_class[:b] = HTMLElement
    #
    # @return [Base]
    #
-   
+
    def base(*args)
      Base.new(self, extract_selector(args).merge(:tag_name => "base"))
    end
-   
+
    #
    # @return [BaseCollection]
    #
-   
+
    def bases(*args)
      BaseCollection.new(self, extract_selector(args).merge(:tag_name => "base"))
    end
-   
+
    Watir.tag_to_class[:base] = Base
    #
    # @return [HTMLElement]
    #
-   
+
    def bdo(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "bdo"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def bdos(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "bdo"))
    end
-   
+
    Watir.tag_to_class[:bdo] = HTMLElement
    #
    # @return [Quote]
    #
-   
+
    def blockquote(*args)
      Quote.new(self, extract_selector(args).merge(:tag_name => "blockquote"))
    end
-   
+
    #
    # @return [QuoteCollection]
    #
-   
+
    def blockquotes(*args)
      QuoteCollection.new(self, extract_selector(args).merge(:tag_name => "blockquote"))
    end
-   
+
    Watir.tag_to_class[:blockquote] = Quote
    #
    # @return [Body]
    #
-   
+
    def body(*args)
      Body.new(self, extract_selector(args).merge(:tag_name => "body"))
    end
-   
+
    #
    # @return [BodyCollection]
    #
-   
+
    def bodys(*args)
      BodyCollection.new(self, extract_selector(args).merge(:tag_name => "body"))
    end
-   
+
    Watir.tag_to_class[:body] = Body
    #
    # @return [BR]
    #
-   
+
    def br(*args)
      BR.new(self, extract_selector(args).merge(:tag_name => "br"))
    end
-   
+
    #
    # @return [BRCollection]
    #
-   
+
    def brs(*args)
      BRCollection.new(self, extract_selector(args).merge(:tag_name => "br"))
    end
-   
+
    Watir.tag_to_class[:br] = BR
    #
    # @return [Button]
    #
-   
+
    def button(*args)
      Button.new(self, extract_selector(args).merge(:tag_name => "button"))
    end
-   
+
    #
    # @return [ButtonCollection]
    #
-   
+
    def buttons(*args)
      ButtonCollection.new(self, extract_selector(args).merge(:tag_name => "button"))
    end
-   
+
    Watir.tag_to_class[:button] = Button
    #
    # @return [Canvas]
    #
-   
+
    def canvas(*args)
      Canvas.new(self, extract_selector(args).merge(:tag_name => "canvas"))
    end
-   
+
    #
    # @return [CanvasCollection]
    #
-   
+
    def canvases(*args)
      CanvasCollection.new(self, extract_selector(args).merge(:tag_name => "canvas"))
    end
-   
+
    Watir.tag_to_class[:canvas] = Canvas
    #
    # @return [TableCaption]
    #
-   
+
    def caption(*args)
      TableCaption.new(self, extract_selector(args).merge(:tag_name => "caption"))
    end
-   
+
    #
    # @return [TableCaptionCollection]
    #
-   
+
    def captions(*args)
      TableCaptionCollection.new(self, extract_selector(args).merge(:tag_name => "caption"))
    end
-   
+
    Watir.tag_to_class[:caption] = TableCaption
    #
    # @return [HTMLElement]
    #
-   
+
    def cite(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "cite"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def cites(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "cite"))
    end
-   
+
    Watir.tag_to_class[:cite] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def code(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "code"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def codes(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "code"))
    end
-   
+
    Watir.tag_to_class[:code] = HTMLElement
    #
    # @return [TableCol]
    #
-   
+
    def col(*args)
      TableCol.new(self, extract_selector(args).merge(:tag_name => "col"))
    end
-   
+
    #
    # @return [TableColCollection]
    #
-   
+
    def cols(*args)
      TableColCollection.new(self, extract_selector(args).merge(:tag_name => "col"))
    end
-   
+
    Watir.tag_to_class[:col] = TableCol
    #
    # @return [TableCol]
    #
-   
+
    def colgroup(*args)
      TableCol.new(self, extract_selector(args).merge(:tag_name => "colgroup"))
    end
-   
+
    #
    # @return [TableColCollection]
    #
-   
+
    def colgroups(*args)
      TableColCollection.new(self, extract_selector(args).merge(:tag_name => "colgroup"))
    end
-   
+
    Watir.tag_to_class[:colgroup] = TableCol
    #
    # @return [Command]
    #
-   
+
    def command(*args)
      Command.new(self, extract_selector(args).merge(:tag_name => "command"))
    end
-   
+
    #
    # @return [CommandCollection]
    #
-   
+
    def commands(*args)
      CommandCollection.new(self, extract_selector(args).merge(:tag_name => "command"))
    end
-   
+
    Watir.tag_to_class[:command] = Command
    #
    # @return [DataList]
    #
-   
+
    def datalist(*args)
      DataList.new(self, extract_selector(args).merge(:tag_name => "datalist"))
    end
-   
+
    #
    # @return [DataListCollection]
    #
-   
+
    def datalists(*args)
      DataListCollection.new(self, extract_selector(args).merge(:tag_name => "datalist"))
    end
-   
+
    Watir.tag_to_class[:datalist] = DataList
    #
    # @return [HTMLElement]
    #
-   
+
    def dd(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dd"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def dds(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dd"))
    end
-   
+
    Watir.tag_to_class[:dd] = HTMLElement
    #
    # @return [Mod]
    #
-   
+
    def del(*args)
      Mod.new(self, extract_selector(args).merge(:tag_name => "del"))
    end
-   
+
    #
    # @return [ModCollection]
    #
-   
+
    def dels(*args)
      ModCollection.new(self, extract_selector(args).merge(:tag_name => "del"))
    end
-   
+
    Watir.tag_to_class[:del] = Mod
    #
    # @return [Details]
    #
-   
+
    def details(*args)
      Details.new(self, extract_selector(args).merge(:tag_name => "details"))
    end
-   
+
    #
    # @return [DetailsCollection]
    #
-   
+
    def details(*args)
      DetailsCollection.new(self, extract_selector(args).merge(:tag_name => "details"))
    end
-   
+
    Watir.tag_to_class[:details] = Details
    #
    # @return [HTMLElement]
    #
-   
+
    def dfn(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dfn"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def dfns(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dfn"))
    end
-   
+
    Watir.tag_to_class[:dfn] = HTMLElement
    #
    # @return [Div]
    #
-   
+
    def div(*args)
      Div.new(self, extract_selector(args).merge(:tag_name => "div"))
    end
-   
+
    #
    # @return [DivCollection]
    #
-   
+
    def divs(*args)
      DivCollection.new(self, extract_selector(args).merge(:tag_name => "div"))
    end
-   
+
    Watir.tag_to_class[:div] = Div
    #
    # @return [DList]
    #
-   
+
    def dl(*args)
      DList.new(self, extract_selector(args).merge(:tag_name => "dl"))
    end
-   
+
    #
    # @return [DListCollection]
    #
-   
+
    def dls(*args)
      DListCollection.new(self, extract_selector(args).merge(:tag_name => "dl"))
    end
-   
+
    Watir.tag_to_class[:dl] = DList
    #
    # @return [HTMLElement]
    #
-   
+
    def dt(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dt"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def dts(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dt"))
    end
-   
+
    Watir.tag_to_class[:dt] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def em(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "em"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def ems(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "em"))
    end
-   
+
    Watir.tag_to_class[:em] = HTMLElement
    #
    # @return [Embed]
    #
-   
+
    def embed(*args)
      Embed.new(self, extract_selector(args).merge(:tag_name => "embed"))
    end
-   
+
    #
    # @return [EmbedCollection]
    #
-   
+
    def embeds(*args)
      EmbedCollection.new(self, extract_selector(args).merge(:tag_name => "embed"))
    end
-   
+
    Watir.tag_to_class[:embed] = Embed
    #
    # @return [FieldSet]
    #
-   
+
    def fieldset(*args)
      FieldSet.new(self, extract_selector(args).merge(:tag_name => "fieldset"))
    end
-   
+
    #
    # @return [FieldSetCollection]
    #
-   
+
    def fieldsets(*args)
      FieldSetCollection.new(self, extract_selector(args).merge(:tag_name => "fieldset"))
    end
-   
+
    Watir.tag_to_class[:fieldset] = FieldSet
    #
    # @return [HTMLElement]
    #
-   
+
    def figcaption(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "figcaption"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def figcaptions(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "figcaption"))
    end
-   
+
    Watir.tag_to_class[:figcaption] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def figure(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "figure"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def figures(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "figure"))
    end
-   
+
    Watir.tag_to_class[:figure] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def footer(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "footer"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def footers(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "footer"))
    end
-   
+
    Watir.tag_to_class[:footer] = HTMLElement
    #
    # @return [Form]
    #
-   
+
    def form(*args)
      Form.new(self, extract_selector(args).merge(:tag_name => "form"))
    end
-   
+
    #
    # @return [FormCollection]
    #
-   
+
    def forms(*args)
      FormCollection.new(self, extract_selector(args).merge(:tag_name => "form"))
    end
-   
+
    Watir.tag_to_class[:form] = Form
    #
    # @return [Heading]
    #
-   
+
    def h1(*args)
      Heading.new(self, extract_selector(args).merge(:tag_name => "h1"))
    end
-   
+
    #
    # @return [HeadingCollection]
    #
-   
+
    def h1s(*args)
      HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h1"))
    end
-   
+
    Watir.tag_to_class[:h1] = Heading
    #
    # @return [Heading]
    #
-   
+
    def h2(*args)
      Heading.new(self, extract_selector(args).merge(:tag_name => "h2"))
    end
-   
+
    #
    # @return [HeadingCollection]
    #
-   
+
    def h2s(*args)
      HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h2"))
    end
-   
+
    Watir.tag_to_class[:h2] = Heading
    #
    # @return [Heading]
    #
-   
+
    def h3(*args)
      Heading.new(self, extract_selector(args).merge(:tag_name => "h3"))
    end
-   
+
    #
    # @return [HeadingCollection]
    #
-   
+
    def h3s(*args)
      HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h3"))
    end
-   
+
    Watir.tag_to_class[:h3] = Heading
    #
    # @return [Heading]
    #
-   
+
    def h4(*args)
      Heading.new(self, extract_selector(args).merge(:tag_name => "h4"))
    end
-   
+
    #
    # @return [HeadingCollection]
    #
-   
+
    def h4s(*args)
      HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h4"))
    end
-   
+
    Watir.tag_to_class[:h4] = Heading
    #
    # @return [Heading]
    #
-   
+
    def h5(*args)
      Heading.new(self, extract_selector(args).merge(:tag_name => "h5"))
    end
-   
+
    #
    # @return [HeadingCollection]
    #
-   
+
    def h5s(*args)
      HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h5"))
    end
-   
+
    Watir.tag_to_class[:h5] = Heading
    #
    # @return [Heading]
    #
-   
+
    def h6(*args)
      Heading.new(self, extract_selector(args).merge(:tag_name => "h6"))
    end
-   
+
    #
    # @return [HeadingCollection]
    #
-   
+
    def h6s(*args)
      HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h6"))
    end
-   
+
    Watir.tag_to_class[:h6] = Heading
    #
    # @return [Head]
    #
-   
+
    def head(*args)
      Head.new(self, extract_selector(args).merge(:tag_name => "head"))
    end
-   
+
    #
    # @return [HeadCollection]
    #
-   
+
    def heads(*args)
      HeadCollection.new(self, extract_selector(args).merge(:tag_name => "head"))
    end
-   
+
    Watir.tag_to_class[:head] = Head
    #
    # @return [HTMLElement]
    #
-   
+
    def header(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "header"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def headers(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "header"))
    end
-   
+
    Watir.tag_to_class[:header] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def hgroup(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "hgroup"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def hgroups(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "hgroup"))
    end
-   
+
    Watir.tag_to_class[:hgroup] = HTMLElement
    #
    # @return [HR]
    #
-   
+
    def hr(*args)
      HR.new(self, extract_selector(args).merge(:tag_name => "hr"))
    end
-   
+
    #
    # @return [HRCollection]
    #
-   
+
    def hrs(*args)
      HRCollection.new(self, extract_selector(args).merge(:tag_name => "hr"))
    end
-   
+
    Watir.tag_to_class[:hr] = HR
    #
    # @return [Html]
    #
-   
+
    def html(*args)
      Html.new(self, extract_selector(args).merge(:tag_name => "html"))
    end
-   
+
    #
    # @return [HtmlCollection]
    #
-   
+
    def htmls(*args)
      HtmlCollection.new(self, extract_selector(args).merge(:tag_name => "html"))
    end
-   
+
    Watir.tag_to_class[:html] = Html
    #
    # @return [HTMLElement]
    #
-   
+
    def i(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "i"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def is(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "i"))
    end
-   
+
    Watir.tag_to_class[:i] = HTMLElement
    #
    # @return [IFrame]
    #
-   
+
    def iframe(*args)
      IFrame.new(self, extract_selector(args).merge(:tag_name => "iframe"))
    end
-   
+
    #
    # @return [IFrameCollection]
    #
-   
+
    def iframes(*args)
      IFrameCollection.new(self, extract_selector(args).merge(:tag_name => "iframe"))
    end
-   
+
    Watir.tag_to_class[:iframe] = IFrame
    #
    # @return [Image]
    #
-   
-   def image(*args)
+
+   def img(*args)
      Image.new(self, extract_selector(args).merge(:tag_name => "img"))
    end
-   
+
    #
    # @return [ImageCollection]
    #
-   
-   def images(*args)
+
+   def imgs(*args)
      ImageCollection.new(self, extract_selector(args).merge(:tag_name => "img"))
    end
-   
+
    Watir.tag_to_class[:img] = Image
    #
    # @return [Input]
    #
-   
+
    def input(*args)
      Input.new(self, extract_selector(args).merge(:tag_name => "input"))
    end
-   
+
    #
    # @return [InputCollection]
    #
-   
+
    def inputs(*args)
      InputCollection.new(self, extract_selector(args).merge(:tag_name => "input"))
    end
-   
+
    Watir.tag_to_class[:input] = Input
    #
    # @return [Mod]
    #
-   
+
    def ins(*args)
      Mod.new(self, extract_selector(args).merge(:tag_name => "ins"))
    end
-   
+
    #
    # @return [ModCollection]
    #
-   
+
    def inses(*args)
      ModCollection.new(self, extract_selector(args).merge(:tag_name => "ins"))
    end
-   
+
    Watir.tag_to_class[:ins] = Mod
    #
    # @return [HTMLElement]
    #
-   
+
    def kbd(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "kbd"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def kbds(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "kbd"))
    end
-   
+
    Watir.tag_to_class[:kbd] = HTMLElement
    #
    # @return [Keygen]
    #
-   
+
    def keygen(*args)
      Keygen.new(self, extract_selector(args).merge(:tag_name => "keygen"))
    end
-   
+
    #
    # @return [KeygenCollection]
    #
-   
+
    def keygens(*args)
      KeygenCollection.new(self, extract_selector(args).merge(:tag_name => "keygen"))
    end
-   
+
    Watir.tag_to_class[:keygen] = Keygen
    #
    # @return [Label]
    #
-   
+
    def label(*args)
      Label.new(self, extract_selector(args).merge(:tag_name => "label"))
    end
-   
+
    #
    # @return [LabelCollection]
    #
-   
+
    def labels(*args)
      LabelCollection.new(self, extract_selector(args).merge(:tag_name => "label"))
    end
-   
+
    Watir.tag_to_class[:label] = Label
    #
    # @return [Legend]
    #
-   
+
    def legend(*args)
      Legend.new(self, extract_selector(args).merge(:tag_name => "legend"))
    end
-   
+
    #
    # @return [LegendCollection]
    #
-   
+
    def legends(*args)
      LegendCollection.new(self, extract_selector(args).merge(:tag_name => "legend"))
    end
-   
+
    Watir.tag_to_class[:legend] = Legend
    #
    # @return [LI]
    #
-   
+
    def li(*args)
      LI.new(self, extract_selector(args).merge(:tag_name => "li"))
    end
-   
+
    #
    # @return [LICollection]
    #
-   
+
    def lis(*args)
      LICollection.new(self, extract_selector(args).merge(:tag_name => "li"))
    end
-   
+
    Watir.tag_to_class[:li] = LI
    #
    # @return [Map]
    #
-   
+
    def map(*args)
      Map.new(self, extract_selector(args).merge(:tag_name => "map"))
    end
-   
+
    #
    # @return [MapCollection]
    #
-   
+
    def maps(*args)
      MapCollection.new(self, extract_selector(args).merge(:tag_name => "map"))
    end
-   
+
    Watir.tag_to_class[:map] = Map
    #
    # @return [HTMLElement]
    #
-   
+
    def mark(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "mark"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def marks(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "mark"))
    end
-   
+
    Watir.tag_to_class[:mark] = HTMLElement
    #
    # @return [Menu]
    #
-   
+
    def menu(*args)
      Menu.new(self, extract_selector(args).merge(:tag_name => "menu"))
    end
-   
+
    #
    # @return [MenuCollection]
    #
-   
+
    def menus(*args)
      MenuCollection.new(self, extract_selector(args).merge(:tag_name => "menu"))
    end
-   
+
    Watir.tag_to_class[:menu] = Menu
    #
    # @return [Meta]
    #
-   
+
    def meta(*args)
      Meta.new(self, extract_selector(args).merge(:tag_name => "meta"))
    end
-   
+
    #
    # @return [MetaCollection]
    #
-   
+
    def metas(*args)
      MetaCollection.new(self, extract_selector(args).merge(:tag_name => "meta"))
    end
-   
+
    Watir.tag_to_class[:meta] = Meta
    #
    # @return [Meter]
    #
-   
+
    def meter(*args)
      Meter.new(self, extract_selector(args).merge(:tag_name => "meter"))
    end
-   
+
    #
    # @return [MeterCollection]
    #
-   
+
    def meters(*args)
      MeterCollection.new(self, extract_selector(args).merge(:tag_name => "meter"))
    end
-   
+
    Watir.tag_to_class[:meter] = Meter
    #
    # @return [HTMLElement]
    #
-   
+
    def nav(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "nav"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def navs(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "nav"))
    end
-   
+
    Watir.tag_to_class[:nav] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def noscript(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "noscript"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def noscripts(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "noscript"))
    end
-   
+
    Watir.tag_to_class[:noscript] = HTMLElement
    #
    # @return [Object]
    #
-   
+
    def object(*args)
      Object.new(self, extract_selector(args).merge(:tag_name => "object"))
    end
-   
+
    #
    # @return [ObjectCollection]
    #
-   
+
    def objects(*args)
      ObjectCollection.new(self, extract_selector(args).merge(:tag_name => "object"))
    end
-   
+
    Watir.tag_to_class[:object] = Object
    #
    # @return [OList]
    #
-   
+
    def ol(*args)
      OList.new(self, extract_selector(args).merge(:tag_name => "ol"))
    end
-   
+
    #
    # @return [OListCollection]
    #
-   
+
    def ols(*args)
      OListCollection.new(self, extract_selector(args).merge(:tag_name => "ol"))
    end
-   
+
    Watir.tag_to_class[:ol] = OList
    #
    # @return [OptGroup]
    #
-   
+
    def optgroup(*args)
      OptGroup.new(self, extract_selector(args).merge(:tag_name => "optgroup"))
    end
-   
+
    #
    # @return [OptGroupCollection]
    #
-   
+
    def optgroups(*args)
      OptGroupCollection.new(self, extract_selector(args).merge(:tag_name => "optgroup"))
    end
-   
+
    Watir.tag_to_class[:optgroup] = OptGroup
    #
    # @return [Option]
    #
-   
+
    def option(*args)
      Option.new(self, extract_selector(args).merge(:tag_name => "option"))
    end
-   
+
    #
    # @return [OptionCollection]
    #
-   
+
    def options(*args)
      OptionCollection.new(self, extract_selector(args).merge(:tag_name => "option"))
    end
-   
+
    Watir.tag_to_class[:option] = Option
    #
    # @return [Output]
    #
-   
+
    def output(*args)
      Output.new(self, extract_selector(args).merge(:tag_name => "output"))
    end
-   
+
    #
    # @return [OutputCollection]
    #
-   
+
    def outputs(*args)
      OutputCollection.new(self, extract_selector(args).merge(:tag_name => "output"))
    end
-   
+
    Watir.tag_to_class[:output] = Output
    #
    # @return [Paragraph]
    #
-   
+
    def p(*args)
      Paragraph.new(self, extract_selector(args).merge(:tag_name => "p"))
    end
-   
+
    #
    # @return [ParagraphCollection]
    #
-   
+
    def ps(*args)
      ParagraphCollection.new(self, extract_selector(args).merge(:tag_name => "p"))
    end
-   
+
    Watir.tag_to_class[:p] = Paragraph
    #
    # @return [Param]
    #
-   
+
    def param(*args)
      Param.new(self, extract_selector(args).merge(:tag_name => "param"))
    end
-   
+
    #
    # @return [ParamCollection]
    #
-   
+
    def params(*args)
      ParamCollection.new(self, extract_selector(args).merge(:tag_name => "param"))
    end
-   
+
    Watir.tag_to_class[:param] = Param
    #
    # @return [Pre]
    #
-   
+
    def pre(*args)
      Pre.new(self, extract_selector(args).merge(:tag_name => "pre"))
    end
-   
+
    #
    # @return [PreCollection]
    #
-   
+
    def pres(*args)
      PreCollection.new(self, extract_selector(args).merge(:tag_name => "pre"))
    end
-   
+
    Watir.tag_to_class[:pre] = Pre
    #
    # @return [Progress]
    #
-   
+
    def progress(*args)
      Progress.new(self, extract_selector(args).merge(:tag_name => "progress"))
    end
-   
+
    #
    # @return [ProgressCollection]
    #
-   
+
    def progresses(*args)
      ProgressCollection.new(self, extract_selector(args).merge(:tag_name => "progress"))
    end
-   
+
    Watir.tag_to_class[:progress] = Progress
    #
    # @return [Quote]
    #
-   
+
    def q(*args)
      Quote.new(self, extract_selector(args).merge(:tag_name => "q"))
    end
-   
+
    #
    # @return [QuoteCollection]
    #
-   
+
    def qs(*args)
      QuoteCollection.new(self, extract_selector(args).merge(:tag_name => "q"))
    end
-   
+
    Watir.tag_to_class[:q] = Quote
    #
    # @return [HTMLElement]
    #
-   
+
    def rp(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "rp"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def rps(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "rp"))
    end
-   
+
    Watir.tag_to_class[:rp] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def rt(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "rt"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def rts(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "rt"))
    end
-   
+
    Watir.tag_to_class[:rt] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def ruby(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "ruby"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def rubies(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "ruby"))
    end
-   
+
    Watir.tag_to_class[:ruby] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def samp(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "samp"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def samps(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "samp"))
    end
-   
+
    Watir.tag_to_class[:samp] = HTMLElement
    #
    # @return [Script]
    #
-   
+
    def script(*args)
      Script.new(self, extract_selector(args).merge(:tag_name => "script"))
    end
-   
+
    #
    # @return [ScriptCollection]
    #
-   
+
    def scripts(*args)
      ScriptCollection.new(self, extract_selector(args).merge(:tag_name => "script"))
    end
-   
+
    Watir.tag_to_class[:script] = Script
    #
    # @return [HTMLElement]
    #
-   
+
    def section(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "section"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def sections(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "section"))
    end
-   
+
    Watir.tag_to_class[:section] = HTMLElement
    #
    # @return [Select]
    #
-   
+
    def select(*args)
      Select.new(self, extract_selector(args).merge(:tag_name => "select"))
    end
-   
+
    #
    # @return [SelectCollection]
    #
-   
+
    def selects(*args)
      SelectCollection.new(self, extract_selector(args).merge(:tag_name => "select"))
    end
-   
+
    Watir.tag_to_class[:select] = Select
    #
    # @return [HTMLElement]
    #
-   
+
    def small(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "small"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def smalls(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "small"))
    end
-   
+
    Watir.tag_to_class[:small] = HTMLElement
    #
    # @return [Source]
    #
-   
+
    def source(*args)
      Source.new(self, extract_selector(args).merge(:tag_name => "source"))
    end
-   
+
    #
    # @return [SourceCollection]
    #
-   
+
    def sources(*args)
      SourceCollection.new(self, extract_selector(args).merge(:tag_name => "source"))
    end
-   
+
    Watir.tag_to_class[:source] = Source
    #
    # @return [Span]
    #
-   
+
    def span(*args)
      Span.new(self, extract_selector(args).merge(:tag_name => "span"))
    end
-   
+
    #
    # @return [SpanCollection]
    #
-   
+
    def spans(*args)
      SpanCollection.new(self, extract_selector(args).merge(:tag_name => "span"))
    end
-   
+
    Watir.tag_to_class[:span] = Span
    #
    # @return [HTMLElement]
    #
-   
+
    def strong(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "strong"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def strongs(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "strong"))
    end
-   
+
    Watir.tag_to_class[:strong] = HTMLElement
    #
    # @return [Style]
    #
-   
+
    def style(*args)
      Style.new(self, extract_selector(args).merge(:tag_name => "style"))
    end
-   
+
    #
    # @return [StyleCollection]
    #
-   
+
    def styles(*args)
      StyleCollection.new(self, extract_selector(args).merge(:tag_name => "style"))
    end
-   
+
    Watir.tag_to_class[:style] = Style
    #
    # @return [HTMLElement]
    #
-   
+
    def sub(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "sub"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def subs(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "sub"))
    end
-   
+
    Watir.tag_to_class[:sub] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def summary(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "summary"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def summaries(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "summary"))
    end
-   
+
    Watir.tag_to_class[:summary] = HTMLElement
    #
    # @return [HTMLElement]
    #
-   
+
    def sup(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "sup"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def sups(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "sup"))
    end
-   
+
    Watir.tag_to_class[:sup] = HTMLElement
    #
    # @return [Table]
    #
-   
+
    def table(*args)
      Table.new(self, extract_selector(args).merge(:tag_name => "table"))
    end
-   
+
    #
    # @return [TableCollection]
    #
-   
+
    def tables(*args)
      TableCollection.new(self, extract_selector(args).merge(:tag_name => "table"))
    end
-   
+
    Watir.tag_to_class[:table] = Table
    #
    # @return [TableSection]
    #
-   
+
    def tbody(*args)
      TableSection.new(self, extract_selector(args).merge(:tag_name => "tbody"))
    end
-   
+
    #
    # @return [TableSectionCollection]
    #
-   
+
    def tbodys(*args)
      TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "tbody"))
    end
-   
+
    Watir.tag_to_class[:tbody] = TableSection
    #
    # @return [TableDataCell]
    #
-   
+
    def td(*args)
      TableDataCell.new(self, extract_selector(args).merge(:tag_name => "td"))
    end
-   
+
    #
    # @return [TableDataCellCollection]
    #
-   
+
    def tds(*args)
      TableDataCellCollection.new(self, extract_selector(args).merge(:tag_name => "td"))
    end
-   
+
    Watir.tag_to_class[:td] = TableDataCell
    #
    # @return [TextArea]
    #
-   
+
    def textarea(*args)
      TextArea.new(self, extract_selector(args).merge(:tag_name => "textarea"))
    end
-   
+
    #
    # @return [TextAreaCollection]
    #
-   
+
    def textareas(*args)
      TextAreaCollection.new(self, extract_selector(args).merge(:tag_name => "textarea"))
    end
-   
+
    Watir.tag_to_class[:textarea] = TextArea
    #
    # @return [TableSection]
    #
-   
+
    def tfoot(*args)
      TableSection.new(self, extract_selector(args).merge(:tag_name => "tfoot"))
    end
-   
+
    #
    # @return [TableSectionCollection]
    #
-   
+
    def tfoots(*args)
      TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "tfoot"))
    end
-   
+
    Watir.tag_to_class[:tfoot] = TableSection
    #
    # @return [TableHeaderCell]
    #
-   
+
    def th(*args)
      TableHeaderCell.new(self, extract_selector(args).merge(:tag_name => "th"))
    end
-   
+
    #
    # @return [TableHeaderCellCollection]
    #
-   
+
    def ths(*args)
      TableHeaderCellCollection.new(self, extract_selector(args).merge(:tag_name => "th"))
    end
-   
+
    Watir.tag_to_class[:th] = TableHeaderCell
    #
    # @return [TableSection]
    #
-   
+
    def thead(*args)
      TableSection.new(self, extract_selector(args).merge(:tag_name => "thead"))
    end
-   
+
    #
    # @return [TableSectionCollection]
    #
-   
+
    def theads(*args)
      TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "thead"))
    end
-   
+
    Watir.tag_to_class[:thead] = TableSection
    #
    # @return [Time]
    #
-   
+
    def time(*args)
      Time.new(self, extract_selector(args).merge(:tag_name => "time"))
    end
-   
+
    #
    # @return [TimeCollection]
    #
-   
+
    def times(*args)
      TimeCollection.new(self, extract_selector(args).merge(:tag_name => "time"))
    end
-   
+
    Watir.tag_to_class[:time] = Time
    #
    # @return [Title]
    #
-   
+
    def title(*args)
      Title.new(self, extract_selector(args).merge(:tag_name => "title"))
    end
-   
+
    #
    # @return [TitleCollection]
    #
-   
+
    def titles(*args)
      TitleCollection.new(self, extract_selector(args).merge(:tag_name => "title"))
    end
-   
+
    Watir.tag_to_class[:title] = Title
    #
    # @return [TableRow]
    #
-   
+
    def tr(*args)
      TableRow.new(self, extract_selector(args).merge(:tag_name => "tr"))
    end
-   
+
    #
    # @return [TableRowCollection]
    #
-   
+
    def trs(*args)
      TableRowCollection.new(self, extract_selector(args).merge(:tag_name => "tr"))
    end
-   
+
    Watir.tag_to_class[:tr] = TableRow
    #
    # @return [Track]
    #
-   
+
    def track(*args)
      Track.new(self, extract_selector(args).merge(:tag_name => "track"))
    end
-   
+
    #
    # @return [TrackCollection]
    #
-   
+
    def tracks(*args)
      TrackCollection.new(self, extract_selector(args).merge(:tag_name => "track"))
    end
-   
+
    Watir.tag_to_class[:track] = Track
    #
    # @return [UList]
    #
-   
+
    def ul(*args)
      UList.new(self, extract_selector(args).merge(:tag_name => "ul"))
    end
-   
+
    #
    # @return [UListCollection]
    #
-   
+
    def uls(*args)
      UListCollection.new(self, extract_selector(args).merge(:tag_name => "ul"))
    end
-   
+
    Watir.tag_to_class[:ul] = UList
    #
    # @return [HTMLElement]
    #
-   
+
    def var(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "var"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def vars(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "var"))
    end
-   
+
    Watir.tag_to_class[:var] = HTMLElement
    #
    # @return [Video]
    #
-   
+
    def video(*args)
      Video.new(self, extract_selector(args).merge(:tag_name => "video"))
    end
-   
+
    #
    # @return [VideoCollection]
    #
-   
+
    def videos(*args)
      VideoCollection.new(self, extract_selector(args).merge(:tag_name => "video"))
    end
-   
+
    Watir.tag_to_class[:video] = Video
    #
    # @return [HTMLElement]
    #
-   
+
    def wbr(*args)
      HTMLElement.new(self, extract_selector(args).merge(:tag_name => "wbr"))
    end
-   
+
    #
    # @return [HTMLElementCollection]
    #
-   
+
    def wbrs(*args)
      HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "wbr"))
    end
-   
+
    Watir.tag_to_class[:wbr] = HTMLElement
  end # Container
 end # Watir