Code coverage for Watir-webdriver

Generated 2010-12-22T11:22:39+01:00

All Files (89.47%)

37 files in total. 2146 relevant lines. 1920 lines covered and 226 lines missed

File	% covered	Lines	Relevant Lines	Lines covered	Lines missed
./lib/watir-webdriver.rb	100.0 %	71	50	50	0
./lib/watir-webdriver/attribute_helper.rb	100.0 %	128	59	59	0
./lib/watir-webdriver/browser.rb	95.18 %	181	83	79	4
./lib/watir-webdriver/cell_container.rb	100.0 %	19	10	10	0
./lib/watir-webdriver/container.rb	100.0 %	40	20	20	0
./lib/watir-webdriver/element_collection.rb	100.0 %	96	24	24	0
./lib/watir-webdriver/elements/button.rb	95.45 %	66	22	21	1
./lib/watir-webdriver/elements/checkbox.rb	100.0 %	65	21	21	0
./lib/watir-webdriver/elements/element.rb	85.61 %	265	139	119	20
./lib/watir-webdriver/elements/file_field.rb	100.0 %	61	20	20	0
./lib/watir-webdriver/elements/font.rb	100.0 %	11	6	6	0
./lib/watir-webdriver/elements/form.rb	100.0 %	17	5	5	0
./lib/watir-webdriver/elements/frame.rb	94.12 %	102	51	48	3
./lib/watir-webdriver/elements/generated.rb	80.58 %	2561	937	755	182
./lib/watir-webdriver/elements/hidden.rb	91.67 %	24	12	11	1
./lib/watir-webdriver/elements/image.rb	71.43 %	51	21	15	6
./lib/watir-webdriver/elements/input.rb	100.0 %	28	9	9	0
./lib/watir-webdriver/elements/link.rb	100.0 %	7	4	4	0
./lib/watir-webdriver/elements/option.rb	100.0 %	55	18	18	0
./lib/watir-webdriver/elements/radio.rb	100.0 %	42	18	18	0
./lib/watir-webdriver/elements/select.rb	97.59 %	222	83	81	2
./lib/watir-webdriver/elements/table.rb	93.75 %	37	16	15	1
./lib/watir-webdriver/elements/table_cell.rb	100.0 %	36	17	17	0
./lib/watir-webdriver/elements/table_row.rb	100.0 %	45	18	18	0
./lib/watir-webdriver/elements/table_section.rb	100.0 %	9	5	5	0
./lib/watir-webdriver/elements/text_field.rb	100.0 %	87	40	40	0
./lib/watir-webdriver/exception.rb	100.0 %	21	14	14	0
./lib/watir-webdriver/extensions/alerts.rb	100.0 %	69	18	18	0
./lib/watir-webdriver/extensions/wait.rb	97.37 %	141	38	37	1
./lib/watir-webdriver/locators/button_locator.rb	100.0 %	74	42	42	0
./lib/watir-webdriver/locators/child_cell_locator.rb	100.0 %	32	15	15	0
./lib/watir-webdriver/locators/child_row_locator.rb	100.0 %	37	18	18	0
./lib/watir-webdriver/locators/element_locator.rb	98.31 %	363	177	174	3
./lib/watir-webdriver/locators/text_field_locator.rb	100.0 %	65	37	37	0
./lib/watir-webdriver/row_container.rb	100.0 %	34	15	15	0
./lib/watir-webdriver/window_switching.rb	96.3 %	105	54	52	2
./lib/watir-webdriver/xpath_support.rb	100.0 %	28	10	10	0



# encoding: utf-8
require "selenium-webdriver"
require "json"

require "watir-webdriver/version"
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"
require "watir-webdriver/locators/text_field_locator"
require "watir-webdriver/locators/child_row_locator"
require "watir-webdriver/locators/child_cell_locator"
require "watir-webdriver/browser"

module Watir
  include Selenium

  class << self
    def tag_to_class
      @tag_to_class ||= {}
    end

    def element_class_for(tag_name)
      tag_to_class[tag_name.to_sym] || HTMLElement
    end
  end

end

require "watir-webdriver/attribute_helper"
require "watir-webdriver/row_container"
require "watir-webdriver/cell_container"
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"
require "watir-webdriver/elements/button"
require "watir-webdriver/elements/checkbox"
require "watir-webdriver/elements/file_field"
require "watir-webdriver/elements/image"
require "watir-webdriver/elements/link"
require "watir-webdriver/elements/font"
require "watir-webdriver/elements/radio"
require "watir-webdriver/elements/text_field"
require "watir-webdriver/elements/hidden"
require "watir-webdriver/elements/select"
require "watir-webdriver/elements/form"
require "watir-webdriver/elements/option"
require "watir-webdriver/elements/table"
require "watir-webdriver/elements/table_row"
require "watir-webdriver/elements/table_cell"
require "watir-webdriver/elements/table_section"

Watir.tag_to_class.freeze

module Watir
  module Container

  end # Container
end # Watir


# undefine deprecated methods to use them for Element attributes
class Object
  undef_method :id if method_defined? "id"
  undef_method :type if method_defined? "type"
end


./lib/watir-webdriver.rb 100.0 % covered
1	# encoding: utf-8
2	require "selenium-webdriver"	1
3	require "json"	1
4
5	require "watir-webdriver/version"	1
6	require "watir-webdriver/exception"	1
7	require "watir-webdriver/xpath_support"	1
8	require "watir-webdriver/window_switching"	1
9	require "watir-webdriver/container"	1
10	require "watir-webdriver/locators/element_locator"	1
11	require "watir-webdriver/locators/button_locator"	1
12	require "watir-webdriver/locators/text_field_locator"	1
13	require "watir-webdriver/locators/child_row_locator"	1
14	require "watir-webdriver/locators/child_cell_locator"	1
15	require "watir-webdriver/browser"	1
16
17	module Watir	1
18	include Selenium	1
19
20	class << self	1
21	def tag_to_class	1
22	@tag_to_class \|\|= {}	124
23	end
24
25	def element_class_for(tag_name)	1
26	tag_to_class[tag_name.to_sym] \|\| HTMLElement	17
27	end
28	end
29
30	end
31
32	require "watir-webdriver/attribute_helper"	1
33	require "watir-webdriver/row_container"	1
34	require "watir-webdriver/cell_container"	1
35	require "watir-webdriver/element_collection"	1
36	require "watir-webdriver/elements/element"	1
37	require "watir-webdriver/elements/generated"	1
38	require "watir-webdriver/elements/frame"	1
39	require "watir-webdriver/elements/input"	1
40	require "watir-webdriver/elements/button"	1
41	require "watir-webdriver/elements/checkbox"	1
42	require "watir-webdriver/elements/file_field"	1
43	require "watir-webdriver/elements/image"	1
44	require "watir-webdriver/elements/link"	1
45	require "watir-webdriver/elements/font"	1
46	require "watir-webdriver/elements/radio"	1
47	require "watir-webdriver/elements/text_field"	1
48	require "watir-webdriver/elements/hidden"	1
49	require "watir-webdriver/elements/select"	1
50	require "watir-webdriver/elements/form"	1
51	require "watir-webdriver/elements/option"	1
52	require "watir-webdriver/elements/table"	1
53	require "watir-webdriver/elements/table_row"	1
54	require "watir-webdriver/elements/table_cell"	1
55	require "watir-webdriver/elements/table_section"	1
56
57	Watir.tag_to_class.freeze	1
58
59	module Watir	1
60	module Container	1
61
62	end # Container
63	end # Watir
64
65
66	# undefine deprecated methods to use them for Element attributes
67	class Object	1
68	undef_method :id if method_defined? "id"	1
69	undef_method :type if method_defined? "type"	1
70	end
71



module Watir

  #
  # @private
  #
  # Extended by Element, provides methods for defining attributes on the element classes.
  #

  module AttributeHelper

    IGNORED_ATTRIBUTES = [:text, :hash]

    def typed_attributes
      @typed_attributes ||= Hash.new { |hash, type| hash[type] = []  }
    end

    def attribute_list
      @attribute_list ||= (
        list = typed_attributes.values.flatten
        list += ancestors[1..-1].map do |e|
          e.attribute_list if e.respond_to?(:attribute_list)
        end.compact.flatten
      ).uniq
    end

    def attributes(attribute_map = nil)
      attribute_map or return attribute_list

      add_attributes attribute_map

      attribute_map.each do |type, attribs|
        attribs.each do |name|
          # we don't want to override methods like :text or :hash
          next if IGNORED_ATTRIBUTES.include?(name)
          define_attribute(type, name)
        end
      end
    end

    private

    def define_attribute(type, name)
      method_name    = method_name_for(type, name)
      attribute_name = attribute_for_method(name)

      (@attributes ||= []) << attribute_name

      case type
      when :string
        define_string_attribute(method_name, attribute_name)
      when :bool
        define_boolean_attribute(method_name, attribute_name)
      when :int
        define_int_attribute(method_name, attribute_name)
      else
        # $stderr.puts "treating #{type.inspect} as string for now"
      end
    end

    def define_string_attribute(mname, aname)
      define_method mname do
        assert_exists
        @element.attribute(aname).to_s
      end
    end

    def define_boolean_attribute(mname, aname)
      define_method mname do
        assert_exists
        @element.attribute(aname) == "true"
      end
    end

    def define_int_attribute(mname, aname)
      define_method mname do
        assert_exists
        value = @element.attribute(aname)
        value && Integer(value)
      end
    end

    def add_attributes(attributes)
      attributes.each do |type, attr_list|
        typed_attributes[type] += attr_list
      end
    end

    def method_name_for(type, attribute)
      # http://github.com/jarib/watir-webdriver/issues/issue/26
      name = case attribute
             when :html_for
               'for'
             when :col_span
               'colspan'
             when :row_span
               'rowspan'
             else
               attribute.to_s
             end

      name << "?" if type == :bool

      name
    end

    def attribute_for_method(method)
      # http://github.com/jarib/watir-webdriver/issues/issue/26

      case method.to_sym
      when :class_name
        'class'
      when :html_for
        'for'
      when :read_only
        'readonly'
      when :http_equiv
        'http-equiv'
      when :col_span
        'colspan'
      when :row_span
        'rowspan'
      else
        method.to_s
      end
    end

  end # AttributeHelper
end # Watir

./lib/watir-webdriver/attribute_helper.rb 100.0 % covered
1	module Watir	1
2
3	#
4	# @private
5	#
6	# Extended by Element, provides methods for defining attributes on the element classes.
7	#
8
9	module AttributeHelper	1
10
11	IGNORED_ATTRIBUTES = [:text, :hash]	1
12
13	def typed_attributes	1
14	@typed_attributes \|\|= Hash.new { \|hash, type\| hash[type] = [] }	402
15	end
16
17	def attribute_list	1
18	@attribute_list \|\|= (
19	list = typed_attributes.values.flatten	37
20	list += ancestors[1..-1].map do \|e\|	37
21	e.attribute_list if e.respond_to?(:attribute_list)	673
22	end.compact.flatten
23	).uniq	2860
24	end
25
26	def attributes(attribute_map = nil)	1
27	attribute_map or return attribute_list	131
28
29	add_attributes attribute_map	89
30
31	attribute_map.each do \|type, attribs\|	89
32	attribs.each do \|name\|	190
33	# we don't want to override methods like :text or :hash
34	next if IGNORED_ATTRIBUTES.include?(name)	665
35	define_attribute(type, name)	658
36	end
37	end
38	end
39
40	private	1
41
42	def define_attribute(type, name)	1
43	method_name = method_name_for(type, name)	658
44	attribute_name = attribute_for_method(name)	658
45
46	(@attributes \|\|= []) << attribute_name	658
47
48	case type	658
49	when :string
50	define_string_attribute(method_name, attribute_name)	328
51	when :bool
52	define_boolean_attribute(method_name, attribute_name)	88
53	when :int
54	define_int_attribute(method_name, attribute_name)	59
55	else
56	# $stderr.puts "treating #{type.inspect} as string for now"
57	end
58	end
59
60	def define_string_attribute(mname, aname)	1
61	define_method mname do	328
62	assert_exists	1149
63	@element.attribute(aname).to_s	1022
64	end
65	end
66
67	def define_boolean_attribute(mname, aname)	1
68	define_method mname do	88
69	assert_exists	94
70	@element.attribute(aname) == "true"	80
71	end
72	end
73
74	def define_int_attribute(mname, aname)	1
75	define_method mname do	59
76	assert_exists	36
77	value = @element.attribute(aname)	36
78	value && Integer(value)	36
79	end
80	end
81
82	def add_attributes(attributes)	1
83	attributes.each do \|type, attr_list\|	89
84	typed_attributes[type] += attr_list	190
85	end
86	end
87
88	def method_name_for(type, attribute)	1
89	# http://github.com/jarib/watir-webdriver/issues/issue/26
90	name = case attribute	658
91	when :html_for
92	'for'	3
93	when :col_span
94	'colspan'	1
95	when :row_span
96	'rowspan'	1
97	else
98	attribute.to_s	653
99	end
100
101	name << "?" if type == :bool	658
102
103	name	658
104	end
105
106	def attribute_for_method(method)	1
107	# http://github.com/jarib/watir-webdriver/issues/issue/26
108
109	case method.to_sym	658
110	when :class_name
111	'class'	1
112	when :html_for
113	'for'	3
114	when :read_only
115	'readonly'	4
116	when :http_equiv
117	'http-equiv'	1
118	when :col_span
119	'colspan'	1
120	when :row_span
121	'rowspan'	1
122	else
123	method.to_s	647
124	end
125	end
126
127	end # AttributeHelper
128	end # Watir



# 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

    class << self
      def start(url, browser = :firefox)
        b = new(browser)
        b.goto url

        b
      end
    end

    #
    # Create a Watir::Browser instance
    #
    # @param [:firefox, :ie, :chrome, :remote, Selenium::WebDriver] browser
    # @param args Passed to the underlying driver
    #

    def initialize(browser = :firefox, *args)
      case browser
      when Symbol, String
        @driver = Selenium::WebDriver.for browser.to_sym, *args
      when Selenium::WebDriver::Driver
        @driver = browser
      else
        raise ArgumentError, "expected Symbol or Selenium::WebDriver::Driver, got #{browser.class}"
      end

      @error_checkers = []
      @current_frame  = nil
      @closed         = false
    end

    def inspect
      '#<%s:0x%x url=%s title=%s>' % [self.class, hash*2, url.inspect, title.inspect]
    end

    #
    # Goto the given URL
    #
    # @param [String] uri The url.
    # @return [String] The url you end up at.
    #

    def goto(uri)
      uri = "http://#{uri}" unless uri.include?("://")

      @driver.navigate.to uri
      run_checkers

      url
    end

    def back
      @driver.navigate.back
    end

    def forward
      @driver.navigate.forward
    end

    def url
      @driver.current_url
    end

    def title
      @driver.title
    end

    def close
      return if @closed
      @driver.quit
      @closed = true
    end
    alias_method :quit, :close # TODO: close vs quit

    def clear_cookies
      @driver.manage.delete_all_cookies
    end

    def text
      @driver.find_element(:tag_name, "body").text
    end

    def html
      # use body.html instead?
      @driver.page_source
    end

    def refresh
      @driver.navigate.refresh
      run_checkers
    end

    def status
      execute_script "return window.status;"
    end

    def execute_script(script, *args)
      args.map! { |e| e.kind_of?(Watir::Element) ? e.element : e }
      returned = @driver.execute_script(script, *args)

      wrap_elements_in(returned)
    end

    def add_checker(checker = nil, &block)
      if block_given?
        @error_checkers << block
      elsif Proc === checker
        @error_checkers << checker
      else
        raise ArgumentError, "argument must be a Proc or block"
      end
    end

    def disable_checker(checker)
      @error_checkers.delete(checker)
    end

    def run_checkers
      @error_checkers.each { |e| e[self] }
    end

    #
    # Protocol shared with Watir::Element
    #
    # @api private
    #

    def assert_exists
      if @closed
        raise Error, "browser was closed"
      else
        driver.switch_to.default_content
        true
      end
    end

    def exist?
      not @closed
    end

    def browser
      self
    end

    private

    def wrap_elements_in(obj)
      case obj
      when WebDriver::Element
        wrap_element(obj)
      when Array
        obj.map { |e| wrap_elements_in(e) }
      when Hash
        obj.each { |k,v| obj[k] = wrap_elements_in(v) }

        obj
      else
        obj
      end
    end

    def wrap_element(element)
      Watir.element_class_for(element.tag_name).new(self, :element => element)
    end

  end # Browser
end # Watir

./lib/watir-webdriver/browser.rb 95.18 % covered
1	# encoding: utf-8
2	module Watir	1
3
4	#
5	# The main class through which you control the browser.
6	#
7
8	class Browser	1
9	include Container	1
10	include WindowSwitching	1
11
12	attr_reader :driver	1
13	alias_method :wd, :driver # ensures duck typing with Watir::Element	1
14
15	class << self	1
16	def start(url, browser = :firefox)	1
17	b = new(browser)	1
18	b.goto url	1
19
20	b	1
21	end
22	end
23
24	#
25	# Create a Watir::Browser instance
26	#
27	# @param [:firefox, :ie, :chrome, :remote, Selenium::WebDriver] browser
28	# @param args Passed to the underlying driver
29	#
30
31	def initialize(browser = :firefox, *args)	1
32	case browser	7
33	when Symbol, String
34	@driver = Selenium::WebDriver.for browser.to_sym, *args	5
35	when Selenium::WebDriver::Driver
36	@driver = browser	1
37	else
38	raise ArgumentError, "expected Symbol or Selenium::WebDriver::Driver, got #{browser.class}"	1
39	end
40
41	@error_checkers = []	6
42	@current_frame = nil	6
43	@closed = false	6
44	end
45
46	def inspect	1
47	'#<%s:0x%x url=%s title=%s>' % [self.class, hash*2, url.inspect, title.inspect]	0
48	end
49
50	#
51	# Goto the given URL
52	#
53	# @param [String] uri The url.
54	# @return [String] The url you end up at.
55	#
56
57	def goto(uri)	1
58	uri = "http://#{uri}" unless uri.include?("://")	1024
59
60	@driver.navigate.to uri	1024
61	run_checkers	1024
62
63	url	1024
64	end
65
66	def back	1
67	@driver.navigate.back	5
68	end
69
70	def forward	1
71	@driver.navigate.forward	3
72	end
73
74	def url	1
75	@driver.current_url	1042
76	end
77
78	def title	1
79	@driver.title	7
80	end
81
82	def close	1
83	return if @closed	4
84	@driver.quit	4
85	@closed = true	4
86	end
87	alias_method :quit, :close # TODO: close vs quit	1
88
89	def clear_cookies	1
90	@driver.manage.delete_all_cookies	0
91	end
92
93	def text	1
94	@driver.find_element(:tag_name, "body").text	9
95	end
96
97	def html	1
98	# use body.html instead?
99	@driver.page_source	1
100	end
101
102	def refresh	1
103	@driver.navigate.refresh	1
104	run_checkers	1
105	end
106
107	def status	1
108	execute_script "return window.status;"	0
109	end
110
111	def execute_script(script, *args)	1
112	args.map! { \|e\| e.kind_of?(Watir::Element) ? e.element : e }	14
113	returned = @driver.execute_script(script, *args)	14
114
115	wrap_elements_in(returned)	14
116	end
117
118	def add_checker(checker = nil, &block)	1
119	if block_given?	3
120	@error_checkers << block	0
121	elsif Proc === checker	3
122	@error_checkers << checker	2
123	else
124	raise ArgumentError, "argument must be a Proc or block"	1
125	end
126	end
127
128	def disable_checker(checker)	1
129	@error_checkers.delete(checker)	2
130	end
131
132	def run_checkers	1
133	@error_checkers.each { \|e\| e[self] }	1078
134	end
135
136	#
137	# Protocol shared with Watir::Element
138	#
139	# @api private
140	#
141
142	def assert_exists	1
143	if @closed	2274
144	raise Error, "browser was closed"	1
145	else
146	driver.switch_to.default_content	2273
147	true	2273
148	end
149	end
150
151	def exist?	1
152	not @closed	2
153	end
154
155	def browser	1
156	self	1
157	end
158
159	private	1
160
161	def wrap_elements_in(obj)	1
162	case obj	22
163	when WebDriver::Element
164	wrap_element(obj)	5
165	when Array
166	obj.map { \|e\| wrap_elements_in(e) }	4
167	when Hash
168	obj.each { \|k,v\| obj[k] = wrap_elements_in(v) }	10
169
170	obj	4
171	else
172	obj	11
173	end
174	end
175
176	def wrap_element(element)	1
177	Watir.element_class_for(element.tag_name).new(self, :element => element)	5
178	end
179
180	end # Browser
181	end # Watir



