vapir-firefox 1.7.0.rc1

data/lib/vapir-firefox/element.rb

@@ -0,0 +1,277 @@
+require 'vapir-common/element'
+require 'vapir-firefox/container'
+
+module Vapir
+  # Base class for html elements.
+  # This is not a class that users would normally access.
+  class Firefox::Element
+    include Vapir::Firefox::Container
+    include Vapir::Element
+
+    # Creates new instance of Firefox::Element. 
+    def initialize(how, what, extra={})
+      @jssh_socket=extra[:jssh_socket]
+      @jssh_socket||= (extra[:browser].jssh_socket if extra[:browser])
+      @jssh_socket||= (extra[:container].jssh_socket if extra[:container])
+      @jssh_socket||= (what.jssh_socket if how==:element_object)
+      unless @jssh_socket
+        raise RuntimeError, "No JSSH socket given! Firefox elements need this (specified in the :jssh_socket key of the extra hash)"
+      end
+      default_initialize(how, what, extra)
+    end
+
+    attr_reader :jssh_socket
+    
+    def outer_html
+      # in case doing appendChild of self on the temp_parent_element causes it to be removed from our parentNode, we first copy the list of parentNode's childNodes (our siblings)
+      # todo/fix: can use cloneNode instead of all this? 
+      if parentNode=element_object.parentNode
+        parentNode=parentNode.store_rand_temp
+        orig_siblings=jssh_socket.object('[]').store_rand_prefix('firewatir_elements')
+        parentNode.childNodes.to_array.each do |node|
+          orig_siblings.push node
+        end
+      end
+      
+      temp_parent_element=document_object.createElement('div')
+      temp_parent_element.appendChild(element_object)
+      self_outer_html=temp_parent_element.innerHTML
+      
+      # reinsert self in parentNode's childNodes if we have disappeared due to the appendChild on different parent
+      if parentNode && parentNode.childNodes.length != orig_siblings.length
+        while parentNode.childNodes.length > 0
+          parentNode.removeChild(parentNode.childNodes[0])
+        end
+        while orig_siblings.length > 0
+          parentNode.appendChild orig_siblings.shift
+        end
+      end
+      
+      return self_outer_html
+    end
+    alias outerHTML outer_html
+    
+    # the containing object is what #locate uses to find stuff contained by this element. 
+    # this is generally the same as the dom object, but different for Browser and Frame. 
+    alias containing_object element_object
+
+#    alias ole_object element_object
+
+    private
+    def base_element_class
+      Firefox::Element
+    end
+    def browser_class
+      Firefox
+    end
+
+    public
+    def current_style_object # currentStyle is IE; document.defaultView.getComputedStyle is mozilla. 
+      document_object.defaultView.getComputedStyle(element_object, nil)
+    end
+    alias computed_style_object current_style_object
+    alias_deprecated :currentStyle, :current_style_object
+    
+    # Fires the given event on this element. 
+    # The given event name can be either of the form 'onclick' (for compatibility with IE) or just 'click' (can also be Symbol :onclick or :click)
+    # takes options:
+    # - :wait => true/false - (default true) whether to wait for the fire event to return, and call #wait (see #wait's documentation). 
+    #   if false, fires the event in a setTimeout(click function, 0) in the browser. 
+    # - :highlight => true/false - (default true) whether to highlight this Element when firing the event. 
+    #
+    # TODO: Provide ability to specify event parameters like keycode for key events, and click screen
+    #       coordinates for mouse events.
+    def fire_event(event_type, options={})
+      options={:wait => true, :highlight => true}.merge(options)
+      with_highlight(options) do
+        event=create_event_object(event_type, options)
+        if !options[:wait]
+          raise "need a content window on which to setTimeout if we are not waiting" unless content_window_object
+          fire_event_func=jssh_socket.object("(function(element_object, event){return function(){element_object.dispatchEvent(event)};})").pass(element_object, event)
+          content_window_object.setTimeout(fire_event_func, 0)
+          nil
+        else
+          result=element_object.dispatchEvent(event)
+          wait if exists?
+          result
+        end
+      end
+    end
+    
+    private
+    # for use with events' button property:
+    # https://developer.mozilla.org/en/DOM/event.button
+    MouseButtonCodes=
+      { :left => 0,
+        :middle => 1,
+        :right => 2,
+      }
+
+    # returns an object representing an event (a jssh object) 
+    def create_event_object(event_type, options)
+      event_type = event_type.to_s.downcase # in case event_type was given as a symbol
+      if event_type =~ /\Aon(.*)\z/i
+        event_type = $1
+      end
+      
+      # info about event types harvested from:
+      #   http://www.howtocreate.co.uk/tutorials/javascript/domevents
+      # the following sets up the dom event type (dom_event_type{, the function 
+      # to be called to initialize the event (init_event_func), and the arguments 
+      # to pass to that function (init_event_args). 
+      # the arguments list is an array of two-element arrays (a hash would 
+      # be more appropriate except that order needs to be preserved). only
+      # the second element is passed to the function that initializes the event;
+      # the first element is just there to identify what the argument is/does
+      # for clarity when reading this code. 
+      case event_type
+      when 'keydown', 'keypress', 'keyup'
+        dom_event_type = 'KeyEvents'
+        init_event_func=:initKeyEvent
+        init_event_args=
+          [ [:type, event_type],
+            [:bubbles, true],
+            [:cancelable, true],
+            [:windowObject, content_window_object],
+            [:ctrlKey, false],
+            [:altKey, false],
+            [:shiftKey, false],
+            [:metaKey, false],
+            [:keyCode, 0],
+            [:charCode, 0],
+          ]
+      when 'click', 'dblclick', 'mousedown', 'mousemove', 'mouseout', 'mouseover', 'mouseup'
+        dom_event_type = 'MouseEvents'
+        init_event_func = :initMouseEvent
+        client_center=self.client_center
+        init_event_args=
+          [ [:type, event_type],
+            [:bubbles, true],
+            [:cancelable, true],
+            [:windowObject, content_window_object], # aka view
+            [:detail, event_type=='dblclick' ? 2 : 1], # value is always 2 for double-click; default to 1 for other stuff. 
+            [:screenX, options[:screenX] || 0], # TODO/fix - use screen_offset (or screen_center) when implemented/exists 
+            [:screenY, options[:screenY] || 0],
+            [:clientX, options[:clientX] || client_center[0]], # by default, assume the mouse is at the center of the element 
+            [:clientY, options[:clientY] || client_center[1]],
+            [:ctrlKey, false],
+            [:altKey, false],
+            [:shiftKey, false],
+            [:metaKey, false],
+            [:button, MouseButtonCodes[options[:button] || :left]],
+            [:relatedTarget, nil],
+          ]
+      #when 'abort', 'blur', 'change', 'error', 'focus', 'load', 'reset', 'resize', 'scroll', 'select', 'submit', 'unload'
+      else
+        dom_event_type = 'HTMLEvents'
+        init_event_func=:initEvent
+        init_event_args=
+          [ [:type, event_type],
+            [:bubbles, true],
+            [:cancelable, true],
+          ]
+      end
+      event=document_object.createEvent(dom_event_type)
+      event.invoke(init_event_func, *init_event_args.map{|arg| arg.last }) # calls to the init*Event method
+      return event
+    end
+    public
+    
+    # Fires the click event on this element. 
+    #
+    # Options:
+    # - :wait => true or false. If true, waits for the javascript call to return, and calls the #wait method. 
+    #   If false, does not wait for the javascript to return and does not call #wait.
+    #   Default is true.
+    # - :highlight => true or false. Highlights the element while clicking if true. Default is true. 
+    def click(options={})
+      options={:wait => true, :highlight => true}.merge(options)
+      result=nil
+      with_highlight(options) do
+        assert_enabled if respond_to?(:assert_enabled)
+        if options[:wait]
+          [:mousedown, :mouseup, :click].each do |event_type|
+            # javascript stuff responding to previous events can cause self to stop existing, so check at every subsequent step
+            if exists?
+              result=fire_event(event_type, options)
+            else
+              return result
+            end
+          end
+          wait
+        else
+          mouse_down_event=create_event_object('mousedown', options)
+          mouse_up_event=create_event_object('mouseup', options)
+          click_event=create_event_object('click', options)
+          click_func=jssh_socket.object("(function(element_object, mouse_down_event, mouse_up_event, click_event)
+          { return function()
+            { element_object.dispatchEvent(mouse_down_event);
+              element_object.dispatchEvent(mouse_up_event);
+              element_object.dispatchEvent(click_event);
+            };
+          })").pass(element_object, mouse_down_event, mouse_up_event, click_event)
+          content_window_object.setTimeout(click_func, 0)
+        end
+      end
+      result
+    end
+
+    # calls #click with :wait option false. 
+    # Takes options:
+    # - :highlight => true or false. Highlights the element while clicking if true. Default is true. 
+    def click_no_wait(options={})
+      click(options.merge(:wait => false))
+    end
+  
+    # Waits for the browser to finish loading, if it is loading. See Firefox#wait. 
+    def wait(options={})
+      @container.wait(options)
+    end
+
+    def self.element_object_style(element_object, document_object)
+      if element_object.nodeType==1 #element_object.instanceof(element_object.jssh_socket.Components.interfaces.nsIDOMDocument)
+        document_object.defaultView.getComputedStyle(element_object, nil)
+      else
+        nil
+      end
+    end
+
+    # Returns the text content of the element.
+    dom_attr :textContent => :text
+    
+    private
+    def element_object_exists?
+#      parent=@element_object
+#      while true
+#        return false unless parent # if we encounter a parent such that parentNode is nil, we aren't on the document. 
+#        return true if parent==document_object # if we encounter the document as a parent, we are on the document. 
+#        new_parent=parent.parentNode
+#        raise(RuntimeError, "Circular reference in parents!") if new_parent==parent
+#        parent=new_parent
+#      end
+      # above is horrendously slow; optimized below. 
+      return false unless @element_object
+      return jssh_socket.object("(function(parent, document_object)
+      { while(true)
+        { if(!parent)
+          { return false;
+          }
+          if(parent==document_object)
+          { return true;
+          }
+          parent=parent.parentNode;
+        }
+      })").call(@element_object, container.document_object) # use the container's document so that frames look at their parent document, not their own document 
+    end
+  
+#    def invoke(js_method)
+#      element_object.invoke(js_method)
+#    end
+
+#    def assign(property, value)
+#      locate
+#      element_object.attr(property).assign(value)
+#    end
+    
+  end # Element
+end # Vapir

