vapir-ie 1.7.0.rc1

data/lib/vapir-ie/non_control_elements.rb

@@ -0,0 +1,77 @@
+module Vapir
+
+  class IE::Pre < IE::Element
+    include Vapir::Pre
+  end
+
+  class IE::P < IE::Element
+    include Vapir::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 IE::Div < IE::Element
+    include Vapir::Div
+  end
+
+  # this class is used to deal with Span tags in the html page. It would not normally be created by users
+  class IE::Span < IE::Element
+    include Vapir::Span
+  end
+
+  class IE::Map < IE::Element
+    include Vapir::Map
+  end
+
+  class IE::Area < IE::Element
+    include Vapir::Area
+  end
+
+  # Accesses Label element on the html page - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/label.asp?frame=true
+  class IE::Label < IE::Element
+    include Vapir::Label
+  end
+
+  class IE::Li < IE::Element
+    include Vapir::Li
+  end
+  class IE::Ul < IE::Element
+    include Vapir::Ul
+  end
+  class IE::Ol < IE::Element
+    include Vapir::Ol
+  end
+  class IE::H1 < IE::Element
+    include Vapir::H1
+  end
+  class IE::H2 < IE::Element
+    include Vapir::H2
+  end
+  class IE::H3 < IE::Element
+    include Vapir::H3
+  end
+  class IE::H4 < IE::Element
+    include Vapir::H4
+  end
+  class IE::H5 < IE::Element
+    include Vapir::H5
+  end
+  class IE::H6 < IE::Element
+    include Vapir::H6
+  end
+  class IE::Dl < IE::Element
+    include Vapir::Dl
+  end
+  class IE::Dt < IE::Element
+    include Vapir::Dt
+  end
+  class IE::Dd < IE::Element
+    include Vapir::Dd
+  end
+  class IE::Strong < IE::Element
+    include Vapir::Strong
+  end
+  class IE::Em < IE::Element
+    include Vapir::Em
+  end
+end

data/lib/vapir-ie/page_container.rb