module Watir
  module CellContainer

    def cell(*args)
      cell = TableCell.new(self, extract_selector(args).merge(:tag_name => /^(th|td)$/))
      cell.locator_class = ChildCellLocator

      cell
    end

    def cells(*args)
      cells = TableCellCollection.new(self, extract_selector(args).merge(:tag_name => /^(th|td)$/))
      cells.locator_class = ChildCellLocator

      cells
    end

  end
end

./lib/watir-webdriver/cell_container.rb 100.0 % covered
1	module Watir	1
2	module CellContainer	1
3
4	def cell(*args)	1
5	cell = TableCell.new(self, extract_selector(args).merge(:tag_name => /^(th\|td)$/))	17
6	cell.locator_class = ChildCellLocator	17
7
8	cell	17
9	end
10
11	def cells(*args)	1
12	cells = TableCellCollection.new(self, extract_selector(args).merge(:tag_name => /^(th\|td)$/))	45
13	cells.locator_class = ChildCellLocator	45
14
15	cells	45
16	end
17
18	end
19	end



# encoding: utf-8
module Watir
  module Container
    include XpathSupport

    def element(*args)
      HTMLElement.new(self, extract_selector(args))
    end

    def elements(*args)
      HTMLElementCollection.new(self, extract_selector(args))
    end

    private

    def browserbot(function_name, *arguments)
      script = browserbot_script + "return browserbot.#{function_name}.apply(browserbot, arguments);"
      driver.execute_script(script, *arguments)
    end

    def browserbot_script
      @browserbot_script ||= File.read("#{File.dirname(__FILE__)}/browserbot.js")
    end

    def extract_selector(selectors)
      case selectors.size
      when 2
        return { selectors[0] => selectors[1] }
      when 1
        obj = selectors.first
        return obj if obj.kind_of? Hash
      when 0
        return {}
      end

      raise ArgumentError, "expected Hash or (:how, 'what'), got #{selectors.inspect}"
    end

  end # Container
end # Watir

./lib/watir-webdriver/container.rb 100.0 % covered
1	# encoding: utf-8
2	module Watir	1
3	module Container	1
4	include XpathSupport	1
5
6	def element(*args)	1
7	HTMLElement.new(self, extract_selector(args))	4
8	end
9
10	def elements(*args)	1
11	HTMLElementCollection.new(self, extract_selector(args))	2
12	end
13
14	private	1
15
16	def browserbot(function_name, *arguments)	1
17	script = browserbot_script + "return browserbot.#{function_name}.apply(browserbot, arguments);"	11
18	driver.execute_script(script, *arguments)	11
19	end
20
21	def browserbot_script	1
22	@browserbot_script \|\|= File.read("#{File.dirname(__FILE__)}/browserbot.js")	11
23	end
24
25	def extract_selector(selectors)	1
26	case selectors.size	2819
27	when 2
28	return { selectors[0] => selectors[1] }	2258
29	when 1
30	obj = selectors.first	220
31	return obj if obj.kind_of? Hash	220
32	when 0
33	return {}	340
34	end
35
36	raise ArgumentError, "expected Hash or (:how, 'what'), got #{selectors.inspect}"	2
37	end
38
39	end # Container
40	end # Watir



# encoding: utf-8
module Watir

  #
  # Base class for element collections.
  #

  class ElementCollection
    include Enumerable

    def initialize(parent, selector)
      @parent   = parent
      @selector = selector
    end

    #
    # @yieldparam [Watir::Element] element Iterate through the elements in this collection.
    #

    def each(&blk)
      to_a.each(&blk)
    end

    #
    # @return [Fixnum] The number of elements in this collection.
    #

    def length
      elements.length
    end
    alias_method :size, :length

    #
    # Get the element at the given index.
    # Note that this is 0-indexed and not compatible with older Watir implementations.
    #
    # Also note that because of Watir's lazy loading, this will return an Element
    # instance even if the index is out of bounds.
    #
    # @param [Fixnum] n Index of wanted element, 0-indexed
    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
    #


    def [](idx)
      to_a[idx] || element_class.new(@parent, :index => idx)
    end

    #
    # First element of this collection
    #
    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
    #

    def first
      self[0]
    end

    #
    # Last element of the collection
    #
    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
    #

    def last
      self[-1]
    end

    #
    # This collection as an Array
    #
    # @return [Array<Watir::Element>]
    #

    def to_a
      # TODO: optimize - lazy element_class instance?
      @to_a ||= elements.map { |e| element_class.new(@parent, :element => e) }
    end

    private

    def elements
      @elements ||= locator_class.new(
        @parent.wd,
        @selector,
        element_class.attribute_list
      ).locate_all
    end

    # overridable by subclasses
    def locator_class
      ElementLocator
    end

  end # ElementCollection
end # Watir

./lib/watir-webdriver/element_collection.rb 100.0 % covered
1	# encoding: utf-8
2	module Watir	1
3
4	#
5	# Base class for element collections.
6	#
7
8	class ElementCollection	1
9	include Enumerable	1
10
11	def initialize(parent, selector)	1
12	@parent = parent	337
13	@selector = selector	337
14	end
15
16	#
17	# @yieldparam [Watir::Element] element Iterate through the elements in this collection.
18	#
19
20	def each(&blk)	1
21	to_a.each(&blk)	131
22	end
23
24	#
25	# @return [Fixnum] The number of elements in this collection.
26	#
27
28	def length	1
29	elements.length	114
30	end
31	alias_method :size, :length	1
32
33	#
34	# Get the element at the given index.
35	# Note that this is 0-indexed and not compatible with older Watir implementations.
36	#
37	# Also note that because of Watir's lazy loading, this will return an Element
38	# instance even if the index is out of bounds.
39	#
40	# @param [Fixnum] n Index of wanted element, 0-indexed
41	# @return [Watir::Element] Returns an instance of a Watir::Element subclass
42	#
43
44
45	def [](idx)	1
46	to_a[idx] \|\| element_class.new(@parent, :index => idx)	63
47	end
48
49	#
50	# First element of this collection
51	#
52	# @return [Watir::Element] Returns an instance of a Watir::Element subclass
53	#
54
55	def first	1
56	self[0]	5
57	end
58
59	#
60	# Last element of the collection
61	#
62	# @return [Watir::Element] Returns an instance of a Watir::Element subclass
63	#
64
65	def last	1
66	self[-1]	3
67	end
68
69	#
70	# This collection as an Array
71	#
72	# @return [Array<Watir::Element>]
73	#
74
75	def to_a	1
76	# TODO: optimize - lazy element_class instance?
77	@to_a \|\|= elements.map { \|e\| element_class.new(@parent, :element => e) }	1177
78	end
79
80	private	1
81
82	def elements	1
83	@elements \|\|= locator_class.new(
84	@parent.wd,
85	@selector,
86	element_class.attribute_list
87	).locate_all	349
88	end
89
90	# overridable by subclasses
91	def locator_class	1
92	ElementLocator	239
93	end
94
95	end # ElementCollection
96	end # Watir



# encoding: utf-8
module Watir

  #
  # Class representing button elements.
  #
  # This class covers both <button> and <input type="submit|reset|image|button" /> elements.
  #

  class Button < HTMLElement

    # add the attributes from <input>
    attributes Watir::Input.typed_attributes

    VALID_TYPES = %w[button reset submit image]

    #
    # Returns the text of the button.
    #
    # For input elements, returns the "value" attribute.
    # For button elements, returns the inner text.
    #

    def text
      assert_exists
      case @element.tag_name
      when 'input'
        @element.attribute(:value)
      when 'button'
        @element.text
      else
        raise Exception::Error, "unknown tag name for button: #{@element.tag_name}"
      end
    end

    #
    # Returns true if this element is enabled
    #
    # @return [Boolean]
    #

    def enabled?
      !disabled?
    end

    private

    def locate
      @parent.assert_exists
      ButtonLocator.new(@parent.wd, @selector, self.class.attribute_list).locate
    end

  end # Button

  class ButtonCollection < ElementCollection
    private

    def locator_class
      ButtonLocator
    end

    def element_class
      Button
    end
  end # ButtonsCollection
end # Watir

./lib/watir-webdriver/elements/button.rb 95.45 % covered
1	# encoding: utf-8
2	module Watir	1
3
4	#
5	# Class representing button elements.
6	#
7	# This class covers both <button> and <input type="submit\|reset\|image\|button" /> elements.
8	#
9
10	class Button < HTMLElement	1
11
12	# add the attributes from <input>
13	attributes Watir::Input.typed_attributes	1
14
15	VALID_TYPES = %w[button reset submit image]	1
16
17	#
18	# Returns the text of the button.
19	#
20	# For input elements, returns the "value" attribute.
21	# For button elements, returns the inner text.
22	#
23
24	def text	1
25	assert_exists	5
26	case @element.tag_name	4
27	when 'input'
28	@element.attribute(:value)	3
29	when 'button'
30	@element.text	1
31	else
32	raise Exception::Error, "unknown tag name for button: #{@element.tag_name}"	0
33	end
34	end
35
36	#
37	# Returns true if this element is enabled
38	#
39	# @return [Boolean]
40	#
41
42	def enabled?	1
43	!disabled?	3
44	end
45
46	private	1
47
48	def locate	1
49	@parent.assert_exists	117
50	ButtonLocator.new(@parent.wd, @selector, self.class.attribute_list).locate	117
51	end
52
53	end # Button
54
55	class ButtonCollection < ElementCollection	1
56	private	1
57
58	def locator_class	1
59	ButtonLocator	8
60	end
61
62	def element_class	1
63	Button	57
64	end
65	end # ButtonsCollection
66	end # Watir



# encoding: utf-8

module Watir
  class CheckBox < Input

    #
    # Set this checkbox to the given value
    #
    # Example:
    #
    #   checkbox.set?        #=> false
    #   checkbox.set
    #   checkbox.set?        #=> true
    #   checkbox.set(false)
    #   checkbox.set?        #=> false
    #

    def set(bool = true)
      assert_exists
      assert_enabled

      if @element.selected?
        @element.click unless bool
      else
        @element.click if bool
      end
    end

    #
    # returns true if the element is checked
    # @return [Boolean]
    #

    def set?
      assert_exists
      @element.selected?
    end

    #
    # Unset this checkbox.
    #
    # Same as +set(false)+
    #

    def clear
      set false
    end
  end # CheckBox

  module Container
    def checkbox(*args)
      CheckBox.new(self, extract_selector(args).merge(:tag_name => "input", :type => "checkbox"))
    end

    def checkboxes(*args)
      CheckBoxCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "checkbox"))
    end
  end # Container

  class CheckBoxCollection < InputCollection
    def element_class
      CheckBox
    end
  end # CheckBoxCollection
end

./lib/watir-webdriver/elements/checkbox.rb 100.0 % covered
1	# encoding: utf-8
2
3	module Watir	1
4	class CheckBox < Input	1
5
6	#
7	# Set this checkbox to the given value
8	#
9	# Example:
10	#
11	# checkbox.set? #=> false
12	# checkbox.set
13	# checkbox.set? #=> true
14	# checkbox.set(false)
15	# checkbox.set? #=> false
16	#
17
18	def set(bool = true)	1
19	assert_exists	17
20	assert_enabled	13
21
22	if @element.selected?	9
23	@element.click unless bool	4
24	else
25	@element.click if bool	5
26	end
27	end
28
29	#
30	# returns true if the element is checked
31	# @return [Boolean]
32	#
33
34	def set?	1
35	assert_exists	12
36	@element.selected?	10
37	end
38
39	#
40	# Unset this checkbox.
41	#
42	# Same as +set(false)+
43	#
44
45	def clear	1
46	set false	8
47	end
48	end # CheckBox
49
50	module Container	1
51	def checkbox(*args)	1
52	CheckBox.new(self, extract_selector(args).merge(:tag_name => "input", :type => "checkbox"))	115
53	end
54
55	def checkboxes(*args)	1
56	CheckBoxCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "checkbox"))	4
57	end
58	end # Container
59
60	class CheckBoxCollection < InputCollection	1
61	def element_class	1
62	CheckBox	19
63	end
64	end # CheckBoxCollection
65	end



# encoding: utf-8

module Watir

  #
  # Base class for HTML elements.
  #

  class Element
    include Exception
    include Container
    include Selenium
    extend AttributeHelper

    def initialize(parent, selector)
      @parent   = parent
      @selector = selector

      unless @selector.kind_of? Hash
        raise ArgumentError, "invalid argument: #{selector.inspect}"
      end

      if @selector.has_key?(:element)
        @element = @selector[:element]
      end
    end

    def exists?
      assert_exists
      true
    rescue UnknownObjectException, UnknownFrameException
      false
    end
    alias_method :exist?, :exists?

    def inspect
      if @selector.has_key?(:element)
        '#<%s:0x%x located=%s selector=%s>' % [self.class, hash*2, !!@element, '{:element=>(webdriver element)}']
      else
        '#<%s:0x%x located=%s selector=%s>' % [self.class, hash*2, !!@element, selector_string]
      end
    end

    def ==(other)
      return false unless other.kind_of? self.class

      assert_exists
      @element == other.element
    end
    alias_method :eql?, :==

    def hash
      @element ? @element.hash : super
    end

    def text
      assert_exists
      @element.text
    end

    def tag_name
      assert_exists
      @element.tag_name
    end

    def click
      assert_exists
      assert_enabled
      @element.click
      run_checkers
    end

    def double_click
      assert_exists
      raise NotImplementedError, "need support in WebDriver"

      @element.double_click
      run_checkers
    end

    def right_click
      assert_exists
      raise NotImplementedError, "need support in WebDriver"

      @element.right_click
      run_checkers
    end

    def flash
      original_color = style("backgroundColor")

      10.times do |n|
        color = (n % 2 == 0) ? "red" : original_color
        driver.execute_script("arguments[0].style.backgroundColor = '#{color}'", @element)
      end
    end

    def value
      assert_exists

      begin
        @element.value || ''
      rescue WebDriver::Error::ElementNotEnabledError
        ""
      end
    end

    def attribute_value(attribute_name)
      assert_exists
      @element.attribute attribute_name
    end

    def html
      assert_exists
      browserbot('getOuterHTML', @element).strip
    end

    def send_keys(*args)
      assert_exists
      @element.send_keys(*args)
    end

    #
    # Note: Firefox queues focus events until the window actually has focus.
    #
    # See http://code.google.com/p/selenium/issues/detail?id=157
    #

    def focus
      assert_exists
      driver.execute_script "return arguments[0].focus()", @element
    end

    def fire_event(event_name, bubble = false)
      assert_exists
      event_name = event_name.to_s.sub(/^on/, '')
      browserbot('triggerEvent', @element, event_name, bubble)
    end

    def parent
      assert_exists

      e = driver.execute_script "return arguments[0].parentNode", @element

      if e.kind_of?(WebDriver::Element)
        Watir.element_class_for(e.tag_name).new(@parent, :element => e)
      end
    end

    def driver
      @parent.driver
    end

    def element
      assert_exists
      @element
    end
    alias_method :wd, :element # ensures duck typing with Browser

    def visible?
      assert_exists
      @element.displayed?
    end

    def style(property = nil)
      if property
        assert_exists
        @element.style property
      else
        attribute_value("style") || ''
      end
    end

    def run_checkers
      @parent.run_checkers
    end

    #
    # Cast this Element instance to a more specific subtype.
    #
    # Example:
    #
    #   browser.element(:xpath => "//input[@type='submit']").to_subtype #=> #<Watir::Button>
    #

    def to_subtype
      elem = element()
      tag_name = elem.tag_name

      klass = nil

      if tag_name == "input"
        klass = case elem.attribute(:type)
          when *Button::VALID_TYPES
            Button
          when 'checkbox'
            CheckBox
          when 'radio'
            Radio
          when 'file'
            FileField
          else
            TextField
          end
      else
        klass = Watir.element_class_for(tag_name)
      end

      klass.new(@parent, :element => elem)
    end

  protected

    def assert_exists
      @element ||= locate

      unless @element
        raise UnknownObjectException, "unable to locate element, using #{selector_string}"
      end
    end

    def browser
      @parent.browser
    end

    def locate
      @parent.assert_exists
      locator_class.new(@parent.wd, @selector, self.class.attribute_list).locate
    end

  private

    def locator_class
      ElementLocator
    end

    def selector_string
      @selector.inspect
    end

    def attribute?(attribute)
      assert_exists
      driver.execute_script "return !!arguments[0].getAttributeNode(arguments[1]);", @element, attribute.to_s.downcase
    end

    def assert_enabled
      raise ObjectDisabledException, "object is disabled #{selector_string}" unless @element.enabled?
    end

    def assert_writable
      assert_enabled
      raise ObjectReadOnlyException if respond_to?(:readonly?) && readonly?
    end

    def method_missing(meth, *args, &blk)
      method = meth.to_s
      if method =~ /^data_(.+)$/
        attribute_value(method.gsub(/_/, '-'), *args)
      else
        super
      end
    end

  end # Element
end # Watir

