watir-classic 3.0.0

data/lib/watir-classic/non_control_elements.rb

@@ -0,0 +1,114 @@
+module Watir
+  class Area < Element
+    attr_ole :alt
+    attr_ole :type
+    attr_ole :href
+  end
+
+  class Audio < Element
+    attr_ole :src
+  end
+
+  class Base < Element
+    attr_ole :href
+  end
+
+  class Command < Element
+    attr_ole :disabled?
+    attr_ole :type
+  end
+
+  class Data < Element
+    attr_ole :value
+  end
+
+  class Embed < Element
+    attr_ole :src
+    attr_ole :type
+  end
+
+  class FieldSet < Element
+    attr_ole :name
+    attr_ole :disabled?
+  end
+
+  class Font < Element
+    attr_ole :color
+    attr_ole :face
+    attr_ole :size
+  end
+
+  class Keygen < Element
+    attr_ole :name
+    attr_ole :disabled?
+  end
+
+  class Label < Element
+    attr_ole :for, :htmlFor
+  end
+
+  class Li < Element
+    attr_ole :value
+  end
+
+  class Map < Element
+    attr_ole :name
+  end
+
+  class Menu < Element
+    attr_ole :type
+  end
+
+  class Meta < Element
+    attr_ole :http_equiv, :httpEquiv
+    attr_ole :content
+    attr_ole :name
+  end
+
+  class Meter < Element
+    attr_ole :value
+  end
+
+  class Object < Element
+    attr_ole :name
+    attr_ole :type
+  end
+
+  class Optgroup < Element
+    attr_ole :disabled?
+  end
+
+  class Output < Element
+    attr_ole :name
+  end
+
+  class Param < Element
+    attr_ole :name
+    attr_ole :value
+  end
+
+  class Progress < Element
+    attr_ole :value
+  end
+
+  class Script < Element
+    attr_ole :src
+    attr_ole :type
+  end
+
+  class Source < Element
+    attr_ole :type
+  end
+
+  class Style < Element
+    attr_ole :type
+  end
+
+  class Track < Element
+    attr_ole :src
+  end
+
+  class Video < Element
+    attr_ole :src
+  end
+end

data/lib/watir-classic/options.rb

@@ -0,0 +1,56 @@
+#--
+# 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-classic/page-container.rb

@@ -0,0 +1,114 @@
+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)
+      result = nil
+      begin
+        source = "(function() {#{source}})()"
+        result = document.parentWindow.eval(source)
+      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.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)
+        result = document.getElementById(wrapper).innerHTML
+      end
+
+      result == "undefined" ? nil : result
+    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-classic/process.rb

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

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

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