@@ -0,0 +1,203 @@
+require 'vapir-ie/container'
+
+module Vapir
+  # A PageContainer contains an HTML Document. In other words, it is a 
+  # what JavaScript calls a Window.
+  #
+  # this assumes that document_object is defined on the includer. 
+  module IE::PageContainer
+    # Used internally to determine when IE has finished loading a page
+    # http://msdn.microsoft.com/en-us/library/system.windows.forms.webbrowserreadystate.aspx
+    # http://msdn.microsoft.com/en-us/library/system.windows.forms.webbrowser.readystate.aspx
+    module WebBrowserReadyState
+      Uninitialized = 0 # No document is currently loaded.
+      Loading       = 1 # The control is loading a new document.
+      Loaded        = 2 # The control has loaded and initialized the new document, but has not yet received all the document data.
+      Interactive   = 3 # The control has loaded enough of the document to allow limited user interaction, such as clicking hyperlinks that have been displayed.
+      Complete      = 4 # The control has finished loading the new document and all its contents.
+    end
+    READYSTATE_COMPLETE = WebBrowserReadyState::Complete
+       
+    def containing_object
+      document_object
+    end
+    include IE::Container
+    include Vapir::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 
+    
+    def document_element
+      document_object.documentElement
+    end
+    def content_window_object
+      document_object.parentWindow
+    end
+    
+    def page_container
+      self
+    end
+
+    # The HTML of the current page
+    def html
+      document_element.outerHTML
+    end
+    
+    # The url of the page object. 
+    def url
+      document_object.location.href
+    end
+    
+    # The text of the current page
+    def text
+      document_element.innerText
+    end
+
+    def close
+      content_window_object.close
+    end
+
+    def title
+      document_object.title
+    end
+
+    # Execute the given JavaScript string
+    def execute_script(source)
+      retried=false
+      result=nil
+      begin
+        result=document_object.parentWindow.eval(source)
+      rescue WIN32OLERuntimeError
+        # don't retry more than once; don't catch anything but the particular thing we're looking for 
+        if retried || $!.message !~ /unknown property or method:? `eval'/
+          raise
+        end
+        # this can happen if no scripts have executed at all - the 'eval' function doesn't exist. 
+        # execScript works, but behaves differently than eval (it doesn't return anything) - but 
+        # once an execScript has run, eval is subsequently defined. so, execScript a blank script, 
+        # and then try again with eval.
+        document.parentWindow.execScript('null')
+        retried=true
+        retry
+      end
+      return result
+    end
+    
+    # Block execution until the page has loaded.
+    # =nodoc
+    # Note: This code needs to be prepared for the ie object to be closed at 
+    # any moment!
+    def wait(options={})
+      unless options.is_a?(Hash)
+        raise ArgumentError, "given options should be a Hash, not #{options.inspect} (#{options.class})\nold conflicting arguments of no_sleep or last_url are gone"
+      end
+      options={:sleep => false, :interval => 0.1, :timeout => 120}.merge(options)
+      @xml_parser_doc = nil
+      @down_load_time = nil
+      start_load_time = Time.now
+      
+      if respond_to?(:browser_object)
+        ::Waiter.try_for(options[:timeout]-(Time.now-start_load_time), :interval => options[:interval], :exception => "The browser was still busy at the end of the specified interval") do
+          return unless exists?
+          !browser_object.busy
+        end
+        ::Waiter.try_for(options[:timeout]-(Time.now-start_load_time), :interval => options[:interval], :exception => "The browser's readyState was still not ready for interaction at the end of the specified interval") do
+          return unless exists?
+          [WebBrowserReadyState::Interactive, WebBrowserReadyState::Complete].include?(browser_object.readyState)
+        end
+      end
+      ::Waiter.try_for(options[:timeout]-(Time.now-start_load_time), :interval => options[:interval], :exception => "The browser's document was still not defined at the end of the specified interval") do
+        return unless exists?
+        document_object
+      end
+      urls=[]
+      all_frames_complete_result=::Waiter.try_for(options[:timeout]-(Time.now-start_load_time), :interval => options[:interval], :exception => nil, :condition => proc{|result| result==true }) do
+        return unless exists?
+        all_frames_complete?(document_object, urls)
+      end
+      case all_frames_complete_result
+      when false
+        raise "A frame on the browser did not come into readyState complete by the end of the specified interval"
+      when Exception
+        message = "A frame on the browser encountered an error.\n"
+        if all_frames_complete_result.message =~ /0x80070005/
+          message += "An 'Access is denied' error might be fixed by adding the domain of the site to your 'Trusted Sites'.\n"
+        end
+        message+="Original message was:\n\n"
+        message+=all_frames_complete_result.message
+        raise all_frames_complete_result.class, message, all_frames_complete_result.backtrace
+      when true
+        # dandy; carry on. 
+      else
+        # this should never happen. 
+        raise "Unexpected result from all_frames_complete?: #{all_frames_complete_result.inspect}"
+      end
+      @url_list=(@url_list || [])+urls
+      
+      @down_load_time= Time.now - start_load_time
+      run_error_checks if respond_to?(:run_error_checks)
+      sleep @pause_after_wait if options[:sleep]
+      @down_load_time
+    end
+    
+    private
+    # this returns true if all frames are complete. 
+    # it returns false if a frame is incomplete. 
+    # if an unexpected exception is encountered, it returns that exception. yes, returns, not raises, 
+    # due to the fact that an exception may indicate either the frame not being complete, or an actual
+    # error condition - it is difficult to differentiate. in the usage above, in #wait, we check
+    # if an exception is still being raised at the end of the specified interval, and raise it if so. 
+    # if it stops being raised, we carry on. 
+    def all_frames_complete?(document, urls=nil)
+      begin
+        if urls && !urls.include?(document.location.href)
+          urls << document.location.href
+        end
+        frames=document.frames
+        return document.readyState=='complete' && (0...frames.length).all? do |i|
+          frame=document.frames[i.to_s]
+          frame_document=begin
+            frame.document
+          rescue WIN32OLERuntimeError
+            $!
+          end
+          case frame_document
+          when nil
+            # frame hasn't loaded to the point where it has a document yet 
+            false
+          when WIN32OLE
+            # frame has a document - check recursively 
+            all_frames_complete?(frame_document, urls)
+          when WIN32OLERuntimeError 
+            # if we get a WIN32OLERuntimeError with access denied, that is probably a 404 and it's not going 
+            # to load, so no reason to keep waiting for it - consider it 'complete' and return true. 
+            # there's probably a better method of determining this but I haven't found it yet. 
+            true
+          else # don't know what we'd have here 
+            raise RuntimeError, "unknown frame.document: #{frame_document.inspect} (#{frame_document.class})"
+          end
+        end
+      rescue WIN32OLERuntimeError
+        return $!
+      end
+    end
+  end # module
+end

data/lib/vapir-ie/process.rb

@@ -0,0 +1,22 @@
+require 'vapir-ie/ie-class'
+
+module Vapir
+  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
+      Vapir::Process.count 'iexplore.exe'
+    end
+  end
+end

data/lib/vapir-ie/screen_capture.rb

@@ -0,0 +1,7 @@
+module Vapir
+  module ScreenCapture
+    def screen_capture(filename , active_window_only=false, save_as_bmp=false)
+      raise NotImplementedError, "This method is gone. Please instead see IE#screen_capture(filename)"
+    end
+  end
+end

data/lib/vapir-ie/scripts/select_file.rb

@@ -0,0 +1,79 @@
+at_exit do
+  if $!
+    err={:class => $!.class, :message => $!.message, :backtrace => $!.backtrace}
+    if $upload_dialog && $upload_dialog.exists? 
+      # if the upload dialog still exists, we need to close it so that the #click WIN32OLE call in the parent process can return. 
+      if (upload_dialog_popup=$upload_dialog.enabled_popup)
+        # we will assume this popup is of the "The above file name is invalid" variety, so click 'OK'
+        contents=begin
+          upload_dialog_popup.children.select{|child| child.class_name=='Static' && child.text!=''}.map{|child| child.text}.join(' ')
+        rescue WinWindow::Error
+          "{Unable to retrieve contents}"
+        end
+        err[:message]+="\n\nA popup was found on the dialog with title: \n#{upload_dialog_popup.text.inspect}\nand text contents: \n#{contents}"
+        if upload_dialog_popup.click_child_button_try_for!('OK', 4, :exception => nil)
+          err[:message]+="\n\nClicked 'OK' on the popup."
+        end
+      end
+      # once the popup is gone (or if there wasn't one - this happens if the field was set to blank, or set to a directory that exists)
+      # then click 'cancel' 
+      if $upload_dialog.click_child_button_try_for!('Cancel', 4, :exception => nil)
+        err[:message]+="\n\nClicked the 'Cancel' button instead of 'Open' on the File Upload dialog."
+      end
+      
+      # none of the above are expected to error, but maybe should be in a begin/rescue just in case?
+    end
+    if $error_file_name && $error_file_name != ''
+      File.open($error_file_name, 'w') do |error_file|
+        to_write=Marshal.dump(err)
+        error_file.write(to_write)
+      end
+    end
+  else
+    if $error_file_name && $error_file_name != '' && File.exists?($error_file_name)
+      File.delete($error_file_name)
+      # the file not existing indicates success. 
+    end
+  end
+end
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'vapir-common', 'lib'))
+
+require 'vapir-common/win_window'
+require 'vapir-common/waiter'
+require 'vapir-common/exceptions'
+
+browser_hwnd, file_path, $error_file_name=*ARGV
+unless (2..3).include?(ARGV.size) && browser_hwnd =~ /^\d+$/ && browser_hwnd.to_i > 0
+  raise ArgumentError, "This script takes two or three arguments: the hWnd that the File Selection dialog will pop up on (positive integer); the path to the file to select; and (optional) a filename to write any failure message to."
+end
+
+# titles of file upload window titles in supported browsers 
+# Add to this titles in other languages, too 
+UploadWindowTitles= { :IE8 => "Choose File to Upload", 
+                      :IE7 => 'Choose file', 
+                    }
+# list of arguments to give to WinWindow#child_control_with_preceding_label to find the filename field
+# on dialogs of supported browsers (just the one right now because it's the same in ie7 and ie8)
+# add to this stuff for other languages, too 
+UploadWindowFilenameFields = [["File &name:", {:control_class_name => 'ComboBoxEx32'}]]
+
+browser_window=WinWindow.new(browser_hwnd.to_i)
+
+popup=nil
+$upload_dialog=::Waiter.try_for(16, :exception => nil) do
+  if (popup=browser_window.enabled_popup) && UploadWindowTitles.values.include?(popup.text)
+    popup
+  end
+end
+unless $upload_dialog
+  raise Vapir::Exception::NoMatchingWindowFoundException.new('No window found to upload a file - '+(popup ? "enabled popup exists but has unrecognized text #{popup.text}" : 'no popup is on the browser'))
+end
+filename_fields=UploadWindowFilenameFields.map do |control_args|
+  $upload_dialog.child_control_with_preceding_label(*control_args)
+end
+unless (filename_field=filename_fields.compact.first)
+  raise Vapir::Exception::NoMatchingWindowFoundException, "Could not find a filename field in the File Upload dialog"
+end
+filename_field.send_set_text! file_path
+$upload_dialog.click_child_button_try_for!('Open', 4, :exception => WinWindow::Error.new("Failed to click the Open button on the File Upload dialog. It exists, but we couldn't click it."))

data/lib/vapir-ie/table.rb

@@ -0,0 +1,33 @@
+require 'vapir-ie/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+
+  # This class is used for dealing with tables.
+  # Normally a user would not need to create this object as it is returned by the Vapir::Container#table method
+  #
+  # many of the methods available to this object are inherited from the Element class
+  #
+  class IE::Table < IE::Element
+    include Vapir::Table
+    
+    def self.create_from_element(container, element)
+      Vapir::Table.create_from_element(container, element)
+    end
+  end
+  
+  # this class is a table body
+  class IE::TableBody < IE::Element
+    include Vapir::TBody
+  end
+    
+  class IE::TableRow < IE::Element
+    include Vapir::TableRow
+  end
+  
+  # this class is a table cell - when called via the Table object
+  class IE::TableCell < IE::Element
+    include Vapir::TableCell
+  end
+  
+end

data/lib/vapir-ie/version.rb

@@ -0,0 +1,5 @@
+module Vapir
+  class IE
+    VERSION = '1.7.0.rc1'
+  end
+end

data/lib/vapir-ie/win32ole.rb

@@ -0,0 +1,45 @@
+# load the correct version of win32ole
+
+# Use our modified win32ole library
+
+if RUBY_VERSION =~ /^1\.8/
+  $LOAD_PATH.unshift  File.expand_path(File.join(File.dirname(__FILE__), '..', 'vapir-ie', 'win32ole'))
+else
+  # loading win32ole from stdlib on 1.9
+end
+
+
+require 'win32ole'
+
+WIN32OLE.codepage = WIN32OLE::CP_UTF8
+
+# necessary extension of win32ole 
+class WIN32OLE
+  def respond_to?(method)
+    super || object_respond_to?(method)
+  end
+  
+  # checks if WIN32OLE#ole_method returns an WIN32OLE_METHOD, or errors. 
+  # WARNING: #ole_method is pretty slow, and consequently so is this. you are likely to be better
+  # off just calling a method you are not sure exists, and rescuing the WIN32OLERuntimeError
+  # that is raised if it doesn't exist. 
+  def object_respond_to?(method)
+    method=method.to_s
+    # strip assignment = from methods. going to assume that if it has a getter method, it will take assignment, too. this may not be correct, but will have to do. 
+    if method =~ /=\z/
+      method=$`
+    end
+    respond_to_cache[method]
+  end
+  
+  private
+  def respond_to_cache
+    @respond_to_cache||=Hash.new do |hash, key|
+      hash[key]=begin
+        !!self.ole_method(key)
+      rescue WIN32OLERuntimeError
+        false
+      end
+    end
+  end
+end