./lib/watir-webdriver/elements/element.rb 85.61 % covered
1	# encoding: utf-8
2
3	module Watir	1
4
5	#
6	# Base class for HTML elements.
7	#
8
9	class Element	1
10	include Exception	1
11	include Container	1
12	include Selenium	1
13	extend AttributeHelper	1
14
15	def initialize(parent, selector)	1
16	@parent = parent	3499
17	@selector = selector	3499
18
19	unless @selector.kind_of? Hash	3499
20	raise ArgumentError, "invalid argument: #{selector.inspect}"	1
21	end
22
23	if @selector.has_key?(:element)	3498
24	@element = @selector[:element]	963
25	end
26	end
27
28	def exists?	1
29	assert_exists	778
30	true	383
31	rescue UnknownObjectException, UnknownFrameException
32	false	314
33	end
34	alias_method :exist?, :exists?	1
35
36	def inspect	1
37	if @selector.has_key?(:element)	0
38	'#<%s:0x%x located=%s selector=%s>' % [self.class, hash*2, !!@element, '{:element=>(webdriver element)}']	0
39	else
40	'#<%s:0x%x located=%s selector=%s>' % [self.class, hash*2, !!@element, selector_string]	0
41	end
42	end
43
44	def ==(other)	1
45	return false unless other.kind_of? self.class	41
46
47	assert_exists	40
48	@element == other.element	40
49	end
50	alias_method :eql?, :==	1
51
52	def hash	1
53	@element ? @element.hash : super	0
54	end
55
56	def text	1
57	assert_exists	200
58	@element.text	162
59	end
60
61	def tag_name	1
62	assert_exists	1
63	@element.tag_name	1
64	end
65
66	def click	1
67	assert_exists	85
68	assert_enabled	52
69	@element.click	51
70	run_checkers	51
71	end
72
73	def double_click	1
74	assert_exists	0
75	raise NotImplementedError, "need support in WebDriver"	0
76
77	@element.double_click	0
78	run_checkers	0
79	end
80
81	def right_click	1
82	assert_exists	0
83	raise NotImplementedError, "need support in WebDriver"	0
84
85	@element.right_click	0
86	run_checkers	0
87	end
88
89	def flash	1
90	original_color = style("backgroundColor")	0
91
92	10.times do \|n\|	0
93	color = (n % 2 == 0) ? "red" : original_color	0
94	driver.execute_script("arguments[0].style.backgroundColor = '#{color}'", @element)	0
95	end
96	end
97
98	def value	1
99	assert_exists	293
100
101	begin	282
102	@element.value \|\| ''	282
103	rescue WebDriver::Error::ElementNotEnabledError	267
104	""	267
105	end
106	end
107
108	def attribute_value(attribute_name)	1
109	assert_exists	130
110	@element.attribute attribute_name	128
111	end
112
113	def html	1
114	assert_exists	4
115	browserbot('getOuterHTML', @element).strip	4
116	end
117
118	def send_keys(*args)	1
119	assert_exists	1
120	@element.send_keys(*args)	1
121	end
122
123	#
124	# Note: Firefox queues focus events until the window actually has focus.
125	#
126	# See http://code.google.com/p/selenium/issues/detail?id=157
127	#
128
129	def focus	1
130	assert_exists	0
131	driver.execute_script "return arguments[0].focus()", @element	0
132	end
133
134	def fire_event(event_name, bubble = false)	1
135	assert_exists	7
136	event_name = event_name.to_s.sub(/^on/, '')	7
137	browserbot('triggerEvent', @element, event_name, bubble)	7
138	end
139
140	def parent	1
141	assert_exists	1
142
143	e = driver.execute_script "return arguments[0].parentNode", @element	1
144
145	if e.kind_of?(WebDriver::Element)	1
146	Watir.element_class_for(e.tag_name).new(@parent, :element => e)	1
147	end
148	end
149
150	def driver	1
151	@parent.driver	240
152	end
153
154	def element	1
155	assert_exists	383
156	@element	383
157	end
158	alias_method :wd, :element # ensures duck typing with Browser	1
159
160	def visible?	1
161	assert_exists	25
162	@element.displayed?	25
163	end
164
165	def style(property = nil)	1
166	if property	6
167	assert_exists	0
168	@element.style property	0
169	else
170	attribute_value("style") \|\| ''	6
171	end
172	end
173
174	def run_checkers	1
175	@parent.run_checkers	55
176	end
177
178	#
179	# Cast this Element instance to a more specific subtype.
180	#
181	# Example:
182	#
183	# browser.element(:xpath => "//input[@type='submit']").to_subtype #=> #<Watir::Button>
184	#
185
186	def to_subtype	1
187	elem = element()	8
188	tag_name = elem.tag_name	8
189
190	klass = nil	8
191
192	if tag_name == "input"	8
193	klass = case elem.attribute(:type)	7
194	when *Button::VALID_TYPES
195	Button	2
196	when 'checkbox'
197	CheckBox	1
198	when 'radio'
199	Radio	2
200	when 'file'
201	FileField	1
202	else
203	TextField	1
204	end
205	else
206	klass = Watir.element_class_for(tag_name)	1
207	end
208
209	klass.new(@parent, :element => elem)	8
210	end
211
212	protected	1
213
214	def assert_exists	1
215	@element \|\|= locate	3921
216
217	unless @element	3822
218	raise UnknownObjectException, "unable to locate element, using #{selector_string}"	556
219	end
220	end
221
222	def browser	1
223	@parent.browser	1
224	end
225
226	def locate	1
227	@parent.assert_exists	2090
228	locator_class.new(@parent.wd, @selector, self.class.attribute_list).locate	2087
229	end
230
231	private	1
232
233	def locator_class	1
234	ElementLocator	2097
235	end
236
237	def selector_string	1
238	@selector.inspect	549
239	end
240
241	def attribute?(attribute)	1
242	assert_exists	67
243	driver.execute_script "return !!arguments[0].getAttributeNode(arguments[1]);", @element, attribute.to_s.downcase	67
244	end
245
246	def assert_enabled	1
247	raise ObjectDisabledException, "object is disabled #{selector_string}" unless @element.enabled?	92
248	end
249
250	def assert_writable	1
251	assert_enabled	14
252	raise ObjectReadOnlyException if respond_to?(:readonly?) && readonly?	13
253	end
254
255	def method_missing(meth, *args, &blk)	1
256	method = meth.to_s	122
257	if method =~ /^data_(.+)$/	122
258	attribute_value(method.gsub(/_/, '-'), *args)	121
259	else
260	super	1
261	end
262	end
263
264	end # Element
265	end # Watir



# encoding: utf-8
module Watir
  class FileField < Input
    #
    # Set the file field to the given path
    #
    # @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

    #
    # Set the file field to the given path
    #
    # @param [String] a path
    #
    def value=(path)
      assert_exists
      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]
    #

    def value
      # since 'value' is an attribute on input fields, we override this here
      assert_exists
      @element.value
    end
  end

  module Container
    def file_field(*args)
      FileField.new(self, extract_selector(args).merge(:tag_name => "input", :type => "file"))
    end

    def file_fields(*args)
      FileFieldCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "file"))
    end
  end # Container

  class FileFieldCollection < InputCollection
    def element_class
      FileField
    end
  end # FileFieldCollection
end # Watir

./lib/watir-webdriver/elements/file_field.rb 100.0 % covered
1	# encoding: utf-8
2	module Watir	1
3	class FileField < Input	1
4	#
5	# Set the file field to the given path
6	#
7	# @param [String] a path
8	#
9	# @raise [Errno::ENOENT] if the file doesn't exist
10	#
11
12	def set(path)	1
13	raise Errno::ENOENT, path unless File.exist?(path)	2
14	self.value = path	1
15	end
16
17	#
18	# Set the file field to the given path
19	#
20	# @param [String] a path
21	#
22	def value=(path)	1
23	assert_exists	4
24	path = path.gsub(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR	4
25	@element.send_keys path	4
26	end
27
28	#
29	# Return the value of this field
30	#
31	# In IE, the path returned depends on the "Include local directory path
32	# when uploading files to a server" security setting:
33	#
34	# @see http://msdn.microsoft.com/en-us/library/ms535128(VS.85).aspx
35	#
36	# @return [String]
37	#
38
39	def value	1
40	# since 'value' is an attribute on input fields, we override this here
41	assert_exists	7
42	@element.value	7
43	end
44	end
45
46	module Container	1
47	def file_field(*args)	1
48	FileField.new(self, extract_selector(args).merge(:tag_name => "input", :type => "file"))	47
49	end
50
51	def file_fields(*args)	1
52	FileFieldCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "file"))	4
53	end
54	end # Container
55
56	class FileFieldCollection < InputCollection	1
57	def element_class	1
58	FileField	9
59	end
60	end # FileFieldCollection
61	end # Watir



module Watir
  module Container
    def font(*args)
      Font.new(self, extract_selector(args).merge(:tag_name => "font"))
    end
    
    def fonts(*args)
      FontCollection.new(self, extract_selector(args).merge(:tag_name => "font"))
    end
  end # Container
end # Watir

./lib/watir-webdriver/elements/font.rb 100.0 % covered
1	module Watir	1
2	module Container	1
3	def font(*args)	1
4	Font.new(self, extract_selector(args).merge(:tag_name => "font"))	4
5	end
6
7	def fonts(*args)	1
8	FontCollection.new(self, extract_selector(args).merge(:tag_name => "font"))	1
9	end
10	end # Container
11	end # Watir



# encoding: utf-8
module Watir
  class Form < HTMLElement

    #
    # Submits the form.
    #
    # This method should be avoided - invoke the user interface element that triggers the submit instead.
    #

    def submit
      assert_exists
      @element.submit
    end

  end # Form
end # Watir

./lib/watir-webdriver/elements/form.rb 100.0 % covered
1	# encoding: utf-8
2	module Watir	1
3	class Form < HTMLElement	1
4
5	#
6	# Submits the form.
7	#
8	# This method should be avoided - invoke the user interface element that triggers the submit instead.
9	#
10
11	def submit	1
12	assert_exists	1
13	@element.submit	1
14	end
15
16	end # Form
17	end # Watir



# encoding: utf-8
module Watir
  class Frame < HTMLElement

    def locate
      @parent.assert_exists

      element = locate_iframe || locate_frame
      element or raise UnknownFrameException, "unable to locate frame/iframe using #{selector_string}"

      FramedDriver.new(element, driver)
    end

    def assert_exists
      if element = @selector[:element]
        @parent.assert_exists
        @element = FramedDriver.new(element, driver)
      else
        @element = nil
      end

      super
    end

    def execute_script(*args)
      browser.execute_script(*args)
    end

    def element_by_xpath(*args)
      assert_exists
      super
    end

    def elements_by_xpath(*args)
      assert_exists
      super
    end

    private

    def locate_iframe
      # hack - frame doesn't have IFrame's attributes either
      IFrame.new(@parent, @selector.merge(:tag_name => "iframe")).locate
    end

    def locate_frame
      locator = locator_class.new(@parent.wd, @selector.merge(:tag_name => "frame"), self.class.attribute_list)
      locator.locate
    end
  end # Frame

  module Container
    def frame(*args)
      Frame.new(self, extract_selector(args))
    end

    def frames(*args)
      FrameCollection.new(self, extract_selector(args).merge(:tag_name => /^(iframe|frame)$/)) # hack
    end
  end

  # @api private
  #
  # another hack..
  #

  class FramedDriver
    def initialize(element, driver)
      @element = element
      @driver = driver
    end
    
    def ==(other)
      @element == other.element
    end
    alias_method :eql?, :==
    
    protected
    
    def element
      @element
    end
    
    private

    def method_missing(meth, *args, &blk)
      if @driver.respond_to?(meth)
        switch!
        @driver.send(meth, *args, &blk)
      else
        @element.send(meth, *args, &blk)
      end
    end

    def switch!
      @driver.switch_to.frame @element
    rescue Selenium::WebDriver::Error::NoSuchFrameError => e
      raise UnknownFrameException, e.message
    end

  end # FramedDriver
end # Watir

./lib/watir-webdriver/elements/frame.rb 94.12 % covered
1	# encoding: utf-8
2	module Watir	1
3	class Frame < HTMLElement	1
4
5	def locate	1
6	@parent.assert_exists	89
7
8	element = locate_iframe \|\| locate_frame	89
9	element or raise UnknownFrameException, "unable to locate frame/iframe using #{selector_string}"	87
10
11	FramedDriver.new(element, driver)	74
12	end
13
14	def assert_exists	1
15	if element = @selector[:element]	102
16	@parent.assert_exists	13
17	@element = FramedDriver.new(element, driver)	13
18	else
19	@element = nil	89
20	end
21
22	super	102
23	end
24
25	def execute_script(*args)	1
26	browser.execute_script(*args)	1
27	end
28
29	def element_by_xpath(*args)	1
30	assert_exists	0
31	super	0
32	end
33
34	def elements_by_xpath(*args)	1
35	assert_exists	2
36	super	2
37	end
38
39	private	1
40
41	def locate_iframe	1
42	# hack - frame doesn't have IFrame's attributes either
43	IFrame.new(@parent, @selector.merge(:tag_name => "iframe")).locate	89
44	end
45
46	def locate_frame	1
47	locator = locator_class.new(@parent.wd, @selector.merge(:tag_name => "frame"), self.class.attribute_list)	65
48	locator.locate	65
49	end
50	end # Frame
51
52	module Container	1
53	def frame(*args)	1
54	Frame.new(self, extract_selector(args))	63
55	end
56
57	def frames(*args)	1
58	FrameCollection.new(self, extract_selector(args).merge(:tag_name => /^(iframe\|frame)$/)) # hack	7
59	end
60	end
61
62	# @api private
63	#
64	# another hack..
65	#
66
67	class FramedDriver	1
68	def initialize(element, driver)	1
69	@element = element	87
70	@driver = driver	87
71	end
72
73	def ==(other)	1
74	@element == other.element	1
75	end
76	alias_method :eql?, :==	1
77
78	protected	1
79
80	def element	1
81	@element	1
82	end
83
84	private	1
85
86	def method_missing(meth, *args, &blk)	1
87	if @driver.respond_to?(meth)	42
88	switch!	20
89	@driver.send(meth, *args, &blk)	20
90	else
91	@element.send(meth, *args, &blk)	22
92	end
93	end
94
95	def switch!	1
96	@driver.switch_to.frame @element	20
97	rescue Selenium::WebDriver::Error::NoSuchFrameError => e
98	raise UnknownFrameException, e.message	0
99	end
100
101	end # FramedDriver
102	end # Watir



