watir 6.19.1 → 7.0.0.beta1

data/lib/watir/cell_container.rb

@@ -6,8 +6,8 @@ module Watir
     # @return [Cell]
     #
 
-    def cell(*args)
-      Cell.new(self, extract_selector(args))
+    def cell(opts = {})
+      Cell.new(self, opts)
     end
 
     #
@@ -16,8 +16,8 @@ module Watir
     # @return [Cell]
     #
 
-    def cells(*args)
-      CellCollection.new(self, extract_selector(args))
+    def cells(opts = {})
+      CellCollection.new(self, opts)
     end
   end # CellContainer
 end # Watir

data/lib/watir/container.rb

@@ -11,8 +11,8 @@ module Watir
     # @return [HTMLElement]
     #
 
-    def element(*args)
-      HTMLElement.new(self, extract_selector(args))
+    def element(opts = {})
+      HTMLElement.new(self, opts)
     end
 
     #
@@ -24,30 +24,8 @@ module Watir
     # @return [HTMLElementCollection]
     #
 
-    def elements(*args)
-      HTMLElementCollection.new(self, extract_selector(args))
-    end
-
-    #
-    # @api private
-    #
-
-    def extract_selector(selector)
-      case selector.size
-      when 2
-        msg = "Using ordered parameters to locate elements (:#{selector.first}, #{selector.last.inspect})"
-        Watir.logger.deprecate msg,
-                               "{#{selector.first}: #{selector.last.inspect}}",
-                               ids: [:selector_parameters]
-        return {selector[0] => selector[1]}
-      when 1
-        obj = selector.first
-        return obj if obj.is_a? Hash
-      when 0
-        return {}
-      end
-
-      raise ArgumentError, "expected Hash, got #{selector.inspect}"
+    def elements(opts = {})
+      HTMLElementCollection.new(self, opts)
     end
   end # Container
 end # Watir

data/lib/watir/elements/checkbox.rb

@@ -40,12 +40,12 @@ module Watir
   end # CheckBox
 
   module Container
-    def checkbox(*args)
-      CheckBox.new(self, extract_selector(args).merge(tag_name: 'input', type: 'checkbox'))
+    def checkbox(opts = {})
+      CheckBox.new(self, opts.merge(tag_name: 'input', type: 'checkbox'))
     end
 
-    def checkboxes(*args)
-      CheckBoxCollection.new(self, extract_selector(args).merge(tag_name: 'input', type: 'checkbox'))
+    def checkboxes(opts = {})
+      CheckBoxCollection.new(self, opts.merge(tag_name: 'input', type: 'checkbox'))
     end
   end # Container
 

data/lib/watir/elements/date_field.rb

@@ -18,12 +18,12 @@ module Watir
   end # DateField
 
   module Container
-    def date_field(*args)
-      DateField.new(self, extract_selector(args).merge(tag_name: 'input', type: 'date'))
+    def date_field(opts = {})
+      DateField.new(self, opts.merge(tag_name: 'input', type: 'date'))
     end
 
-    def date_fields(*args)
-      DateFieldCollection.new(self, extract_selector(args).merge(tag_name: 'input', type: 'date'))
+    def date_fields(opts = {})
+      DateFieldCollection.new(self, opts.merge(tag_name: 'input', type: 'date'))
     end
   end # Container
 

data/lib/watir/elements/date_time_field.rb

@@ -18,12 +18,12 @@ module Watir
   end # DateTimeField
 
   module Container
-    def date_time_field(*args)
-      DateTimeField.new(self, extract_selector(args).merge(tag_name: 'input', type: 'datetime-local'))
+    def date_time_field(opts = {})
+      DateTimeField.new(self, opts.merge(tag_name: 'input', type: 'datetime-local'))
     end
 
-    def date_time_fields(*args)
-      DateTimeFieldCollection.new(self, extract_selector(args).merge(tag_name: 'input', type: 'datetime-local'))
+    def date_time_fields(opts = {})
+      DateTimeFieldCollection.new(self, opts.merge(tag_name: 'input', type: 'datetime-local'))
     end
   end # Container
 

data/lib/watir/elements/element.rb

@@ -8,7 +8,6 @@ module Watir
 
     include Exception
     include Container
-    include EventuallyPresent
     include Waitable
     include Adjacent
     include JSExecution
@@ -45,11 +44,10 @@ module Watir
 
       raise ArgumentError, "invalid argument: #{selector.inspect}" unless selector.is_a? Hash
 
+      selector[:index] = 0 if selector.empty?
       @element = selector.delete(:element)
 
-      if @element && !(selector.keys - %i[tag_name]).empty?
-        Watir.logger.deprecate(':element locator to initialize a relocatable Element', '#cache=', ids: [:element_cache])
-      end
+      selector = {} if @element && !(selector.keys - [:tag_name]).empty?
 
       @selector = selector
 
@@ -375,21 +373,6 @@ module Watir
       element_call { @element == driver.switch_to.active_element }
     end
 
-    #
-    # Scroll until the element is in the view screen
-    #
-    # @example
-    #   browser.button(name: "new_user_button").scroll_into_view
-    #
-    # @return [Selenium::WebDriver::Point]
-    #
-
-    def scroll_into_view
-      Watir.logger.deprecate 'Element#scroll_into_view', 'Element#scroll methods', ids: [:scroll_into_view]
-
-      element_call { @element.location_once_scrolled_into_view }
-    end
-
     #
     # location of element (x, y)
     #
@@ -478,20 +461,6 @@ module Watir
       @element
     end
 
-    #
-    # Returns true if this element is visible on the page.
-    # Raises exception if element does not exist
-    #
-    # @return [Boolean]
-    #
-
-    def visible?
-      msg = '#visible? behavior will be changing slightly, consider switching to #present? ' \
-            '(more details: http://watir.com/element-existentialism/)'
-      Watir.logger.warn msg, ids: [:visible_element]
-      display_check
-    end
-
     #
     # Returns true if this element is present and enabled on the page.
     #
