watir 1.6.5 → 1.6.6.rc1

data/lib/watir/irb-history.rb

@@ -1,31 +1,31 @@
-# snarfed from http://blog.nicksieger.com/articles/2006/04/23/tweaking-irb
-module Readline
-  module History
-    @@log ||= File.join(Dir.pwd, 'console.log')
-    
-    def self.log= log
-      @@log = log
-    end
-    
-    def self.write_log(line)
-      begin
-        File.open(@@log, 'ab') {|f| f << "#{line}\n"}
-      rescue
-      end
-    end 
-
-    def self.start_session_log
-      write_log("# session start: #{Time.now}")
-      at_exit { write_log("# session stop: #{Time.now}\n") }
-    end
-  end
-
-  alias :old_readline :readline
-  def readline(*args)
-    ln = old_readline(*args)
-    History.write_log(ln)
-    ln
-  end
-end
-
+# snarfed from http://blog.nicksieger.com/articles/2006/04/23/tweaking-irb
+module Readline
+  module History
+    @@log ||= File.join(Dir.pwd, 'console.log')
+    
+    def self.log= log
+      @@log = log
+    end
+    
+    def self.write_log(line)
+      begin
+        File.open(@@log, 'ab') {|f| f << "#{line}\n"}
+      rescue
+      end
+    end 
+
+    def self.start_session_log
+      write_log("# session start: #{Time.now}")
+      at_exit { write_log("# session stop: #{Time.now}\n") }
+    end
+  end
+
+  alias :old_readline :readline
+  def readline(*args)
+    ln = old_readline(*args)
+    History.write_log(ln)
+    ln
+  end
+end
+
 Readline::History.start_session_log

data/lib/watir/link.rb

@@ -1,65 +1,65 @@
-module Watir  
-  
-  # This class is the means of accessing a link on a page
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#link method
-  # many of the methods available to this object are inherited from the Element class
-  #
-  class Link < Element
-    # Returns an initialized instance of a link object
-    #   * container  - an instance of a container
-    #   * how         - symbol - how we access the link
-    #   * what         - what we use to access the link, text, url, index etc
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      super(nil)
-    end
-    
-    def locate
-      if @how == :xpath
-        @o = @container.element_by_xpath(@what)
-      else
-        begin
-          @o = @container.locate_tagged_element('A', @how, @what)
-        rescue UnknownObjectException
-          @o = nil
-        end
-      end
-    end
-    
-    # if an image is used as part of the link, this will return true
-    def link_has_image
-      assert_exists
-      return true if @o.getElementsByTagName("IMG").length > 0
-      return false
-    end
-    
-    # this method returns the src of an image, if an image is used as part of the link
-    def src # BUG?
-      assert_exists
-      if @o.getElementsByTagName("IMG").length > 0
-        return @o.getElementsByTagName("IMG")[0.to_s].src
-      else
-        return ""
-      end
-    end
-    
-    def link_string_creator
-      n = []
-      n <<   "href:".ljust(TO_S_SIZE) + self.href
-      n <<   "inner text:".ljust(TO_S_SIZE) + self.text
-      n <<   "img src:".ljust(TO_S_SIZE) + self.src if self.link_has_image
-      return n
-    end
-    
-    # returns a textual description of the link
-    def to_s
-      assert_exists
-      r = string_creator
-      r = r + link_string_creator
-      return r.join("\n")
-    end
-  end
-  
+module Watir  
+  
+  # This class is the means of accessing a link on a page
+  # Normally a user would not need to create this object as it is returned by the Watir::Container#link method
+  # many of the methods available to this object are inherited from the Element class
+  #
+  class Link < Element
+    # Returns an initialized instance of a link object
+    #   * container  - an instance of a container
+    #   * how         - symbol - how we access the link
+    #   * what         - what we use to access the link, text, url, index etc
+    def initialize(container, how, what)
+      set_container container
+      @how = how
+      @what = what
+      super(nil)
+    end
+    
+    def locate
+      if @how == :xpath
+        @o = @container.element_by_xpath(@what)
+      else
+        begin
+          @o = @container.locate_tagged_element('A', @how, @what)
+        rescue UnknownObjectException
+          @o = nil
+        end
+      end
+    end
+    
+    # if an image is used as part of the link, this will return true
+    def link_has_image
+      assert_exists
+      return true if @o.getElementsByTagName("IMG").length > 0
+      return false
+    end
+    
+    # this method returns the src of an image, if an image is used as part of the link
+    def src # BUG?
+      assert_exists
+      if @o.getElementsByTagName("IMG").length > 0
+        return @o.getElementsByTagName("IMG")[0.to_s].src
+      else
+        return ""
+      end
+    end
+    
+    def link_string_creator
+      n = []
+      n <<   "href:".ljust(TO_S_SIZE) + self.href
+      n <<   "inner text:".ljust(TO_S_SIZE) + self.text
+      n <<   "img src:".ljust(TO_S_SIZE) + self.src if self.link_has_image
+      return n
+    end
+    
+    # returns a textual description of the link
+    def to_s
+      assert_exists
+      r = string_creator
+      r = r + link_string_creator
+      return r.join("\n")
+    end
+  end
+  
 end

