watir 3.0.0.rc3 → 3.0.0

data/lib/watir/page-container.rb

@@ -1,108 +0,0 @@
-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.location.href
-        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
-
-    # Execute the given JavaScript string
-    def execute_script(source)
-      document.parentWindow.eval(source.to_s)
-    rescue WIN32OLERuntimeError, NoMethodError #if eval fails we need to use execScript(source.to_s) which does not return a value, hence the workaround
-      escaped_src = source.to_s.gsub(/[\r\n']/) {|m| "\\#{m}"}
-      wrapper = "_watir_helper_div_#{::Time.now.to_i + ::Time.now.usec}"
-      cmd = "var e = document.createElement('DIV'); e.style.display='none'; e.id='#{wrapper}'; e.innerHTML = eval('#{escaped_src}'); document.body.appendChild(e);"
-      document.parentWindow.execScript(cmd)
-      document.getElementById(wrapper).innerHTML
-    end
-
-    # 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 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.item(i).name.to_s
-            puts "frame  index: #{i + 1} name: #{fname}"
-          rescue => e
-            if e.to_s.match(/Access is denied/)
-              puts "frame  index: #{i + 1} Access Denied, see http://wiki.openqa.org/display/WTR/FAQ#access-denied"
-            end
-          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

data/lib/watir/process.rb

@@ -1,20 +0,0 @@
-module Watir
-  module Process
-    
-    # Returns the number of windows processes running with the specified name.
-    def self.count name
-      mgmt = WIN32OLE.connect('winmgmts:\\\\.')
-      processes = mgmt.InstancesOf('win32_process')
-      processes.extend Enumerable
-      processes.select{|x| x.name == name}.length
-    end
-    
-  end
-  
-  class IE
-    # Returns the number of IEXPLORE processes currently running.
-    def self.process_count
-      Watir::Process.count 'iexplore.exe'
-    end    
-  end
-end

data/lib/watir/screen_capture.rb

@@ -1,115 +0,0 @@
-
-require 'Win32API'
-
-module Watir
-  module ScreenCapture
-    
-    KEYEVENTF_KEYUP = 0x2
-    SW_HIDE         = 0
-    SW_SHOW         = 5
-    SW_SHOWNORMAL   = 1
-    VK_CONTROL      = 0x11
-    VK_F4           = 0x73
-    VK_MENU         = 0x12
-    VK_RETURN       = 0x0D
-    VK_SHIFT        = 0x10
-    VK_SNAPSHOT     = 0x2C
-    VK_TAB      = 0x09
-    GMEM_MOVEABLE = 0x0002
-    CF_TEXT = 1
-
-    # this method saves the current window or whole screen as either a bitmap or a jpeg
-    # It uses paint to save the file, so will barf if a duplicate filename is selected, or  the path doesnt exist etc
-    #    * filename        - string  -  the name of the file to save. If its not fully qualified the current directory is used
-    #    * active_window   - boolean - if true, the whole screen is captured, if false,  just the active window is captured
-    #    * save_as_bmp     - boolean - if true saves the file as a bitmap, saves it as a jpeg otherwise
-    def screen_capture(filename , active_window_only=false, save_as_bmp=false)
-
-
-      keybd_event = Win32API.new("user32", "keybd_event", ['I','I','L','L'], 'V')
-      vkKeyScan = Win32API.new("user32", "VkKeyScan", ['I'], 'I')
-      winExec = Win32API.new("kernel32", "WinExec", ['P','L'], 'L')
-      openClipboard = Win32API.new('user32', 'OpenClipboard', ['L'], 'I')
-      setClipboardData = Win32API.new('user32', 'SetClipboardData', ['I', 'I'], 'I')
-      closeClipboard = Win32API.new('user32', 'CloseClipboard', [], 'I')
-      globalAlloc = Win32API.new('kernel32', 'GlobalAlloc', ['I', 'I'], 'I')
-      globalLock = Win32API.new('kernel32', 'GlobalLock', ['I'], 'I')
-      globalUnlock = Win32API.new('kernel32', 'GlobalUnlock', ['I'], 'I')
-      memcpy = Win32API.new('msvcrt', 'memcpy', ['I', 'P', 'I'], 'I')
-
-     
-      filename = Dir.getwd.tr('/','\\') + '\\' + filename unless filename.index('\\')
-
-      if active_window_only ==false
-          keybd_event.Call(VK_SNAPSHOT,0,0,0)   # Print Screen
-      else
-          keybd_event.Call(VK_SNAPSHOT,1,0,0)   # Alt+Print Screen
-      end 
-
-      winExec.Call('mspaint.exe', SW_SHOW)
-      sleep(1)
-     
-      # Ctrl + V  : Paste
-      keybd_event.Call(VK_CONTROL, 1, 0, 0)
-      keybd_event.Call(vkKeyScan.Call(?V), 1, 0, 0)
-      keybd_event.Call(vkKeyScan.Call(?V), 1, KEYEVENTF_KEYUP, 0)
-      keybd_event.Call(VK_CONTROL, 1, KEYEVENTF_KEYUP, 0)
-
-
-      # Alt F + A : Save As
-      keybd_event.Call(VK_MENU, 1, 0, 0)
-      keybd_event.Call(vkKeyScan.Call(?F), 1, 0, 0)
-      keybd_event.Call(vkKeyScan.Call(?F), 1, KEYEVENTF_KEYUP, 0)
-      keybd_event.Call(VK_MENU, 1, KEYEVENTF_KEYUP, 0)
-      keybd_event.Call(vkKeyScan.Call(?A), 1, 0, 0)
-      keybd_event.Call(vkKeyScan.Call(?A), 1, KEYEVENTF_KEYUP, 0)
-      sleep(1)
-
-      # copy filename to clipboard
-      hmem = globalAlloc.Call(GMEM_MOVEABLE, filename.length+1)
-      mem = globalLock.Call(hmem)
-      memcpy.Call(mem, filename, filename.length+1)
-      globalUnlock.Call(hmem)
-      openClipboard.Call(0)
-      setClipboardData.Call(CF_TEXT, hmem) 
-      closeClipboard.Call 
-      sleep(1)
-      
-      # Ctrl + V  : Paste
-      keybd_event.Call(VK_CONTROL, 1, 0, 0)
-      keybd_event.Call(vkKeyScan.Call(?V), 1, 0, 0)
-      keybd_event.Call(vkKeyScan.Call(?V), 1, KEYEVENTF_KEYUP, 0)
-      keybd_event.Call(VK_CONTROL, 1, KEYEVENTF_KEYUP, 0)
-
-      if save_as_bmp == false
-        # goto the combo box
-        keybd_event.Call(VK_TAB, 1, 0, 0)
-        keybd_event.Call(VK_TAB, 1, KEYEVENTF_KEYUP, 0)
-        sleep(0.5)
-
-        # select the first entry with J
-        keybd_event.Call(vkKeyScan.Call(?J), 1, 0, 0)
-        keybd_event.Call(vkKeyScan.Call(?J), 1, KEYEVENTF_KEYUP, 0)
-        sleep(0.5)
-      end  
-
-      # Enter key
-      keybd_event.Call(VK_RETURN, 1, 0, 0)
-      keybd_event.Call(VK_RETURN, 1, KEYEVENTF_KEYUP, 0)
-      sleep(1)
-     
-      # Alt + F4 : Exit
-      keybd_event.Call(VK_MENU, 1, 0, 0)
-      keybd_event.Call(VK_F4, 1, 0, 0)
-      keybd_event.Call(VK_F4, 1, KEYEVENTF_KEYUP, 0)
-      keybd_event.Call(VK_MENU, 1, KEYEVENTF_KEYUP, 0)
-      sleep(1) 
-
-    end
-  end
-
-end
-
-
-#screenCapture( "f.bmp", false , true)
-

data/lib/watir/supported_elements.rb

@@ -1,172 +0,0 @@
-module Watir
-  module Container
-
-    class << self
-      def support_element method_name, args={}
-        klass = args[:class] || method_name.to_s.capitalize
-        super_class = args[:super_class] || "Element"
-
-        unless Watir.const_defined? klass
-          Watir.class_eval %Q[class #{klass} < #{super_class}; end]
-        end
-
-        unless Watir.const_defined? "#{klass}Collection"
-          Watir.class_eval %Q[class #{klass}Collection < #{args[:super_collection] || super_class}Collection; end]
-        end
-
-        tag_name = args[:tag_name] || method_name
-
-        Watir::Container.module_eval %Q[
-          def #{method_name}(how={}, what=nil)
-            #{klass}.new(self, format_specifiers(#{tag_name.inspect}, how, what))
-          end
-
-          def #{args.delete(:plural) || method_name.to_s + "s"}(how={}, what=nil)
-            specifiers = format_specifiers(#{tag_name.inspect}, how, what)
-            #{klass}Collection.new(self, specifiers)
-          end
-        ]
-      end
-
-      private :support_element
-    end
-
-    def format_specifiers(tag_name, how, what)
-      defaults = {:tag_name => [tag_name].flatten.map(&:to_s)}
-      formatted_specifiers = defaults.merge(what ? {how => what} : how)
-      if (formatted_specifiers[:css] || formatted_specifiers[:xpath]) && formatted_specifiers.size > 2
-        raise ArgumentError, ":xpath and :css specifiers should be the only one when used in #{formatted_specifiers.inspect}"
-      end
-      formatted_specifiers
-    end
-
-    private :format_specifiers
-
-    support_element :a, :class => :Link
-    alias_method :link, :a
-    alias_method :links, :as
-    support_element :abbr
-    support_element :address, :plural => :addresses
-    support_element :area
-    support_element :article
-    support_element :aside
-    support_element :audio
-    support_element :b
-    support_element :base
-    support_element :bdi
-    support_element :bdo
-    support_element :blockquote
-    support_element :body
-    support_element :br
-    support_element :button, :tag_name => [:button, :submit, :image, :reset], :super_class => :InputElement
-    support_element :canvas, :plural => :canvases 
-    support_element :caption
-    support_element :checkbox, :plural => :checkboxes, :class => :CheckBox, :super_class => :InputElement
-    support_element :cite
-    support_element :code
-    support_element :col
-    support_element :colgroup
-    support_element :command
-    support_element :data
-    support_element :datalist
-    support_element :dd
-    support_element :del
-    support_element :details, :plural => :detailses
-    support_element :dfn
-    support_element :div
-    support_element :dl
-    support_element :dt
-    support_element :element, :tag_name => "*", :class => :HTMLElement
-    support_element :em
-    support_element :embed
-    support_element :fieldset, :class => :FieldSet
-    alias_method :field_set, :fieldset
-    alias_method :field_sets, :fieldsets
-    support_element :figcaption
-    support_element :figure
-    support_element :file_field, :tag_name => :file, :class => :FileField, :super_collection => :InputElement
-    support_element :font
-    support_element :footer
-    support_element :form
-    support_element :frame, :tag_name => [:frame, :iframe]
-    alias_method :iframe, :frame
-    alias_method :iframes, :frames
-    support_element :frameset
-    support_element :h1
-    support_element :h2
-    support_element :h3
-    support_element :h4
-    support_element :h5
-    support_element :h6
-    support_element :head
-    support_element :header
-    support_element :hgroup
-    support_element :hidden, :super_class => :TextField, :super_collection => :InputElement
-    support_element :hr
-    # html and htmls?!
-    support_element :i
-    support_element :img, :class => :Image
-    alias_method :image, :img
-    alias_method :images, :imgs
-    support_element :input, :super_class => :InputElement
-    support_element :ins, :plural => :inses
-    support_element :kbd
-    support_element :keygen
-    support_element :label
-    support_element :legend
-    support_element :li
-    support_element :map
-    support_element :mark
-    support_element :menu
-    support_element :meta
-    support_element :meter
-    support_element :nav
-    support_element :noscript
-    support_element :object
-    support_element :ol
-    support_element :optgroup
-    support_element :option
-    support_element :output
-    support_element :p
-    support_element :param
-    support_element :pre
-    support_element :progress, :plural => :progresses
-    support_element :q
-    support_element :radio, :super_class => :InputElement
-    support_element :rp
-    support_element :rt
-    support_element :ruby, :plural => :rubies
-    support_element :s
-    support_element :samp
-    support_element :script
-    support_element :section
-    support_element :select, :class => :SelectList, :super_class => :InputElement
-    alias_method :select_list, :select
-    alias_method :select_lists, :selects
-    support_element :small
-    support_element :source
-    support_element :span
-    support_element :strong
-    support_element :style
-    support_element :sub
-    support_element :summary, :plural => :summaries
-    support_element :sup
-    support_element :table
-    support_element :tbody, :class => :TableSection
-    support_element :td, :tag_name => [:th, :td], :class => :TableCell
-    support_element :text_field, :tag_name => [:text, :password, :textarea], :class => :TextField, :super_class => :InputElement
-    support_element :textarea, :class => :TextArea, :super_class => :TextField, :super_collection => :InputElement
-    support_element :tfoot, :class => :TableSection
-    support_element :th
-    support_element :thead, :class => :TableSection
-    support_element :time
-    support_element :title
-    support_element :tr, :class => :TableRow
-    support_element :track
-    support_element :u
-    support_element :ul
-    support_element :var
-    support_element :video
-    support_element :wbr
-  end
-end

data/lib/watir/table.rb

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