@@ -512,10 +481,15 @@ module Watir
     #
 
     def present?
-      display_check
+      assert_exists
+      @element.displayed?
     rescue UnknownObjectException, UnknownFrameException
       false
+    rescue Selenium::WebDriver::Error::StaleElementReferenceError
+      reset!
+      retry
     end
+    alias visible? present?
 
     #
     # Returns true if the element's center point is covered by a non-descendant element.
@@ -621,6 +595,9 @@ module Watir
     #
 
     def locate
+      msg = 'Can not relocate a Watir element initialized by a Selenium element'
+      raise LocatorException, msg if @selector.empty?
+
       ensure_context
       locate_in_context
       self
@@ -669,7 +646,6 @@ module Watir
     protected
 
     def wait_for_exists
-      return assert_exists unless Watir.relaxed_locate?
       return if located? # Performance shortcut
 
       begin
@@ -682,8 +658,7 @@ module Watir
     end
 
     def wait_for_present
-      p = present?
-      return p if !Watir.relaxed_locate? || p
+      return true if present?
 
       begin
         @query_scope.wait_for_present unless @query_scope.is_a? Browser
@@ -696,8 +671,6 @@ module Watir
     end
 
     def wait_for_enabled
-      return assert_enabled unless Watir.relaxed_locate?
-
       wait_for_exists
       return unless [Input, Button, Select, Option].any? { |c| is_a? c } || content_editable
       return if enabled?
@@ -711,7 +684,6 @@ module Watir
 
     def wait_for_writable
       wait_for_enabled
-      raise_writable unless Watir.relaxed_locate? || (!respond_to?(:readonly?) || !readonly?)
 
       return if !respond_to?(:readonly?) || !readonly?
 
@@ -779,15 +751,6 @@ module Watir
       raise TypeError, "expected Watir::Element, got #{obj.inspect}:#{obj.class}" unless obj.is_a? Element
     end
 
-    # Removes duplication in #present? & #visible? and makes setting deprecation notice easier
-    def display_check
-      assert_exists
-      @element.displayed?
-    rescue Selenium::WebDriver::Error::StaleElementReferenceError
-      reset!
-      retry
-    end
-
     # TODO: - this will get addressed with Watir::Executor implementation
     # rubocop:disable Metrics/AbcSize
     # rubocop:disable Metrics/MethodLength

data/lib/watir/elements/file_field.rb

@@ -27,12 +27,12 @@ module Watir
   end # FileField
 
   module Container
-    def file_field(*args)
-      FileField.new(self, extract_selector(args).merge(tag_name: 'input', type: 'file'))
+    def file_field(opts = {})
+      FileField.new(self, opts.merge(tag_name: 'input', type: 'file'))
     end
 
-    def file_fields(*args)
-      FileFieldCollection.new(self, extract_selector(args).merge(tag_name: 'input', type: 'file'))
+    def file_fields(opts = {})
+      FileFieldCollection.new(self, opts.merge(tag_name: 'input', type: 'file'))
     end
   end # Container
 

data/lib/watir/elements/font.rb

@@ -12,12 +12,12 @@ module Watir
   end # Font
 
   module Container
-    def font(*args)
-      Font.new(self, extract_selector(args).merge(tag_name: 'font'))
+    def font(opts = {})
+      Font.new(self, opts.merge(tag_name: 'font'))
     end
 
-    def fonts(*args)
-      FontCollection.new(self, extract_selector(args).merge(tag_name: 'font'))
+    def fonts(opts = {})
+      FontCollection.new(self, opts.merge(tag_name: 'font'))
     end
   end # Container
 end # Watir

data/lib/watir/elements/hidden.rb

@@ -10,12 +10,12 @@ module Watir
   end
 
   module Container
-    def hidden(*args)
-      Hidden.new(self, extract_selector(args).merge(tag_name: 'input', type: 'hidden'))
+    def hidden(opts = {})
+      Hidden.new(self, opts.merge(tag_name: 'input', type: 'hidden'))
     end
 
-    def hiddens(*args)
-      HiddenCollection.new(self, extract_selector(args).merge(tag_name: 'input', type: 'hidden'))
+    def hiddens(opts = {})
+      HiddenCollection.new(self, opts.merge(tag_name: 'input', type: 'hidden'))
     end
   end # Container
 

data/lib/watir/elements/html_elements.rb

@@ -467,7 +467,6 @@ module Watir
   end
 
   class Table < HTMLElement
-    attribute(String, :caption, :caption)
     attribute(String, :tbodies, :tBodies)
     attribute(String, :align, :align)
     attribute(String, :border, :border)
@@ -870,1112 +869,1112 @@ module Watir
   module Container
 
     # @return [Anchor]
-    def a(*args)
-      Anchor.new(self, extract_selector(args).merge(tag_name: "a"))
+    def a(opts = {})
+      Anchor.new(self, opts.merge(tag_name: "a"))
     end
     # @return [AnchorCollection]
-    def as(*args)
-      AnchorCollection.new(self, extract_selector(args).merge(tag_name: "a"))
+    def as(opts = {})
+      AnchorCollection.new(self, opts.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"))
+    def abbr(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "abbr"))
     end
     # @return [HTMLElementCollection]
-    def abbrs(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "abbr"))
+    def abbrs(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def address(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "address"))
     end
     # @return [HTMLElementCollection]
