jarib-celerity 0.0.5

data/lib/celerity/default_viewer.rb

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

data/lib/celerity/disabled_element.rb

@@ -0,0 +1,27 @@
+module Celerity
+  # Module 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,241 @@
+module Celerity
+
+  # Superclass for all HTML elements.
+  class Element
+    include Exception
+    include Container
+
+    attr_reader :container, :object
+
+    # number of spaces that separate the property from the value in the create_string method
+    TO_S_SIZE = 14
+
+    # 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
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 2)"
+      end
+
+      @conditions.freeze
+    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
+
+    # Used internally. Find the element on the page.
+    # @api private
+    def locate
+      @object = ElementLocator.new(@container, self.class).find_by_conditions(@conditions)
+    end
+
+    # @return [String] A string representation of the element.
+    def to_s
+      assert_exists
+      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?
+      obj = self
+      while obj
+        return false if obj.respond_to?(:type) && obj.type == 'hidden'
+        return false if obj.style =~ /display\s*:\s*none|visibility\s*:\s*hidden/
+        obj = obj.parent
+      end
+
+      return true
+    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
+        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.getHtmlValue.to_s}"}
+      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)
+        return @object.getAttributeValue(meth.to_s)
+      end
+
+      Log.warn "Element\#method_missing calling super with #{meth.inspect}"
+      super
+    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 create_string(element)
+      ret = []
+
+      unless (tag = element.getTagName).empty?
+        ret << "tag:".ljust(TO_S_SIZE) + tag
+      end
+
+      element.getAttributes.each do |attribute|
+        ret << "  #{attribute.getName}:".ljust(TO_S_SIZE+2) + attribute.getHtmlValue.to_s
+      end
+
+      unless (text = element.asText).empty?
+        ret << "  text:".ljust(TO_S_SIZE+2) + element.asText
+      end
+
+      ret.join("\n")
+    end
+
+    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_collections.rb

@@ -0,0 +1,68 @@
+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 ElementCollections
+    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.
+    # This is 1-indexed to keep compatibility with Watir - subject to change.
+    # 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.
+    # @return [Celerity::Element] Returns a subclass of Celerity::Element
+    def [](n)
+      if @elements && @elements[n - INDEX_OFFSET]
+        element_class.new(@container, :object, @elements[n - INDEX_OFFSET])
+      else
+        iterator_object(n - INDEX_OFFSET)
+      end
+    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+1)
+    end
+
+  end # ElementCollections
+end # Celerity

data/lib/celerity/element_locator.rb

@@ -0,0 +1,167 @@
+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 :id
+          return find_by_id(what)
+        when :xpath
+          return find_by_xpath(what)
+        when :label
+          return find_by_label(what)
+        when :class_name
+          how = :class
+        when :url
+          how = :href
+        when :caption
+          how = :text
+        end
+
+        if @attributes.include?(how = how.to_sym)
+          attributes[how] << what
+        elsif how == :index
+          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) { |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.getIdAttribute =~ what }
+      when String
+        obj = @object.getHtmlElementById(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.getIdAttribute == 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 = nil)
+      get_by_idents(:select, idents || @idents)
+    end
+
+    def element_by_idents(idents = nil)
+      get_by_idents(:find, idents || @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.getAttributeValue(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