oki-celerity 0.8.1.dev

data/lib/celerity/default_viewer.rb

@@ -0,0 +1,14 @@
+module Celerity
+  class DefaultViewer
+    IMAGE = "#{Celerity::DIR}/resources/no_viewer.png"
+
+    class << self
+      def save(path = nil)
+        return unless path
+        FileUtils.copy(IMAGE, path)
+      end
+
+      def close; end
+    end
+  end
+end

data/lib/celerity/disabled_element.rb

@@ -0,0 +1,40 @@
+module Celerity
+
+  #
+  # Mixed in to all elements that can have the 'disabled' attribute.
+  #
+
+  module DisabledElement
+    include Celerity::Exception
+
+    #
+    # Returns false if the element is disabled.
+    #
+
+    def enabled?
+      !disabled?
+    end
+
+    #
+    # Returns true if the element is disabled.
+    #
+
+    def disabled?
+      assert_exists unless defined?(@object) && @object
+      @object.isDisabled
+    end
+    alias_method :disabled, :disabled?
+
+    #
+    # Used internally.
+    # @api private
+    #
+
+    def assert_enabled
+      if disabled?
+        raise ObjectDisabledException, "Object #{identifier_string} is disabled"
+      end
+    end
+
+  end
+end

data/lib/celerity/element.rb