-    def addresses(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "address"))
+    def addresses(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def area(opts = {})
+      Area.new(self, opts.merge(tag_name: "area"))
     end
     # @return [AreaCollection]
-    def areas(*args)
-      AreaCollection.new(self, extract_selector(args).merge(tag_name: "area"))
+    def areas(opts = {})
+      AreaCollection.new(self, opts.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"))
+    def article(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "article"))
     end
     # @return [HTMLElementCollection]
-    def articles(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "article"))
+    def articles(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def aside(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "aside"))
     end
     # @return [HTMLElementCollection]
-    def asides(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "aside"))
+    def asides(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def audio(opts = {})
+      Audio.new(self, opts.merge(tag_name: "audio"))
     end
     # @return [AudioCollection]
-    def audios(*args)
-      AudioCollection.new(self, extract_selector(args).merge(tag_name: "audio"))
+    def audios(opts = {})
+      AudioCollection.new(self, opts.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"))
+    def b(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "b"))
     end
     # @return [HTMLElementCollection]
-    def bs(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "b"))
+    def bs(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def base(opts = {})
+      Base.new(self, opts.merge(tag_name: "base"))
     end
     # @return [BaseCollection]
-    def bases(*args)
-      BaseCollection.new(self, extract_selector(args).merge(tag_name: "base"))
+    def bases(opts = {})
+      BaseCollection.new(self, opts.merge(tag_name: "base"))
     end
     Watir.tag_to_class[:base] = Base
 
     # @return [HTMLElement]
-    def bdi(*args)
-      HTMLElement.new(self, extract_selector(args).merge(tag_name: "bdi"))
+    def bdi(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "bdi"))
     end
     # @return [HTMLElementCollection]
-    def bdis(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "bdi"))
+    def bdis(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "bdi"))
     end
     Watir.tag_to_class[:bdi] = HTMLElement
 
     # @return [HTMLElement]
-    def bdo(*args)
-      HTMLElement.new(self, extract_selector(args).merge(tag_name: "bdo"))
+    def bdo(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "bdo"))
     end
     # @return [HTMLElementCollection]