# Autogenerated from the HTML5 specification. Edits may be lost.
module Watir











































 class HTMLElement < Element
   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, :dropzone], :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, :onreset, :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])
 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, :content_window], :bool => [:no_resize], :document => [:content_document])
 end
 class FrameCollection < ElementCollection
   def element_class
     Frame
   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, :onscroll, :onstorage, :onundo, :onunload])
 end
 class FrameSetCollection < ElementCollection
   def element_class
     FrameSet
   end
 end
 class Marquee < HTMLElement
   attributes(:string => [:behavior, :bg_color, :direction, :height, :width], :int => [:hspace, :loop, :scroll_amount, :scroll_delay, :vspace], :bool => [:true_speed], :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])
 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])
 end
 class MenuCollection < ElementCollection
   def element_class
     Menu
   end
 end
 class Menu < HTMLElement
   attributes(:bool => [:compact])
 end
 # do nothing
 class Command < HTMLElement
   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], :html_element => [:form], :list => [:labels])
 end
 class MeterCollection < ElementCollection
   def element_class
     Meter
   end
 end
 class Progress < HTMLElement
   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(: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
     Keygen
   end
 end
 class TextArea < HTMLElement
   attributes(:bool => [:autofocus, :disabled, :read_only, :required, :will_validate], :int => [:cols, :max_length, :rows, :text_length, :selection_start, :selection_end], :string => [:dir_name, :name, :placeholder, :wrap, :type, :default_value, :value, :validity, :validation_message], :html_element => [:form], :list => [:labels])
 end
 class TextAreaCollection < ElementCollection
   def element_class
     TextArea
   end
 end
 class Option < HTMLElement
   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])
 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, :dir_name, :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
     Input
   end
 end
 class Input < HTMLElement
   attributes(:string => [:align, :use_map])
 end
 # do nothing
 class Label < HTMLElement
   attributes(:html_element => [:form, :control], :string => [:html_for])
 end
 class LabelCollection < ElementCollection
   def element_class
     Label
   end
 end
 class Legend < HTMLElement
   attributes(:html_element => [:form])
 end
 class LegendCollection < ElementCollection
   def element_class
     Legend
   end
 end
 class Legend < HTMLElement
   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, :encoding, :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])
 end
 class TableRowCollection < ElementCollection
   def element_class
     TableRow
   end
 end
 class TableRow < HTMLElement
   attributes(:string => [:align, :bg_color, :ch, :ch_off, :v_align])
 end
 # do nothing
 class TableSection < HTMLElement
   attributes(:html_collection => [:rows])
 end
 class TableSectionCollection < ElementCollection
   def element_class
     TableSection
   end
 end
 class TableSection < HTMLElement
   attributes(:string => [:align, :ch, :ch_off, :v_align])
 end
 # do nothing
 class TableCol < HTMLElement
   attributes(:int => [:span])
 end
 class TableColCollection < ElementCollection
   def element_class
     TableCol
   end
 end
 class TableCol < HTMLElement
   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(:html_element => [:caption, :t_head, :t_foot], :html_collection => [:t_bodies, :rows], :string => [:summary])
 end
 class TableCollection < ElementCollection
   def element_class
     Table
   end
 end
 class Table < HTMLElement
   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])
 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], :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
     Media
   end
 end
 class Audio < Media
   # do nothing
 end
 class AudioCollection < ElementCollection
   def element_class
     Audio
   end
 end
 class Video < Media
   attributes(:int => [:width, :height, :video_width, :video_height], :string => [:poster], :token_list => [:audio])
 end
 class VideoCollection < ElementCollection
   def element_class
     Video
   end
 end
 class Track < HTMLElement
   attributes(:string => [:kind, :src, :srclang, :label, :track], :bool => [:default])
 end
 class TrackCollection < ElementCollection
   def element_class
     Track
   end
 end
 class Source < HTMLElement
   attributes(:string => [:src, :type, :media])
 end
 class SourceCollection < ElementCollection
   def element_class
     Source
   end
 end
 class Param < HTMLElement
   attributes(:string => [:name, :value])
 end
 class ParamCollection < ElementCollection
   def element_class
     Param
   end
 end
 class Param < HTMLElement
   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], :document => [:content_document], :bool => [:will_validate])
 end
 class ObjectCollection < ElementCollection
   def element_class
     Object
   end
 end
 class Object < HTMLElement
   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(:string => [:src, :srcdoc, :name, :width, :height, :content_window], :token_list => [:sandbox], :bool => [:seamless], :document => [:content_document])
 end
 class IFrameCollection < ElementCollection
   def element_class
     IFrame
   end
 end
 class IFrame < HTMLElement
   attributes(:string => [:align, :frame_border, :long_desc, :margin_height, :margin_width, :scrolling])
 end
 # do nothing
 class Image < HTMLElement
   attributes(:string => [:alt, :src, :use_map], :bool => [:is_map, :complete], :int => [:width, :height, :natural_width, :natural_height])
 end
 class ImageCollection < ElementCollection
   def element_class
     Image
   end
 end
 class Image < HTMLElement
   attributes(:string => [:name, :align, :border, :long_desc], :int => [:hspace, :vspace])
 end
 # do nothing
 class Mod < HTMLElement
   attributes(:string => [:cite, :date_time])
 end
 class ModCollection < ElementCollection
   def element_class
     Mod
   end
 end
 class BR < HTMLElement
   # do nothing
 end
 class BRCollection < ElementCollection
   def element_class
     BR
   end
 end
 class BR < HTMLElement
   attributes(:string => [:clear])
 end
 # do nothing
 class Span < HTMLElement
   # do nothing
 end
 class SpanCollection < ElementCollection
   def element_class
     Span
   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 Anchor < HTMLElement
   attributes(:string => [:href, :target, :ping, :rel, :media, :hreflang, :type, :text, :protocol, :host, :hostname, :port, :pathname, :search, :hash], :token_list => [:rel_list])
 end
 class AnchorCollection < ElementCollection
   def element_class
     Anchor
   end
 end
 class Anchor < HTMLElement
   attributes(:string => [:coords, :charset, :name, :rev, :shape])
 end
 # do nothing
 class Div < HTMLElement
   # do nothing
 end
 class DivCollection < ElementCollection
   def element_class
     Div
   end
 end
 class Div < HTMLElement
   attributes(:string => [:align])
 end
 # do nothing
 class DList < HTMLElement
   # do nothing
 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 UList < HTMLElement
   # do nothing
 end
 class UListCollection < ElementCollection
   def element_class
     UList
   end
 end
 class UList < HTMLElement
   attributes(:bool => [:compact], :string => [:type])
 end
 # do nothing
 class OList < HTMLElement
   attributes(:bool => [:reversed], :int => [:start], :string => [:type])
 end
 class OListCollection < ElementCollection
   def element_class
     OList
   end
 end
 class OList < HTMLElement
   attributes(:bool => [:compact])
 end
 # do nothing
 class Quote < HTMLElement
   attributes(:string => [:cite])
 end
 class QuoteCollection < ElementCollection
   def element_class
     Quote
   end
 end
 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
   def element_class
     HR
   end
 end
 class HR < HTMLElement
   attributes(:string => [:align, :color, :size, :width], :bool => [:no_shade])
 end
 # do nothing
 class Paragraph < HTMLElement
   # do nothing
 end
 class ParagraphCollection < ElementCollection
   def element_class
     Paragraph
   end
 end
 class Paragraph < HTMLElement
   attributes(:string => [:align])
 end
 # do nothing
 class Heading < 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, :onscroll, :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(:bool => [:disabled, :scoped], :string => [:media, :type])
 end
 class StyleCollection < ElementCollection
   def element_class
     Style
   end
 end
 class Meta < HTMLElement
   attributes(:string => [:name, :http_equiv, :content])
 end
 class MetaCollection < ElementCollection
   def element_class
     Meta
   end
 end
 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])
 end
 class TitleCollection < ElementCollection
   def element_class
     Title
   end
 end
 class Head < HTMLElement
   # do nothing
 end
 class HeadCollection < ElementCollection
   def element_class
     Head
   end
 end
 class Html < HTMLElement
   # do nothing
 end
 class HtmlCollection < ElementCollection
   def element_class
     Html
   end
 end
 class Html < HTMLElement
   attributes(:string => [:version])
 end
 # do nothing
 class Unknown < HTMLElement
   # do nothing
 end
 class UnknownCollection < ElementCollection
   def element_class
     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 bdi(*args)
     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "bdi"))
   end

   #
   # @return [HTMLElementCollection]
   #

   def bdis(*args)
     HTMLElementCollection.new(self, extract_selector(args).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"))
   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 img(*args)
     Image.new(self, extract_selector(args).merge(:tag_name => "img"))
   end

   #
   # @return [ImageCollection]
   #

   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 s(*args)
     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "s"))
   end

   #
   # @return [HTMLElementCollection]
   #

   def ss(*args)
     HTMLElementCollection.new(self, extract_selector(args).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"))
   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

./lib/watir-webdriver/elements/generated.rb 80.58 % covered
1	# Autogenerated from the HTML5 specification. Edits may be lost.
2	module Watir	1
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46	class HTMLElement < Element	1
47	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, :dropzone], :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, :onreset, :onscroll, :onseeked, :onseeking, :onselect, :onshow, :onstalled, :onsubmit, :onsuspend, :ontimeupdate, :onvolumechange, :onwaiting])	1
48	end
49	class HTMLElementCollection < ElementCollection	1
50	def element_class	1
51	HTMLElement	72
52	end
53	end
54	class Font < HTMLElement	1
55	attributes(:string => [:color, :face, :size])	1
56	end
57	class FontCollection < ElementCollection	1
58	def element_class	1
59	Font	1
60	end
61	end
62	class Directory < HTMLElement	1
63	attributes(:bool => [:compact])	1
64	end
65	class DirectoryCollection < ElementCollection	1
66	def element_class	1
67	Directory	0
68	end
69	end
70	class BaseFont < HTMLElement	1
71	attributes(:string => [:color, :face], :int => [:size])	1
72	end
73	class BaseFontCollection < ElementCollection	1
74	def element_class	1
75	BaseFont	0
76	end
77	end
78	class Frame < HTMLElement	1
79	attributes(:string => [:frame_border, :long_desc, :margin_height, :margin_width, :name, :scrolling, :src, :content_window], :bool => [:no_resize], :document => [:content_document])	1
80	end
81	class FrameCollection < ElementCollection	1
82	def element_class	1
83	Frame	16
84	end
85	end
86	class FrameSet < HTMLElement	1
87	attributes(:string => [:cols, :rows], :function => [:onafterprint, :onbeforeprint, :onbeforeunload, :onblur, :onerror, :onfocus, :onhashchange, :onload, :onmessage, :onoffline, :ononline, :onpagehide, :onpageshow, :onpopstate, :onredo, :onresize, :onscroll, :onstorage, :onundo, :onunload])	1
88	end
89	class FrameSetCollection < ElementCollection	1
90	def element_class	1
91	FrameSet	0
92	end
93	end
94	class Marquee < HTMLElement	1
95	attributes(:string => [:behavior, :bg_color, :direction, :height, :width], :int => [:hspace, :loop, :scroll_amount, :scroll_delay, :vspace], :bool => [:true_speed], :function => [:onbounce, :onfinish, :onstart])	1
96	end
97	class MarqueeCollection < ElementCollection	1
98	def element_class	1
99	Marquee	0
100	end
101	end
102	class Applet < HTMLElement	1
103	attributes(:string => [:align, :alt, :archive, :code, :code_base, :height, :name, :object, :width], :int => [:hspace, :vspace])	1
104	end
105	class AppletCollection < ElementCollection	1
106	def element_class	1
107	Applet	0
108	end
109	end
110	class Device < HTMLElement	1
111	attributes(:string => [:type, :data])	1
112	end
113	class DeviceCollection < ElementCollection	1
114	def element_class	1
115	Device	0
116	end
117	end
118	class Menu < HTMLElement	1
119	attributes(:string => [:type, :label])	1
120	end
121	class MenuCollection < ElementCollection	1
122	def element_class	1
123	Menu	0
124	end
125	end
126	class Menu < HTMLElement	1
127	attributes(:bool => [:compact])	1
128	end
129	# do nothing
130	class Command < HTMLElement	1
131	attributes(:string => [:type, :label, :icon, :radiogroup], :bool => [:disabled, :checked])	1
132	end
133	class CommandCollection < ElementCollection	1
134	def element_class	1
135	Command	0
136	end
137	end
138	class Details < HTMLElement	1
139	attributes(:bool => [:open])	1
140	end
141	class DetailsCollection < ElementCollection	1
142	def element_class	1
143	Details	0
144	end
145	end
146	class Meter < HTMLElement	1
147	attributes(:float => [:value, :min, :max, :low, :high, :optimum], :html_element => [:form], :list => [:labels])	1
148	end
149	class MeterCollection < ElementCollection	1
150	def element_class	1
151	Meter	0
152	end
153	end
154	class Progress < HTMLElement	1
155	attributes(:float => [:value, :max, :position], :html_element => [:form], :list => [:labels])	1
156	end
157	class ProgressCollection < ElementCollection	1
158	def element_class	1
159	Progress	0
160	end
161	end
162	class Output < HTMLElement	1
163	attributes(:token_list => [:html_for], :html_element => [:form], :string => [:name, :type, :default_value, :value, :validity, :validation_message], :bool => [:will_validate], :list => [:labels])	1
164	end
165	class OutputCollection < ElementCollection	1
166	def element_class	1
167	Output	0
168	end
169	end
170	class Keygen < HTMLElement	1
171	attributes(:bool => [:autofocus, :disabled, :will_validate], :string => [:challenge, :keytype, :name, :type, :validity, :validation_message], :html_element => [:form], :list => [:labels])	1
172	end
173	class KeygenCollection < ElementCollection	1
174	def element_class	1
175	Keygen	0
176	end
177	end
178	class TextArea < HTMLElement	1
179	attributes(:bool => [:autofocus, :disabled, :read_only, :required, :will_validate], :int => [:cols, :max_length, :rows, :text_length, :selection_start, :selection_end], :string => [:dir_name, :name, :placeholder, :wrap, :type, :default_value, :value, :validity, :validation_message], :html_element => [:form], :list => [:labels])	1
180	end
181	class TextAreaCollection < ElementCollection	1
182	def element_class	1
183	TextArea	0
184	end
185	end
186	class Option < HTMLElement	1
187	attributes(:bool => [:disabled, :default_selected, :selected], :html_element => [:form], :string => [:label, :value, :text], :int => [:index])	1
188	end
189	class OptionCollection < ElementCollection	1
190	def element_class	1
191	Option	221
192	end
193	end
194	class OptGroup < HTMLElement	1
195	attributes(:bool => [:disabled], :string => [:label])	1
196	end
197	class OptGroupCollection < ElementCollection	1
198	def element_class	1
199	OptGroup	0
200	end
201	end
202	class DataList < HTMLElement	1
203	attributes(:html_collection => [:options])	1
204	end
205	class DataListCollection < ElementCollection	1
206	def element_class	1
207	DataList	0
208	end
209	end
210	class Select < HTMLElement	1
211	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])	1
212	end
213	class SelectCollection < ElementCollection	1
214	def element_class	1
215	Select	33
216	end
217	end
218	class Button < HTMLElement	1
219	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])	1
220	end
221	class ButtonCollection < ElementCollection	1
222	def element_class	1
223	Button	0
224	end
225	end
226	class Input < HTMLElement	1
227	attributes(:string => [:accept, :alt, :autocomplete, :dir_name, :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])	1
228	end
229	class InputCollection < ElementCollection	1
230	def element_class	1
231	Input	0
232	end
233	end
234	class Input < HTMLElement	1
235	attributes(:string => [:align, :use_map])	1
236	end
237	# do nothing
238	class Label < HTMLElement	1
239	attributes(:html_element => [:form, :control], :string => [:html_for])	1
240	end
241	class LabelCollection < ElementCollection	1
242	def element_class	1
243	Label	57
244	end
245	end
246	class Legend < HTMLElement	1
247	attributes(:html_element => [:form])	1
248	end
249	class LegendCollection < ElementCollection	1
250	def element_class	1
251	Legend	0
252	end
253	end
254	class Legend < HTMLElement	1
255	attributes(:string => [:align])	1
256	end
257	# do nothing
258	class FieldSet < HTMLElement	1
259	attributes(:bool => [:disabled, :will_validate], :html_element => [:form], :string => [:name, :type, :validity, :validation_message], :html_collection => [:elements])	1
260	end
261	class FieldSetCollection < ElementCollection	1
262	def element_class	1
263	FieldSet	0
264	end
265	end
266	class Form < HTMLElement	1
267	attributes(:string => [:accept_charset, :action, :autocomplete, :enctype, :encoding, :method, :name, :target], :bool => [:no_validate], :html_collection => [:elements], :int => [:length])	1
268	end
269	class FormCollection < ElementCollection	1
270	def element_class	1
271	Form	12
272	end
273	end
274	class TableCell < HTMLElement	1
275	attributes(:int => [:col_span, :row_span, :cell_index], :token_list => [:headers])	1
276	end
277	class TableCellCollection < ElementCollection	1
278	def element_class	1
279	TableCell	103
280	end
281	end
282	class TableCell < HTMLElement	1
283	attributes(:string => [:abbr, :align, :axis, :bg_color, :ch, :ch_off, :height, :v_align, :width], :bool => [:no_wrap])	1
284	end
285	# do nothing
286	class TableHeaderCell < TableCell	1
287	attributes(:string => [:scope])	1
288	end
289	class TableHeaderCellCollection < ElementCollection	1
290	def element_class	1
291	TableHeaderCell	5
292	end
293	end
294	class TableDataCell < TableCell	1
295	# do nothing
296	end
297	class TableDataCellCollection < ElementCollection	1
298	def element_class	1
299	TableDataCell	36
300	end
301	end
302	class TableRow < HTMLElement	1
303	attributes(:int => [:row_index, :section_row_index], :html_collection => [:cells])	1
304	end
305	class TableRowCollection < ElementCollection	1
306	def element_class	1
307	TableRow	130
308	end
309	end
310	class TableRow < HTMLElement	1
311	attributes(:string => [:align, :bg_color, :ch, :ch_off, :v_align])	1
312	end
313	# do nothing
314	class TableSection < HTMLElement	1
315	attributes(:html_collection => [:rows])	1
316	end
317	class TableSectionCollection < ElementCollection	1
318	def element_class	1
319	TableSection	66
320	end
321	end
322	class TableSection < HTMLElement	1
323	attributes(:string => [:align, :ch, :ch_off, :v_align])	1
324	end
325	# do nothing
326	class TableCol < HTMLElement	1
327	attributes(:int => [:span])	1
328	end
329	class TableColCollection < ElementCollection	1
330	def element_class	1
331	TableCol	0
332	end
333	end
334	class TableCol < HTMLElement	1
335	attributes(:string => [:align, :ch, :ch_off, :v_align, :width])	1
336	end
337	# do nothing
338	class TableCaption < HTMLElement	1
339	# do nothing
340	end
341	class TableCaptionCollection < ElementCollection	1
342	def element_class	1
343	TableCaption	0
344	end
345	end
346	class TableCaption < HTMLElement	1
347	attributes(:string => [:align])	1
348	end
349	# do nothing
350	class Table < HTMLElement	1
351	attributes(:html_element => [:caption, :t_head, :t_foot], :html_collection => [:t_bodies, :rows], :string => [:summary])	1
352	end
353	class TableCollection < ElementCollection	1
354	def element_class	1
355	Table	48
356	end
357	end
358	class Table < HTMLElement	1
359	attributes(:string => [:align, :bg_color, :border, :cell_padding, :cell_spacing, :frame, :rules, :width])	1
360	end
361	# do nothing
362	class Area < HTMLElement	1
363	attributes(:string => [:alt, :coords, :shape, :href, :target, :ping, :rel, :media, :hreflang, :type, :protocol, :host, :hostname, :port, :pathname, :search, :hash], :token_list => [:rel_list])	1
364	end
365	class AreaCollection < ElementCollection	1
366	def element_class	1
367	Area	11
368	end
369	end
370	class Area < HTMLElement	1
371	attributes(:bool => [:no_href])	1
372	end
373	# do nothing
374	class Map < HTMLElement	1
375	attributes(:string => [:name], :html_collection => [:areas, :images])	1
376	end
377	class MapCollection < ElementCollection	1
378	def element_class	1
379	Map	9
380	end
381	end
382	class Canvas < HTMLElement	1
383	attributes(:int => [:width, :height])	1
384	end
385	class CanvasCollection < ElementCollection	1
386	def element_class	1
387	Canvas	0
388	end
389	end
390	class Media < HTMLElement	1
391	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])	1
392	end
393	class MediaCollection < ElementCollection	1
394	def element_class	1
395	Media	0
396	end
397	end
398	class Audio < Media	1
399	# do nothing
400	end
401	class AudioCollection < ElementCollection	1
402	def element_class	1
403	Audio	0
404	end
405	end
406	class Video < Media	1
407	attributes(:int => [:width, :height, :video_width, :video_height], :string => [:poster], :token_list => [:audio])	1
408	end
409	class VideoCollection < ElementCollection	1
410	def element_class	1
411	Video	0
412	end
413	end
414	class Track < HTMLElement	1
415	attributes(:string => [:kind, :src, :srclang, :label, :track], :bool => [:default])	1
416	end
417	class TrackCollection < ElementCollection	1
418	def element_class	1
419	Track	0
420	end
421	end
422	class Source < HTMLElement	1
423	attributes(:string => [:src, :type, :media])	1
424	end
425	class SourceCollection < ElementCollection	1
426	def element_class	1
427	Source	0
428	end
429	end
430	class Param < HTMLElement	1
431	attributes(:string => [:name, :value])	1
432	end
433	class ParamCollection < ElementCollection	1
434	def element_class	1
435	Param	0
436	end
437	end
438	class Param < HTMLElement	1
439	attributes(:string => [:type, :value_type])	1
440	end
441	# do nothing
442	class Object < HTMLElement	1
443	attributes(:string => [:data, :type, :name, :use_map, :width, :height, :content_window, :validity, :validation_message], :html_element => [:form], :document => [:content_document], :bool => [:will_validate])	1
444	end
445	class ObjectCollection < ElementCollection	1
446	def element_class	1
447	Object	0
448	end
449	end
450	class Object < HTMLElement	1
451	attributes(:string => [:align, :archive, :border, :code, :code_base, :code_type, :standby], :bool => [:declare], :int => [:hspace, :vspace])	1
452	end
453	# do nothing
454	class Embed < HTMLElement	1
455	attributes(:string => [:src, :type, :width, :height])	1
456	end
457	class EmbedCollection < ElementCollection	1
458	def element_class	1
459	Embed	0
460	end
461	end
462	class Embed < HTMLElement	1
463	attributes(:string => [:align, :name])	1
464	end
465	# do nothing
466	class IFrame < HTMLElement	1
467	attributes(:string => [:src, :srcdoc, :name, :width, :height, :content_window], :token_list => [:sandbox], :bool => [:seamless], :document => [:content_document])	1
468	end
469	class IFrameCollection < ElementCollection	1
470	def element_class	1
471	IFrame	0
472	end
473	end
474	class IFrame < HTMLElement	1
475	attributes(:string => [:align, :frame_border, :long_desc, :margin_height, :margin_width, :scrolling])	1
476	end
477	# do nothing
478	class Image < HTMLElement	1
479	attributes(:string => [:alt, :src, :use_map], :bool => [:is_map, :complete], :int => [:width, :height, :natural_width, :natural_height])	1
480	end
481	class ImageCollection < ElementCollection	1
482	def element_class	1
483	Image	25
484	end
485	end
486	class Image < HTMLElement	1
487	attributes(:string => [:name, :align, :border, :long_desc], :int => [:hspace, :vspace])	1
488	end
489	# do nothing
490	class Mod < HTMLElement	1
491	attributes(:string => [:cite, :date_time])	1
492	end
493	class ModCollection < ElementCollection	1
494	def element_class	1
495	Mod	30
496	end
497	end
498	class BR < HTMLElement	1
499	# do nothing
500	end



# encoding: utf-8
module Watir
  class Hidden < Input
    def visible?
      false
    end
  end

  module Container
    def hidden(*args)
      Hidden.new(self, extract_selector(args).merge(:tag_name => "input", :type => "hidden"))
    end

    def hiddens(*args)
      HiddenCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "hidden"))
    end
  end # Container

  class HiddenCollection < InputCollection
    def element_class
      Hidden
    end
  end # HiddenCollection
end

./lib/watir-webdriver/elements/hidden.rb 91.67 % covered
1	# encoding: utf-8
2	module Watir	1
3	class Hidden < Input	1
4	def visible?	1
5	false	0
6	end
7	end
8
9	module Container	1
10	def hidden(*args)	1
11	Hidden.new(self, extract_selector(args).merge(:tag_name => "input", :type => "hidden"))	41
12	end
13
14	def hiddens(*args)	1
15	HiddenCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "hidden"))	4
16	end
17	end # Container
18
19	class HiddenCollection < InputCollection	1
20	def element_class	1
21	Hidden	7
22	end
23	end # HiddenCollection
24	end



