celerity 0.0.4 → 0.0.6

data/lib/celerity/element_locator.rb

@@ -1,33 +1,46 @@
 module Celerity
-  
+
+  #
   # Used internally to locate elements on the page.
+  # 
+  
   class ElementLocator
     include Celerity::Exception
     attr_accessor :idents
-    
-    
-    def initialize(object, element_class)
-      @object = object
+
+
+    def initialize(container, element_class)
+      container.assert_exists
+
+      @container     = container
+      @object        = container.object
       @element_class = element_class
-      @attributes = @element_class::ATTRIBUTES # could check for 'strict' here?
-      @idents = @element_class::TAGS
-      @tags = @idents.map { |e| e.tag.downcase }
+      @attributes    = @element_class::ATTRIBUTES # could check for 'strict' here?
+      @idents        = @element_class::TAGS
+      @tags          = @idents.map { |e| e.tag.downcase }
     end
 
-    def find_by_conditions(conditions)
+    def find_by_conditions(conditions) # TODO: refactor without performance hit
+      return nil unless @object # probably means we're on a TextPage (content-type is "text/plain")
+
       @condition_idents = []
       attributes = Hash.new { |h, k| h[k] = [] }
       index = 0 # by default, return the first matching element
-      text = nil 
-      
+      text = nil
+
       conditions.each do |how, what|
         case how
         when :object
+          unless what.is_a?(HtmlUnit::Html::HtmlElement) || what.nil?
+            raise ArgumentError, "expected an HtmlUnit::Html::HtmlElement subclass, got #{what.inspect}:#{what.class}"
+          end
           return what
         when :id
           return find_by_id(what)
         when :xpath
           return find_by_xpath(what)
+        when :label
+          return find_by_label(what) unless @attributes.include?(:label)
         when :class_name
           how = :class
         when :url
@@ -35,30 +48,25 @@ module Celerity
         when :caption
           how = :text
         end
-      
-        if @attributes.include?(how)
-          attributes[how] << what  
+
+        if @attributes.include?(how = how.to_sym)
+          attributes[how] << what
         elsif how == :index
-          index = what.to_i - 1
+          index = what.to_i - INDEX_OFFSET
         elsif how == :text
           text = what
         else
           raise MissingWayOfFindingObjectException, "No how #{how.inspect}"
         end
-
       end
 
       @idents.each do |ident|
-        merged = attributes.merge(ident.attributes) do |key, v1, v2|
-          v1 | v2
-        end
-          
+        merged = attributes.merge(ident.attributes) { |key, v1, v2| v1 | v2 }
         id = Identifier.new(ident.tag, merged)
-        # «original» identifier takes precedence for :text
-        id.text = ident.text || text
+        id.text = ident.text || text # «original» identifier takes precedence for :text
         @condition_idents << id
       end
-      
+
       if index == 0
         element_by_idents(@condition_idents)
       else
@@ -68,80 +76,95 @@ module Celerity
     rescue HtmlUnit::ElementNotFoundException
       nil # for rcov
     end
-    
+
     def find_by_id(what)
       case what
       when Regexp
-        elements_by_tag_names.find { |elem| elem.getIdAttribute =~ what }
+        elements_by_tag_names.find { |elem| elem.getId =~ what }
       when String
         obj = @object.getHtmlElementById(what)
-        if @tags.include?(obj.getTagName)
-          obj
-        else
-          $stderr.puts "warning: multiple elements with identical id (#{what.inspect})? " if $VERBOSE
-          elements_by_tag_names.find { |elem| elem.getIdAttribute == what }
-        end
+        return obj if @tags.include?(obj.getTagName)
+
+        $stderr.puts "warning: multiple elements with identical id? (#{what.inspect})" if $VERBOSE
+        elements_by_tag_names.find { |elem| elem.getId == what }
       else
-        raise ArgumentError, "Argument #{what.inspect} should be a String or Regexp"
+        raise TypeError, "expected String or Regexp, got #{what.inspect}:#{what.class}"
       end
     end
-    
+
     def find_by_xpath(what)
-      what = ".#{what}" if what[0] == ?/
+      what = ".#{what}" if what[0].chr == "/"
       @object.getByXPath(what).to_a.first
     end
 
+    def find_by_label(what)
+      obj = elements_by_tag_names(%w[label]).find { |e| matches?(e.asText, what) }
+
+      return nil unless obj && (ref = obj.getReferencedElement)
+      return ref if @tags.include?(ref.getTagName)
+
+      find_by_id obj.getForAttribute
+    end
+
     def elements_by_idents(idents = nil)
       get_by_idents(:select, idents || @idents)
     end
-    
+
     def element_by_idents(idents = nil)
       get_by_idents(:find, idents || @idents)
     end
 
-    private 
+    private
 
     def get_by_idents(meth, idents)