-    def bdos(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "bdo"))
+    def bdos(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def blockquote(opts = {})
+      Quote.new(self, opts.merge(tag_name: "blockquote"))
     end
     # @return [QuoteCollection]
-    def blockquotes(*args)
-      QuoteCollection.new(self, extract_selector(args).merge(tag_name: "blockquote"))
+    def blockquotes(opts = {})
+      QuoteCollection.new(self, opts.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"))
+    def body(opts = {})
+      Body.new(self, opts.merge(tag_name: "body"))
     end
     # @return [BodyCollection]
-    def bodys(*args)
-      BodyCollection.new(self, extract_selector(args).merge(tag_name: "body"))
+    def bodys(opts = {})
+      BodyCollection.new(self, opts.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"))
+    def br(opts = {})
+      BR.new(self, opts.merge(tag_name: "br"))
     end
     # @return [BRCollection]
-    def brs(*args)
-      BRCollection.new(self, extract_selector(args).merge(tag_name: "br"))
+    def brs(opts = {})
+      BRCollection.new(self, opts.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"))
+    def button(opts = {})
+      Button.new(self, opts.merge(tag_name: "button"))
     end
     # @return [ButtonCollection]
-    def buttons(*args)
-      ButtonCollection.new(self, extract_selector(args).merge(tag_name: "button"))
+    def buttons(opts = {})
+      ButtonCollection.new(self, opts.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"))
+    def canvas(opts = {})
+      Canvas.new(self, opts.merge(tag_name: "canvas"))
     end
     # @return [CanvasCollection]
-    def canvases(*args)
-      CanvasCollection.new(self, extract_selector(args).merge(tag_name: "canvas"))
+    def canvases(opts = {})
+      CanvasCollection.new(self, opts.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"))
+    def caption(opts = {})
+      TableCaption.new(self, opts.merge(tag_name: "caption"))
     end
     # @return [TableCaptionCollection]
-    def captions(*args)
-      TableCaptionCollection.new(self, extract_selector(args).merge(tag_name: "caption"))
+    def captions(opts = {})
+      TableCaptionCollection.new(self, opts.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"))
+    def cite(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "cite"))
     end
     # @return [HTMLElementCollection]
-    def cites(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "cite"))
+    def cites(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def code(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "code"))
     end
     # @return [HTMLElementCollection]
-    def codes(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "code"))
+    def codes(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def col(opts = {})
+      TableCol.new(self, opts.merge(tag_name: "col"))
     end
     # @return [TableColCollection]
-    def cols(*args)
-      TableColCollection.new(self, extract_selector(args).merge(tag_name: "col"))
+    def cols(opts = {})
+      TableColCollection.new(self, opts.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"))
+    def colgroup(opts = {})
+      TableCol.new(self, opts.merge(tag_name: "colgroup"))
     end
     # @return [TableColCollection]
-    def colgroups(*args)
-      TableColCollection.new(self, extract_selector(args).merge(tag_name: "colgroup"))
+    def colgroups(opts = {})
+      TableColCollection.new(self, opts.merge(tag_name: "colgroup"))
     end
     Watir.tag_to_class[:colgroup] = TableCol
 
     # @return [Data]
-    def data(*args)
-      Data.new(self, extract_selector(args).merge(tag_name: "data"))
+    def data(opts = {})
+      Data.new(self, opts.merge(tag_name: "data"))
     end
     # @return [DataCollection]
-    def datas(*args)
-      DataCollection.new(self, extract_selector(args).merge(tag_name: "data"))
+    def datas(opts = {})
+      DataCollection.new(self, opts.merge(tag_name: "data"))
     end
     Watir.tag_to_class[:data] = Data
 
     # @return [DataList]
-    def datalist(*args)
-      DataList.new(self, extract_selector(args).merge(tag_name: "datalist"))
+    def datalist(opts = {})
+      DataList.new(self, opts.merge(tag_name: "datalist"))
     end
     # @return [DataListCollection]
-    def datalists(*args)
-      DataListCollection.new(self, extract_selector(args).merge(tag_name: "datalist"))
+    def datalists(opts = {})
+      DataListCollection.new(self, opts.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"))
+    def dd(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "dd"))
     end
     # @return [HTMLElementCollection]
-    def dds(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "dd"))
+    def dds(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def del(opts = {})
+      Mod.new(self, opts.merge(tag_name: "del"))
     end
     # @return [ModCollection]
-    def dels(*args)
-      ModCollection.new(self, extract_selector(args).merge(tag_name: "del"))
+    def dels(opts = {})
+      ModCollection.new(self, opts.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"))
+    def details(opts = {})
+      Details.new(self, opts.merge(tag_name: "details"))
     end
     # @return [DetailsCollection]
-    def detailses(*args)
-      DetailsCollection.new(self, extract_selector(args).merge(tag_name: "details"))
+    def detailses(opts = {})
+      DetailsCollection.new(self, opts.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"))
+    def dfn(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "dfn"))
     end
     # @return [HTMLElementCollection]
-    def dfns(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "dfn"))
+    def dfns(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "dfn"))
     end
     Watir.tag_to_class[:dfn] = HTMLElement
 
     # @return [Dialog]
-    def dialog(*args)
-      Dialog.new(self, extract_selector(args).merge(tag_name: "dialog"))
+    def dialog(opts = {})
+      Dialog.new(self, opts.merge(tag_name: "dialog"))
     end
     # @return [DialogCollection]
-    def dialogs(*args)
-      DialogCollection.new(self, extract_selector(args).merge(tag_name: "dialog"))
+    def dialogs(opts = {})
+      DialogCollection.new(self, opts.merge(tag_name: "dialog"))
     end
     Watir.tag_to_class[:dialog] = Dialog
 
     # @return [Div]
-    def div(*args)
-      Div.new(self, extract_selector(args).merge(tag_name: "div"))
+    def div(opts = {})
+      Div.new(self, opts.merge(tag_name: "div"))
     end
     # @return [DivCollection]
-    def divs(*args)
-      DivCollection.new(self, extract_selector(args).merge(tag_name: "div"))
+    def divs(opts = {})
+      DivCollection.new(self, opts.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"))
+    def dl(opts = {})
+      DList.new(self, opts.merge(tag_name: "dl"))
     end
     # @return [DListCollection]
-    def dls(*args)
-      DListCollection.new(self, extract_selector(args).merge(tag_name: "dl"))
+    def dls(opts = {})
+      DListCollection.new(self, opts.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"))
+    def dt(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "dt"))
     end
     # @return [HTMLElementCollection]
-    def dts(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "dt"))
+    def dts(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def em(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "em"))
     end
     # @return [HTMLElementCollection]
-    def ems(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "em"))
+    def ems(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def embed(opts = {})
+      Embed.new(self, opts.merge(tag_name: "embed"))
     end
     # @return [EmbedCollection]
-    def embeds(*args)
-      EmbedCollection.new(self, extract_selector(args).merge(tag_name: "embed"))
+    def embeds(opts = {})
+      EmbedCollection.new(self, opts.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"))
+    def fieldset(opts = {})
+      FieldSet.new(self, opts.merge(tag_name: "fieldset"))
     end
     # @return [FieldSetCollection]
-    def fieldsets(*args)
-      FieldSetCollection.new(self, extract_selector(args).merge(tag_name: "fieldset"))
+    def fieldsets(opts = {})
+      FieldSetCollection.new(self, opts.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"))
+    def figcaption(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "figcaption"))
     end
     # @return [HTMLElementCollection]
-    def figcaptions(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "figcaption"))
+    def figcaptions(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def figure(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "figure"))
     end
     # @return [HTMLElementCollection]
-    def figures(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "figure"))
+    def figures(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def footer(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "footer"))
     end
     # @return [HTMLElementCollection]
-    def footers(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "footer"))
+    def footers(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def form(opts = {})
+      Form.new(self, opts.merge(tag_name: "form"))
     end
     # @return [FormCollection]
-    def forms(*args)
-      FormCollection.new(self, extract_selector(args).merge(tag_name: "form"))
+    def forms(opts = {})
+      FormCollection.new(self, opts.merge(tag_name: "form"))
     end
     Watir.tag_to_class[:form] = Form
 
     # @return [FrameSet]
-    def frameset(*args)
-      FrameSet.new(self, extract_selector(args).merge(tag_name: "frameset"))
+    def frameset(opts = {})
+      FrameSet.new(self, opts.merge(tag_name: "frameset"))
     end
     # @return [FrameSetCollection]
-    def framesets(*args)
-      FrameSetCollection.new(self, extract_selector(args).merge(tag_name: "frameset"))
+    def framesets(opts = {})
+      FrameSetCollection.new(self, opts.merge(tag_name: "frameset"))
     end
     Watir.tag_to_class[:frameset] = FrameSet
 
     # @return [Heading]
-    def h1(*args)
-      Heading.new(self, extract_selector(args).merge(tag_name: "h1"))
+    def h1(opts = {})
+      Heading.new(self, opts.merge(tag_name: "h1"))
     end
     # @return [HeadingCollection]
-    def h1s(*args)
-      HeadingCollection.new(self, extract_selector(args).merge(tag_name: "h1"))
+    def h1s(opts = {})
+      HeadingCollection.new(self, opts.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"))
+    def h2(opts = {})
+      Heading.new(self, opts.merge(tag_name: "h2"))
     end
     # @return [HeadingCollection]
-    def h2s(*args)
-      HeadingCollection.new(self, extract_selector(args).merge(tag_name: "h2"))
+    def h2s(opts = {})
+      HeadingCollection.new(self, opts.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"))
+    def h3(opts = {})
+      Heading.new(self, opts.merge(tag_name: "h3"))
     end
     # @return [HeadingCollection]
-    def h3s(*args)
-      HeadingCollection.new(self, extract_selector(args).merge(tag_name: "h3"))
+    def h3s(opts = {})
+      HeadingCollection.new(self, opts.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"))
+    def h4(opts = {})
+      Heading.new(self, opts.merge(tag_name: "h4"))
     end
     # @return [HeadingCollection]
-    def h4s(*args)
-      HeadingCollection.new(self, extract_selector(args).merge(tag_name: "h4"))
+    def h4s(opts = {})
+      HeadingCollection.new(self, opts.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"))
+    def h5(opts = {})
+      Heading.new(self, opts.merge(tag_name: "h5"))
     end
     # @return [HeadingCollection]
-    def h5s(*args)
-      HeadingCollection.new(self, extract_selector(args).merge(tag_name: "h5"))
+    def h5s(opts = {})
+      HeadingCollection.new(self, opts.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"))
+    def h6(opts = {})
+      Heading.new(self, opts.merge(tag_name: "h6"))
     end
     # @return [HeadingCollection]
-    def h6s(*args)
-      HeadingCollection.new(self, extract_selector(args).merge(tag_name: "h6"))
+    def h6s(opts = {})
+      HeadingCollection.new(self, opts.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"))
+    def head(opts = {})
+      Head.new(self, opts.merge(tag_name: "head"))
     end
     # @return [HeadCollection]
-    def heads(*args)
-      HeadCollection.new(self, extract_selector(args).merge(tag_name: "head"))
+    def heads(opts = {})
+      HeadCollection.new(self, opts.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"))
+    def header(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "header"))
     end
     # @return [HTMLElementCollection]
-    def headers(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "header"))
+    def headers(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "header"))
     end
     Watir.tag_to_class[:header] = HTMLElement
 
     # @return [HR]
-    def hr(*args)
-      HR.new(self, extract_selector(args).merge(tag_name: "hr"))
+    def hr(opts = {})
+      HR.new(self, opts.merge(tag_name: "hr"))
     end
     # @return [HRCollection]
-    def hrs(*args)
-      HRCollection.new(self, extract_selector(args).merge(tag_name: "hr"))
+    def hrs(opts = {})
+      HRCollection.new(self, opts.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"))
+    def html(opts = {})
+      Html.new(self, opts.merge(tag_name: "html"))
     end
     # @return [HtmlCollection]
-    def htmls(*args)
-      HtmlCollection.new(self, extract_selector(args).merge(tag_name: "html"))
+    def htmls(opts = {})
+      HtmlCollection.new(self, opts.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"))
+    def i(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "i"))
     end
     # @return [HTMLElementCollection]
-    def is(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "i"))
+    def is(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def iframe(opts = {})
+      IFrame.new(self, opts.merge(tag_name: "iframe"))
     end
     # @return [IFrameCollection]
-    def iframes(*args)
-      IFrameCollection.new(self, extract_selector(args).merge(tag_name: "iframe"))
+    def iframes(opts = {})
+      IFrameCollection.new(self, opts.merge(tag_name: "iframe"))
     end
     Watir.tag_to_class[:iframe] = IFrame
 
     # @return [Image]
-    def img(*args)
-      Image.new(self, extract_selector(args).merge(tag_name: "img"))
+    def img(opts = {})
+      Image.new(self, opts.merge(tag_name: "img"))
     end
     # @return [ImageCollection]
-    def imgs(*args)
-      ImageCollection.new(self, extract_selector(args).merge(tag_name: "img"))
+    def imgs(opts = {})
+      ImageCollection.new(self, opts.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"))
+    def input(opts = {})
+      Input.new(self, opts.merge(tag_name: "input"))
     end
     # @return [InputCollection]
-    def inputs(*args)
-      InputCollection.new(self, extract_selector(args).merge(tag_name: "input"))
+    def inputs(opts = {})
+      InputCollection.new(self, opts.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"))
+    def ins(opts = {})
+      Mod.new(self, opts.merge(tag_name: "ins"))
     end
     # @return [ModCollection]
-    def inses(*args)
-      ModCollection.new(self, extract_selector(args).merge(tag_name: "ins"))
+    def inses(opts = {})
+      ModCollection.new(self, opts.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"))
+    def kbd(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "kbd"))
     end
     # @return [HTMLElementCollection]
-    def kbds(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "kbd"))
+    def kbds(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "kbd"))
     end
     Watir.tag_to_class[:kbd] = HTMLElement
 
     # @return [Label]
-    def label(*args)
-      Label.new(self, extract_selector(args).merge(tag_name: "label"))
+    def label(opts = {})
+      Label.new(self, opts.merge(tag_name: "label"))
     end
     # @return [LabelCollection]
-    def labels(*args)
-      LabelCollection.new(self, extract_selector(args).merge(tag_name: "label"))
+    def labels(opts = {})
+      LabelCollection.new(self, opts.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"))
+    def legend(opts = {})
+      Legend.new(self, opts.merge(tag_name: "legend"))
     end
     # @return [LegendCollection]
-    def legends(*args)
-      LegendCollection.new(self, extract_selector(args).merge(tag_name: "legend"))
+    def legends(opts = {})
+      LegendCollection.new(self, opts.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"))
+    def li(opts = {})
+      LI.new(self, opts.merge(tag_name: "li"))
     end
     # @return [LICollection]
-    def lis(*args)
-      LICollection.new(self, extract_selector(args).merge(tag_name: "li"))
+    def lis(opts = {})
+      LICollection.new(self, opts.merge(tag_name: "li"))
     end
     Watir.tag_to_class[:li] = LI
 
     # @return [HTMLElement]
-    def main(*args)
-      HTMLElement.new(self, extract_selector(args).merge(tag_name: "main"))
+    def main(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "main"))
     end
     # @return [HTMLElementCollection]
-    def mains(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "main"))
+    def mains(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "main"))
     end
     Watir.tag_to_class[:main] = HTMLElement
 
     # @return [Map]
-    def map(*args)
-      Map.new(self, extract_selector(args).merge(tag_name: "map"))
+    def map(opts = {})
+      Map.new(self, opts.merge(tag_name: "map"))
     end
     # @return [MapCollection]
-    def maps(*args)
-      MapCollection.new(self, extract_selector(args).merge(tag_name: "map"))
+    def maps(opts = {})
+      MapCollection.new(self, opts.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"))
+    def mark(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "mark"))
     end
     # @return [HTMLElementCollection]
-    def marks(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "mark"))
+    def marks(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "mark"))
     end
     Watir.tag_to_class[:mark] = HTMLElement
 
     # @return [Meta]
-    def meta(*args)
-      Meta.new(self, extract_selector(args).merge(tag_name: "meta"))
+    def meta(opts = {})
+      Meta.new(self, opts.merge(tag_name: "meta"))
     end
     # @return [MetaCollection]
-    def metas(*args)
-      MetaCollection.new(self, extract_selector(args).merge(tag_name: "meta"))
+    def metas(opts = {})
+      MetaCollection.new(self, opts.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"))
+    def meter(opts = {})
+      Meter.new(self, opts.merge(tag_name: "meter"))
     end
     # @return [MeterCollection]
-    def meters(*args)
-      MeterCollection.new(self, extract_selector(args).merge(tag_name: "meter"))
+    def meters(opts = {})
+      MeterCollection.new(self, opts.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"))
+    def nav(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "nav"))
     end
     # @return [HTMLElementCollection]
-    def navs(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "nav"))
+    def navs(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def noscript(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "noscript"))
     end
     # @return [HTMLElementCollection]
-    def noscripts(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "noscript"))
+    def noscripts(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def object(opts = {})
+      Object.new(self, opts.merge(tag_name: "object"))
     end
     # @return [ObjectCollection]
-    def objects(*args)
-      ObjectCollection.new(self, extract_selector(args).merge(tag_name: "object"))
+    def objects(opts = {})
+      ObjectCollection.new(self, opts.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"))
+    def ol(opts = {})
+      OList.new(self, opts.merge(tag_name: "ol"))
     end
     # @return [OListCollection]
-    def ols(*args)
-      OListCollection.new(self, extract_selector(args).merge(tag_name: "ol"))
+    def ols(opts = {})
+      OListCollection.new(self, opts.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"))
+    def optgroup(opts = {})
+      OptGroup.new(self, opts.merge(tag_name: "optgroup"))
     end
     # @return [OptGroupCollection]
-    def optgroups(*args)
-      OptGroupCollection.new(self, extract_selector(args).merge(tag_name: "optgroup"))
+    def optgroups(opts = {})
+      OptGroupCollection.new(self, opts.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"))
+    def option(opts = {})
+      Option.new(self, opts.merge(tag_name: "option"))
     end
     # @return [OptionCollection]
-    def options(*args)
-      OptionCollection.new(self, extract_selector(args).merge(tag_name: "option"))
+    def options(opts = {})
+      OptionCollection.new(self, opts.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"))
+    def output(opts = {})
+      Output.new(self, opts.merge(tag_name: "output"))
     end
     # @return [OutputCollection]
-    def outputs(*args)
-      OutputCollection.new(self, extract_selector(args).merge(tag_name: "output"))
+    def outputs(opts = {})
+      OutputCollection.new(self, opts.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"))
+    def p(opts = {})
+      Paragraph.new(self, opts.merge(tag_name: "p"))
     end
     # @return [ParagraphCollection]
-    def ps(*args)
-      ParagraphCollection.new(self, extract_selector(args).merge(tag_name: "p"))
+    def ps(opts = {})
+      ParagraphCollection.new(self, opts.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"))
+    def param(opts = {})
+      Param.new(self, opts.merge(tag_name: "param"))
     end
     # @return [ParamCollection]
-    def params(*args)
-      ParamCollection.new(self, extract_selector(args).merge(tag_name: "param"))
+    def params(opts = {})
+      ParamCollection.new(self, opts.merge(tag_name: "param"))
     end
     Watir.tag_to_class[:param] = Param
 
     # @return [Picture]
-    def picture(*args)
-      Picture.new(self, extract_selector(args).merge(tag_name: "picture"))
+    def picture(opts = {})
+      Picture.new(self, opts.merge(tag_name: "picture"))
     end
     # @return [PictureCollection]
-    def pictures(*args)
-      PictureCollection.new(self, extract_selector(args).merge(tag_name: "picture"))
+    def pictures(opts = {})
+      PictureCollection.new(self, opts.merge(tag_name: "picture"))
     end
     Watir.tag_to_class[:picture] = Picture
 
     # @return [Pre]
-    def pre(*args)
-      Pre.new(self, extract_selector(args).merge(tag_name: "pre"))
+    def pre(opts = {})
+      Pre.new(self, opts.merge(tag_name: "pre"))
     end
     # @return [PreCollection]
-    def pres(*args)
-      PreCollection.new(self, extract_selector(args).merge(tag_name: "pre"))
+    def pres(opts = {})
+      PreCollection.new(self, opts.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"))
+    def progress(opts = {})
+      Progress.new(self, opts.merge(tag_name: "progress"))
     end
     # @return [ProgressCollection]
-    def progresses(*args)
-      ProgressCollection.new(self, extract_selector(args).merge(tag_name: "progress"))
+    def progresses(opts = {})
+      ProgressCollection.new(self, opts.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"))
+    def q(opts = {})
+      Quote.new(self, opts.merge(tag_name: "q"))
     end
     # @return [QuoteCollection]
-    def qs(*args)
-      QuoteCollection.new(self, extract_selector(args).merge(tag_name: "q"))
+    def qs(opts = {})
+      QuoteCollection.new(self, opts.merge(tag_name: "q"))
     end
     Watir.tag_to_class[:q] = Quote
 
     # @return [HTMLElement]
-    def rb(*args)
-      HTMLElement.new(self, extract_selector(args).merge(tag_name: "rb"))
+    def rb(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "rb"))
     end
     # @return [HTMLElementCollection]
-    def rbs(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "rb"))
+    def rbs(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "rb"))
     end
     Watir.tag_to_class[:rb] = HTMLElement
 
     # @return [HTMLElement]
-    def rp(*args)
-      HTMLElement.new(self, extract_selector(args).merge(tag_name: "rp"))
+    def rp(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "rp"))
     end
     # @return [HTMLElementCollection]
-    def rps(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "rp"))
+    def rps(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def rt(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "rt"))
     end
     # @return [HTMLElementCollection]
-    def rts(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "rt"))
+    def rts(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "rt"))
     end
     Watir.tag_to_class[:rt] = HTMLElement
 
     # @return [HTMLElement]
-    def rtc(*args)
-      HTMLElement.new(self, extract_selector(args).merge(tag_name: "rtc"))
+    def rtc(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "rtc"))
     end
     # @return [HTMLElementCollection]
-    def rtcs(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "rtc"))
+    def rtcs(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "rtc"))
     end
     Watir.tag_to_class[:rtc] = HTMLElement
 
     # @return [HTMLElement]
-    def ruby(*args)
-      HTMLElement.new(self, extract_selector(args).merge(tag_name: "ruby"))
+    def ruby(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "ruby"))
     end
     # @return [HTMLElementCollection]
-    def rubies(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "ruby"))
+    def rubies(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "ruby"))
     end
     Watir.tag_to_class[:ruby] = HTMLElement
 
     # @return [HTMLElement]
-    def s(*args)
-      HTMLElement.new(self, extract_selector(args).merge(tag_name: "s"))
+    def s(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "s"))
     end
     # @return [HTMLElementCollection]
