vapir-firefox 1.7.2 → 1.8.0

data/lib/vapir-firefox/clear_tracks.rb

@@ -0,0 +1,50 @@
+require 'vapir-firefox/browser.rb'
+
+module Vapir
+  class Firefox
+    module ClearTracksMethods
+      #--
+      #
+      # currently defined sanitizer items are: 
+      #  ["cache", "cookies", "offlineApps", "history", "formdata", "downloads", "passwords", "sessions", "siteSettings"]
+      def sanitizer # :nodoc:
+        @@sanitizer ||= begin
+          sanitizer_class = jssh_socket.object('Sanitizer')
+          if sanitizer_class.type=='undefined'
+            loader = jssh_socket.Components.classes["@mozilla.org/moz/jssubscript-loader;1"].getService(jssh_socket.Components.interfaces.mozIJSSubScriptLoader)
+            loader.loadSubScript("chrome://browser/content/sanitize.js")
+            sanitizer_class = jssh_socket.object('Sanitizer')
+          end 
+          sanitizer_class.new
+        end
+      end
+      # 
+      def clear_history
+        sanitizer.items.history.clear()
+      end
+      def clear_cookies
+        sanitizer.items.cookies.clear()
+        #cookie_manager = jssh_socket.Components.classes["@mozilla.org/cookiemanager;1"].getService(jssh_socket.Components.interfaces.nsICookieManager)
+        #cookie_manager.removeAll()
+      end
+      def clear_cache
+        sanitizer.items.cache.clear
+      end
+      alias clear_temporary_files clear_cache
+      def clear_all_tracks
+        sanitizer.items.to_hash.inject({}) do |hash, (key, item)|
+          # don't try to clear siteSettings; sometimes siteSettings.clear() raises 
+          # an error which jssh doesn't handle properly - it somehow bypasses the 
+          # try/catch block and shows up on the socket outside of the returned value. 
+          # jssh bug? 
+          if key!='siteSettings' && hash[key].canClear 
+            hash[key]=(item.clear() rescue $!)
+          end
+          hash
+        end
+      end
+    end
+    include ClearTracksMethods
+    extend ClearTracksMethods
+  end
+end

data/lib/vapir-firefox/config.rb

@@ -0,0 +1,17 @@
+require 'vapir-common/config'
+require 'vapir-firefox' # need the class to be set first
+
+module Vapir
+  # if vapir-firefox is required before any other browser-specific library, then set the default browser to firefox 
+  @base_configuration.default_browser = :firefox unless @base_configuration.locally_defined_key?(:default_browser)
+
+  # add firefox-specific stuff to base, and then bring them in from env and yaml 
+  @base_configuration.create(:firefox_profile)
+  @base_configuration.create(:firefox_binary_path)
+  @base_configuration.create_update(:firefox_quit_sleep_time, 4, :validator => :numeric)
+  @configurations.update_from_source
+  class Firefox
+    @configuration_parent = Vapir.config
+    extend Configurable
+  end
+end

data/lib/vapir-firefox/container.rb

@@ -44,7 +44,7 @@ module Vapir
     include Vapir::Container
     
     def extra_for_contained
-      default_extra_for_contained.merge(:jssh_socket => jssh_socket)
+      base_extra_for_contained.merge(:jssh_socket => jssh_socket)
     end
 
     public
@@ -79,5 +79,71 @@ module Vapir
         base_element_class.factory(element_object, extra_for_contained)
       end
     end