data/lib/vapir-firefox/elements/button.rb

@@ -0,0 +1,21 @@
+require 'vapir-firefox/elements/input_element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  #
+  # Description:
+  #   Class for Button element.
+  #
+  class Firefox::Button < Firefox::InputElement
+    include Vapir::Button
+    
+    # locating should check both of these values if :caption is specified because, unlike IE,
+    # ff doesn't make the value of a button be its text content when there's no value. 
+    # likewise, the #caption method should pick whatever's not blank. 
+    dom_attr_locate_alias :value, :caption
+    dom_attr_locate_alias :textContent, :caption
+    def caption
+      value.empty? ? text : value
+    end
+  end # Button
+end # Vapir

data/lib/vapir-firefox/elements/file_field.rb

@@ -0,0 +1,27 @@
+require 'vapir-firefox/elements/input_element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  #
+  # Description:
+  #   Class for FileField element.
+  #
+  class Firefox::FileField < Firefox::InputElement
+    include Vapir::FileField
+
+    #
+    # Description:
+    #   Sets the path of the file in the textbox.
+    #
+    # Input:
+    #   path - Path of the file.
+    #
+    def set(path)
+      assert_exists do
+        element_object.value=path
+        fire_event("onChange")
+      end
+    end
+
+  end # FileField
+end # Vapir