@@ -0,0 +1,311 @@
+module Celerity
+
+  #
+  # Superclass for all HTML elements.
+  #
+
+  class Element
+    include Exception
+    include Container
+
+    attr_reader :container
+
+    # HTML 4.01 Transitional DTD
+    HTML_401_TRANSITIONAL = {
+      :core        => [:class, :id, :style, :title],
+      :cell_halign => [:align, :char, :charoff],
+      :cell_valign => [:valign],
+      :i18n        => [:dir, :lang],
+      :event       => [:onclick, :ondblclick, :onmousedown, :onmouseup, :onmouseover,
+                       :onmousemove, :onmouseout, :onkeypress, :onkeydown, :onkeyup],
+      :sloppy      => [:name, :value]
+    }
+
+    CELLHALIGN_ATTRIBUTES = HTML_401_TRANSITIONAL[:cell_halign]
+    CELLVALIGN_ATTRIBUTES = HTML_401_TRANSITIONAL[:cell_valign]
+    BASE_ATTRIBUTES       = HTML_401_TRANSITIONAL.values_at(:core, :i18n, :event, :sloppy).flatten
+    ATTRIBUTES            = BASE_ATTRIBUTES
+    TAGS                  = []
+
+    DEFAULT_HOW = nil
+
+    # @api private
+    def initialize(container, *args)
+      self.container = container
+
+      case args.size
+      when 2
+        @conditions = { args[0] => args[1] }
+      when 1
+        if args.first.is_a? Hash
+          @conditions = args.first
+        elsif (how = self.class::DEFAULT_HOW)
+          @conditions = { how => args.first }
+        else
+          raise ArgumentError, "wrong number of arguments (1 for 2)"
+        end
+      when 0
+        @conditions = { :index => Celerity.index_offset }
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 2)"
+      end
+
+      @conditions.freeze
+      @object = nil
+    end
+
+    def ==(other)
+      return false unless other.kind_of? Element
+      xpath == other.xpath
+    end
+
+    #
+    # Get the parent element
+    # @return [Celerity::Element, nil] subclass of Celerity::Element, or nil if no parent was found
+    #
+
+    def parent
+      assert_exists
+
+      obj = @object.parentNode
+      until element_class = Celerity::Util.htmlunit2celerity(obj.class)
+        return nil if obj.nil?
+        obj = obj.parentNode
+      end
+
+      element_class.new(@container, :object, obj)
+    end
+
+    #
+    # Sets the focus to this element.
+    #
+
+    def focus
+      assert_exists
+      @object.focus
+    end
+
+    #
+    # Returns true if this element is the currently focused element
+    #
+    # Celerity-specific.
+    #
+
+    def focused?
+      assert_exists
+      @object == browser.page.getFocusedElement
+    end
+
+    #
+    # Fires the given event for this element
+    #
+
+    def fire_event(event_name)
+      assert_exists
+      @object.fireEvent(event_name.sub(/^on/, ''))
+    end
+
+    #
+    # Used internally. Find the element on the page.
+    # @api private
+    #
+
+    def locate
+      @object = ElementLocator.new(@container, self.class).find_by_conditions(@conditions)
+    end
+
+    #
+    # Returns the HtmlUnit object backing this element
+    #
+
+    def object
+      @object || locate
+    end
+
+    #
+    # Returns a JavaScript object representing the receiver
+    #
+    # @api internal - subject to change
+    #
+
+    def javascript_object
+      assert_exists
+      @object.getScriptObject
+    end
+
+    #
+    # @return [String] A string representation of the element.
+    #
+
+    def to_s
+      assert_exists
+      Celerity::Util.create_string @object
+    end
+
+    #
+    # @param [String, #to_s] The attribute.
+    # @return [String] The value of the given attribute.
+    #
+
+    def attribute_value(attribute)
+      assert_exists
+      @object.getAttribute attribute.to_s
+    end
+
+    #
+    # Check if the element is visible to the user or not.
+    # Note that this only takes the _style attribute_ of the element (and
+    # its parents) into account - styles from applied CSS is not considered.
+    #
+    # @return [boolean]
+    #
+
+    def visible?
+      assert_exists
+      @object.isDisplayed
+    end
+
+    #
+    # Used internally to ensure the element actually exists.
+    #
+    # @raise [Celerity::Exception::UnknownObjectException] if the element can't be found.
+    # @api private
+    #
+
+    def assert_exists
+      locate unless @object
+      unless @object
+        raise UnknownObjectException, "Unable to locate #{self.class.name[/::(.*)$/, 1]}, using #{identifier_string}"
+      end
+    end
+
+    #
+    # Checks if the element exists.
+    # @return [true, false]
+    #
+
+    def exists?
+      assert_exists
+      true
+    rescue UnknownObjectException, UnknownFrameException
+      false
+    end
+    alias_method :exist?, :exists?
+
+    #
+    # Return a text representation of the element as it would appear in a browser.
+    #
+    # @see inner_text
+    # @return [String]
+    #
+
+    def text
+      assert_exists
+      @object.asText.strip # this must behave like ElementLocator
+    end
+
+    #
+    # Return the text content of this DOM node, disregarding its visibility.
+    #
+    # (Celerity-specific?)
+    #
+    # @see text
+    # @return [String]
+    #
+
+    def inner_text
+      assert_exists
+      Celerity::Util.normalize_text @object.getTextContent
+    end
+
+    #
+    # @return [String] The normative XML representation of the element (including children).
+    #
+
+    def to_xml
+      assert_exists
+      @object.asXml
+    end
+    alias_method :asXml,  :to_xml
+    alias_method :as_xml, :to_xml
+    alias_method :html,   :to_xml
+
+    #
+    # @return [String] A string representation of the element's attributes.
+    #
+
+    def attribute_string
+      assert_exists
+
+      result = ''
+      @object.getAttributes.each do |attribute|
+        result << %Q{#{attribute.getName}="#{attribute.getValue}"}
+      end
+
+      result
+    end
+
+    #
+    # return the canonical xpath for this element (Celerity-specific)
+    #
+
+    def xpath
+      assert_exists
+      @object.getCanonicalXPath
+    end
+
+    #
+    # Dynamically get element attributes.
+    #
+    # @see ATTRIBUTES constant for a list of valid methods for a given element.
+    #
+    # @return [String] The resulting attribute.
+    # @raise  [NoMethodError] if the element doesn't support this attribute.
+    #
+
+    def method_missing(meth, *args, &blk)
+      assert_exists
+
+      meth = selector_to_attribute(meth)
+
+      if self.class::ATTRIBUTES.include?(meth) || (self.class == Element && @object.hasAttribute(meth.to_s))
+        return @object.getAttribute(meth.to_s)
+      end
+      Log.warn "Element\#method_missing calling super with #{meth.inspect}"
+      super
+    end
+
+    def methods(*args)
+      ms = super
+      ms += self.class::ATTRIBUTES.map { |e| e.to_s }
+      ms.sort
+    end
+
+    def respond_to?(meth, include_private = false)
+      meth = selector_to_attribute(meth)
+      return true if self.class::ATTRIBUTES.include?(meth)
+      super
+    end
+
+    private
+
+    def identifier_string
+      if @conditions.size == 1
+        how, what = @conditions.to_a.first
+        "#{how.inspect} and #{what.inspect}"
+      else
+        @conditions.inspect
+      end
+    end
+
+    def selector_to_attribute(meth)
+      case meth
+      when :class_name then :class
+      when :caption    then :value
+      when :url        then :href
+      else meth
+      end
+    end
+
+  end # Element
+end # Celerity

data/lib/celerity/element_collection.rb

@@ -0,0 +1,107 @@
+module Celerity
+
+  #
+  # This class is the superclass for the iterator classes (Buttons, Links, Spans etc.)
+  # It would normally only be accessed by the iterator methods (Browser#spans, Browser#links, ...).
+  #
+
+  class ElementCollection
+    include Enumerable
+
+    #
+    # @api private
+    #
+
+    def initialize(container, how = nil, what = nil)
+      @container = container
+      @object = (how == :object ? what : nil)
+      @length = length
+    end
+
+    #
+    # @return [Fixnum] The number of elements in this collection.
+    #
+
+    def length
+      if @object
+        @object.length
+      else
+        @elements ||= ElementLocator.new(@container, element_class).elements_by_idents
+        @elements.size
+      end
+    end
+    alias_method :size, :length
+
+    #
+    # @yieldparam [Celerity::Element] element Iterate through the elements in this collection.
+    #
+
+    def each
+      if @elements
+        @elements.each { |e| yield(element_class.new(@container, :object, e)) }
+      else
+        0.upto(@length - 1) { |i| yield iterator_object(i) }
+      end
+
+      @length
+    end
+
+    #
+    # Get the element at the given index.
+    # By default, this is 1-indexed to keep compatibility with Watir.
+    #
+    # Also note that because of Watir's lazy loading, this will return an Element
+    # instance even if the index is out of bounds.
+    #
+    # @param [Fixnum] n Index of wanted element, 1-indexed unless Celerity.index_offset is changed.
+    # @return [Celerity::Element] Returns a subclass of Celerity::Element
+    #
+
+    def [](n)
+      if @elements && @elements[n - Celerity.index_offset]
+        element_class.new(@container, :object, @elements[n - Celerity.index_offset])
+      else
+        iterator_object(n - Celerity.index_offset)
+      end
+    end
+
+    #
+    # Get the first element in this collection. (Celerity-specific)
+    #
+    # @return [Celerity::Element] Returns a subclass of Celerity::Element
+    #
+
+    def first
+      self[Celerity.index_offset]
+    end
+
+    #
+    # Get the last element in this collection. (Celerity-specific)
+    #
+    # @return [Celerity::Element] Returns a subclass of Celerity::Element
+    #
+
+    def last
+      self[Celerity.index_offset - 1]
+    end
+
+    #
+    # Note: This can be quite useful in irb:
+    #
+    #   puts browser.text_fields
+    #
+    # @return [String] A string representation of all elements in this collection.
+    #
+
+    def to_s
+      map { |e| e.to_s }.join("\n")
+    end
+
+    private
+
+    def iterator_object(i)
+      element_class.new(@container, :index, i + Celerity.index_offset)
+    end
+
+  end # ElementCollection
+end # Celerity

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> and <input type="submit|reset|image|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 = 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