commonwatir 3.0.0.rc3 → 3.0.0

data/lib/watir/matches.rb

@@ -1,23 +0,0 @@
-class String
-  def matches(x)
-    return self == x
-  end
-end
-
-class Regexp
-  def matches(x)
-    return self.match(x)
-  end
-end
-
-class Integer
-  def matches(x)
-    return self == x
-  end
-end
-
-class Object
-  def matches(x)
-    raise TypeError, "#{self.class} is not supported as a locator"
-  end
-end

data/lib/watir/options.rb

@@ -1,56 +0,0 @@
-#--
-# watir/options
-require 'rubygems'
-
-require 'user-choices'
-
-module Watir
-  @@options_file = nil
-  @@options = nil
-  class << self
-    # Specify the location of a yaml file containing Watir options. Must be
-    # specified before the options are parsed.
-    def options_file= file
-      @@options_file = file
-    end
-    def options_file
-      @@options_file
-    end
-    def options= x
-      @@options = x
-    end
-    # Return the Watir options, as a hash. If they haven't been parsed yet,
-    # they will be now.
-    def options
-      @@options ||= Watir::WatirOptions.new.execute
-    end
-  end
-
-  class WatirOptions < UserChoices::Command
-    include UserChoices
-    def add_sources builder
-      builder.add_source EnvironmentSource, :with_prefix, 'watir_'
-      if Watir.options_file
-        builder.add_source YamlConfigFileSource, :from_complete_path, 
-          Watir.options_file
-      end
-    end
-    def add_choices builder
-      builder.add_choice :browser, 
-      :type => Watir::Browser.browser_names, 
-      :default => Watir::Browser.default
-      builder.add_choice :speed, 
-      :type => ['slow', 'fast', 'zippy'], 
-      :default => 'fast'
-      builder.add_choice :visible,
-      :type => :boolean
-      builder.add_choice :zero_based_indexing,
-      :type => :boolean,
-      :default => true
-    end
-    def execute 
-      @user_choices[:speed] = @user_choices[:speed].to_sym
-      @user_choices
-    end 
-  end
-end

data/lib/watir/testcase.rb

@@ -1,97 +0,0 @@
-require 'test/unit'
-require 'watir/assertions'
-
-module Watir
-
-  # This is a 'test/unit' testcase customized to exeucte test methods sequentially by default
-  # and extra assertions
-  #
-  # Example Usage
-  #
-  #   require 'watir/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/util.rb

@@ -1,35 +0,0 @@
-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/version.rb

@@ -1,4 +0,0 @@
-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/wait.rb

@@ -1,41 +0,0 @@
-# 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/wait_helper.rb

@@ -1,12 +0,0 @@
-# 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/waiter.rb

@@ -1,98 +0,0 @@
-#######
-#
-# 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/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

data/unittests/attach_to_existing_window_test.rb

@@ -1,70 +0,0 @@
-# feature tests for attaching to existing IE windows
-
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') unless $SETUP_LOADED
-require 'unittests/setup'
-
-class TC_ExistingWindow < Test::Unit::TestCase
-  location __FILE__
-  include Watir
-
-  def setup 
-    @original_timeout = Browser.options[:attach_timeout]
-    @browsers = []
-    uses_page "pass.html"
-  end 
-
-  def teardown
-    Browser.set_options :attach_timeout => @original_timeout
-    @browsers.each {|x| x.close}
-  end
-
-  def test_missing_window
-    Browser.set_options :attach_timeout => 0.1
-    assert_raises(NoMatchingWindowFoundException) { Browser.attach(:title, "missing") }
-    assert_raises(NoMatchingWindowFoundException) { Browser.attach(:title, /missing/) }
-    assert_raises(NoMatchingWindowFoundException) { Browser.attach(:url, "missing") }
-    assert_raises(NoMatchingWindowFoundException) { Browser.attach(:url, /missing/) }
-  end    
-
-  # Open a few browsers so that the test has a few windows to choose
-  # from. The test harness has already opened a window that we won't
-  # use.
-  def open_several_windows
-    ["buttons1.html", "whitespace.html"].each do |file|
-      @browsers << Browser.start(self.class.html_root + file)
-    end
-  end
-  
-  def test_existing_window
-    open_several_windows
-      
-    b1 = Browser.attach(:title , /buttons/i)
-    assert_equal("Test page for buttons", b1.title)
-
-    b2 = Browser.attach(:title , "Test page for buttons")
-    assert_equal("Test page for buttons", b2.title)
-    
-    b3 = Browser.attach(:url, /buttons1.html/)
-    assert_equal("Test page for buttons", b3.title)
-  end
-  
-  def test_title_and_url_are_correct_after_reload
-    uses_page "whitespace.html"
-    assert_equal 'Test page for whitespace', browser.title
-    assert_match /whitespace.html/, browser.url
-    browser.link(:text, 'Login').click
-    assert_equal 'Pass Page', browser.title
-    assert_match /pass.html/, browser.url
-  end
-
-  tag_method :test_working_back_and_forth, :fails_on_firefox
-  def test_working_back_and_forth
-    open_several_windows
-    buttons = Browser.attach(:url, /buttons1.html/)
-    whitespace = Browser.attach(:url, /whitespace.html/)
-    assert_match /This button is a submit/, buttons.text
-    whitespace.link(:text, 'Login').click
-    assert_match /pass/i, whitespace.text
-  end
-end
-