data/lib/vapir-firefox/elements/form.rb

@@ -0,0 +1,8 @@
+require 'vapir-firefox/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  class Firefox::Form < Firefox::Element
+    include Vapir::Form
+  end # Form
+end # Vapir

data/lib/vapir-firefox/elements/frame.rb

@@ -0,0 +1,23 @@
+require 'vapir-firefox/element'
+require 'vapir-common/elements/elements'
+require 'vapir-firefox/page_container'
+
+module Vapir
+  class Firefox::Frame < Firefox::Element
+    include Vapir::Frame
+    include Firefox::PageContainer
+
+    def document_object
+      unless @element_object
+        # don't use element_object because it does assert_exists, and don't assert_exists
+        # unless @element_object isn't defined at all, because element_object_exists? uses
+        # the document_object, so that would infinite loop. 
+        locate!
+      end
+      @element_object.contentDocument # OR content_window_object.document
+    end
+    def content_window_object
+      element_object.contentWindow
+    end
+  end # Frame
+end # Vapir

data/lib/vapir-firefox/elements/hidden.rb

@@ -0,0 +1,12 @@
+require 'vapir-firefox/elements/text_field'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  #
+  # Description:
+  #   Class for Hidden Field element.
+  #
+  class Firefox::Hidden < Firefox::TextField
+    include Vapir::Hidden
+  end # Hidden
+end # Vapir

