watir-classic 3.0.0

data/lib/watir-classic/irb-history.rb

@@ -0,0 +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
+
+Readline::History.start_session_log

data/lib/watir-classic/link.rb

@@ -0,0 +1,46 @@
+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
+    attr_ole :type
+    attr_ole :href
+
+    # 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-classic/locator.rb

@@ -0,0 +1,243 @@
+module Watir
+  class Locator
+    include Watir
+    include Watir::Exception
+    include XpathLocator
+
+    def initialize container, specifiers, klass
+      @container = container
+      @specifiers = {:index => Watir::IE.base_index}.merge(normalize_specifiers(specifiers))
+      @tags = @specifiers.delete(:tag_name)
+      @klass = klass
+    end
+
+    def each
+      if has_excluding_specifiers?
+        locate_elements_by_xpath_css_ole.each do |element|
+          yield element
+        end
+      else
+        @tags.each do |tag|
+          each_element(tag) do |element| 
+            next unless type_matches?(element.ole_object) && match_with_specifiers?(element)
+            yield element          
+          end 
+        end
+      end
+      nil
+    end    
+
+    def document
+      @document ||= @container.document
+    end
+
+    def normalize_specifiers(specifiers)
+      specifiers.reduce({}) do |memo, pair|
+        how, what = *pair
+        case how
+        when :index
+          what = what.to_i
+        when :url
+          how = :href
+        when :class
+          how = :class_name
+        when :caption
+          how = :value
+        when :method
+          how = :form_method
+        when :value
+          what = what.is_a?(Regexp) ? what : what.to_s
+        end
+
+        memo[how] = what
+        memo
+      end
+    end
+
+    def match_with_specifiers?(element)
+      return true if has_excluding_specifiers?
+      @specifiers.all? do |how, what|
+        how == :index || 
+          (how == :class_name && match_class?(element, what)) ||
+          match?(element, how, what)
+      end
+    end
+
+    def match_class? element, what
+      classes = element.class_name.split(/\s+/)
+      classes.any? {|clazz| what.matches(clazz)}
+    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 a <#{@tags.join(", ")}> element (#{what})"
+      end
+
+      what.matches(attribute)
+    end
+
+    def has_excluding_specifiers?
+      @specifiers.keys.any? {|specifier| [:css, :xpath, :ole_object].include? specifier}
+    end
+
+    def locate_by_id
+      # Searching through all elements returned by __ole_inner_elements
+      # is *significantly* slower than IE's getElementById() and
+      # getElementsByName() calls when how is :id.  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 
+        element = document.getElementById(the_id) rescue nil
+        # Return if our fast match really HAS a matching :id
+        return element if element && element.invoke('id') == the_id && type_matches?(element) && match_with_specifiers?(create_element element)
+      end
+
+      nil
+    end
+
+    def locate_elements_by_xpath_css_ole
+      els = []
+
+      if @specifiers[:xpath]
+        els = elements_by_xpath(@specifiers[:xpath])
+      elsif @specifiers[:css]
+        els = elements_by_css(@specifiers[:css])
+      elsif @specifiers[:ole_object]
+        return [@specifiers[:ole_object]]
+      end      
+
+      els.select {|element| type_matches?(element) && match_with_specifiers?(create_element element)}
+    end
+
+    def type_matches?(el)
+      @tags == ["*"] || 
+        @tags.include?(el.tagName.downcase) || 
+        @tags.include?(el.invoke('type').downcase) rescue false
+    end
+
+    def create_element ole_object
+      element = @klass.new(@container, @specifiers.merge(:ole_object => ole_object))
+      def element.locate; @o; end
+      element
+    end
+  end
+
+  class TaggedElementLocator < Locator
+    def each_element(tag)
+      document.getElementsByTagName(tag).each do |ole_object|
+        yield create_element ole_object
+      end
+    end
+
+    def locate
+      el = locate_by_id
+      return el if el
+      return locate_elements_by_xpath_css_ole[0] if has_excluding_specifiers?
+
+      count = Watir::IE.base_index - 1
+      each do |element|
+        count += 1
+        return element.ole_object if count == @specifiers[:index]
+      end # elements
+      nil
+    end
+  end
+
+  class FrameLocator < TaggedElementLocator
+    def each_element(tag)
+      frames = @container.page_container.document.frames
+      i = 0
+      document.getElementsByTagName(tag).each do |ole_object|
+        frame = create_element ole_object
+        frame.document = frames.item(i)
+        yield frame
+        i += 1
+      end
+    end
+
+    def locate
+      count = Watir::IE.base_index - 1
+      each do |frame|
+        count += 1
+        return frame.ole_object, frame.document if count == @specifiers[:index]
+      end
+    end
+
+    def locate_elements_by_xpath_css_ole
+      super.map do |frame|
+        frame = create_element frame
+        each_element(frame.tag_name) do |frame_with_document|
+          if frame_with_document == frame
+            frame = frame_with_document
+            break
+          end
+        end
+        frame
+      end
+    end
+  end
+
+  class FormLocator < TaggedElementLocator
+    def each_element(tag)
+      document.forms.each do |form|
+        yield create_element form
+      end
+    end
+  end
+
+  class InputElementLocator < Locator
+    def each_element
+      elements = locate_by_name || @container.__ole_inner_elements
+      elements.each do |object|
+        yield create_element object
+      end
+      nil
+    end    
+
+    def locate
+      el = locate_by_id
+      return el if el
+      return locate_elements_by_xpath_css_ole[0] if has_excluding_specifiers?
+
+      count = Watir::IE.base_index - 1
+      each do |element|
+        count += 1
+        return element.ole_object if count == @specifiers[:index]
+      end
+    end
+
+    def each
+      if has_excluding_specifiers?
+        locate_elements_by_xpath_css_ole.each do |element|
+          yield element
+        end
+      else
+        each_element do |element| 
+          next unless type_matches?(element.ole_object) && match_with_specifiers?(element)
+          yield element
+        end 
+      end
+      nil
+    end    
+
+    private
+
+    def locate_by_name
+      the_name = @specifiers[:name]
+      if the_name && the_name.class == String
+        return document.getElementsByName(the_name) rescue nil
+      end      
+      nil
+    end
+  end
+
+end    