# encoding: utf-8
module Watir
  class Image < HTMLElement

    alias_method :loaded?, :complete?

    #
    # returns the image's width in pixels
    #
    # @return [Integer] width
    #

    def width
      assert_exists
      driver.execute_script "return arguments[0].width", @element
    end

    #
    # returns the image's height in pixels
    #
    # @return [Integer] height
    #

    def height
      assert_exists
      driver.execute_script "return arguments[0].height", @element
    end

    def file_created_date
      assert_exists
      raise NotImplementedError
    end

    def file_size
      assert_exists
      raise NotImplementedError
    end

    def save(path)
      assert_exists
      raise NotImplementedError
    end

  end # Image

  module Container
     alias_method :image, :img
     alias_method :images, :imgs
  end # Container

end # Watir

./lib/watir-webdriver/elements/image.rb 71.43 % covered
1	# encoding: utf-8
2	module Watir	1
3	class Image < HTMLElement	1
4
5	alias_method :loaded?, :complete?	1
6
7	#
8	# returns the image's width in pixels
9	#
10	# @return [Integer] width
11	#
12
13	def width	1
14	assert_exists	2
15	driver.execute_script "return arguments[0].width", @element	1
16	end
17
18	#
19	# returns the image's height in pixels
20	#
21	# @return [Integer] height
22	#
23
24	def height	1
25	assert_exists	2
26	driver.execute_script "return arguments[0].height", @element	1
27	end
28
29	def file_created_date	1
30	assert_exists	0
31	raise NotImplementedError	0
32	end
33
34	def file_size	1
35	assert_exists	0
36	raise NotImplementedError	0
37	end
38
39	def save(path)	1
40	assert_exists	0
41	raise NotImplementedError	0
42	end
43
44	end # Image
45
46	module Container	1
47	alias_method :image, :img	1
48	alias_method :images, :imgs	1
49	end # Container
50
51	end # Watir



# encoding: utf-8
module Watir
  class Input < HTMLElement

    alias_method :readonly?, :read_only?

    def enabled?
      !disabled?
    end

    #
    # Return the type attribute of the element, or 'text' if the attribute is invalid.
    # TODO: discuss.
    #
    # @return [String]
    #

    def type
      assert_exists
      value = @element.attribute("type").to_s

      # we return 'text' if the type is invalid
      # not sure if we really should do this
      TextFieldLocator::NON_TEXT_TYPES.include?(value) ? value : 'text'
    end

  end # Input
end # Watir

./lib/watir-webdriver/elements/input.rb 100.0 % covered
1	# encoding: utf-8
2	module Watir	1
3	class Input < HTMLElement	1
4
5	alias_method :readonly?, :read_only?	1
6
7	def enabled?	1
8	!disabled?	16
9	end
10
11	#
12	# Return the type attribute of the element, or 'text' if the attribute is invalid.
13	# TODO: discuss.
14	#
15	# @return [String]
16	#
17
18	def type	1
19	assert_exists	12
20	value = @element.attribute("type").to_s	7
21
22	# we return 'text' if the type is invalid
23	# not sure if we really should do this
24	TextFieldLocator::NON_TEXT_TYPES.include?(value) ? value : 'text'	7
25	end
26
27	end # Input
28	end # Watir

#		Hits
./lib/watir-webdriver/elements/link.rb 100.0 % covered
1	# encoding: utf-8
2	module Watir	1
3	module Container	1
4	alias_method :link, :a	1
5	alias_method :links, :as	1
6	end
7	end # Watir



# encoding: utf-8
module Watir

  #
  # Represents an option in a select list.
  #

  class Option < HTMLElement

    #
    # Select this option
    #

    def select
      assert_exists

      @element.select
      fire_event("onclick") rescue nil
    end

    #
    # Toggle the selected state of this option
    #

    def toggle
      assert_exists
      @element.toggle
    end

    #
    # Is this option selected?
    #

    def selected?
      assert_exists
      @element.selected?
    end

    def text
      assert_exists

      # A little unintuitive - we'll return the 'label' or 'text' attribute if
      # they exist, otherwise the inner text of the element

      attribute = [:label, :text].find { |a| attribute? a }

      if attribute
        @element.attribute(attribute)
      else
        @element.text
      end
    end

  end # Option
end # Watir

./lib/watir-webdriver/elements/option.rb 100.0 % covered
1	# encoding: utf-8
2	module Watir	1
3
4	#
5	# Represents an option in a select list.
6	#
7
8	class Option < HTMLElement	1
9
10	#
11	# Select this option
12	#
13
14	def select	1
15	assert_exists	12
16
17	@element.select	6
18	fire_event("onclick") rescue nil	6
19	end
20
21	#
22	# Toggle the selected state of this option
23	#
24
25	def toggle	1
26	assert_exists	14
27	@element.toggle	14
28	end
29
30	#
31	# Is this option selected?
32	#
33
34	def selected?	1
35	assert_exists	133
36	@element.selected?	133
37	end
38
39	def text	1
40	assert_exists	35
41
42	# A little unintuitive - we'll return the 'label' or 'text' attribute if
43	# they exist, otherwise the inner text of the element
44
45	attribute = [:label, :text].find { \|a\| attribute? a }	102
46
47	if attribute	35
48	@element.attribute(attribute)	3
49	else
50	@element.text	32
51	end
52	end
53
54	end # Option
55	end # Watir



# encoding: utf-8
module Watir
  class Radio < Input
    #
    # Select this radio button.
    #

    def set
      assert_exists
      assert_enabled

      @element.click unless set?
    end

    #
    # Is this radio set?
    #

    def set?
      assert_exists
      @element.selected?
    end
  end # Radio

  module Container
    def radio(*args)
      Radio.new(self, extract_selector(args).merge(:tag_name => "input", :type => "radio"))
    end

    def radios(*args)
      RadioCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "radio" ))
    end
  end # Container

  class RadioCollection < InputCollection
    private

    def element_class
      Radio
    end
  end # RadioCollection
end # Watir

./lib/watir-webdriver/elements/radio.rb 100.0 % covered
1	# encoding: utf-8
2	module Watir	1
3	class Radio < Input	1
4	#
5	# Select this radio button.
6	#
7
8	def set	1
9	assert_exists	15
10	assert_enabled	13
11
12	@element.click unless set?	11
13	end
14
15	#
16	# Is this radio set?
17	#
18
19	def set?	1
20	assert_exists	20
21	@element.selected?	18
22	end
23	end # Radio
24
25	module Container	1
26	def radio(*args)	1
27	Radio.new(self, extract_selector(args).merge(:tag_name => "input", :type => "radio"))	103
28	end
29
30	def radios(*args)	1
31	RadioCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "radio" ))	4
32	end
33	end # Container
34
35	class RadioCollection < InputCollection	1
36	private	1
37
38	def element_class	1
39	Radio	15
40	end
41	end # RadioCollection
42	end # Watir



# encoding: utf-8
module Watir
  class Select < HTMLElement
    include Watir::Exception

    #
    # Returns true if this element is enabled
    #
    # @return [Boolean]
    #

    def enabled?
      !disabled?
    end

    #
    # Clear all selected options
    #

    def clear
      assert_exists

      raise Error, "you can only clear multi-selects" unless multiple?

      options.each do |o|
        o.toggle if o.selected?
      end
    end

    #
    # Get all the options in the select list
    #
    # @return [Watir::OptionCollection]
    #

    def options
      assert_exists
      super
    end

    #
    # Returns true if the select list has one or more options where text or label matches the given value.
    #
    # @param [String, Regexp] value A value.
    # @return [Boolean]
    #

    def include?(str_or_rx)
      assert_exists
      # TODO: optimize similar to selected?
      options.any? { |e| str_or_rx === e.text }
    end

    #
    # Select the option(s) whose text or label matches the given string.
    # If this is a multi-select and several options match the value given, all will be selected.
    #
    # @param [String, Regexp] value A value.
    # @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
    # @return [String] The text of the option selected. If multiple options match, returns the first match.
    #

    def select(str_or_rx)
      select_by :text, str_or_rx
    end

    #
    # Selects the option(s) whose value attribute matches the given string.
    #
    # @see +select+
    #
    # @param [String, Regexp] value A value.
    # @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
    # @return [String] The option selected. If multiple options match, returns the first match
    #

    def select_value(str_or_rx)
      select_by :value, str_or_rx
    end

    #
    # Returns true if any of the selected options' text or label match the given value.
    #
    # @param [String, Regexp] value A value.
    # @raise [Watir::Exception::UnknownObjectException] if the value does not exist.
    # @return [Boolean]
    #

    def selected?(str_or_rx)
      assert_exists
      matches = @element.find_elements(:tag_name, 'option').select { |e| str_or_rx === e.text || str_or_rx === e.attribute(:label) }

      if matches.empty?
        raise UnknownObjectException, "Unable to locate option matching #{str_or_rx.inspect}"
      end

      matches.any? { |e| e.selected? }
    end

    #
    # Returns the value of the first selected option in the select list.
    # Returns nil if no option is selected.
    #
    # @return [String, nil]
    #

    def value
      o = options.find { |e| e.selected? } || return
      o.value
    end


    #
    # @return [Array<String>] An array of strings representing the text value of the currently selected options.
    #

    def selected_options
      assert_exists
      options.map { |e| e.text if e.selected? }.compact
    end

    private

    def select_by(how, str_or_rx)
      assert_exists

      case str_or_rx
      when String, Numeric
        select_by_string(how, str_or_rx.to_s)
      when Regexp
        select_by_regexp(how, str_or_rx)
      else
        raise TypeError, "expected String or Regexp, got #{str_or_rx.inspect}:#{str_or_rx.class}"
      end
    end

    def select_by_string(how, string)
      xpath = option_xpath_for(how, string)

      if multiple?
        elements = @element.find_elements(:xpath, xpath)
        no_value_found(string) if elements.empty?

        elements.each { |e| e.select unless e.selected? }
        elements.first.text
      else
        begin
          e = @element.find_element(:xpath, xpath)
        rescue WebDriver::Error::NoSuchElementError
          no_value_found(string)
        end

        e.select unless e.selected?

        safe_text(e)
      end
    end

    def select_by_regexp(how, exp)
      elements = @element.find_elements(:tag_name, 'option')
      no_value_found(nil, "no options in select list") if elements.empty?

      if multiple?
        found = elements.select do |e|
          next unless matches_regexp?(how, e, exp)
          e.select unless e.selected?
          true
        end

        no_value_found(exp) if found.empty?

        found.first.text
      else
        element = elements.find { |e| matches_regexp?(how, e, exp) }
        no_value_found(exp) unless element

        element.select unless element.selected?

        safe_text(element)
      end
    end

    def option_xpath_for(how, string)
      case how
      when :text
        ".//option[normalize-space()='#{string}' or @label='#{string}']"
      when :value
        ".//option[@value='#{string}']"
      else
        raise Error, "unknown how: #{how.inspect}"
      end
    end

    def matches_regexp?(how, element, exp)
      case how
      when :text
        element.text =~ exp || element.attribute(:label) =~ exp
      when :value
        element.attribute(:value) =~ exp
      else
        raise Error, "unknown how: #{how.inspect}"
      end
    end

    def safe_text(element)
      element.text
    rescue Selenium::WebDriver::Error::ObsoleteElementError
      # guard for scenario where selecting the element changes the page, making our element obsolete

      ''
    end

    def no_value_found(arg, msg = nil)
      raise NoValueFoundException, msg || "#{arg.inspect} not found in select list"
    end
  end # Select

  module Container
    alias_method :select_list,  :select
    alias_method :select_lists, :selects
  end # Container
end # Watir

./lib/watir-webdriver/elements/select.rb 97.59 % covered
1	# encoding: utf-8
2	module Watir	1
3	class Select < HTMLElement	1
4	include Watir::Exception	1
5
6	#
7	# Returns true if this element is enabled
8	#
9	# @return [Boolean]
10	#
11
12	def enabled?	1
13	!disabled?	3
14	end
15
16	#
17	# Clear all selected options
18	#
19
20	def clear	1
21	assert_exists	9
22
23	raise Error, "you can only clear multi-selects" unless multiple?	8
24
25	options.each do \|o\|	7
26	o.toggle if o.selected?	28
27	end
28	end
29
30	#
31	# Get all the options in the select list
32	#
33	# @return [Watir::OptionCollection]
34	#
35
36	def options	1
37	assert_exists	41
38	super	39
39	end
40
41	#
42	# Returns true if the select list has one or more options where text or label matches the given value.
43	#
44	# @param [String, Regexp] value A value.
45	# @return [Boolean]
46	#
47
48	def include?(str_or_rx)	1
49	assert_exists	2
50	# TODO: optimize similar to selected?
51	options.any? { \|e\| str_or_rx === e.text }	9
52	end
53
54	#
55	# Select the option(s) whose text or label matches the given string.
56	# If this is a multi-select and several options match the value given, all will be selected.
57	#
58	# @param [String, Regexp] value A value.
59	# @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
60	# @return [String] The text of the option selected. If multiple options match, returns the first match.
61	#
62
63	def select(str_or_rx)	1
64	select_by :text, str_or_rx	21
65	end
66
67	#
68	# Selects the option(s) whose value attribute matches the given string.
69	#
70	# @see +select+
71	#
72	# @param [String, Regexp] value A value.
73	# @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
74	# @return [String] The option selected. If multiple options match, returns the first match
75	#
76
77	def select_value(str_or_rx)	1
78	select_by :value, str_or_rx	4
79	end
80
81	#
82	# Returns true if any of the selected options' text or label match the given value.
83	#
84	# @param [String, Regexp] value A value.
85	# @raise [Watir::Exception::UnknownObjectException] if the value does not exist.
86	# @return [Boolean]
87	#
88
89	def selected?(str_or_rx)	1
90	assert_exists	3
91	matches = @element.find_elements(:tag_name, 'option').select { \|e\| str_or_rx === e.text \|\| str_or_rx === e.attribute(:label) }	21
92
93	if matches.empty?	3
94	raise UnknownObjectException, "Unable to locate option matching #{str_or_rx.inspect}"	1
95	end
96
97	matches.any? { \|e\| e.selected? }	4
98	end
99
100	#
101	# Returns the value of the first selected option in the select list.
102	# Returns nil if no option is selected.
103	#
104	# @return [String, nil]
105	#
106
107	def value	1
108	o = options.find { \|e\| e.selected? } \|\| return	37
109	o.value	13
110	end
111
112
113	#
114	# @return [Array<String>] An array of strings representing the text value of the currently selected options.
115	#
116
117	def selected_options	1
118	assert_exists	17
119	options.map { \|e\| e.text if e.selected? }.compact	96
120	end
121
122	private	1
123
124	def select_by(how, str_or_rx)	1
125	assert_exists	25
126
127	case str_or_rx	25
128	when String, Numeric
129	select_by_string(how, str_or_rx.to_s)	16
130	when Regexp
131	select_by_regexp(how, str_or_rx)	8
132	else
133	raise TypeError, "expected String or Regexp, got #{str_or_rx.inspect}:#{str_or_rx.class}"	1
134	end
135	end
136
137	def select_by_string(how, string)	1
138	xpath = option_xpath_for(how, string)	16
139
140	if multiple?	16
141	elements = @element.find_elements(:xpath, xpath)	9
142	no_value_found(string) if elements.empty?	9
143
144	elements.each { \|e\| e.select unless e.selected? }	16
145	elements.first.text	8
146	else
147	begin	7
148	e = @element.find_element(:xpath, xpath)	7
149	rescue WebDriver::Error::NoSuchElementError
150	no_value_found(string)	1
151	end
152
153	e.select unless e.selected?	6
154
155	safe_text(e)	6
156	end
157	end
158
159	def select_by_regexp(how, exp)	1
160	elements = @element.find_elements(:tag_name, 'option')	8
161	no_value_found(nil, "no options in select list") if elements.empty?	8
162
163	if multiple?	8
164	found = elements.select do \|e\|	5
165	next unless matches_regexp?(how, e, exp)	20
166	e.select unless e.selected?	11
167	true	11
168	end
169
170	no_value_found(exp) if found.empty?	5
171
172	found.first.text	4
173	else
174	element = elements.find { \|e\| matches_regexp?(how, e, exp) }	13
175	no_value_found(exp) unless element	3
176
177	element.select unless element.selected?	2
178
179	safe_text(element)	2
180	end
181	end
182
183	def option_xpath_for(how, string)	1
184	case how	16
185	when :text
186	".//option[normalize-space()='#{string}' or @label='#{string}']"	14
187	when :value
188	".//option[@value='#{string}']"	2
189	else
190	raise Error, "unknown how: #{how.inspect}"	0
191	end
192	end
193
194	def matches_regexp?(how, element, exp)	1
195	case how	30
196	when :text
197	element.text =~ exp \|\| element.attribute(:label) =~ exp	22
198	when :value
199	element.attribute(:value) =~ exp	8
200	else
201	raise Error, "unknown how: #{how.inspect}"	0
202	end
203	end
204
205	def safe_text(element)	1
206	element.text	8
207	rescue Selenium::WebDriver::Error::ObsoleteElementError
208	# guard for scenario where selecting the element changes the page, making our element obsolete
209
210	''	1
211	end
212
213	def no_value_found(arg, msg = nil)	1
214	raise NoValueFoundException, msg \|\| "#{arg.inspect} not found in select list"	4
215	end
216	end # Select
217
218	module Container	1
219	alias_method :select_list, :select	1
220	alias_method :select_lists, :selects	1
221	end # Container
222	end # Watir



# encoding: utf-8

module Watir
  class Table < HTMLElement
    include RowContainer

    def hashes
      all_rows   = rows.to_a
      header_row = all_rows.shift or raise Exception::Error, "no rows in table"

      headers = header_row.ths.map { |header_cell| header_cell.text  }
      result = []

      all_rows.each_with_index do |row, idx|
        cells = row.cells.to_a
        if cells.length != headers.length
          raise Exception::Error, "row at index #{idx} has #{cells.length} cells, expected #{headers.length}"
        end

        result << headers.inject({}) { |res, header| res.merge(header => cells.shift.text) }
      end

      result
    end

    #
    # Get the n'th row of this table.
    #
    # @return Watir::TableRow
    #

    def [](idx)
      row(:index, idx)
    end

  end # Table
end # Watir

./lib/watir-webdriver/elements/table.rb 93.75 % covered
1	# encoding: utf-8
2
3	module Watir	1
4	class Table < HTMLElement	1
5	include RowContainer	1
6
7	def hashes	1
8	all_rows = rows.to_a	1
9	header_row = all_rows.shift or raise Exception::Error, "no rows in table"	1
10
11	headers = header_row.ths.map { \|header_cell\| header_cell.text }	5
12	result = []	1
13
14	all_rows.each_with_index do \|row, idx\|	1
15	cells = row.cells.to_a	7
16	if cells.length != headers.length	7
17	raise Exception::Error, "row at index #{idx} has #{cells.length} cells, expected #{headers.length}"	0
18	end
19
20	result << headers.inject({}) { \|res, header\| res.merge(header => cells.shift.text) }	35
21	end
22
23	result	1
24	end
25
26	#
27	# Get the n'th row of this table.
28	#
29	# @return Watir::TableRow
30	#
31
32	def [](idx)	1
33	row(:index, idx)	11
34	end
35
36	end # Table
37	end # Watir