-    def ss(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "s"))
+    def ss(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "s"))
     end
     Watir.tag_to_class[:s] = HTMLElement
 
     # @return [HTMLElement]
-    def samp(*args)
-      HTMLElement.new(self, extract_selector(args).merge(tag_name: "samp"))
+    def samp(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "samp"))
     end
     # @return [HTMLElementCollection]
-    def samps(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "samp"))
+    def samps(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def script(opts = {})
+      Script.new(self, opts.merge(tag_name: "script"))
     end
     # @return [ScriptCollection]
-    def scripts(*args)
-      ScriptCollection.new(self, extract_selector(args).merge(tag_name: "script"))
+    def scripts(opts = {})
+      ScriptCollection.new(self, opts.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"))
+    def section(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "section"))
     end
     # @return [HTMLElementCollection]
-    def sections(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "section"))
+    def sections(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def select(opts = {})
+      Select.new(self, opts.merge(tag_name: "select"))
     end
     # @return [SelectCollection]
-    def selects(*args)
-      SelectCollection.new(self, extract_selector(args).merge(tag_name: "select"))
+    def selects(opts = {})
+      SelectCollection.new(self, opts.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"))
+    def small(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "small"))
     end
     # @return [HTMLElementCollection]
-    def smalls(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "small"))
+    def smalls(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def source(opts = {})
+      Source.new(self, opts.merge(tag_name: "source"))
     end
     # @return [SourceCollection]
-    def sources(*args)
-      SourceCollection.new(self, extract_selector(args).merge(tag_name: "source"))
+    def sources(opts = {})
+      SourceCollection.new(self, opts.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"))
+    def span(opts = {})
+      Span.new(self, opts.merge(tag_name: "span"))
     end
     # @return [SpanCollection]
-    def spans(*args)
-      SpanCollection.new(self, extract_selector(args).merge(tag_name: "span"))
+    def spans(opts = {})
+      SpanCollection.new(self, opts.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"))
+    def strong(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "strong"))
     end
     # @return [HTMLElementCollection]
-    def strongs(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "strong"))
+    def strongs(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def style(opts = {})
+      Style.new(self, opts.merge(tag_name: "style"))
     end
     # @return [StyleCollection]
-    def styles(*args)
-      StyleCollection.new(self, extract_selector(args).merge(tag_name: "style"))
+    def styles(opts = {})
+      StyleCollection.new(self, opts.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"))
+    def sub(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "sub"))
     end
     # @return [HTMLElementCollection]
-    def subs(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "sub"))
+    def subs(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def summary(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "summary"))
     end
     # @return [HTMLElementCollection]
-    def summaries(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "summary"))
+    def summaries(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def sup(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "sup"))
     end
     # @return [HTMLElementCollection]