data/lib/watir-classic/logger.rb

@@ -0,0 +1,19 @@
+module Watir
+  class WatirLogger < Logger
+    def initialize(filName, logsToKeep, maxLogSize)
+      super(filName, logsToKeep, maxLogSize)
+      self.level = Logger::DEBUG
+      self.datetime_format = "%d-%b-%Y %H:%M:%S"
+      self.debug("Watir starting")
+    end
+  end
+  
+  class DefaultLogger < Logger
+    def initialize
+      super(STDERR)
+      self.level = Logger::WARN
+      self.datetime_format = "%d-%b-%Y %H:%M:%S"
+      self.info "Log started"
+    end
+  end
+end

data/lib/watir-classic/matches.rb

@@ -0,0 +1,23 @@
+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-classic/modal_dialog.rb

@@ -0,0 +1,72 @@
+class WinClicker
+  def initialize
+    raise NotImplementedError, 'Watir no longer supports WinClicker. Please use click_no_wait and the javascript_dialog method.'
+  end
+end
+
+module Watir
+  class ModalDialog
+    include Container
+    include PageContainer
+    include Win32
+
+    def initialize(container)
+      set_container container
+      @modal = ::RAutomation::Window.new(:hwnd=>@container.hwnd).child(:class => 'Internet Explorer_TridentDlgFrame')
+    end
+
+    def locate
+      @modal.wait_until_present rescue raise NoMatchingWindowFoundException
+
+      intUnknown = 0
+      Watir::until_with_timeout do
+        intPointer = " " * 4 # will contain the int value of the IUnknown*
+        GetUnknown.call(hwnd, intPointer)
+        intArray = intPointer.unpack('L')
+        intUnknown = intArray.first
+        intUnknown > 0
+      end
+      
+      WIN32OLE.connect_unknown(intUnknown)
+    rescue NoMatchingWindowFoundException, Wait::TimeoutError
+      raise NoMatchingWindowFoundException,
+        "Unable to attach to Modal Window."
+    end
+
+    alias_method :document, :locate
+
+    def title
+      document.title
+    end
+
+    def close(timeout=5)
+      return unless exists?
+      document.parentWindow.close
+      Watir::Wait.until(timeout) {!exists?} rescue nil
+      wait
+    end
+
+    def attach_command
+      "Watir::IE.find(:hwnd, #{@container.hwnd}).modal_dialog"
+    end
+
+    def wait(no_sleep=false)
+      @container.page_container.wait unless exists?
+    end
+
+    def hwnd
+      @modal.hwnd
+    end
+
+    def active?
+      @modal.active?
+    end
+
+    def exists?
+      @modal.exists?
+    end
+
+    alias_method :exist?, :exists?
+
+  end
+end

data/lib/watir-classic/module.rb

@@ -0,0 +1,12 @@
+module Watir
+  include Watir::Exception
+
+# Directory containing the watir.rb file
+  @@dir = File.expand_path(File.dirname(__FILE__))
+
+# Like regular Ruby "until", except that a Wait::TimeoutError is raised
+# if the timeout is exceeded. Timeout is IE.attach_timeout.
+  def self.until_with_timeout # block
+    Wait.until(IE.attach_timeout) { yield }
+  end
+end