module Watir
  class TableCell < HTMLElement
    # @private
    attr_writer :locator_class

    def locator_class
      @locator_class || super
    end

    def colspan
      value = attribute_value :colspan
      value ? Integer(value) : 1
    end
  end

  class TableCellCollection < ElementCollection
    attr_writer :locator_class

    def locator_class
      @locator_class || super
    end

    def elements
      # we do this craziness since the xpath used will find direct child rows
      # before any rows inside thead/tbody/tfoot...
      elements = super

      if locator_class == ChildCellLocator
        elements = elements.sort_by { |row| row.attribute(:cellIndex).to_i }
      end

      elements
    end

  end
end

./lib/watir-webdriver/elements/table_cell.rb 100.0 % covered
1	module Watir	1
2	class TableCell < HTMLElement	1
3	# @private
4	attr_writer :locator_class	1
5
6	def locator_class	1
7	@locator_class \|\| super	102
8	end
9
10	def colspan	1
11	value = attribute_value :colspan	2
12	value ? Integer(value) : 1	2
13	end
14	end
15
16	class TableCellCollection < ElementCollection	1
17	attr_writer :locator_class	1
18
19	def locator_class	1
20	@locator_class \|\| super	90
21	end
22
23	def elements	1
24	# we do this craziness since the xpath used will find direct child rows
25	# before any rows inside thead/tbody/tfoot...
26	elements = super	45
27
28	if locator_class == ChildCellLocator	45
29	elements = elements.sort_by { \|row\| row.attribute(:cellIndex).to_i }	115
30	end
31
32	elements	45
33	end
34
35	end
36	end



module Watir
  class TableRow < HTMLElement
    include CellContainer

    # @private
    attr_writer :locator_class

    #
    # Get the n'th cell (<th> or <td>) of this row
    #
    # @return Watir::TableCell
    #

    def [](idx)
      cell(:index, idx)
    end

    private

    def locator_class
      @locator_class || super
    end
  end # TableRow


  class TableRowCollection < ElementCollection
    attr_writer :locator_class

    def elements
      # we do this craziness since the xpath used will find direct child rows
      # before any rows inside thead/tbody/tfoot...
      elements = super

      if locator_class == ChildRowLocator and @parent.kind_of? Table
        elements = elements.sort_by { |row| row.attribute(:rowIndex).to_i }
      end

      elements
    end

    def locator_class
      @locator_class || super
    end
  end # TableRowCollection
end # Watir

./lib/watir-webdriver/elements/table_row.rb 100.0 % covered
1	module Watir	1
2	class TableRow < HTMLElement	1
3	include CellContainer	1
4
5	# @private
6	attr_writer :locator_class	1
7
8	#
9	# Get the n'th cell (<th> or <td>) of this row
10	#
11	# @return Watir::TableCell
12	#
13
14	def [](idx)	1
15	cell(:index, idx)	15
16	end
17
18	private	1
19
20	def locator_class	1
21	@locator_class \|\| super	59
22	end
23	end # TableRow
24
25
26	class TableRowCollection < ElementCollection	1
27	attr_writer :locator_class	1
28
29	def elements	1
30	# we do this craziness since the xpath used will find direct child rows
31	# before any rows inside thead/tbody/tfoot...
32	elements = super	62
33
34	if locator_class == ChildRowLocator and @parent.kind_of? Table	62
35	elements = elements.sort_by { \|row\| row.attribute(:rowIndex).to_i }	54
36	end
37
38	elements	62
39	end
40
41	def locator_class	1
42	@locator_class \|\| super	120
43	end
44	end # TableRowCollection
45	end # Watir



module Watir
  class TableSection < HTMLElement
    include RowContainer

    def [](idx)
      row(:index => idx)
    end
  end
end

./lib/watir-webdriver/elements/table_section.rb 100.0 % covered
1	module Watir	1
2	class TableSection < HTMLElement	1
3	include RowContainer	1
4
5	def [](idx)	1
6	row(:index => idx)	19
7	end
8	end
9	end



# encoding: utf-8
module Watir
  class TextField < Input

    attributes Watir::TextArea.typed_attributes
    remove_method :type # we want Input#type here, which was overriden by TextArea's attributes

    #
    # Clear the element, the type in the given value.
    #

    def set(*args)
      assert_exists
      assert_writable

      @element.clear
      @element.send_keys(*args)
    end
    alias_method :value=, :set

    #
    # Append the given value to the text in the text field.
    #

    def append(*args)
      assert_exists
      assert_writable

      @element.send_keys(*args)
    end

    #
    # Clear the text field.
    #

    def clear
      assert_exists
      @element.clear
    end

    #
    # Returns the text in the text field.
    #

    def value
      # since 'value' is an attribute on input fields, we override this here
      assert_exists
      @element.value
    end

    private

    def locate
      @parent.assert_exists
      TextFieldLocator.new(@parent.wd, @selector, self.class.attribute_list).locate
    end

    def selector_string
      selector = @selector.dup
      selector[:type] = '(any text type)'
      selector[:tag_name] = "input or textarea"
      selector.inspect
    end
  end

  module Container
    def text_field(*args)
      TextField.new(self, extract_selector(args).merge(:tag_name => "input"))
    end

    def text_fields(*args)
      TextFieldCollection.new(self, extract_selector(args).merge(:tag_name => "input"))
    end
  end # Container

  class TextFieldCollection < InputCollection
    private

    def locator_class
      TextFieldLocator
    end

    def element_class
      TextField
    end
  end # TextFieldCollection
end

./lib/watir-webdriver/elements/text_field.rb 100.0 % covered
1	# encoding: utf-8
2	module Watir	1
3	class TextField < Input	1
4
5	attributes Watir::TextArea.typed_attributes	1
6	remove_method :type # we want Input#type here, which was overriden by TextArea's attributes	1
7
8	#
9	# Clear the element, the type in the given value.
10	#
11
12	def set(*args)	1
13	assert_exists	12
14	assert_writable	10
15
16	@element.clear	10
17	@element.send_keys(*args)	10
18	end
19	alias_method :value=, :set	1
20
21	#
22	# Append the given value to the text in the text field.
23	#
24
25	def append(*args)	1
26	assert_exists	5
27	assert_writable	4
28
29	@element.send_keys(*args)	2
30	end
31
32	#
33	# Clear the text field.
34	#
35
36	def clear	1
37	assert_exists	3
38	@element.clear	2
39	end
40
41	#
42	# Returns the text in the text field.
43	#
44
45	def value	1
46	# since 'value' is an attribute on input fields, we override this here
47	assert_exists	43
48	@element.value	42
49	end
50
51	private	1
52
53	def locate	1
54	@parent.assert_exists	134
55	TextFieldLocator.new(@parent.wd, @selector, self.class.attribute_list).locate	134
56	end
57
58	def selector_string	1
59	selector = @selector.dup	28
60	selector[:type] = '(any text type)'	28
61	selector[:tag_name] = "input or textarea"	28
62	selector.inspect	28
63	end
64	end
65
66	module Container	1
67	def text_field(*args)	1
68	TextField.new(self, extract_selector(args).merge(:tag_name => "input"))	140
69	end
70
71	def text_fields(*args)	1
72	TextFieldCollection.new(self, extract_selector(args).merge(:tag_name => "input"))	6
73	end
74	end # Container
75
76	class TextFieldCollection < InputCollection	1
77	private	1
78
79	def locator_class	1
80	TextFieldLocator	6
81	end
82
83	def element_class	1
84	TextField	43
85	end
86	end # TextFieldCollection
87	end



# encoding: utf-8

module Watir
  module Exception
    class Error < StandardError; end

    # TODO: rename Object -> Element?
    class UnknownObjectException < Error; end
    class ObjectDisabledException < Error; end
    class ObjectReadOnlyException < Error; end
    class NoValueFoundException < Error; end
    class MissingWayOfFindingObjectException < Error; end
    class UnknownCellException < Error; end
    class NoMatchingWindowFoundException < Error; end
    class NoStatusBarException < Error; end
    class NavigationException < Error; end
    class UnknownFrameException < Error; end
    class UnknownRowException < Error; end

  end # Exception
end # Watir

./lib/watir-webdriver/exception.rb 100.0 % covered
1	# encoding: utf-8
2
3	module Watir	1
4	module Exception	1
5	class Error < StandardError; end	1
6
7	# TODO: rename Object -> Element?
8	class UnknownObjectException < Error; end	1
9	class ObjectDisabledException < Error; end	1
10	class ObjectReadOnlyException < Error; end	1
11	class NoValueFoundException < Error; end	1
12	class MissingWayOfFindingObjectException < Error; end	1
13	class UnknownCellException < Error; end	1
14	class NoMatchingWindowFoundException < Error; end	1
15	class NoStatusBarException < Error; end	1
16	class NavigationException < Error; end	1
17	class UnknownFrameException < Error; end	1
18	class UnknownRowException < Error; end	1
19
20	end # Exception
21	end # Watir



module Watir

  #
  # Module provided by optional require:
  #
  #   require "watir-webdriver/extensions/alerts"
  #

  module AlertHelper

    #
    # Overwrite window.alert()
    #
    # This method is provided by an optional require - API is subject to change.
    #
    # @example
    #   browser.alert do
    #     browser.button(:value => "Alert").click
    #   end #=> "the alert message"
    #

    def alert(&blk)
      execute_script "window.alert = function(msg) { window.__lastWatirAlert = msg; }"
      yield
      execute_script "return window.__lastWatirAlert"
    end

    #
    # Overwrite window.confirm()
    #
    # This method is provided by an optional require - API is subject to change.
    #
    # @example
    #   browser.confirm(true) do
    #     browser.button(:value => "Confirm").click
    #   end #=> "the confirm message"

    def confirm(bool, &blk)
      execute_script "window.confirm = function(msg) { window.__lastWatirConfirm = msg; return #{!!bool} }"
      yield
      execute_script "return window.__lastWatirConfirm"
    end

    #
    # Overwrite window.prompt()
    #
    # This method is provided by an optional require - API is subject to change.
    #
    # @example
    #   browser.prompt("hello") do
    #     browser.button(:value => "Prompt").click
    #   end #=> { :message => "foo", :default_value => "bar" }
    #

    def prompt(answer, &blk)
      execute_script "window.prompt = function(text, value) { window.__lastWatirPrompt = { message: text, default_value: value }; return #{answer.to_json}; }"
      yield
      result = execute_script "return window.__lastWatirPrompt"

      result && result.dup.each_key { |k| result[k.to_sym] = result.delete(k)}
      result
    end
  end

  class Browser
    include AlertHelper
  end

end

./lib/watir-webdriver/extensions/alerts.rb 100.0 % covered
1	module Watir	1
2
3	#
4	# Module provided by optional require:
5	#
6	# require "watir-webdriver/extensions/alerts"
7	#
8
9	module AlertHelper	1
10
11	#
12	# Overwrite window.alert()
13	#
14	# This method is provided by an optional require - API is subject to change.
15	#
16	# @example
17	# browser.alert do
18	# browser.button(:value => "Alert").click
19	# end #=> "the alert message"
20	#
21
22	def alert(&blk)	1
23	execute_script "window.alert = function(msg) { window.__lastWatirAlert = msg; }"	1
24	yield	1
25	execute_script "return window.__lastWatirAlert"	1
26	end
27
28	#
29	# Overwrite window.confirm()
30	#
31	# This method is provided by an optional require - API is subject to change.
32	#
33	# @example
34	# browser.confirm(true) do
35	# browser.button(:value => "Confirm").click
36	# end #=> "the confirm message"
37
38	def confirm(bool, &blk)	1
39	execute_script "window.confirm = function(msg) { window.__lastWatirConfirm = msg; return #{!!bool} }"	2
40	yield	2
41	execute_script "return window.__lastWatirConfirm"	2
42	end
43
44	#
45	# Overwrite window.prompt()
46	#
47	# This method is provided by an optional require - API is subject to change.
48	#
49	# @example
50	# browser.prompt("hello") do
51	# browser.button(:value => "Prompt").click
52	# end #=> { :message => "foo", :default_value => "bar" }
53	#
54
55	def prompt(answer, &blk)	1
56	execute_script "window.prompt = function(text, value) { window.__lastWatirPrompt = { message: text, default_value: value }; return #{answer.to_json}; }"	1
57	yield	1
58	result = execute_script "return window.__lastWatirPrompt"	1
59
60	result && result.dup.each_key { \|k\| result[k.to_sym] = result.delete(k)}	3
61	result	1
62	end
63	end
64
65	class Browser	1
66	include AlertHelper	1
67	end
68
69	end



# encoding: utf-8
module Watir

  #
  # Module provided by optional require:
  #
  #   require "watir-webdriver/extensions/wait"
  #

  module Wait
    module_function

    class TimeoutError < StandardError
    end

    #
    # Wait until the block evaluates to true or times out.
    #

    def until(timeout = 30, &block)
      end_time = ::Time.now + timeout

      until ::Time.now > end_time
        result = yield(self)
        return result if result
        sleep 0.5
      end

      raise TimeoutError, "timed out after #{timeout} seconds"
    end

    #
    # Wait while the block evaluates to true or times out.
    #

    def while(timeout = 30, &block)
      end_time = ::Time.now + timeout

      until ::Time.now > end_time
        return unless yield(self)
        sleep 0.5
      end

      raise TimeoutError, "timed out after #{timeout} seconds"
    end

  end # Wait

  #
  # Wraps an Element so that any subsequent method calls are
  # put on hold until the element is present (exists and is visible) on the page.
  #

  class WhenPresentDecorator
    def initialize(element, timeout)
      @element = element
      @timeout = timeout
    end

    def method_missing(m, *args, &block)
      unless @element.respond_to?(m)
        raise NoMethodError, "undefined method `#{m}' for #{@element.inspect}:#{@element.class}"
      end

      Watir::Wait.until(@timeout) { @element.present? }

      @element.__send__(m, *args, &block)
    end
  end # WhenPresentDecorator

  class Element

    #
    # Returns true if the element exists and is visible on the page
    #
    # This method is provided by an optional require.
    # @see Watir::Wait
    #

    def present?
      exists? && visible?
    end

    #
    # Waits until the element is present.
    #
    # This method is provided by an optional require.
    # @see Watir::Wait
    #
    # Example:
    #   browser.button(:id, 'foo').when_present.click
    #   browser.div(:id, 'bar').when_present { |div| ... }
    #   browser.p(:id, 'baz').when_present(60).text
    #
    # @param [Integer] timeout seconds to wait before timing out
    #

    def when_present(timeout = 30)
      if block_given?
        Watir::Wait.until(timeout) { self.present? }
        yield self
      else
        WhenPresentDecorator.new(self, timeout)
      end
    end

    #
    # Waits until the element is present.
    #
    # This method is provided by an optional require.
    #
    # @param [Integer] timeout seconds to wait before timing out
    #
    # @see Watir::Wait
    # @see Watir::Element#present?
    #

    def wait_until_present(timeout = 30)
      Watir::Wait.until(timeout) { self.present? }
    end

    #
    # Waits while the element is present.
    #
    # This method is provided by an optional require.
    #
    # @param [Integer] timeout seconds to wait before timing out
    #
    # @see Watir::Wait
    # @see Watir::Element#present?
    #

    def wait_while_present(timeout = 30)
      Watir::Wait.while(timeout) { self.present? }
    rescue Selenium::WebDriver::Error::ObsoleteElementError
      # it's not present
    end
  end # Element


end # Watir

./lib/watir-webdriver/extensions/wait.rb 97.37 % covered
1	# encoding: utf-8
2	module Watir	1
3
4	#
5	# Module provided by optional require:
6	#
7	# require "watir-webdriver/extensions/wait"
8	#
9
10	module Wait	1
11	module_function	1
12
13	class TimeoutError < StandardError	1
14	end
15
16	#
17	# Wait until the block evaluates to true or times out.
18	#
19
20	def until(timeout = 30, &block)	1
21	end_time = ::Time.now + timeout	8
22
23	until ::Time.now > end_time	8
24	result = yield(self)	15
25	return result if result	15
26	sleep 0.5	11
27	end
28
29	raise TimeoutError, "timed out after #{timeout} seconds"	4
30	end
31
32	#
33	# Wait while the block evaluates to true or times out.
34	#
35
36	def while(timeout = 30, &block)	1
37	end_time = ::Time.now + timeout	5
38
39	until ::Time.now > end_time	5
40	return unless yield(self)	9
41	sleep 0.5	6
42	end
43
44	raise TimeoutError, "timed out after #{timeout} seconds"	2
45	end
46
47	end # Wait
48
49	#
50	# Wraps an Element so that any subsequent method calls are
51	# put on hold until the element is present (exists and is visible) on the page.
52	#
53
54	class WhenPresentDecorator	1
55	def initialize(element, timeout)	1
56	@element = element	2
57	@timeout = timeout	2
58	end
59
60	def method_missing(m, *args, &block)	1
61	unless @element.respond_to?(m)	2
62	raise NoMethodError, "undefined method `#{m}' for #{@element.inspect}:#{@element.class}"	0
63	end
64
65	Watir::Wait.until(@timeout) { @element.present? }	6
66
67	@element.__send__(m, *args, &block)	1
68	end
69	end # WhenPresentDecorator
70
71	class Element	1
72
73	#
74	# Returns true if the element exists and is visible on the page
75	#
76	# This method is provided by an optional require.
77	# @see Watir::Wait
78	#
79
80	def present?	1
81	exists? && visible?	21
82	end
83
84	#
85	# Waits until the element is present.
86	#
87	# This method is provided by an optional require.
88	# @see Watir::Wait
89	#
90	# Example:
91	# browser.button(:id, 'foo').when_present.click
92	# browser.div(:id, 'bar').when_present { \|div\| ... }
93	# browser.p(:id, 'baz').when_present(60).text
94	#
95	# @param [Integer] timeout seconds to wait before timing out
96	#
97
98	def when_present(timeout = 30)	1
99	if block_given?	4
100	Watir::Wait.until(timeout) { self.present? }	6
101	yield self	1
102	else
103	WhenPresentDecorator.new(self, timeout)	2
104	end
105	end
106
107	#
108	# Waits until the element is present.
109	#
110	# This method is provided by an optional require.
111	#
112	# @param [Integer] timeout seconds to wait before timing out
113	#
114	# @see Watir::Wait
115	# @see Watir::Element#present?
116	#
117
118	def wait_until_present(timeout = 30)	1
119	Watir::Wait.until(timeout) { self.present? }	6
120	end
121
122	#
123	# Waits while the element is present.
124	#
125	# This method is provided by an optional require.
126	#
127	# @param [Integer] timeout seconds to wait before timing out
128	#
129	# @see Watir::Wait
130	# @see Watir::Element#present?
131	#
132
133	def wait_while_present(timeout = 30)	1
134	Watir::Wait.while(timeout) { self.present? }	9
135	rescue Selenium::WebDriver::Error::ObsoleteElementError
136	# it's not present
137	end
138	end # Element
139
140
141	end # Watir