data/lib/vapir-firefox/elements/image.rb

@@ -0,0 +1,38 @@
+require 'vapir-firefox/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  #
+  # Description:
+  #   Class for Image element.
+  #
+  class Firefox::Image < Firefox::Element
+    include Vapir::Image
+
+    # this method returns the file created date of the image
+    #def file_created_date
+    #    assert_exists
+    #    return @o.invoke("fileCreatedDate")
+    #end
+    # alias fileCreatedDate file_created_date
+
+    # this method returns the filesize of the image
+    #def file_size
+    #    assert_exists
+    #    return @o.invoke("fileSize")
+    #end
+    # alias fileSize file_size
+
+    # This method attempts to find out if the image was actually loaded by the web browser.
+    # If the image was not loaded, the browser is unable to determine some of the properties.
+    # We look for these missing properties to see if the image is really there or not.
+    # If the Disk cache is full ( tools menu -> Internet options -> Temporary Internet Files) , it may produce incorrect responses.
+    #def has_loaded
+    #    locate
+    #    raise UnknownObjectException, "Unable to locate image using #{@how} and #{@what}" if @o == nil
+    #    return false if @o.fileCreatedDate == "" and  @o.fileSize.to_i == -1
+    #    return true
+    #end
+    # alias hasLoaded? loaded?
+  end # Image
+end # Vapir

data/lib/vapir-firefox/elements/input_element.rb

@@ -0,0 +1,12 @@
+require 'vapir-firefox/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  #
+  # Description:
+  #   Base class containing items that are common between select list, text field, button, hidden, file field classes.
+  #
+  class Firefox::InputElement < Firefox::Element
+    include Vapir::InputElement
+  end # Vapir
+end # InputElement

data/lib/vapir-firefox/elements/link.rb

@@ -0,0 +1,30 @@
+require 'vapir-firefox/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  #
+  # Description:
+  #   Class for Link element.
+  #
+  class Firefox::Link < Firefox::Element
+    include Vapir::Link
+
+    #TODO: 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
+
+    #TODO: 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
+
+  end # Link
+end # Vapir

data/lib/vapir-firefox/elements/non_control_elements.rb

