watir 1.5.2 → 1.5.3

data/watir/link.rb

@@ -0,0 +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
+  
+end

data/watir/locator.rb

@@ -0,0 +1,79 @@
+module Watir
+  class TaggedElementLocator
+    include Watir
+    include Watir::Exception
+
+    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
+
+      specifiers.each do |how, what|  
+        what = what.to_i if how == :index
+        how = :href if how == :url
+        how = :class_name if how == :class
+        
+        @specifiers[how] = what
+      end
+
+    end
+
+    def each_element tag
+      @container.document.getElementsByTagName(tag).each do |ole_element| 
+        yield Element.new(ole_element) 
+      end
+    end    
+
+    def locate
+      index_target = @specifiers[:index]
+
+      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 index_target == count
+            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  
+end    

data/watir/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/watir/modal_dialog.rb

@@ -0,0 +1,123 @@
+module Watir
+  class ModalDialog
+    include Container
+    include PageContainer
+    include Win32
+
+    # Return the current window handle
+    attr_reader :hwnd
+
+    def find_modal_from_window
+      # Use handle of our parent window to see if we have any currently
+      # enabled popup.
+      hwnd = @container.hwnd
+      hwnd_modal = 0
+      begin
+        Watir::until_with_timeout do
+          hwnd_modal, arr = GetWindow.call(hwnd, GW_ENABLEDPOPUP) # GW_ENABLEDPOPUP = 6
+          hwnd_modal > 0
+        end
+      rescue TimeOutException
+        return nil
+      end
+      if hwnd_modal == hwnd || hwnd_modal == 0
+        hwnd_modal = nil
+      end
+      @hwnd = hwnd_modal
+    end
+    private :find_modal_from_window
+
+    def locate
+      how = @how
+      what = @what
+
+      case how
+      when nil
+        unless find_modal_from_window
+          raise NoMatchingWindowFoundException, 
+            "Modal Dialog not found. Timeout = #{Watir::IE.attach_timeout}"
+        end
+      when :title
+        case what.class.to_s
+        # TODO: re-write like WET's so we can select on regular expressions too.
+        when "String"
+          begin
+            Watir::until_with_timeout do
+              title = "#{what} -- Web Page Dialog"
+              @hwnd, arr = FindWindowEx.call(0, 0, nil, title)
+              @hwnd > 0
+            end
+          rescue TimeOutException
+            raise NoMatchingWindowFoundException, 
+              "Modal Dialog with title #{what} not found. Timeout = #{Watir::IE.attach_timeout}"
+          end
+        else
+          raise ArgumentError, "Title value must be String"
+        end
+      else
+        raise ArgumentError, "Only null and :title methods are supported"
+      end
+
+      intUnknown = 0
+      begin
+        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
+      rescue TimeOutException => e        
+        raise NoMatchingWindowFoundException, 
+          "Unable to attach to Modal Window #{what.inspect} after #{e.duration} seconds."
+      end
+      
+      copy_test_config @parent_container
+      @document = WIN32OLE.connect_unknown(intUnknown)
+    end
+
+    def initialize(container, how, what=nil)
+      set_container container
+      @how = how
+      @what = what
+      @parent_container = container
+      # locate our modal dialog's Document object and save it
+      begin
+        locate
+      rescue NoMethodError => e
+        message = 
+          "IE#modal_dialog not supported with the current version of Ruby (#{RUBY_VERSION}).\n" + 
+          "See http://jira.openqa.org/browse/WTR-2 for details.\n" +
+            e.message
+        raise NoMethodError.new(message)
+      end
+    end
+
+    def document
+      @document
+    end
+    
+    # Return the title of the document
+    def title
+      document.title
+    end
+
+    def close
+      document.parentWindow.close
+    end
+
+    def attach_command
+      "Watir::IE.find(:hwnd, #{@container.hwnd}).modal_dialog"
+    end
+      
+    def wait(no_sleep=false)
+    end
+    
+    # Return true if the modal exists. Mostly this is useful for testing whether
+    # a modal has closed.
+    def exists?
+      Watir::Win32::window_exists? @hwnd
+    end
+    alias :exist? :exists?
+  end
+end

data/watir/non_control_elements.rb