module Watir
  class ButtonLocator < ElementLocator

    def locate_all
      find_all_by_multiple
    end

    private

    def wd_find_first_by(how, what)
      if how == :tag_name
        how  = :xpath
        what = ".//button | .//input[#{attribute_expression :type => Button::VALID_TYPES}]"
      end

      super
    end

    def build_xpath(selectors)
      return if selectors.values.any? { |e| e.kind_of? Regexp }

      selectors.delete(:tag_name) || raise("internal error: no tag_name?!")

      @building = :button
      button_attr_exp = attribute_expression(selectors)

      @building = :input
      selectors[:type] = Button::VALID_TYPES
      input_attr_exp = attribute_expression(selectors)

      xpath = ".//button"
      xpath << "[#{button_attr_exp}]" unless button_attr_exp.empty?
      xpath << " | .//input"
      xpath << "[#{input_attr_exp}]"

      p :build_xpath => xpath if $DEBUG

      xpath
    end

    def lhs_for(key)
      if @building == :input && key == :text
        "@value"
      elsif @building == :button && key == :value
        "text()"
      else
        super
      end
    end

    def matches_selector?(element, rx_selector)
      rx_selector = rx_selector.dup

      [:value, :caption].each do |key|
        if rx_selector.has_key?(key)
          correct_key = element.tag_name == 'button' ? :text : :value
          rx_selector[correct_key] = rx_selector.delete(key)
        end
      end

      super
    end

    def tag_name_matches?(element, _)
      !!(/^(input|button)$/ === element.tag_name)
    end

    def validate_element(element)
      return if element.tag_name == "input" && !Button::VALID_TYPES.include?(element.attribute(:type))
      super
    end

  end # ButtonLocator
end # Watir

./lib/watir-webdriver/locators/button_locator.rb 100.0 % covered
1	module Watir	1
2	class ButtonLocator < ElementLocator	1
3
4	def locate_all	1
5	find_all_by_multiple	8
6	end
7
8	private	1
9
10	def wd_find_first_by(how, what)	1
11	if how == :tag_name	1
12	how = :xpath	1
13	what = ".//button \| .//input[#{attribute_expression :type => Button::VALID_TYPES}]"	1
14	end
15
16	super	1
17	end
18
19	def build_xpath(selectors)	1
20	return if selectors.values.any? { \|e\| e.kind_of? Regexp }	264
21
22	selectors.delete(:tag_name) \|\| raise("internal error: no tag_name?!")	101
23
24	@building = :button	101
25	button_attr_exp = attribute_expression(selectors)	101
26
27	@building = :input	101
28	selectors[:type] = Button::VALID_TYPES	101
29	input_attr_exp = attribute_expression(selectors)	101
30
31	xpath = ".//button"	101
32	xpath << "[#{button_attr_exp}]" unless button_attr_exp.empty?	101
33	xpath << " \| .//input"	101
34	xpath << "[#{input_attr_exp}]"	101
35
36	p :build_xpath => xpath if $DEBUG	101
37
38	xpath	101
39	end
40
41	def lhs_for(key)	1
42	if @building == :input && key == :text	476
43	"@value"	3
44	elsif @building == :button && key == :value	473
45	"text()"	4
46	else
47	super	469
48	end
49	end
50
51	def matches_selector?(element, rx_selector)	1
52	rx_selector = rx_selector.dup	76
53
54	[:value, :caption].each do \|key\|	76
55	if rx_selector.has_key?(key)	152
56	correct_key = element.tag_name == 'button' ? :text : :value	12
57	rx_selector[correct_key] = rx_selector.delete(key)	12
58	end
59	end
60
61	super	76
62	end
63
64	def tag_name_matches?(element, _)	1
65	!!(/^(input\|button)$/ === element.tag_name)	89
66	end
67
68	def validate_element(element)	1
69	return if element.tag_name == "input" && !Button::VALID_TYPES.include?(element.attribute(:type))	73
70	super	72
71	end
72
73	end # ButtonLocator
74	end # Watir



module Watir
  class ChildCellLocator < ElementLocator

    def locate_all
      find_all_by_multiple
    end

    private

    def by_id
      nil
    end

    def build_xpath(selectors)
      return if selectors.values.any? { |e| e.kind_of? Regexp }

      expressions = %w[./th ./td]
      attr_expr = attribute_expression(selectors)

      unless attr_expr.empty?
        expressions.map! { |e| "#{e}[#{attr_expr}]" }
      end

      xpath = expressions.join(" | ")

      p :build_xpath => xpath if $DEBUG

      xpath
    end

  end # ChildCellLocator
end # Watir

./lib/watir-webdriver/locators/child_cell_locator.rb 100.0 % covered
1	module Watir	1
2	class ChildCellLocator < ElementLocator	1
3
4	def locate_all	1
5	find_all_by_multiple	45
6	end
7
8	private	1
9
10	def by_id	1
11	nil
12	end
13
14	def build_xpath(selectors)	1
15	return if selectors.values.any? { \|e\| e.kind_of? Regexp }	188
16
17	expressions = %w[./th ./td]	62
18	attr_expr = attribute_expression(selectors)	62
19
20	unless attr_expr.empty?	62
21	expressions.map! { \|e\| "#{e}[#{attr_expr}]" }	3
22	end
23
24	xpath = expressions.join(" \| ")	62
25
26	p :build_xpath => xpath if $DEBUG	62
27
28	xpath	62
29	end
30
31	end # ChildCellLocator
32	end # Watir



module Watir
  class ChildRowLocator < ElementLocator

    def locate_all
      find_all_by_multiple
    end

    private

    def by_id
      nil # avoid this
    end

    def build_xpath(selectors)
      return if selectors.values.any? { |e| e.kind_of? Regexp }
      selectors.delete(:tag_name) || raise("internal error: no tag_name?!")

      expressions = %w[./tr]
      unless %w[tbody tfoot thead].include?(@wd.tag_name)
        expressions += %w[./tbody/tr ./thead/tr ./tfoot/tr]
      end

      attr_expr = attribute_expression(selectors)

      unless attr_expr.empty?
        expressions.map! { |e| "#{e}[#{attr_expr}]" }
      end

      xpath = expressions.join(" | ")

      p :build_xpath => xpath if $DEBUG

      xpath
    end

  end # ChildRowLocator
end # Watir

./lib/watir-webdriver/locators/child_row_locator.rb 100.0 % covered
1	module Watir	1
2	class ChildRowLocator < ElementLocator	1
3
4	def locate_all	1
5	find_all_by_multiple	49
6	end
7
8	private	1
9
10	def by_id	1
11	nil # avoid this
12	end
13
14	def build_xpath(selectors)	1
15	return if selectors.values.any? { \|e\| e.kind_of? Regexp }	190
16	selectors.delete(:tag_name) \|\| raise("internal error: no tag_name?!")	87
17
18	expressions = %w[./tr]	87
19	unless %w[tbody tfoot thead].include?(@wd.tag_name)	87
20	expressions += %w[./tbody/tr ./thead/tr ./tfoot/tr]	47
21	end
22
23	attr_expr = attribute_expression(selectors)	87
24
25	unless attr_expr.empty?	87
26	expressions.map! { \|e\| "#{e}[#{attr_expr}]" }	25
27	end
28
29	xpath = expressions.join(" \| ")	87
30
31	p :build_xpath => xpath if $DEBUG	87
32
33	xpath	87
34	end
35
36	end # ChildRowLocator
37	end # Watir



# encoding: utf-8
module Watir
  class ElementLocator
    include Watir::Exception
    include Selenium

    WD_FINDERS =  [
      :class,
      :class_name,
      :css,
      :id,
      :link,
      :link_text,
      :name,
      :partial_link_text,
      :tag_name,
      :xpath
    ]

    def initialize(wd, selector, valid_attributes)
      @wd               = wd
      @selector         = selector.dup
      @valid_attributes = valid_attributes
    end

    def locate
      e = by_id and return e # short-circuit if :id is given


      if @selector.size == 1
        element = find_first_by_one
      else
        element = find_first_by_multiple
      end

      # this actually only applies when finding by xpath - browser.text_field(:xpath, "//input[@type='radio']")
      # we don't need to validate the element if we built the xpath ourselves.
      validate_element(element) if element
    rescue WebDriver::Error::NoSuchElementError => wde
      nil
    end

    def locate_all
      if @selector.size == 1
        find_all_by_one
      else
        find_all_by_multiple
      end
    end

    private

    def find_first_by_one
      how, what = @selector.to_a.first
      check_type how, what

      if WD_FINDERS.include?(how)
        wd_find_first_by(how, what)
      else
        find_first_by_multiple
      end
    end

    def find_all_by_one
      how, what = @selector.to_a.first
      check_type how, what

      if WD_FINDERS.include?(how)
        wd_find_all_by(how, what)
      else
        find_all_by_multiple
      end
    end

    def find_first_by_multiple
      selector = normalized_selector

      idx   = selector.delete(:index)
      xpath = given_xpath(selector) || build_xpath(selector)

      if xpath
        # could build xpath for selector
        if idx
          @wd.find_elements(:xpath, xpath)[idx]
        else
          @wd.find_element(:xpath, xpath)
        end
      else
        # can't use xpath, probably a regexp in there
        if idx
          wd_find_by_regexp_selector(selector, :select)[idx]
        else
          wd_find_by_regexp_selector(selector, :find)
        end
      end
    end

    def find_all_by_multiple
      selector = normalized_selector

      if selector.has_key? :index
        raise ArgumentError, "can't locate all elements by :index"
      end

      xpath = given_xpath(selector) || build_xpath(selector)
      if xpath
        @wd.find_elements(:xpath, xpath)
      else
        wd_find_by_regexp_selector(selector, :select)
      end
    end

    def wd_find_first_by(how, what)
      if what.kind_of? String
        @wd.find_element(how, what)
      else
        all_elements.find { |element| fetch_value(element, how) =~ what }
      end
    end

    def wd_find_all_by(how, what)
      if what.kind_of? String
        @wd.find_elements(how, what)
      else
        all_elements.select { |element| fetch_value(element, how) =~ what }
      end
    end

    def wd_find_by_regexp_selector(selector, method = :find)
      rx_selector = delete_regexps_from(selector)

      if rx_selector.has_key?(:label) && should_use_label_element?
        selector[:id] = id_from_label(rx_selector.delete(:label)) || return
      end

      xpath = build_xpath(selector) || raise("internal error: unable to build xpath from #{selector.inspect}")

      elements = @wd.find_elements(:xpath, xpath)
      elements.__send__(method) { |el| matches_selector?(el, rx_selector) }
    end

    VALID_WHATS = [String, Regexp]

    def check_type(how, what)
      case how
      when :index
        unless what.kind_of?(Fixnum)
          raise TypeError, "expected Fixnum, got #{what.inspect}:#{what.class}"
        end
      else
        unless VALID_WHATS.any? { |t| what.kind_of? t }
          raise TypeError, "expected one of #{VALID_WHATS.inspect}, got #{what.inspect}:#{what.class}"
        end
      end
    end

    def id_from_label(label_exp)
      # TODO: this won't work correctly if @wd is a sub-element
      label = @wd.find_elements(:tag_name, 'label').find do |el|
        matches_selector?(el, :text => label_exp)
      end

      label.attribute(:for) if label
    end

    def fetch_value(element, how)
      case how
      when :text
        element.text
      when :tag_name
        element.tag_name
      when :href
        (href = element.attribute(:href)) && href.strip
      else
        element.attribute(how)
      end
    end

    def matches_selector?(element, selector)
      selector.all? do |how, what|
        what === fetch_value(element, how)
      end
    end

    def normalized_selector
      selector = {}

      @selector.each do |how, what|
        check_type(how, what)

        how, what = normalize_selector(how, what)
        selector[how] = what
      end

      selector
    end

    def normalize_selector(how, what)
      case how
      when :tag_name, :text, :xpath, :index, :class, :for
        # include :class since the valid attribute is 'class_name'
        # include :for since the valid attribute is 'html_for'
        [how, what]
      when :class_name
        [:class, what]
      when :caption
        [:text, what]
      else
        assert_valid_as_attribute how
        [how, what]
      end
    end

    def delete_regexps_from(selector)
      rx_selector = {}

      selector.dup.each do |how, what|
        next unless what.kind_of?(Regexp)
        rx_selector[how] = what
        selector.delete how
      end

      rx_selector
    end

    def assert_valid_as_attribute(attribute)
      unless valid_attribute? attribute or attribute.to_s =~ /^data_.+$/
        raise MissingWayOfFindingObjectException, "invalid attribute: #{attribute.inspect}"
      end
    end

    def by_id
      return unless id = @selector[:id] and id.kind_of? String

      selector = @selector.dup
      selector.delete(:id)

      tag_name = selector.delete(:tag_name)
      return unless selector.empty? # multiple attributes

      element = @wd.find_element(:id, id)
      return if tag_name && !tag_name_matches?(element, tag_name)

      element
    rescue WebDriver::Error::NoSuchElementError => wde
      nil
    end

    def all_elements
      @wd.find_elements(:xpath => ".//*")
    end

    def tag_name_matches?(element, tag_name)
      tag_name === element.tag_name
    end

    def valid_attribute?(attribute)
      @valid_attributes && @valid_attributes.include?(attribute)
    end

    def should_use_label_element?
      @selector[:tag_name] != "option"
    end

    def build_xpath(selectors)
      return if selectors.values.any? { |e| e.kind_of? Regexp }

      xpath = ".//"
      xpath << (selectors.delete(:tag_name) || '*').to_s

      idx = selectors.delete(:index)

      # the remaining entries should be attributes
      unless selectors.empty?
        xpath << "[" << attribute_expression(selectors) << "]"
      end

      if idx
        xpath << "[#{idx + 1}]"
      end

      p :xpath => xpath, :selectors => selectors if $DEBUG

      xpath
    end

    def attribute_expression(selectors)
      selectors.map do |key, val|
        if val.kind_of?(Array)
          "(" + val.map { |v| equal_pair(key, v) }.join(" or ") + ")"
        else
          equal_pair(key, val)
        end
      end.join(" and ")
    end

    def equal_pair(key, value)
      # we assume :label means a corresponding label element, not the attribute
      if key == :label && should_use_label_element?
        "@id=//label[normalize-space()=#{xpath_string(value)}]/@for"
      else
        "#{lhs_for(key)}=#{xpath_string(value)}"
      end
    end

    def lhs_for(key)
      case key
      when :text, 'text'
        'normalize-space()'
      when :href
        # TODO: change this behaviour?
        'normalize-space(@href)'
      else
        "@#{key.to_s.gsub("_", "-")}"
      end
    end

    def validate_element(element)
      tn = @selector[:tag_name]
      return if tn && !tag_name_matches?(element, tn)

      if element.tag_name == 'input'
        return if @selector[:type] && @selector[:type] != element.attribute(:type)
      end

      element
    end

    def given_xpath(selector)
      return unless xpath = selector.delete(:xpath)

      unless selector.empty? || can_be_combined_with_xpath?(selector)
        raise ArgumentError, ":xpath cannot be combined with other selectors (#{selector.inspect})"
      end

      xpath
    end

    def can_be_combined_with_xpath?(selector)
      # ouch - is this worth it?
      keys = selector.keys
      return true if keys == [:tag_name]

      if selector[:tag_name] == "input"
        return keys == [:tag_name, :type] || keys == [:type, :tag_name]
      end

      false
    end

    def xpath_string(value)
      if value.include? "'"
        parts = value.split("'", -1).map { |part| "'#{part}'" }
        string = parts.join(%{,"'",})

        "concat(#{string})"
      else
        "'#{value}'"
      end
    end

  end # ElementLocator
end # Watir

