celerity_thingista 0.9.2

data/lib/celerity/element_locator.rb

@@ -0,0 +1,164 @@
+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 = @object.getByXPath(what).to_a.first || return
+
+      return unless @idents.any? { |id| id.match?(object) }
+
+
+      object
+    end
+
+    def find_by_label(what)
+      obj = elements_by_tag_names(%w[label]).find { |e| Util.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
+        all_elements.send(meth) do |element|
+          next unless @tags.include?(element.getTagName)
+          idents.any? { |id| id.match?(element) }
+        end
+      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 looping through all elements instead.
+        all_elements.select { |elem| tags.include?(elem.getTagName) }
+      end
+    end
+
+    def all_elements
+      unless @object
+        raise %{internal error in #{self.class}: @container=#{@container.inspect} @element_class=#{@element_class.inspect}
+          Please report this failure and the code/HTML that caused it at http://github.com/jarib/celerity/issues}
+      end
+
+      @object.getHtmlElementDescendants
+    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
+      warn "warning: celerity caught #{e} - retry ##{tries}"
+      retry
+    end
+
+  end # ElementLocator
+end # Celerity

data/lib/celerity/elements/button.rb

@@ -0,0 +1,54 @@
+module Celerity
+
+  #
+  # Input: Button
+  #
+  # Class representing button elements.
+  #
+  # This class covers both button elements and input elements with type submit|reset|image|button.
+  #
+
+  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 = ATTRIBUTES | [
+                                :accesskey,
+                                :disabled,
+                                :ismap,
+                                :onblur,
+                                :onfocus,
+                                :src,
+                                :tabindex,
+                                :type,
+                                :usemap,
+                              ]
+    DEFAULT_HOW = :value
+
+    #
+    # @api private
+    #
+
+    def locate
+      # We want the :value attribute to point to the inner text 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,29 @@
+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
+
+      @object.setValueAttribute path
+
+      unless @object.getContentType
+        @object.setContentType(Celerity::Util.content_type_for(path))
+      end
+
+      path
+    end
+
+  end # FileField
+end # Celerity

data/lib/celerity/elements/form.rb

@@ -0,0 +1,22 @@
+module Celerity
+  class Form < Element
+    include Container
+
+    TAGS = [Identifier.new('form')]
+
+    # HTML 4.01 Transitional DTD
+    ATTRIBUTES = BASE_ATTRIBUTES | [
+                                      :'accept-charset',
+                                      :accept,
+                                      :action,
+                                      :enctype,
+                                      :method,
+                                      :name,
+                                      :onreset,
+                                      :onsubmit,
+                                      :target,
+                                    ]
+    DEFAULT_HOW = :name
+
+  end # Form
+end # Celerity

data/lib/celerity/elements/frame.rb

@@ -0,0 +1,86 @@
+module Celerity
+  class Frame < Element
+    include Container
+    include XpathSupport
+
+    attr_accessor :page
+
+    TAGS = [Identifier.new('frame'), Identifier.new('iframe')]
+    ATTRIBUTES = BASE_ATTRIBUTES | [
+                                      :frameborder,
+                                      :longdesc,
+                                      :marginheight,
+                                      :marginwidth,
+                                      :name,
+                                      :noresize,
+                                      :scrolling,
+                                      :src,
+                                    ]
+    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
+      Celerity::Util.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,89 @@
+module Celerity
+
+  class Image < Element
+    include ClickableElement
+
+    TAGS = [ Identifier.new('img') ]
+
+    ATTRIBUTES = BASE_ATTRIBUTES | [
+                                      :align,
+                                      :alt,
+                                      :border,
+                                      :height,
+                                      :hspace,
+                                      :ismap,
+                                      :longdesc,
+                                      :name,
+                                      :src,
+                                      :usemap,
+                                      :vspace,
+                                      :width,
+                                    ]
+    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.getContentAsString.bytesize
+    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