@@ -0,0 +1,91 @@
+module Watir
+  
+  # this class contains items that are common between the span, div, and pre objects
+  # it would not normally be used directly
+  #
+  # many of the methods available to this object are inherited from the Element class
+  #
+  class NonControlElement < Element
+    include Watir::Exception
+    
+    def locate
+      if @how == :xpath
+        @o = @container.element_by_xpath(@what)
+      else
+        @o = @container.locate_tagged_element(self.class::TAG, @how, @what)
+      end
+    end
+    
+    def initialize(container, how, what)
+      set_container container
+      @how = how
+      @what = what
+      super nil
+    end
+    
+    # this method is used to populate the properties in the to_s method
+    def span_div_string_creator
+      n = []
+      n <<   "class:".ljust(TO_S_SIZE) + self.class_name
+      n <<   "text:".ljust(TO_S_SIZE) + self.text
+      return n
+    end
+    private :span_div_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 += span_div_string_creator
+      return r.join("\n")
+    end
+  end
+  
+  class Pre < NonControlElement
+    TAG = 'PRE'
+  end
+  
+  class P < NonControlElement
+    TAG = 'P'
+  end
+  
+  # this class is used to deal with Div tags in the html page. http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/div.asp?frame=true
+  # It would not normally be created by users
+  class Div < NonControlElement
+    TAG = 'DIV'
+  end
+  
+  # this class is used to deal with Span tags in the html page. It would not normally be created by users
+  class Span < NonControlElement
+    TAG = 'SPAN'
+  end
+  
+  # Accesses Label element on the html page - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/label.asp?frame=true
+  class Label < NonControlElement
+    TAG = 'LABEL'
+    
+    # this method is used to populate the properties in the to_s method
+    def label_string_creator
+      n = []
+      n <<   "for:".ljust(TO_S_SIZE) + self.for
+      n <<   "text:".ljust(TO_S_SIZE) + self.text
+      return n
+    end
+    private :label_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 += label_string_creator
+      return r.join("\n")
+    end
+  end
+  
+  class Li < NonControlElement
+    TAG = 'LI'
+  end  
+  
+end

data/watir/page-container.rb

@@ -0,0 +1,106 @@
+module Watir    
+  # A PageContainer contains an HTML Document. In other words, it is a 
+  # what JavaScript calls a Window.
+  module PageContainer
+    include Watir::Exception
+
+    # This method checks the currently displayed page for http errors, 404, 500 etc
+    # It gets called internally by the wait method, so a user does not need to call it explicitly
+
+    def check_for_http_error
+      # check for IE7
+      n = self.document.invoke('parentWindow').navigator.appVersion
+      m=/MSIE\s(.*?);/.match( n )
+      if m and m[1] =='7.0'
+        if m=/HTTP (\d\d\d.*)/.match( self.title )
+          raise NavigationException, m[1]
+        end
+      else
+        # assume its IE6
+        url = self.document.url
+        if /shdoclc.dll/.match(url)
+          m = /id=IEText.*?>(.*?)</i.match(self.html)
+          raise NavigationException, m[1] if m
+        end
+      end
+      false
+    end 
+    
+    # The HTML Page
+    def page
+      document.documentelement
+    end
+    private :page
+        
+    # The HTML of the current page
+    def html
+      page.outerhtml
+    end
+    
+    # The url of the page object. 
+    def url
+      page.document.location.href
+    end
+    
+    # The text of the current page
+    def text
+      page.innertext.strip
+    end
+
+    def eval_in_spawned_process(command)
+      command.strip!
+      load_path_code = _code_that_copies_readonly_array($LOAD_PATH, '$LOAD_PATH')
+      ruby_code = "require 'watir'; "
+#      ruby_code = "$HIDE_IE = #{$HIDE_IE};" # This prevents attaching to a window from setting it visible. However modal dialogs cannot be attached to when not visible.
+      ruby_code << "pc = #{attach_command}; " # pc = page container
+      # IDEA: consider changing this to not use instance_eval (it makes the code hard to understand)
+      ruby_code << "pc.instance_eval(#{command.inspect})"
+      exec_string = "start rubyw -e #{(load_path_code + '; ' + ruby_code).inspect}"
+      system(exec_string)
+    end
+    
+    def set_container container
+      @container = container
+      @page_container = self
+    end
+    
+    # This method is used to display the available html frames that Internet Explorer currently has loaded.
+    # This method is usually only used for debugging test scripts.
+    def show_frames
+      if allFrames = document.frames
+        count = allFrames.length
+        puts "there are #{count} frames"
+        for i in 0..count-1 do
+          begin
+            fname = allFrames[i.to_s].name.to_s
+            puts "frame  index: #{i + 1} name: #{fname}"
+          rescue => e
+            puts "frame  index: #{i + 1} Access Denied, see http://wiki.openqa.org/display/WTR/FAQ#access-denied" if e.to_s.match(/Access is denied/)
+          end
+        end
+      else
+        puts "no frames"
+      end
+    end
+
+    # Search the current page for specified text or regexp.
+    # Returns the index if the specified text was found.
+    # Returns matchdata object if the specified regexp was found.
+    # 
+    # *Deprecated* 
+    # Instead use 
+    #   IE#text.include? target 
+    # or
+    #   IE#text.match target
+    def contains_text(target)
+        if target.kind_of? Regexp
+          self.text.match(target)
+        elsif target.kind_of? String
+          self.text.index(target)
+        else
+          raise ArgumentError, "Argument #{target} should be a string or regexp."
+        end
+    end
+
+  end # module
+end