-      @object.getAllHtmlChildElements.iterator.to_a.send(meth) do |e|
-        if @tags.include?(e.getTagName)
-          idents.any? do |ident|
-            next unless ident.tag == e.getTagName
-            
-            attr_result = ident.attributes.all? do |key, value| 
-              value.any? { |val| matches?(e.getAttributeValue(key.to_s), val) } 
-            end 
-            
-            if ident.text
-              attr_result && matches?(e.asText, ident.text) 
-            else
-              attr_result
-            end
-          end
+      with_nullpointer_retry do
+        @object.getAllHtmlChildElements.send(meth) do |e|
+          next unless @tags.include?(e.getTagName)
+          idents.any? { |id| element_matches_ident?(e, id) }
         end
       end
     end
 
-    def matches?(string, what)
-      Regexp === what ? string.match(what) : string == what.to_s
-    end
+    def element_matches_ident?(element, ident)
+      return false unless ident.tag == element.getTagName
 
-    def elements_by_tag_names
-      tries = 0
-      # HtmlUnit's getHtmlElementsByTagNames won't get elements in the correct order, making :index fail
-      @object.getAllHtmlChildElements.iterator.to_a.select do |elem|
-        @tags.include?(elem.getTagName)
+      attr_result = ident.attributes.all? do |key, values|
+        values.any? { |val| matches?(element.getAttributeValue(key.to_s), val) }
       end
-    # workaround for HtmlUnit bug?
-    rescue java.lang.NullPointerException => e
-      $stderr.puts "warning: celerity caught #{e}"
-      if tries < 2
-        tries += 1
-        retry
+
+      if ident.text
+        attr_result && matches?(element.asText.strip, ident.text)
       else
-        raise e
+        attr_result
+      end
+    end
+
+    def elements_by_tag_names(tags = @tags)
+      with_nullpointer_retry do
+        # HtmlUnit's getHtmlElementsByTagNames won't get elements in the correct
+        # order (making :index fail), so we're using getAllHtmlChildElements instead.
+        @object.getAllHtmlChildElements.select do |elem|
+          tags.include?(elem.getTagName)
+        end
       end
     end
 
+    # HtmlUnit throws NPEs sometimes when we're locating elements
+    # Retry seems to work fine.
+    def with_nullpointer_retry(max_retries = 3)
+      tries = 0
+      yield
+    rescue java.lang.NullPointerException => e
+      raise e if tries >= max_retries
+
+      tries += 1
+      $stderr.puts "warning: celerity caught #{e} - retry ##{tries}"
+      retry
+    end
+
+    def matches?(string, what)
+      Regexp === what ? string.strip =~ what : string == what.to_s
+    end
 
   end # ElementLocator
 end # Celerity

data/lib/celerity/elements/button.rb

@@ -1,25 +1,36 @@
 module Celerity
-  # 
+  
+  #
   # Input: Button
   #
   # Class representing button elements
   #
+  
   class Button < InputElement
-    TAGS = [ Identifier.new('button'), 
-             Identifier.new('input', :type => %w(submit reset image button)) ]
-    # A little wierd attribute list due to button being both <button> and <input type="submit|reset|image|button" />
+    TAGS = [ Identifier.new('button'),
+             Identifier.new('input', :type => %w[submit reset image button]) ]
+             
+    # Attribute list is a little weird due to this class covering both <button>
+    # and <input type="submit|reset|image|button" />
     ATTRIBUTES = BASE_ATTRIBUTES | [:type, :disabled, :tabindex, :accesskey, :onfocus, :onblur] | [:src, :usemap, :ismap]
     DEFAULT_HOW = :value
 
+    #
+    # @api private
+    #
+    
     def locate
-      # ugly..
-      # this is done to make <button> and <input>-buttons look similar
+      # We want the :value attribute to point to the inner HTML for <button> elements, 
+      # and to the value attribute for <input type="button"> elements. 
+      
       if (val = @conditions[:value])
-        locator = ElementLocator.new(@container.object, self.class)
-        button_ident = Identifier.new('button')
+        button_ident      = Identifier.new('button')
         button_ident.text = val
-        input_ident = Identifier.new('input', :type => %w(submit reset image button), :value => [val])
+        input_ident       = Identifier.new('input', :type => %w[submit reset image button], :value => [val])
+        
+        locator        = ElementLocator.new(@container, self.class)
         locator.idents = [button_ident, input_ident]
+        
         conditions = @conditions.dup
         conditions.delete(:value)
         @object = locator.find_by_conditions(conditions)
@@ -27,7 +38,6 @@ module Celerity
         super
       end
     end
-    
-  end
-  
-end
+
+  end # Button
+end # Celerity

data/lib/celerity/elements/file_field.rb

@@ -1,13 +1,25 @@
 module Celerity
+  
+  #
   # For fields that accept file uploads
+  #
+
   class FileField < InputElement
-    TAGS = [ Identifier.new('input', :type => %w(file)) ]
+    TAGS = [ Identifier.new('input', :type => %w[file]) ]
     DEFAULT_HOW = :name
-  
+
+    #
     # Set the file field to the given path
+    # 
+
     def set(path)
       assert_exists
