watir-classic 3.0.0

data/lib/watir-classic/table.rb

@@ -0,0 +1,224 @@
+module Watir
+
+  module TableContainer
+    # Returns a row in the table
+    #   * index         - the index of the row
+    def [](index)
+      assert_exists
+      TableRow.new(self, :ole_object => @o.rows.item(index))
+    end
+    
+    def strings
+      assert_exists
+      rows_memo = []
+      @o.rows.each do |row|
+        cells_memo = []
+        row.cells.each do |cell|
+          cells_memo << TableCell.new(self, :ole_object => cell).text.gsub("\r\n","")
+        end
+        rows_memo << cells_memo
+      end
+      rows_memo
+    end
+  end
+
+  module TableElementsContainer
+    def table_elements(klass, tags, how, what, ole_collection)
+      specifiers = format_specifiers(tags, how, what)
+      klass.new(self, specifiers, ole_collection)
+    end
+
+    private :table_elements
+  end
+
+  module TableCellsContainer
+    include TableElementsContainer
+
+    def cells(how={}, what=nil)
+      assert_exists
+      table_elements(TableCellCollection, [:th, :td], how, what, @o.cells)
+    end
+
+    def cell(how={}, what=nil)
+      specifiers = format_specifiers([:th, :td], how, what)
+      index = specifiers.delete(:index) || 0
+      cells(specifiers)[index]
+    end
+  end
+
+  module TableRowsContainer
+    include TableElementsContainer
+
+    def rows(how={}, what=nil)
+      assert_exists
+      table_elements(TableRowCollection, [:tr], how, what, @o.rows)
+    end
+
+    def row(how={}, what=nil)
+      specifiers = format_specifiers([:tr], how, what)
+      index = specifiers.delete(:index) || 0
+      rows(specifiers)[index]
+    end
+  end
+
+  # This class is used for dealing with tables.
+  # Normally a user would not need to create this object as it is returned by the Watir::Container#table method
+  #
+  # many of the methods available to this object are inherited from the Element class
+  #
+  class Table < Element
+    include TableContainer
+    include TableRowsContainer
+    include TableCellsContainer
+
+    attr_ole :rules
+
+    # override the highlight method, as if the tables rows are set to have a background color,
+    # this will override the table background color, and the normal flash method won't work
+    def highlight(set_or_clear)
+      if set_or_clear == :set
+        begin
+          @original_border = @o.border.to_i
+          if @o.border.to_i==1
+            @o.border = 2
+          else
+            @o.border = 1
+          end
+        rescue
+          @original_border = nil
+        end
+      else
+        begin
+          @o.border= @original_border unless @original_border == nil
+          @original_border = nil
+        rescue
+          # we could be here for a number of reasons...
+        ensure
+          @original_border = nil
+        end
+      end
+      super
+    end
+    
+    # this method is used to populate the properties in the to_s method
+    def table_string_creator
+      n = []
+      n << "rows:".ljust(TO_S_SIZE) + self.row_count.to_s
+      n << "cols:".ljust(TO_S_SIZE) + self.column_count.to_s
+      return n
+    end
+    private :table_string_creator
+    
+    # returns the properties of the object in a string
+    # raises an ObjectNotFound exception if the object cannot be found
+    def to_s
+      assert_exists
+      r = string_creator
+      r += table_string_creator
+      return r.join("\n")
+    end
+    
+    # Returns the number of rows inside the table, including rows in nested tables.
+    def row_count
+      assert_exists
+      rows.length
+    end
+
+    # This method returns the number of columns in a row of the table.
+    # Raises an UnknownObjectException if the table doesn't exist.
+    #   * index         - the index of the row
+    def column_count(index=0)
+      assert_exists
+      rows[index].cells.length
+    end
+    
+    # Returns an array containing all the text values in the specified column
+    # Raises an UnknownCellException if the specified column does not exist in every
+    # Raises an UnknownObjectException if the table doesn't exist.
+    # row of the table
+    #   * columnnumber  - column index to extract values from
+    def column_values(columnnumber)
+      return (0..row_count - 1).collect {|i| self[i][columnnumber].text}
+    end
+    
+    # Returns an array containing all the text values in the specified row
+    # Raises an UnknownObjectException if the table doesn't exist.
+    #   * rownumber  - row index to extract values from
+    def row_values(rownumber)
+      return (0..column_count(rownumber) - 1).collect {|i| self[rownumber][i].text}
+    end
+    
+    def hashes
+      assert_exists
+
+      headers = []
+      @o.rows.item(0).cells.each do |cell|
+        headers << TableCell.new(self, :ole_object => cell).text
+      end
+
+      rows_memo = []
+      i = 0
+      @o.rows.each do |row|
+        next if row.uniqueID == @o.rows.item(0).uniqueID
+
+        cells_memo = {}
+        cells = row.cells
+        raise "row at index #{i} has #{cells.length} cells, expected #{headers.length}" if cells.length < headers.length
+
+        j = 0
+        cells.each do |cell|
+          cells_memo[headers[j]] = TableCell.new(self, :ole_object => cell).text
+          j += 1
+        end
+
+        rows_memo << cells_memo
+        i += 1
+      end
+      rows_memo
+    end
+  end
+
+  class TableSection < Element
+    include TableContainer
+    include TableRowsContainer
+    include TableCellsContainer
+  end
+
+  class TableRow < Element
+    include TableCellsContainer
+
+    # this method iterates through each of the cells in the row. Yields a TableCell object
+    def each
+      locate
+      cells.each {|cell| yield cell}
+    end
+    
+    # Returns an element from the row as a TableCell object
+    def [](index)
+      assert_exists
+      if cells.length <= index
+        raise UnknownCellException, "Unable to locate a cell at index #{index}" 
+      end
+      return cells[index]
+    end
+    
+    def column_count
+      assert_exists
+      cells.length
+    end
+
+  end
+  
+  # this class is a table cell - when called via the Table object
+  class TableCell < Element
+    attr_ole :headers
+
+    alias_method :to_s, :text
+    
+    def colspan
+      locate
+      @o.colSpan
+    end
+  end
+  
+end