./lib/watir-webdriver/locators/element_locator.rb 98.31 % covered
1	# encoding: utf-8
2	module Watir	1
3	class ElementLocator	1
4	include Watir::Exception	1
5	include Selenium	1
6
7	WD_FINDERS = [	1
8	:class,
9	:class_name,
10	:css,
11	:id,
12	:link,
13	:link_text,
14	:name,
15	:partial_link_text,
16	:tag_name,
17	:xpath
18	]
19
20	def initialize(wd, selector, valid_attributes)	1
21	@wd = wd	2782
22	@selector = selector.dup	2782
23	@valid_attributes = valid_attributes	2782
24	end
25
26	def locate	1
27	e = by_id and return e # short-circuit if :id is given	2433
28
29
30	if @selector.size == 1	2151
31	element = find_first_by_one	51
32	else
33	element = find_first_by_multiple	2100
34	end
35
36	# this actually only applies when finding by xpath - browser.text_field(:xpath, "//input[@type='radio']")
37	# we don't need to validate the element if we built the xpath ourselves.
38	validate_element(element) if element	1703
39	rescue WebDriver::Error::NoSuchElementError => wde
40	nil	362
41	end
42
43	def locate_all	1
44	if @selector.size == 1	241
45	find_all_by_one	187
46	else
47	find_all_by_multiple	54
48	end
49	end
50
51	private	1
52
53	def find_first_by_one	1
54	how, what = @selector.to_a.first	51
55	check_type how, what	51
56
57	if WD_FINDERS.include?(how)	50
58	wd_find_first_by(how, what)	48
59	else
60	find_first_by_multiple	2
61	end
62	end
63
64	def find_all_by_one	1
65	how, what = @selector.to_a.first	187
66	check_type how, what	187
67
68	if WD_FINDERS.include?(how)	187
69	wd_find_all_by(how, what)	187
70	else
71	find_all_by_multiple	0
72	end
73	end
74
75	def find_first_by_multiple	1
76	selector = normalized_selector	2102
77
78	idx = selector.delete(:index)	2018
79	xpath = given_xpath(selector) \|\| build_xpath(selector)	2018
80
81	if xpath	2017
82	# could build xpath for selector
83	if idx	1765
84	@wd.find_elements(:xpath, xpath)[idx]	967
85	else
86	@wd.find_element(:xpath, xpath)	798
87	end
88	else
89	# can't use xpath, probably a regexp in there
90	if idx	252
91	wd_find_by_regexp_selector(selector, :select)[idx]	16
92	else
93	wd_find_by_regexp_selector(selector, :find)	236
94	end
95	end
96	end
97
98	def find_all_by_multiple	1
99	selector = normalized_selector	162
100
101	if selector.has_key? :index	162
102	raise ArgumentError, "can't locate all elements by :index"	1
103	end
104
105	xpath = given_xpath(selector) \|\| build_xpath(selector)	161
106	if xpath	161
107	@wd.find_elements(:xpath, xpath)	108
108	else
109	wd_find_by_regexp_selector(selector, :select)	53
110	end
111	end
112
113	def wd_find_first_by(how, what)	1
114	if what.kind_of? String	48
115	@wd.find_element(how, what)	48
116	else
117	all_elements.find { \|element\| fetch_value(element, how) =~ what }	0
118	end
119	end
120
121	def wd_find_all_by(how, what)	1
122	if what.kind_of? String	187
123	@wd.find_elements(how, what)	180
124	else
125	all_elements.select { \|element\| fetch_value(element, how) =~ what }	179
126	end
127	end
128
129	def wd_find_by_regexp_selector(selector, method = :find)	1
130	rx_selector = delete_regexps_from(selector)	305
131
132	if rx_selector.has_key?(:label) && should_use_label_element?	305
133	selector[:id] = id_from_label(rx_selector.delete(:label)) \|\| return	4
134	end
135
136	xpath = build_xpath(selector) \|\| raise("internal error: unable to build xpath from #{selector.inspect}")	303
137
138	elements = @wd.find_elements(:xpath, xpath)	303
139	elements.__send__(method) { \|el\| matches_selector?(el, rx_selector) }	1510
140	end
141
142	VALID_WHATS = [String, Regexp]	1
143
144	def check_type(how, what)	1
145	case how	4886
146	when :index
147	unless what.kind_of?(Fixnum)	985
148	raise TypeError, "expected Fixnum, got #{what.inspect}:#{what.class}"	1
149	end
150	else
151	unless VALID_WHATS.any? { \|t\| what.kind_of? t }	8157
152	raise TypeError, "expected one of #{VALID_WHATS.inspect}, got #{what.inspect}:#{what.class}"	41
153	end
154	end
155	end
156
157	def id_from_label(label_exp)	1
158	# TODO: this won't work correctly if @wd is a sub-element
159	label = @wd.find_elements(:tag_name, 'label').find do \|el\|	4
160	matches_selector?(el, :text => label_exp)	29
161	end
162
163	label.attribute(:for) if label	4
164	end
165
166	def fetch_value(element, how)	1
167	case how	1408
168	when :text
169	element.text	301
170	when :tag_name
171	element.tag_name	172
172	when :href
173	(href = element.attribute(:href)) && href.strip	19
174	else
175	element.attribute(how)	916
176	end
177	end
178
179	def matches_selector?(element, selector)	1
180	selector.all? do \|how, what\|	1236
181	what === fetch_value(element, how)	1236
182	end
183	end
184
185	def normalized_selector	1
186	selector = {}	2264
187
188	@selector.each do \|how, what\|	2264
189	check_type(how, what)	4648
190
191	how, what = normalize_selector(how, what)	4607
192	selector[how] = what	4564
193	end
194
195	selector	2180
196	end
197
198	def normalize_selector(how, what)	1
199	case how	4607
200	when :tag_name, :text, :xpath, :index, :class, :for
201	# include :class since the valid attribute is 'class_name'
202	# include :for since the valid attribute is 'html_for'
203	[how, what]	3578
204	when :class_name
205	[:class, what]	2
206	when :caption
207	[:text, what]	3
208	else
209	assert_valid_as_attribute how	1024
210	[how, what]	981
211	end
212	end
213
214	def delete_regexps_from(selector)	1
215	rx_selector = {}	305
216
217	selector.dup.each do \|how, what\|	305
218	next unless what.kind_of?(Regexp)	586
219	rx_selector[how] = what	307
220	selector.delete how	307
221	end
222
223	rx_selector	305
224	end
225
226	def assert_valid_as_attribute(attribute)	1
227	unless valid_attribute? attribute or attribute.to_s =~ /^data_.+$/	1024
228	raise MissingWayOfFindingObjectException, "invalid attribute: #{attribute.inspect}"	43
229	end
230	end
231
232	def by_id	1
233	return unless id = @selector[:id] and id.kind_of? String	2378
234
235	selector = @selector.dup	470
236	selector.delete(:id)	470
237
238	tag_name = selector.delete(:tag_name)	470
239	return unless selector.empty? # multiple attributes	470
240
241	element = @wd.find_element(:id, id)	414
242	return if tag_name && !tag_name_matches?(element, tag_name)	300
243
244	element	282
245	rescue WebDriver::Error::NoSuchElementError => wde
246	nil	114
247	end
248
249	def all_elements	1
250	@wd.find_elements(:xpath => ".//*")	7
251	end
252
253	def tag_name_matches?(element, tag_name)	1
254	tag_name === element.tag_name	1515
255	end
256
257	def valid_attribute?(attribute)	1
258	@valid_attributes && @valid_attributes.include?(attribute)	1024
259	end
260
261	def should_use_label_element?	1
262	@selector[:tag_name] != "option"	11
263	end
264
265	def build_xpath(selectors)	1
266	return if selectors.values.any? { \|e\| e.kind_of? Regexp }	4653
267
268	xpath = ".//"	1670
269	xpath << (selectors.delete(:tag_name) \|\| '*').to_s	1670
270
271	idx = selectors.delete(:index)	1670
272
273	# the remaining entries should be attributes
274	unless selectors.empty?	1670
275	xpath << "[" << attribute_expression(selectors) << "]"	739
276	end
277
278	if idx	1670
279	xpath << "[#{idx + 1}]"	0
280	end
281
282	p :xpath => xpath, :selectors => selectors if $DEBUG	1670
283
284	xpath	1670
285	end
286
287	def attribute_expression(selectors)	1
288	selectors.map do \|key, val\|	1305
289	if val.kind_of?(Array)	1158
290	"(" + val.map { \|v\| equal_pair(key, v) }.join(" or ") + ")"	510
291	else
292	equal_pair(key, val)	1056
293	end
294	end.join(" and ")
295	end
296
297	def equal_pair(key, value)	1
298	# we assume :label means a corresponding label element, not the attribute
299	if key == :label && should_use_label_element?	1464
300	"@id=//label[normalize-space()=#{xpath_string(value)}]/@for"	5
301	else
302	"#{lhs_for(key)}=#{xpath_string(value)}"	1459
303	end
304	end
305
306	def lhs_for(key)	1
307	case key	1447
308	when :text, 'text'
309	'normalize-space()'	59
310	when :href
311	# TODO: change this behaviour?
312	'normalize-space(@href)'	5
313	else
314	"@#{key.to_s.gsub("_", "-")}"	1383
315	end
316	end
317
318	def validate_element(element)	1
319	tn = @selector[:tag_name]	1419
320	return if tn && !tag_name_matches?(element, tn)	1419
321
322	if element.tag_name == 'input'	1415
323	return if @selector[:type] && @selector[:type] != element.attribute(:type)	330
324	end
325
326	element	1415
327	end
328
329	def given_xpath(selector)	1
330	return unless xpath = selector.delete(:xpath)	2179
331
332	unless selector.empty? \|\| can_be_combined_with_xpath?(selector)	150
333	raise ArgumentError, ":xpath cannot be combined with other selectors (#{selector.inspect})"	1
334	end
335
336	xpath	149
337	end
338
339	def can_be_combined_with_xpath?(selector)	1
340	# ouch - is this worth it?
341	keys = selector.keys	150
342	return true if keys == [:tag_name]	150
343
344	if selector[:tag_name] == "input"	35
345	return keys == [:tag_name, :type] \|\| keys == [:type, :tag_name]	34
346	end
347
348	false	1
349	end
350
351	def xpath_string(value)	1
352	if value.include? "'"	1464
353	parts = value.split("'", -1).map { \|part\| "'#{part}'" }	8
354	string = parts.join(%{,"'",})	2
355
356	"concat(#{string})"	2
357	else
358	"'#{value}'"	1462
359	end
360	end
361
362	end # ElementLocator
363	end # Watir



module Watir
  class TextFieldLocator < ElementLocator

    NON_TEXT_TYPES     = %w[file radio checkbox submit reset image button hidden url datetime date month week time datetime-local range color]
    # TODO: better way of finding input text fields?
    NEGATIVE_TYPE_EXPR = NON_TEXT_TYPES.map { |t| "@type!=#{t.inspect}" }.join(" and ")

    def locate_all
      find_all_by_multiple
    end

    private

    def build_xpath(selectors)
      return if selectors.values.any? { |e| e.kind_of? Regexp }

      selectors.delete(:tag_name)

      @building = :textarea
      textarea_attr_exp = attribute_expression(selectors)

      @building = :input
      input_attr_exp = attribute_expression(selectors)

      xpath = ".//input[(not(@type) or (#{NEGATIVE_TYPE_EXPR}))"
      xpath << " and #{input_attr_exp}" unless input_attr_exp.empty?
      xpath << "] "
      xpath << "| .//textarea"
      xpath << "[#{textarea_attr_exp}]" unless textarea_attr_exp.empty?

      p :build_xpath => xpath if $DEBUG

      xpath
    end

    def lhs_for(key)
      if @building == :input && key == :text
        "@value"
      elsif @building == :textarea && key == :value
        "text()"
      else
        super
      end
    end

    def matches_selector?(element, rx_selector)
      rx_selector = rx_selector.dup

      [:text, :value, :label].each do |key|
        if rx_selector.has_key?(key)
          correct_key = element.tag_name == 'input' ? :value : :text
          rx_selector[correct_key] = rx_selector.delete(key)
        end
      end

      super
    end

    VALID_TEXT_FIELD_TAGS = %w[input textarea]

    def tag_name_matches?(element, _)
      VALID_TEXT_FIELD_TAGS.include?(element.tag_name)
    end
  end # TextFieldLocator
end # Watir

./lib/watir-webdriver/locators/text_field_locator.rb 100.0 % covered
1	module Watir	1
2	class TextFieldLocator < ElementLocator	1
3
4	NON_TEXT_TYPES = %w[file radio checkbox submit reset image button hidden url datetime date month week time datetime-local range color]	1
5	# TODO: better way of finding input text fields?
6	NEGATIVE_TYPE_EXPR = NON_TEXT_TYPES.map { \|t\| "@type!=#{t.inspect}" }.join(" and ")	18
7
8	def locate_all	1
9	find_all_by_multiple	6
10	end
11
12	private	1
13
14	def build_xpath(selectors)	1
15	return if selectors.values.any? { \|e\| e.kind_of? Regexp }	288
16
17	selectors.delete(:tag_name)	107
18
19	@building = :textarea	107
20	textarea_attr_exp = attribute_expression(selectors)	107
21
22	@building = :input	107
23	input_attr_exp = attribute_expression(selectors)	107
24
25	xpath = ".//input[(not(@type) or (#{NEGATIVE_TYPE_EXPR}))"	107
26	xpath << " and #{input_attr_exp}" unless input_attr_exp.empty?	107
27	xpath << "] "	107
28	xpath << "\| .//textarea"	107
29	xpath << "[#{textarea_attr_exp}]" unless textarea_attr_exp.empty?	107
30
31	p :build_xpath => xpath if $DEBUG	107
32
33	xpath	107
34	end
35
36	def lhs_for(key)	1
37	if @building == :input && key == :text	92
38	"@value"	2
39	elsif @building == :textarea && key == :value	90
40	"text()"	3
41	else
42	super	87
43	end
44	end
45
46	def matches_selector?(element, rx_selector)	1
47	rx_selector = rx_selector.dup	92
48
49	[:text, :value, :label].each do \|key\|	92
50	if rx_selector.has_key?(key)	276
51	correct_key = element.tag_name == 'input' ? :value : :text	65
52	rx_selector[correct_key] = rx_selector.delete(key)	65
53	end
54	end
55
56	super	92
57	end
58
59	VALID_TEXT_FIELD_TAGS = %w[input textarea]	1
60
61	def tag_name_matches?(element, _)	1
62	VALID_TEXT_FIELD_TAGS.include?(element.tag_name)	105
63	end
64	end # TextFieldLocator
65	end # Watir



module Watir
  module RowContainer

    def row(*args)
      row = tr(*args)
      row.locator_class = ChildRowLocator

      row
    end

    def rows(*args)
      rows = trs(*args)
      rows.locator_class = ChildRowLocator

      rows
    end
    
    #
    # The table as a 2D Array of strings with the text of each cell.
    #
    # @return [Array<Array<String>>]
    #

    def strings
      assert_exists

      rows.inject [] do |res, row|
        res << row.cells.map { |cell| cell.text }
      end
    end
    alias_method :to_a, :strings

  end
end

./lib/watir-webdriver/row_container.rb 100.0 % covered
1	module Watir	1
2	module RowContainer	1
3
4	def row(*args)	1
5	row = tr(*args)	38
6	row.locator_class = ChildRowLocator	38
7
8	row	38
9	end
10
11	def rows(*args)	1
12	rows = trs(*args)	49
13	rows.locator_class = ChildRowLocator	49
14
15	rows	49
16	end
17
18	#
19	# The table as a 2D Array of strings with the text of each cell.
20	#
21	# @return [Array<Array<String>>]
22	#
23
24	def strings	1
25	assert_exists	5
26
27	rows.inject [] do \|res, row\|	5
28	res << row.cells.map { \|cell\| cell.text }	37
29	end
30	end
31	alias_method :to_a, :strings	1
32
33	end
34	end



module Watir
  module WindowSwitching

    class NoMatchingWindowFoundException < StandardError
    end

    def windows(*args)
      all = @driver.window_handles.map { |id| Window.new(@driver, id) }

      if args.empty?
        all
      else
        filter_windows(args, all, :select)
      end
    end

    def window(*args, &blk)
      win = filter_windows(args, windows, :find)

      if win && block_given?
        win.use(&blk)
      end

      win or raise NoMatchingWindowFoundException, args.inspect
    end

    private

    def filter_windows(args, all, method)
      sel = extract_selector(args)

      if sel.empty?
        all.find { |w| w.current? }
      end

      unless sel.keys.all? { |k| [:title, :url].include? k }
        raise ArgumentError, "invalid window selector: #{sel.inspect}"
      end

      all.send(method) do |win|
        sel.all? { |key, value| value === win.send(key) }
      end
    end
  end # WindowSwitching

  class Window
    def initialize(driver, id)
      @driver, @id = driver, id
    end

    def inspect
      '#<%s:0x%x id=%s>' % [self.class, hash*2, @id.to_s]
    end

    def ==(other)
      return false unless other.kind_of?(self.class)

      @id == other.id
    end
    alias_method :eql?, :==

    def hash
      @id.hash ^ self.class.hash
    end

    def current?
      @driver.window_handle == @id
    end

    def close
      use { @driver.close }
    end

    def title
      title = nil
      use { title = @driver.title }

      title
    end

    def url
      url = nil
      use { url = @driver.current_url }

      url
    end

    def use(&blk)
      if current?
        yield if block_given?
        return self
      end

      @driver.switch_to.window(@id, &blk)
      self
    end

    protected

    def id
      @id
    end

  end # Window
end # Watir

./lib/watir-webdriver/window_switching.rb 96.3 % covered
1	module Watir	1
2	module WindowSwitching	1
3
4	class NoMatchingWindowFoundException < StandardError	1
5	end
6
7	def windows(*args)	1
8	all = @driver.window_handles.map { \|id\| Window.new(@driver, id) }	121
9
10	if args.empty?	41
11	all	38
12	else
13	filter_windows(args, all, :select)	3
14	end
15	end
16
17	def window(*args, &blk)	1
18	win = filter_windows(args, windows, :find)	30
19
20	if win && block_given?	29
21	win.use(&blk)	1
22	end
23
24	win or raise NoMatchingWindowFoundException, args.inspect	29
25	end
26
27	private	1
28
29	def filter_windows(args, all, method)	1
30	sel = extract_selector(args)	33
31
32	if sel.empty?	33
33	all.find { \|w\| w.current? }	8
34	end
35
36	unless sel.keys.all? { \|k\| [:title, :url].include? k }	62
37	raise ArgumentError, "invalid window selector: #{sel.inspect}"	2
38	end
39
40	all.send(method) do \|win\|	31
41	sel.all? { \|key, value\| value === win.send(key) }	108
42	end
43	end
44	end # WindowSwitching
45
46	class Window	1
47	def initialize(driver, id)	1
48	@driver, @id = driver, id	80
49	end
50
51	def inspect	1
52	'#<%s:0x%x id=%s>' % [self.class, hash*2, @id.to_s]	0
53	end
54
55	def ==(other)	1
56	return false unless other.kind_of?(self.class)	2
57
58	@id == other.id	2
59	end
60	alias_method :eql?, :==	1
61
62	def hash	1
63	@id.hash ^ self.class.hash	0
64	end
65
66	def current?	1
67	@driver.window_handle == @id	87
68	end
69
70	def close	1
71	use { @driver.close }	34
72	end
73
74	def title	1
75	title = nil	54
76	use { title = @driver.title }	108
77
78	title	54
79	end
80
81	def url	1
82	url = nil	9
83	use { url = @driver.current_url }	18
84
85	url	9
86	end
87
88	def use(&blk)	1
89	if current?	81
90	yield if block_given?	33
91	return self	33
92	end
93
94	@driver.switch_to.window(@id, &blk)	48
95	self	48
96	end
97
98	protected	1
99
100	def id	1
101	@id	2
102	end
103
104	end # Window
105	end # Watir



# encoding: utf-8
module Watir
  module XpathSupport
    include Selenium

    #
    # Find the first element matching the given XPath
    #

    def element_by_xpath(xpath)
      e = wd.find_element(:xpath, xpath)
      Watir.element_class_for(e.tag_name).new(self, :element => e)
    rescue WebDriver::Error::NoSuchElementError
      Element.new(self, :xpath => xpath)
    end

    #
    # Find all elements matching the given XPath
    #

    def elements_by_xpath(xpath)
      wd.find_elements(:xpath, xpath).map do |e|
        Watir.element_class_for(e.tag_name).new(self, :element => e)
      end
    end

  end # XpathSupport
end # Watir

./lib/watir-webdriver/xpath_support.rb 100.0 % covered
1	# encoding: utf-8
2	module Watir	1
3	module XpathSupport	1
4	include Selenium	1
5
6	#
7	# Find the first element matching the given XPath
8	#
9
10	def element_by_xpath(xpath)	1
11	e = wd.find_element(:xpath, xpath)	5
12	Watir.element_class_for(e.tag_name).new(self, :element => e)	4
13	rescue WebDriver::Error::NoSuchElementError
14	Element.new(self, :xpath => xpath)	1
15	end
16
17	#
18	# Find all elements matching the given XPath
19	#
20
21	def elements_by_xpath(xpath)	1
22	wd.find_elements(:xpath, xpath).map do \|e\|	4
23	Watir.element_class_for(e.tag_name).new(self, :element => e)	6
24	end
25	end
26
27	end # XpathSupport
28	end # Watir

All Files (89.47%)

./lib/watir-webdriver.rb

100.0 % covered

./lib/watir-webdriver/attribute_helper.rb

100.0 % covered

./lib/watir-webdriver/browser.rb

95.18 % covered

./lib/watir-webdriver/cell_container.rb

100.0 % covered

./lib/watir-webdriver/container.rb

100.0 % covered

./lib/watir-webdriver/element_collection.rb

100.0 % covered

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

95.45 % covered

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

100.0 % covered

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

85.61 % covered

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

100.0 % covered

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

100.0 % covered

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

100.0 % covered

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

94.12 % covered

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

80.58 % covered

./lib/watir-webdriver/elements/hidden.rb

91.67 % covered

./lib/watir-webdriver/elements/image.rb

71.43 % covered

./lib/watir-webdriver/elements/input.rb

100.0 % covered

./lib/watir-webdriver/elements/link.rb

100.0 % covered

./lib/watir-webdriver/elements/option.rb

100.0 % covered

./lib/watir-webdriver/elements/radio.rb

100.0 % covered

./lib/watir-webdriver/elements/select.rb

97.59 % covered

./lib/watir-webdriver/elements/table.rb

93.75 % covered

./lib/watir-webdriver/elements/table_cell.rb

100.0 % covered

./lib/watir-webdriver/elements/table_row.rb

100.0 % covered

./lib/watir-webdriver/elements/table_section.rb

100.0 % covered

./lib/watir-webdriver/elements/text_field.rb

100.0 % covered

./lib/watir-webdriver/exception.rb

100.0 % covered

./lib/watir-webdriver/extensions/alerts.rb

100.0 % covered

./lib/watir-webdriver/extensions/wait.rb

97.37 % covered

./lib/watir-webdriver/locators/button_locator.rb

100.0 % covered

./lib/watir-webdriver/locators/child_cell_locator.rb

100.0 % covered

./lib/watir-webdriver/locators/child_row_locator.rb

100.0 % covered

./lib/watir-webdriver/locators/element_locator.rb

98.31 % covered

./lib/watir-webdriver/locators/text_field_locator.rb

100.0 % covered

./lib/watir-webdriver/row_container.rb

100.0 % covered

./lib/watir-webdriver/window_switching.rb

96.3 % covered

./lib/watir-webdriver/xpath_support.rb

100.0 % covered