data/lib/watir/locator.rb

@@ -1,176 +1,200 @@
-module Watir
-  class Locator
-    include Watir
-    include Watir::Exception
-
-    def normalize_specifiers!(specifiers)
-      specifiers.each do |how, what|
-        case how
-        when :index
-          what = what.to_i
-        when :url
-          how = :href
-        when :class
-          how = :class_name
-        when :caption
-          how = :value
-        end
-
-        @specifiers[how] = what
-      end
-    end
-
-
-  end
-
-  class TaggedElementLocator < Locator
-    def initialize(container, tag)
-      @container = container
-      @tag = tag
-    end
-
-    def set_specifier(how, what)
-      if how.class == Hash and what.nil?
-        specifiers = how
-      else
-        specifiers = {how => what}
-      end
-
-      @specifiers = {:index => 1} # default if not specified
-      normalize_specifiers! specifiers
-    end
-
-    def each_element tag
-      @container.document.getElementsByTagName(tag).each do |ole_element|
-        yield Element.new(ole_element)
-      end
-    end
-
-    def locate
-      count = 0
-      each_element(@tag) do |element|
-
-        catch :next_element do
-          @specifiers.each do |how, what|
-            next if how == :index
-            unless match? element, how, what
-              throw :next_element
-            end
-          end
-          count += 1
-          unless count == @specifiers[:index]
-            throw :next_element
-          end
-          return element.ole_object
-        end
-
-      end # elements
-      nil
-    end
-
-    def match?(element, how, what)
-      begin
-        method = element.method(how)
-      rescue NameError
-        raise MissingWayOfFindingObjectException,
-              "#{how} is an unknown way of finding a <#{@tag}> element (#{what})"
-      end
-      case method.arity
-      when 0
-        what.matches method.call
-      when 1
-       	method.call(what)
-      else
-        raise MissingWayOfFindingObjectException,
-              "#{how} is an unknown way of finding a <#{@tag}> element (#{what})"
-      end
-    end
-
-  end
-  class InputElementLocator < Locator
-
-    attr_accessor :document, :element, :elements
-
-    def initialize container, types
-      @container = container
-      @types = types
-      @elements = nil
-    end
-
-    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
-
-    def locate
-      count = 0
-      @elements.each do |object|
-        element = Element.new(object)
-
-        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
-    # return true if the element matches the provided how and what
-    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
-
-    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
-
-  end
-end
+module Watir
+  class Locator
+    include Watir
+    include Watir::Exception
+
+    def normalize_specifiers!(specifiers)
+      specifiers.each do |how, what|
+        case how
+        when :index
+          what = what.to_i
+        when :url
+          how = :href
+        when :class
+          how = :class_name
+        when :caption
+          how = :value
+        end
+
+        @specifiers[how] = what
+      end
+    end
+
+
+  end
+
+  class TaggedElementLocator < Locator
+    def initialize(container, tag)
+      @container = container
+      @tag = tag
+    end
+
+    def set_specifier(how, what)
+      if how.class == Hash and what.nil?
+        specifiers = how
+      else
+        specifiers = {how => what}
+      end
+
+      @specifiers = {:index => 1} # default if not specified
+      normalize_specifiers! specifiers
+    end
+
+    def each_element tag
+      @container.document.getElementsByTagName(tag).each do |ole_element|
+        yield Element.new(ole_element)
+      end
+    end
+
+    def locate
+      count = 0
+      each_element(@tag) do |element|
+
+        catch :next_element do
+          @specifiers.each do |how, what|
+            next if how == :index
+            unless match? element, how, what
+              throw :next_element
+            end
+          end
+          count += 1
+          unless count == @specifiers[:index]
+            throw :next_element
+          end
+          return element.ole_object
+        end
+
+      end # elements
+      nil
+    end
+
+    def match?(element, how, what)
+      begin
+        method = element.method(how)
+      rescue NameError
+        raise MissingWayOfFindingObjectException,
+              "#{how} is an unknown way of finding a <#{@tag}> element (#{what})"
+      end
+      case method.arity
+      when 0
+        what.matches method.call
+      when 1
+       	method.call(what)
+      else
+        raise MissingWayOfFindingObjectException,
+              "#{how} is an unknown way of finding a <#{@tag}> element (#{what})"
+      end
+    end
+
+  end
+  class InputElementLocator < Locator
+
+    attr_accessor :document, :element, :elements
+
+    def initialize container, types
+      @container = container
+      @types = types
+      @elements = nil
+    end
+
+    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
+
+    def locate
+      count = 0
+      @elements.each do |object|
+        element = Element.new(object)
+
+        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
+    # return true if the element matches the provided how and what
+    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
+
+    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
+  end
+
+  # This is like the TaggedElementLocator but
+  # get all the elements by forcing @tag to be '*'
+  class ElementLocator < TaggedElementLocator
+    def initialize(container)
+      @container = container
+    end
+    
+    def each
+      count = 0
+      each_element('*') do |element| 
+        catch :next_element do
+          @specifiers.each do |how, what|
+            next if how == :index
+            unless match? element, how, what
+              throw :next_element
+            end
+          end
+          yield element          
+        end
+      end 
+      nil
+    end
+    
+  end  
+end