data/lib/watir-classic/testcase.rb

@@ -0,0 +1,97 @@
+require 'test/unit'
+require 'watir-classic/assertions'
+
+module Watir
+
+  # This is a 'test/unit' testcase customized to exeucte test methods sequentially by default
+  # and extra assertions
+  #
+  # Example Usage
+  #
+  #   require 'watir-classic/testcase'
+  #
+  #   class MyTestCase < Watir::TestCase
+  #
+  #     # some helpers
+  #     @@browser = nil
+  #     def browser
+  #       @browser ||= Watir::IE.start(:url, 'http://watir.com/")
+  #     end
+  #
+  #     # TESTS
+  #     def test_text
+  #       browser.goto "http://watir.com/"
+  #       verify_match "Web Application Testing in Ruby", browser.text
+  #     end
+  #
+  #     def test_title
+  #       verify browser.title == 'Watir'
+  #     end
+  #
+  #     def test_link
+  #       verify_match 'watir.com', browser.link(:text, 'Home').href
+  #     end
+  #
+  #     def test_navigate_to_examples
+  #       browser.div(:id, 'nav').link(:text, 'Examples').click
+  #     end
+  #
+  #     def test_url
+  #       verify_equal browser.url, 'http://watir.com/examples/'
+  #     end
+  #
+  #   end
+  #
+  class TestCase < Test::Unit::TestCase
+    include Watir::Assertions
+    @@order = :sequentially
+    def initialize name
+      throw :invalid_test if name == :default_test && self.class == Watir::TestCase
+      super
+    end        
+    class << self
+      attr_accessor :test_methods, :order
+      def test_methods
+        @test_methods ||= []
+      end
+      def order
+        @order || @@order
+      end
+      def default_order= order
+        @@order = order
+      end
+      def sorted_test_methods
+        case order
+        when :alphabetically then          test_methods.sort
+        when :sequentially then            test_methods
+        when :reversed_sequentially then   test_methods.reverse
+        when :reversed_alphabetically then test_methods.sort.reverse
+        else raise ArgumentError, "Execute option not supported: #{@order}"
+        end
+      end
+      def suite
+        suite = Test::Unit::TestSuite.new(name)
+        sorted_test_methods.each do |test|
+          catch :invalid_test do
+            suite << new(test)
+          end
+        end
+        if (suite.empty?)
+          catch :invalid_test do
+            suite << new(:default_test)
+          end
+        end
+        return suite
+      end
+      def method_added id
+        name = id.id2name
+        test_methods << name if name =~ /^test./
+      end
+      def execute order
+        @order = order
+      end
+    end
+    public :add_assertion
+  end    
+
+end  

data/lib/watir-classic/util.rb

@@ -0,0 +1,35 @@
+module Watir
+  class Util
+    class << self
+      #
+      # "Watir::Span" => "Span"
+      # 
+      def demodulize(str)
+        str.gsub(/^.*::/, '')
+      end
+
+      #
+      # "FooBar" => "foo_bar"
+      # 
+      def underscore(str)
+        str.gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
+      end
+
+      #
+      # "Checkboxes" => "Checkbox"
+      # "Bodies" => "Body"
+      # "Buttons" => "Button"
+      #
+      def singularize(str)
+        case str.downcase
+        when "checkboxes"
+          str.chop.chop
+        when "bodies"
+          str.chop.chop.chop + "y"
+        else
+          str.chop
+        end
+      end
+    end    
+  end
+end