+
+    # returns a JsshObject representing an array (in javascript) of the visible text nodes of this container. same as
+    # the Vapir::Common #visible_text_nodes implementation, but much much faster. 
+    def visible_text_nodes
+      text_nodes = jssh_socket.call_function(:element_object => containing_object, :document_object => document_object) do %Q(
+          var Ycomb = function(gen){ return function(f){ return f(f); }(function(f){ return gen(function(){ return f(f).apply(null, arguments); }); }); }; // TODO: move this somewhere better - jssh_socket? 
+          var recurse_text_nodes = Ycomb(function(recurse)
+          { return function(node, parent_visibility)
+            { if(node.nodeType==1 || node.nodeType==9)
+              { var style = node.nodeType==1 ? document_object.defaultView.getComputedStyle(node, null) : null;
+                var our_visibility = style && style.visibility;
+                if(!(our_visibility && $A(['hidden', 'collapse', 'visible']).include(our_visibility.toLowerCase())))
+                { our_visibility = parent_visibility;
+                }
+                var display = style && style.display;
+                if(display && display.toLowerCase()=='none')
+                { return [];
+                }
+                else
+                { return $A(node.childNodes).inject([], function(result, child_node)
+                  { return result.concat(recurse(child_node, our_visibility));
+                  });
+                }
+              }
+              else if(node.nodeType==3)
+              { if(parent_visibility && $A(['hidden', 'collapse']).include(parent_visibility.toLowerCase()))
+                { return [];
+                }
+                else
+                { return [node.data];
+                }
+              }
+              else
+              { return [];
+              }
+            };
+          });
+          var element_to_check = element_object;
+          var real_visibility = null;
+          while(element_to_check)
+          { var style = element_to_check.nodeType==1 ? document_object.defaultView.getComputedStyle(element_object, null) : null;
+            if(style)
+            { // only pay attention to the innermost definition that really defines visibility - one of 'hidden', 'collapse' (only for table elements), 
+              // or 'visible'. ignore 'inherit'; keep looking upward. 
+              // this makes it so that if we encounter an explicit 'visible', we don't pay attention to any 'hidden' further up. 
+              // this style is inherited - may be pointless for firefox, but IE uses the 'inherited' value. not sure if/when ff does.
+              if(real_visibility==null && (visibility=style.visibility))
+              { var visibility=visibility.toLowerCase();
+                if($A(['hidden', 'collapse', 'visible']).include(visibility))
+                { real_visibility=visibility;
+                }
+              }
+              // check for display property. this is not inherited, and a parent with display of 'none' overrides an immediate visibility='visible' 
+              var display=style.display;
+              if(display && (display=display.toLowerCase())=='none')
+              { // if display is none, then this element is not visible, and thus has no visible text nodes underneath. 
+                return [];
+              }
+            }
+            element_to_check=element_to_check.parentNode;
+          }
+          return recurse_text_nodes(element_object, real_visibility);
+      )
+      end.to_array
+    end
+
   end
 end # module 

data/lib/vapir-firefox/element.rb

@@ -23,15 +23,10 @@ module Vapir
     attr_reader :jssh_socket
     
     def outer_html
-orig_siblings_length = (parentNode = element_object.parentNode) && parentNode.childNodes.length
-      
       temp_parent_element=document_object.createElement('div')
       temp_parent_element.appendChild(element_object.cloneNode(true))
       self_outer_html=temp_parent_element.innerHTML
       
-new_siblings_length = (parentNode = element_object.parentNode) && parentNode.childNodes.length
-#debug code:
-raise "the parent somehow changed - had #{orig_siblings_length} children; now has #{new_siblings_length}" unless orig_siblings_length==new_siblings_length
       return self_outer_html
     end
     alias outerHTML outer_html
@@ -70,8 +65,7 @@ raise "the parent somehow changed - had #{orig_siblings_length} children; now ha
         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)
+          content_window_object.setTimeout(jssh_socket.call_function(:element_object => element_object, :event => event){ "return function(){ element_object.dispatchEvent(event) };" }, 0)
           nil
         else
           result=element_object.dispatchEvent(event)
@@ -116,12 +110,12 @@ raise "the parent somehow changed - had #{orig_siblings_length} children; now ha
             [:bubbles, true],
             [:cancelable, true],
             [:windowObject, content_window_object],