-    def sups(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "sup"))
+    def sups(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def table(opts = {})
+      Table.new(self, opts.merge(tag_name: "table"))
     end
     # @return [TableCollection]
-    def tables(*args)
-      TableCollection.new(self, extract_selector(args).merge(tag_name: "table"))
+    def tables(opts = {})
+      TableCollection.new(self, opts.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"))
+    def tbody(opts = {})
+      TableSection.new(self, opts.merge(tag_name: "tbody"))
     end
     # @return [TableSectionCollection]
-    def tbodys(*args)
-      TableSectionCollection.new(self, extract_selector(args).merge(tag_name: "tbody"))
+    def tbodys(opts = {})
+      TableSectionCollection.new(self, opts.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"))
+    def td(opts = {})
+      TableDataCell.new(self, opts.merge(tag_name: "td"))
     end
     # @return [TableDataCellCollection]
-    def tds(*args)
-      TableDataCellCollection.new(self, extract_selector(args).merge(tag_name: "td"))
+    def tds(opts = {})
+      TableDataCellCollection.new(self, opts.merge(tag_name: "td"))
     end
     Watir.tag_to_class[:td] = TableDataCell
 
     # @return [Template]
-    def template(*args)
-      Template.new(self, extract_selector(args).merge(tag_name: "template"))
+    def template(opts = {})
+      Template.new(self, opts.merge(tag_name: "template"))
     end
     # @return [TemplateCollection]
-    def templates(*args)
-      TemplateCollection.new(self, extract_selector(args).merge(tag_name: "template"))
+    def templates(opts = {})
+      TemplateCollection.new(self, opts.merge(tag_name: "template"))
     end
     Watir.tag_to_class[:template] = Template
 
     # @return [TextArea]
-    def textarea(*args)
-      TextArea.new(self, extract_selector(args).merge(tag_name: "textarea"))
+    def textarea(opts = {})
+      TextArea.new(self, opts.merge(tag_name: "textarea"))
     end
     # @return [TextAreaCollection]
-    def textareas(*args)
-      TextAreaCollection.new(self, extract_selector(args).merge(tag_name: "textarea"))
+    def textareas(opts = {})
+      TextAreaCollection.new(self, opts.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"))
+    def tfoot(opts = {})
+      TableSection.new(self, opts.merge(tag_name: "tfoot"))
     end
     # @return [TableSectionCollection]
-    def tfoots(*args)
-      TableSectionCollection.new(self, extract_selector(args).merge(tag_name: "tfoot"))
+    def tfoots(opts = {})
+      TableSectionCollection.new(self, opts.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"))
+    def th(opts = {})
+      TableHeaderCell.new(self, opts.merge(tag_name: "th"))
     end
     # @return [TableHeaderCellCollection]
-    def ths(*args)
-      TableHeaderCellCollection.new(self, extract_selector(args).merge(tag_name: "th"))
+    def ths(opts = {})
+      TableHeaderCellCollection.new(self, opts.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"))
+    def thead(opts = {})
+      TableSection.new(self, opts.merge(tag_name: "thead"))
     end
     # @return [TableSectionCollection]
-    def theads(*args)
-      TableSectionCollection.new(self, extract_selector(args).merge(tag_name: "thead"))
+    def theads(opts = {})
+      TableSectionCollection.new(self, opts.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"))
+    def time(opts = {})
+      Time.new(self, opts.merge(tag_name: "time"))
     end
     # @return [TimeCollection]
-    def times(*args)
-      TimeCollection.new(self, extract_selector(args).merge(tag_name: "time"))
+    def times(opts = {})
+      TimeCollection.new(self, opts.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"))
+    def title(opts = {})
+      Title.new(self, opts.merge(tag_name: "title"))
     end
     # @return [TitleCollection]
-    def titles(*args)
-      TitleCollection.new(self, extract_selector(args).merge(tag_name: "title"))
+    def titles(opts = {})
+      TitleCollection.new(self, opts.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"))
+    def tr(opts = {})
+      TableRow.new(self, opts.merge(tag_name: "tr"))
     end
     # @return [TableRowCollection]
-    def trs(*args)
-      TableRowCollection.new(self, extract_selector(args).merge(tag_name: "tr"))
+    def trs(opts = {})
+      TableRowCollection.new(self, opts.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"))
+    def track(opts = {})
+      Track.new(self, opts.merge(tag_name: "track"))
     end
     # @return [TrackCollection]
-    def tracks(*args)
-      TrackCollection.new(self, extract_selector(args).merge(tag_name: "track"))
+    def tracks(opts = {})
+      TrackCollection.new(self, opts.merge(tag_name: "track"))
     end
     Watir.tag_to_class[:track] = Track
 
     # @return [HTMLElement]
-    def u(*args)
-      HTMLElement.new(self, extract_selector(args).merge(tag_name: "u"))
+    def u(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "u"))
     end
     # @return [HTMLElementCollection]
-    def us(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "u"))
+    def us(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "u"))
     end
     Watir.tag_to_class[:u] = HTMLElement
 
     # @return [UList]
-    def ul(*args)
-      UList.new(self, extract_selector(args).merge(tag_name: "ul"))
+    def ul(opts = {})
+      UList.new(self, opts.merge(tag_name: "ul"))
     end
     # @return [UListCollection]
-    def uls(*args)
-      UListCollection.new(self, extract_selector(args).merge(tag_name: "ul"))
+    def uls(opts = {})
+      UListCollection.new(self, opts.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"))
+    def var(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "var"))
     end
     # @return [HTMLElementCollection]
-    def vars(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "var"))
+    def vars(opts = {})
+      HTMLElementCollection.new(self, opts.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"))
+    def video(opts = {})
+      Video.new(self, opts.merge(tag_name: "video"))
     end
     # @return [VideoCollection]
-    def videos(*args)
-      VideoCollection.new(self, extract_selector(args).merge(tag_name: "video"))
+    def videos(opts = {})
+      VideoCollection.new(self, opts.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"))
+    def wbr(opts = {})
+      HTMLElement.new(self, opts.merge(tag_name: "wbr"))
     end
     # @return [HTMLElementCollection]
-    def wbrs(*args)
-      HTMLElementCollection.new(self, extract_selector(args).merge(tag_name: "wbr"))
+    def wbrs(opts = {})
+      HTMLElementCollection.new(self, opts.merge(tag_name: "wbr"))
     end
     Watir.tag_to_class[:wbr] = HTMLElement
   end # Container