data/lib/watir-classic/version.rb

@@ -0,0 +1,4 @@
+module Watir
+  version_file = File.dirname(__FILE__) + '/../../VERSION'
+  VERSION = File.exists?(version_file) ? File.read(version_file).strip : "0.0.0"
+end

data/lib/watir-classic/wait.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Watir
+  module Wait
+    extend self
+
+    class TimeoutError < StandardError
+    end
+
+    #
+    # Wait until the block evaluates to true or times out.
+    #
+
+    def until(timeout = 60, &block)
+      end_time = ::Time.now + timeout
+
+      until ::Time.now > end_time
+        result = yield(self)
+        return result if result
+        sleep 0.1
+      end
+
+      raise TimeoutError, "timed out after #{timeout} seconds"
+    end
+
+    #
+    # Wait while the block evaluates to true or times out.
+    #
+    def while(timeout = 60, &block)
+      end_time = ::Time.now + timeout
+
+      until ::Time.now > end_time
+        return unless yield(self)
+        sleep 0.1
+      end
+
+      raise TimeoutError, "timed out after #{timeout} seconds"
+    end
+
+  end # Wait
+end # Watir

data/lib/watir-classic/wait_helper.rb

@@ -0,0 +1,12 @@
+# include this module if there's a need to have wait_until and wait_while methods in some different scope
+module Watir
+  module WaitHelper
+    def wait_until(*args, &blk)
+      Wait.until(*args, &blk)
+    end
+
+    def wait_while(*args, &blk)
+      Wait.while(*args, &blk)
+    end
+  end
+end

data/lib/watir-classic/waiter.rb

@@ -0,0 +1,98 @@
+#######
+#
+# Using Watir::Waiter is DEPRECATED and will be removed in some newer version of Watir! Use Watir::Wait and Watir::ElementExtensions methods instead!
+#
+#######
+require 'watir-classic/exceptions'
+
+module Watir
+  
+  def wait_until(*args)
+    Waiter.wait_until(*args) {yield}
+  end  
+
+class TimeKeeper
+  attr_reader :sleep_time
+  def initialize 
+    @sleep_time = 0.0
+  end
+  def sleep seconds
+    @sleep_time += Kernel.sleep seconds    
+  end
+  def now
+    ::Time.now
+  end
+end
+
+class Waiter
+  # This is an interface to a TimeKeeper which proxies
+  # calls to "sleep" and "Time.now".
+  # Useful for unit testing Waiter.
+  attr_accessor :timer
+
+  # How long to wait between each iteration through the wait_until
+  # loop. In seconds.
+  attr_accessor :polling_interval
+
+  # Timeout for wait_until.
+  attr_accessor :timeout
+  
+  @@default_polling_interval = 0.5
+  @@default_timeout = 60.0
+
+  def initialize(timeout=@@default_timeout,
+                 polling_interval=@@default_polling_interval)
+    Kernel.warn "Using Watir::Waiter is DEPRECATED and will be removed in some newer version of Watir! Use Watir::Wait and Watir::ElementExtensions methods instead!"
+    @timeout = timeout
+    @polling_interval = polling_interval
+    @timer = TimeKeeper.new
+  end
+
+  # Execute the provided block until either (1) it returns true, or
+  # (2) the timeout (in seconds) has been reached. If the timeout is reached,
+  # a TimeOutException will be raised. The block will always
+  # execute at least once.  
+  # 
+  # waiter = Waiter.new(5)
+  # waiter.wait_until {puts 'hello'}
+  # 
+  # This code will print out "hello" for five seconds, and then raise a 
+  # Watir::TimeOutException.
+  def wait_until # block
+    start_time = now
+    until yield do
+      if (duration = now - start_time) > @timeout
+        raise Watir::Exception::TimeOutException.new(duration, @timeout),
+          "Timed out after #{duration} seconds."
+      end
+      sleep @polling_interval
+    end
+  end  
+
+  # Execute the provided block until either (1) it returns true, or
+  # (2) the timeout (in seconds) has been reached. If the timeout is reached,
+  # a TimeOutException will be raised. The block will always
+  # execute at least once.  
+  # 
+  # Waiter.wait_until(5) {puts 'hello'}
+  # 
+  # This code will print out "hello" for five seconds, and then raise a 
+  # Watir::TimeOutException.  
+
+  # IDEA: wait_until: remove defaults from Waiter.wait_until
+  def self.wait_until(timeout=@@default_timeout,
+                      polling_interval=@@default_polling_interval)
+    waiter = new(timeout, polling_interval)
+    waiter.wait_until { yield }
+  end
+     
+  private
+  def sleep seconds
+    @timer.sleep seconds
+  end
+  def now
+    @timer.now
+  end
+end  
+    
+end # module