@@ -0,0 +1,89 @@
+require 'vapir-firefox/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  class Firefox::Pre < Firefox::Element
+    include Vapir::Pre
+  end
+
+  class Firefox::P < Firefox::Element
+    include Vapir::P
+  end
+
+  class Firefox::Div < Firefox::Element
+    include Vapir::Div
+  end
+
+  class Firefox::Span < Firefox::Element
+    include Vapir::Span
+  end
+
+  class Firefox::Strong < Firefox::Element
+    include Vapir::Strong
+  end
+
+  class Firefox::Label < Firefox::Element
+    include Vapir::Label
+  end
+
+  class Firefox::Ul < Firefox::Element
+    include Vapir::Ul
+  end
+
+  class Firefox::Ol < Firefox::Element
+    include Vapir::Ol
+  end
+
+  class Firefox::Li < Firefox::Element
+    include Vapir::Li
+  end
+
+  class Firefox::Dl < Firefox::Element
+    include Vapir::Dl
+  end
+
+  class Firefox::Dt < Firefox::Element
+    include Vapir::Dt
+  end
+
+  class Firefox::Dd < Firefox::Element
+    include Vapir::Dd
+  end
+
+  class Firefox::H1 < Firefox::Element
+    include Vapir::H1
+  end
+
+  class Firefox::H2 < Firefox::Element
+    include Vapir::H2
+  end
+
+  class Firefox::H3 < Firefox::Element
+    include Vapir::H3
+  end
+
+  class Firefox::H4 < Firefox::Element
+    include Vapir::H4
+  end
+
+  class Firefox::H5 < Firefox::Element
+    include Vapir::H5
+  end
+
+  class Firefox::H6 < Firefox::Element
+    include Vapir::H6
+  end
+
+  class Firefox::Map < Firefox::Element
+    include Vapir::Map
+  end
+
+  class Firefox::Area < Firefox::Element
+    include Vapir::Area
+  end
+
+  class Firefox::Em < Firefox::Element
+    include Vapir::Em
+  end
+
+end # Vapir

data/lib/vapir-firefox/elements/option.rb

@@ -0,0 +1,12 @@
+require 'vapir-firefox/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  #
+  # Description:
+  #   Class for Option element.
+  #
+  class Firefox::Option < Firefox::Element
+    include Vapir::Option
+  end # Option
+end # Vapir

data/lib/vapir-firefox/elements/radio_check_common.rb

@@ -0,0 +1,36 @@
+require 'vapir-firefox/elements/input_element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  module Firefox::RadioCheckboxCommon
+    private
+    # radios in firefox seem to be totally unresponsive to css color and border, but
+    # they can change size, so use that for the highlight method. 
+    # see http://www.456bereastreet.com/lab/styling-form-controls-revisited/radio-button/
+    def set_highlight(options={})
+      assert_exists do
+        @original_height=element_object.offsetHeight
+        @original_width=element_object.offsetWidth
+        element_object.style.height=@original_height+3
+        element_object.style.width=@original_width+3
+      end
+    end
+    def clear_highlight(options={})
+      element_object.style.height=@original_height
+      element_object.style.width=@original_width
+    end
+  end
+  class Firefox::Radio < Firefox::InputElement
+    include Vapir::Radio
+    include Firefox::RadioCheckboxCommon
+  end # Radio
+
+  #
+  # Description:
+  # Class for Checkbox element.
+  #
+  class Firefox::CheckBox < Firefox::InputElement
+    include Vapir::CheckBox
+    include Firefox::RadioCheckboxCommon
+  end # CheckBox
+end # Vapir

data/lib/vapir-firefox/elements/select_list.rb

@@ -0,0 +1,12 @@
+require 'vapir-firefox/elements/input_element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  #
+  # Description:
+  #   Class for SelectList element.
+  #
+  class Firefox::SelectList < Firefox::InputElement
+    include Vapir::SelectList
+  end # SelectList
+end # Vapir

data/lib/vapir-firefox/elements/table.rb

@@ -0,0 +1,16 @@
+require 'vapir-firefox/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  class Firefox::Table < Firefox::Element
+    include Vapir::Table
+
+    def self.create_from_element(container, element)
+      Vapir::Table.create_from_element(container, element)
+    end
+  end # Table
+
+  class Firefox::TBody < Firefox::Element
+    include Vapir::TBody
+  end
+end # Vapir

data/lib/vapir-firefox/elements/table_cell.rb

@@ -0,0 +1,12 @@
+require 'vapir-firefox/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  #
+  # Description:
+  # Class for Table Cell.
+  #
+  class Firefox::TableCell < Firefox::Element
+    include Vapir::TableCell
+  end # TableCell
+end # Vapir

data/lib/vapir-firefox/elements/table_row.rb

@@ -0,0 +1,12 @@
+require 'vapir-firefox/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  #
+  # Description:
+  # Class for Table row element.
+  #
+  class Firefox::TableRow < Firefox::Element
+    include Vapir::TableRow
+  end # TableRow
+end # Vapir