-            [:ctrlKey, false],
-            [:altKey, false],
-            [:shiftKey, false],
-            [:metaKey, false],
-            [:keyCode, 0],
-            [:charCode, 0],
+            [:ctrlKey, options[:ctrlKey] || false],
+            [:altKey, options[:altKey] || false],
+            [:shiftKey, options[:shiftKey] || false],
+            [:metaKey, options[:metaKey] || false],
+            [:keyCode, options[:keyCode] || 0],
+            [:charCode, options[:charCode] || 0],
           ]
       when 'click', 'dblclick', 'mousedown', 'mousemove', 'mouseout', 'mouseover', 'mouseup'
         dom_event_type = 'MouseEvents'
@@ -137,10 +131,10 @@ raise "the parent somehow changed - had #{orig_siblings_length} children; now ha
             [: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],
+            [:ctrlKey, options[:ctrlKey] || false],
+            [:altKey, options[:altKey] || false],
+            [:shiftKey, options[:shiftKey] || false],
+            [:metaKey, options[:metaKey] || false],
             [:button, MouseButtonCodes[options[:button] || :left]],
             [:relatedTarget, nil],
           ]
@@ -186,14 +180,13 @@ raise "the parent somehow changed - had #{orig_siblings_length} children; now ha
           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()
+          content_window_object.setTimeout(jssh_socket.call_function(:element_object => element_object, :mouse_down_event => mouse_down_event, :mouse_up_event => mouse_up_event, :click_event => click_event) do 
+          " 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, 0)
         end
       end
       result
@@ -205,11 +198,51 @@ raise "the parent somehow changed - had #{orig_siblings_length} children; now ha
     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
+    
+    # Checks this element and its parents for display: none or visibility: hidden, these are 
+    # the most common methods to hide an html element. Returns false if this seems to be hidden
+    # or a parent is hidden. 
+    def visible? 
+      assert_exists do
+        jssh_socket.call_function(:element_to_check => element_object, :document_object => document_object) do %Q(
+          var really_visible=null;
+          while(element_to_check) //&& !(element_to_check instanceof Components.interfaces.nsIDOMDocument)
+          { var style = element_to_check.nodeType==1 ? document_object.defaultView.getComputedStyle(element_to_check, null) : null;
+            if(style)
+            { // only pay attention to the innermost definition that really defines visibility - one of 'hidden', 'collapse' (only for table elements), 
+              // or 'visible'. ignore 'inherit'; keep looking upward. 
+              // this makes it so that if we encounter an explicit 'visible', we don't pay attention to any 'hidden' further up. 
+              // this style is inherited - may be pointless for firefox, but IE uses the 'inherited' value. not sure if/when ff does.
+              var visibility=style && style.visibility;
+              if(really_visible==null && visibility)
+              { visibility=visibility.toLowerCase();
+                if(visibility=='hidden' || visibility=='collapse')
+                { really_visible=false;
+                  return false; // don't need to continue knowing it's not visible. 
+                }
+                else if(visibility=='visible')
+                { really_visible=true; // we don't return true yet because a parent with display of 'none' can override 
+                }
+              }
+              // check for display property. this is not inherited, and a parent with display of 'none' overrides an immediate visibility='visible' 
+              var display=style && style.display;
+              if(display && display.toLowerCase()=='none')
+              { return false;
+              }
+            }
+            element_to_check=element_to_check.parentNode;
+          }
+          return true;
+        )
+        end
+      end
+    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)
@@ -224,27 +257,18 @@ raise "the parent somehow changed - had #{orig_siblings_length} children; now ha
     
     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)
+      return jssh_socket.call_function(:parent => @element_object, :document_object => container.document_object) do  # use the container's document so that frames look at their parent document, not their own document
+      " while(true)
         { if(!parent)
-          { return false;
+          { return false; // if we encounter a parent such that parentNode is nil, we aren't on the document. 
           }
-          if(parent==document_object)
+          if(parent==document_object) // if we encounter the document as a parent, we are on the document. 
           { 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
     end
   
   end # Element