walidhalabi-celerity 0.0.6.11

data/lib/celerity/element_locator.rb

@@ -0,0 +1,170 @@
+module Celerity
+
+  #
+  # Used internally to locate elements on the page.
+  #
+
+  class ElementLocator
+    include Celerity::Exception
+    attr_accessor :idents
+
+
+    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 }
+    end
+
+    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
+
+      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 :xpath
+          return find_by_xpath(what)
+        when :label
+          return find_by_label(what) unless @attributes.include?(:label)
+        when :class_name
+          how = :class
+        when :url
+          how = :href
+        when :caption
+          how = :text
+        end
+
+        if how == :id && conditions.size == 1
+          return find_by_id(what)
+        elsif @attributes.include?(how = how.to_sym)
+          attributes[how] << what
+        elsif how == :index
+          index = what.to_i - Celerity.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) { |key, v1, v2| v1 | v2 }
+        id = Identifier.new(ident.tag, merged)
+        id.text = ident.text || text # «original» identifier takes precedence for :text
+        @condition_idents << id
+      end
+
+      if index == 0
+        element_by_idents(@condition_idents)
+      else
+        elements_by_idents(@condition_idents)[index]
+      end
+
+    rescue HtmlUnit::ElementNotFoundException
+      nil # for rcov
+    end
+
+    def find_by_id(what)
+      case what
+      when Regexp
+        elements_by_tag_names.find { |elem| elem.getId =~ what }
+      when String
+        obj = @object.getElementById(what)
+        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 TypeError, "expected String or Regexp, got #{what.inspect}:#{what.class}"
+      end
+    end
+
+    def find_by_xpath(what)
+      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 = @idents)
+      get_by_idents(:select, idents)
+    end
+
+    def element_by_idents(idents = @idents)
+      get_by_idents(:find, idents)
+    end
+
+    private
+
+    def get_by_idents(meth, idents)
+      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 element_matches_ident?(element, ident)
+      return false unless ident.tag == element.getTagName
+
+      attr_result = ident.attributes.all? do |key, values|
+        values.any? { |val| matches?(element.getAttribute(key.to_s), val) }
+      end
+
+      if ident.text
+        attr_result && matches?(element.asText.strip, ident.text)
+      else
+        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

@@ -0,0 +1,43 @@
+module Celerity
+
+  #
+  # Input: Button
+  #
+  # Class representing button elements
+  #
+
+  class Button < InputElement
+    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
+      # 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])
+        button_ident      = Identifier.new('button')
+        button_ident.text = 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)
+      else
+        super
+      end
+    end
+
+  end # Button
+end # Celerity

data/lib/celerity/elements/file_field.rb

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

data/lib/celerity/elements/form.rb

@@ -0,0 +1,23 @@
+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.
+    #
+    # This method should be avoided - invoke the user interface element that triggers the submit instead.
+    #
+
+    def submit
+      assert_exists
+      @container.update_page @object.submit(nil)
+    end
+
+  end # Form
+end # Celerity

data/lib/celerity/elements/frame.rb

@@ -0,0 +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 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.getAttribute(meth.to_s)
+      else
+        Log.warn "Element\#method_missing calling super with #{meth.inspect}"
+        super
+      end
+    end
+
+  end # Frame
+end # Celerity

data/lib/celerity/elements/image.rb

@@ -0,0 +1,76 @@
+module Celerity
+
+  class Image < Element
+    include ClickableElement
+
+    TAGS = [ Identifier.new('img') ]
+
+    ATTRIBUTES = BASE_ATTRIBUTES | [:src, :alt, :longdesc, :name, :height, :width, :usemap, :ismap, :align, :border, :hspace, :vspace]
+    DEFAULT_HOW = :src
+
+    #
+    # returns the file created date of the image
+    #
+
+    def file_created_date
+      assert_exists
+      web_response = @object.getWebResponse(true)
+      Time.parse(web_response.getResponseHeaderValue("Last-Modified").to_s)
+    end
+
+    #
+    # returns the file size of the image in bytes
+    #
+
+    def file_size
+      assert_exists
+      web_response = @object.getWebResponse(true)
+      web_response.getContentAsBytes.length
+    end
+
+    #
+    # returns the width in pixels of the image, as a string
+    #
+
+    def width
+      assert_exists
+      @object.getWidth
+    end
+
+    #
+    # returns the height in pixels of the image, as a string
+    #
+
+    def height
+      assert_exists
+      @object.getHeight
+    end
+
+    #
+    # returns true if the image is loaded
+    #
+
+    def loaded?
+      assert_exists
+      begin
+        @object.getImageReader
+        true
+      rescue
+        false
+      end
+    end
+
+    #
+    # Saves the image to the given file
+    #
+
+    def save(filename)
+      assert_exists
+      image_reader = @object.getImageReader
+      file = java.io.File.new(filename)
+      buffered_image = image_reader.read(0);
+      javax.imageio.ImageIO.write(buffered_image, image_reader.getFormatName(), file);
+    end
+
+  end # Image
+end # Celerity

data/lib/celerity/elements/label.rb

@@ -0,0 +1,11 @@
+module Celerity
+
+  class Label < Element
+    include ClickableElement
+
+    TAGS = [ Identifier.new('label') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | [:for, :accesskey, :onfocus, :onblur]
+    DEFAULT_HOW = :text
+  end
+
+end

data/lib/celerity/elements/link.rb

@@ -0,0 +1,30 @@
+module Celerity
+  class Link < Element
+    include ClickableElement
+
+    TAGS = [ Identifier.new('a') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | [:charset, :type, :name, :href, :hreflang,
+                                    :target, :rel, :rev, :accesskey, :shape,
+                                    :coords, :tabindex, :onfocus, :onblur]
+    DEFAULT_HOW = :href
+
+    #
+    # Returns the absolute URL for this link (Celerity-specific)
+    #
+    # (Watir/IE does this for href(), but we don't want that.)
+    #
+
+    def absolute_url
+      assert_exists
+      href = @object.getAttribute('href')
+
+      unless href.empty? || URI.parse(href).absolute?
+        href = URI.join(browser.url, href).to_s
+      end
+
+      href
+    end
+
+
+  end # Link
+end # Celerity