-      @object.setValueAttribute(path.to_s)
+      path = path.to_s
+      @container.update_page @object.setValueAttribute(path)
+      unless @object.getContentType
+        @object.setContentType(Celerity::Util.content_type_for(path))
+      end
     end
-  end
-end
+    
+  end # FileField
+end # Celerity

data/lib/celerity/elements/form.rb

@@ -1,16 +1,21 @@
-module Celerity
-  class Form < Element
-    include Container
-    TAGS = [Identifier.new('form')]
-    # HTML 4.01 Transitional DTD
-    ATTRIBUTES = BASE_ATTRIBUTES | [:action, :method, :enctype, :accept, :name, :onsubmit, :onreset, :target, :'accept-charset']
-    DEFAULT_HOW = :name
-  
-    # Submits the form.
-    def submit
-      assert_exists
-      @container.update_page @object.submit(nil)
-    end
-
-  end  
-end
+module Celerity
+  class Form < Element
+    include Container
+    
+    TAGS = [Identifier.new('form')]
+    
+    # HTML 4.01 Transitional DTD
+    ATTRIBUTES = BASE_ATTRIBUTES | [:action, :method, :enctype, :accept, :name, :onsubmit, :onreset, :target, :'accept-charset']
+    DEFAULT_HOW = :name
+
+    #
+    # Submits the form.
+    # 
+    
+    def submit
+      assert_exists
+      @container.update_page @object.submit(nil)
+    end
+
+  end # Form
+end # Celerity

data/lib/celerity/elements/frame.rb

@@ -1,53 +1,75 @@
-module Celerity
-  class Frame < Element
-    include Container
-    attr_accessor :page
-    
-    TAGS = [Identifier.new('frame'), Identifier.new('iframe')]
-    ATTRIBUTES = BASE_ATTRIBUTES | [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :noresize, :scrolling]
-    DEFAULT_HOW = :name
-    
-    # Override the default locate to handle frame and inline frames.
-    # @api internal
-    def locate
-      super
-      if @object
-        @inline_frame_object = @object.getEnclosedWindow.getFrameElement
-        if (frame = @object.getEnclosedPage.getDocumentElement)
-          @object = frame
-        end
-      end
-    end
-    
-    # Override assert_exists to raise UnknownFrameException (for Watir compatibility)
-    # @api internal
-    def assert_exists
-      locate unless @object
-      unless @object
-        raise UnknownFrameException, "unable to locate frame, using #{identifier_string}"
-      end
-    end
-    
-    def update_page(value)
-      @page_container.page = value.getEnclosingWindow.getTopWindow.getEnclosedPage
-    end
-
-    def to_s
-      assert_exists
-      create_string(@inline_frame_object)
-    end
-    
-    def method_missing(meth, *args, &blk)
-      meth = selector_to_attribute(meth)
-      if self.class::ATTRIBUTES.include?(meth)
-        assert_exists
-        @inline_frame_object.getAttributeValue(meth.to_s)
-      else
-        Log.warn "Element\#method_missing calling super with #{meth.inspect}"
-        super
-      end
-    end
-    
-  end
-
-end
+module Celerity
+  class Frame < Element
+    include Container
+    attr_accessor :page
+
+    TAGS = [Identifier.new('frame'), Identifier.new('iframe')]
+    ATTRIBUTES = BASE_ATTRIBUTES | [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :noresize, :scrolling]
+    DEFAULT_HOW = :name
+
+    #
+    # Override the default locate to handle frame and inline frames.
+    # @api private
+    # 
+
+    def locate
+      super
+      if @object
+        @inline_frame_object = @object.getEnclosedWindow.getFrameElement
+        self.page            = @object.getEnclosedPage
+        if (frame = self.page.getDocumentElement)
+          @object = frame
+        end
+      end
+    end
+    
+    #
+    # Override assert_exists to raise UnknownFrameException (for Watir compatibility)
+    # @api private
+    #
+
+    def assert_exists
+      locate
+      unless @object
+        raise UnknownFrameException, "unable to locate frame, using #{identifier_string}"
+      end
+    end
+
+    #
+    # Executes the given JavaScript string in this frame. (Celerity only)
+    #
+
+    def execute_script(source)
+      assert_exists
+      @page.executeJavaScript(source.to_s).getJavaScriptResult
+    end
+
+    #
+    # Updates the brwoser page with the page from this frame's top window.
+    # Used internally.
+    #
+    # @api private
+    #
+
+    def update_page(value)
+      @browser.page = value.getEnclosingWindow.getTopWindow.getEnclosedPage
+    end
+
+    def to_s
+      assert_exists
+      create_string(@inline_frame_object)
+    end
+
+    def method_missing(meth, *args, &blk)
+      meth = selector_to_attribute(meth)
+      if self.class::ATTRIBUTES.include?(meth)
+        assert_exists
+        @inline_frame_object.getAttributeValue(meth.to_s)
+      else
+        Log.warn "Element\#method_missing calling super with #{meth.inspect}"
+        super
+      end
+    end
+
+  end # Frame
+end # Celerity