Class: Watir::InputElementLocator

Inherits:
Locator
  • Object
show all
Defined in:
lib/watir/locator.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from Locator

#normalize_specifiers!

Methods included from Watir

_register, _unregister, autoit, #dialog, until_with_timeout

Constructor Details

#initialize(container, types) ⇒ InputElementLocator

Returns a new instance of InputElementLocator.



94
95
96
97
98
99
 
# File 'lib/watir/locator.rb', line 94

def initialize container, types
  @container = container
  @types = types
  @elements = nil
  @klass = Element
end

Instance Attribute Details

#document ⇒ Object

Returns the value of attribute document.



92
93
94
 
# File 'lib/watir/locator.rb', line 92

def document
  @document
end

#element ⇒ Object

Returns the value of attribute element.



92
93
94
 
# File 'lib/watir/locator.rb', line 92

def element
  @element
end

#elements ⇒ Object

Returns the value of attribute elements.



92
93
94
 
# File 'lib/watir/locator.rb', line 92

def elements
  @elements
end

#klass ⇒ Object

Returns the value of attribute klass.



92
93
94
 
# File 'lib/watir/locator.rb', line 92

def klass
  @klass
end

Instance Method Details

#fast_locate ⇒ Object 



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
 
# File 'lib/watir/locator.rb', line 157

def fast_locate
  # Searching through all elements returned by ole_inner_elements
  # is *significantly* slower than IE's getElementById() and
  # getElementsByName() calls when how is :id or :name.  However
  # IE doesn't match Regexps, so first we make sure what is a String.
  # In addition, IE's getElementById() will also return an element
  # where the :name matches, so we will only return the results of
  # getElementById() if the matching element actually HAS a matching
  # :id.

  the_id = @specifiers[:id]
  if the_id && the_id.class == String &&
    @specifiers[:index] == 1 && @specifiers.length == 2
    @element = @document.getElementById(the_id) rescue nil
    # Return if our fast match really HAS a matching :id
    return true if @element && @element.invoke('id') == the_id
  end

  the_name = @specifiers[:name]
  if the_name && the_name.class == String
    @elements = @document.getElementsByName(the_name) rescue nil
  end
  false
end

#locate ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/watir/locator.rb', line 118

def locate
  count = 0
  @elements.each do |object|
    if @klass == Element
      element = Element.new(object)
    else
      element = @klass.new(@container, @specifiers, nil)
      element.ole_object = object
      def element.locate; @o; end
    end

    catch :next_element do
      throw :next_element unless @types.include?(element.type)
      @specifiers.each do |how, what|
        next if how == :index
        unless match? element, how, what
          throw :next_element
        end
      end
      count += 1
      throw :next_element unless count == @specifiers[:index]
      return object
    end

  end
  nil
end

#match?(element, how, what) ⇒ Boolean

return true if the element matches the provided how and what

Returns:

  • (Boolean) 


146
147
148
149
150
151
152
153
154
155
 
# File 'lib/watir/locator.rb', line 146

def match? element, how, what
  begin
    attribute = element.send(how)
  rescue NoMethodError
    raise MissingWayOfFindingObjectException,
      "#{how} is an unknown way of finding an <INPUT> element (#{what})"
  end

  what.matches(attribute)
end

#specifier=(arg) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/watir/locator.rb', line 101

def specifier= arg
  how, what, value = arg

  if how.class == Hash and what.nil?
    specifiers = how
  else
    specifiers = {how => what}
  end

  @specifiers = {:index => 1} # default if not specified
  if value
    @specifiers[:value] = value.is_a?(Regexp) ? value : value.to_s
  end

  normalize_specifiers! specifiers
end