oki-celerity 0.8.1.dev

data/lib/celerity/elements/table.rb

@@ -0,0 +1,153 @@
+module Celerity
+
+  class Table < Element
+    include ClickableElement
+    include Enumerable
+    include Container
+
+    TAGS = [ Identifier.new('table') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | [
+                                      :align,
+                                      :bgcolor,
+                                      :border,
+                                      :cellpadding,
+                                      :cellspacing,
+                                      :frame,
+                                      :rules,
+                                      :summary,
+                                      :width,
+                                    ]
+    DEFAULT_HOW = :id
+
+    def locate
+      super
+      if @object
+        @rows = @object.getRows
+        @cells = []
+        @rows.each do |row|
+          row.getCells.each do |c|
+            @cells << c
+          end
+        end
+      end
+
+      @object
+    end
+
+    #
+    # @return [Celerity::TableRows]
+    #
+
+    def rows
+      assert_exists
+      TableRows.new(self, :object, @rows)
+    end
+
+    #
+    # @return [Celerity::TableCells]
+    #
+
+    def cells
+      assert_exists
+      TableCells.new(self, :object, @cells)
+    end
+
+    #
+    # Iterates through each row in the table.
+    # @yieldparam [Celerity::TableRow] row A row.
+    #
+
+    def each
+      assert_exists
+      @rows.each { |row| yield TableRow.new(self, :object, row)  }
+    end
+
+    #
+    # Returns the TableRow at the given index (1-indexed).
+    #
+    #   browser.table(:foo, 'bar')[1] # => #<TableRow...>
+    #   browser.table(:foo, 'bar').child_row[1] # => #<TableRow...>
+    #
+    # @param [Fixnum] index The index of the wanted row, 1-indexed.
+    # @raise [Celerity::Exception::UnknownRowException]
+    # @return [Celerity::TableRow]
+    #
+
+    def child_row(index)
+      assert_exists
+
+      if (index - Celerity.index_offset) >= @rows.length
+        raise UnknownRowException, "Unable to locate a row at index #{index}"
+      end
+
+      TableRow.new(self, :object, @rows[index - Celerity.index_offset])
+    end
+    alias_method :[], :child_row
+
+    #
+    # Returns the TableCell at the given index (1-indexed).
+    #
+    # In a 10-column row, table.child_cell[11] will return the first cell on the second row.
+    #
+    # @param [Fixnum] index The index of the wanted cell, 1-indexed.
+    # @raise [Celerity::Exception::UnknownCellException]
+    # @return [Celerity::TableCell]
+    #
+
+    def child_cell(index)
+      assert_exists
+
+      if (index - Celerity.index_offset) >= @cells.length
+        raise UnknownCellException, "Unable to locate a cell at index #{index}"
+      end
+
+      TableCell.new(self, :object, @cells[index - Celerity.index_offset])
+    end
+
+    #
+    # The number of rows in the table
+    # @return [Fixnum]
+    #
+
+    def row_count
+      assert_exists
+      @object.getRowCount
+    end
+
+    #
+    # Returns the number of columns on the row at the given index. (1-indexed)
+    # Default is the number of columns on the first row
+    # @param [Fixnum] index An index, 1-indexed (optional).
+    # @return [Fixnum]
+    #
+
+    def column_count(index = Celerity.index_offset)
+      assert_exists
+      @object.getRow(index - Celerity.index_offset).getCells.length
+    end
+
+    #
+    # Returns the text of each cell in the the table as a two-dimensional array.
+    # @return [Array<Array<String>>]
+    #
+
+    def to_a
+      assert_exists
+      # @object.getRows.map do |table_row|
+      #   table_row.getCells.map { |td| td.asText.strip }
+      # end
+      rows.map do |table_row|
+        table_row.map { |td| td.text }
+      end
+    end
+
+    def column_values(column_number)
+      (0..row_count-1).map { |index| self[index + Celerity.index_offset][column_number].text }
+    end
+
+    def row_values(row_number)
+      (0..column_count(row_number)-1).map { |index| self[row_number][index + Celerity.index_offset].text }
+    end
+
+  end # Table
+end # Celerity

data/lib/celerity/elements/table_cell.rb

@@ -0,0 +1,36 @@
+module Celerity
+
+  class TableCell < Element
+    include Celerity::Exception
+    include ClickableElement
+    include Container
+
+    TAGS = [ Identifier.new('td') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | CELLHALIGN_ATTRIBUTES | CELLVALIGN_ATTRIBUTES |
+                 [
+                   :abbr,
+                   :axis,
+                   :colspan,
+                   :headers,
+                   :rowspan,
+                   :scope,
+                 ]
+
+    DEFAULT_HOW = :id
+
+    alias_method :to_s, :text # why?
+
+    def colspan
+      assert_exists
+      attribute_value = @object.getAttribute('colspan').to_i
+      attribute_value > 0 ? attribute_value : 1
+    end
+
+  end
+
+  #-- needs code review regarding attributes/correctness of this
+  class Th < TableCell
+    TAGS = [ Identifier.new('th')]
+  end
+
+end

data/lib/celerity/elements/table_elements.rb

@@ -0,0 +1,42 @@
+module Celerity
+  class TableElement < Element
+    include Enumerable
+    include ClickableElement
+
+    ATTRIBUTES = BASE_ATTRIBUTES | CELLHALIGN_ATTRIBUTES | CELLVALIGN_ATTRIBUTES
+    DEFAULT_HOW = :id
+
+    def locate
+      super
+      @rows = @object.getRows if @object
+    end
+
+    def [](index)
+      assert_exists
+      TableRow.new(self, :object, @rows[index - Celerity.index_offset])
+    end
+
+    def length
+      assert_exists
+      @object.getRows.length
+    end
+
+    def each
+      assert_exists
+      @rows.each { |row| yield TableRow.new(self, :object, row) }
+    end
+  end
+
+  class TableBody < TableElement
+    TAGS = [ Identifier.new('tbody') ]
+  end
+
+  class TableFooter < TableElement
+    TAGS = [ Identifier.new('tfoot') ]
+  end
+
+  class TableHeader < TableElement
+    TAGS = [ Identifier.new('thead') ]
+  end
+
+end

data/lib/celerity/elements/table_row.rb

@@ -0,0 +1,49 @@
+module Celerity
+  class TableRow < Element
+    include Enumerable
+    include ClickableElement
+
+    TAGS = [ Identifier.new('tr') ]
+    DEFAULT_HOW = :id
+
+    def locate
+      super
+      @cells = @object.getCells if @object
+      @object
+    end
+
+    #
+    # Yields each TableCell in this row to the given block.
+    #
+
+    def each
+      assert_exists
+      @cells.each { |cell| yield TableCell.new(self, :object, cell) }
+    end
+
+    #
+    # Get the child cell at the given index
+    #
+
+    def child_cell(index)
+      assert_exists
+
+      if (index - Celerity.index_offset) >= @cells.length
+        raise UnknownCellException, "Unable to locate a cell at index #{index}"
+      end
+
+      TableCell.new(self, :object, @cells[index - Celerity.index_offset])
+    end
+    alias_method :[], :child_cell
+
+    #
+    # Number of cells in this row.
+    #
+
+    def column_count
+      assert_exists
+      @cells.length
+    end
+
+  end # TableRow
+end # Celerity

data/lib/celerity/elements/text_field.rb

@@ -0,0 +1,168 @@
+module Celerity
+
+  #
+  # Class representing text field elements
+  #
+  # This class is the main class for Text Fields
+  # Normally a user would not need to create this object as it is returned by the Watir::Container#text_field method
+  #
+
+  class TextField < InputElement
+    NON_TEXT_TYPES = %w[file radio checkbox submit reset image button hidden]
+    TAGS = [ Identifier.new('textarea'),
+             Identifier.new('input', :type => ["text", "password", /^(?!(#{ Regexp.union(*NON_TEXT_TYPES) })$)/])  ]
+    DEFAULT_HOW = :name
+
+    def visible?
+      assert_exists
+      type == 'hidden' ? false : super
+    end
+
+    #
+    # Clear the text field.
+    #
+
+    def clear
+      assert_exists
+      insert_string ''
+    end
+
+    #
+    # Set the text field to the given value.
+    # This ensures execution of JavaScript events (onkeypress etc.), but is slower than +value=+
+    #
+
+    def set(value)
+      assert_enabled
+      assert_not_readonly
+      clear
+      type_string(value.to_s)
+
+      value
+    end
+
+    #
+    # This directly sets the text field to the given value, skipping exectuion of JavaScript events.
+    # Use +set+ if you want to run events on text fields.
+    #
+
+    def value=(value)
+      assert_enabled
+      assert_not_readonly
+      clear
+
+      insert_string value.to_s
+
+      value
+    end
+
+    #
+    # Returns the text in the text field.
+    #
+
+    def value
+      assert_exists
+      case @object.getTagName
+      when 'textarea'
+        @object.getText
+      when 'input'
+        @object.getValueAttribute
+      end
+    end
+
+    #
+    # Append the given value to the text in the text field.
+    #
+
+    def append(value)
+      assert_enabled
+      assert_not_readonly
+      type_string value
+    end
+
+
+    def type
+      assert_exists
+      type = @object.getAttribute 'type'
+
+      NON_TEXT_TYPES.include?(type) ? type : 'text'
+    end
+
+    #
+    # This bascially just moves the text to the other text field using TextField#append
+    # TODO: check if HtmlUnit supports some kind of dragging.
+    #
+
+    def drag_contents_to(how, what)
+      assert_exists # assert_enabled?
+      val = self.value
+      self.value = ''
+      @container.text_field(how, what).append(val)
+    end
+
+    #
+    # Check if the given text fields contains the given String or Regexp.
+    #
+
+    def contains_text(expected_text)
+      assert_exists
+
+      case expected_text
+      when Regexp
+        value() =~ expected_text
+      when String
+        value().index(expected_text)
+      else
+        raise TypeError, "expected String or Regexp, got #{expected_text.inspect}:#{expected_text.class}"
+      end
+    end
+
+    #
+    # A boolean version of TextField#contains_text
+    #
+    # @param  [String, Regexp] expected_text The text to look for.
+    # @return [boolean]
+    #
+
+    def verify_contains(expected)
+      # assert_exists called by contains_text
+      !!contains_text(expected)
+    end
+
+    private
+
+    def type_string(value)
+      java.lang.String.new(value.to_java_bytes, @browser.page.getPageEncoding).toCharArray.each do |char|
+        @object.type(char)
+      end
+    end
+
+    def insert_string(value)
+      case @object.getTagName
+      when 'textarea'
+        @object.setText(value)
+      when 'input'
+        @object.setValueAttribute(value)
+      else
+        raise "unknown tag name #{@object.getTagName.inspect} for #{self.class}"
+      end
+    end
+
+  end # TextField
+
+  #
+  # This class can be used to access hidden field objects
+  # Normally a user would not need to create this object as it is returned by the Celerity::Container#hidden method
+  #
+
+  class Hidden < TextField
+    TAGS = [ Identifier.new('input', :type => %w[hidden]) ]
+    DEFAULT_HOW = :name
+
+    def visible?
+      assert_exists
+      false
+    end
+  end
+
+end # Celerity

data/lib/celerity/exception.rb

@@ -0,0 +1,83 @@
+module Celerity
+  module Exception
+
+    #
+    # Superclass for all Celerity exceptions.
+    #
+
+    class CelerityException < StandardError; end
+
+    #
+    # This exception is thrown if an attempt is made to access an object that doesn't exist
+    #
+
+    class UnknownObjectException < CelerityException; end
+
+    #
+    # This exception is thrown if an attempt is made to access an object that is in a disabled state
+    #
+
+    class ObjectDisabledException < CelerityException; end
+
+    #
+    # This exception is thrown if an attempt is made to access a frame that cannot be found
+    #
+
+    class UnknownFrameException < CelerityException; end
+
+    #
+    # This exception is thrown if an attempt is made to access a form that cannot be found
+    #
+
+    class UnknownFormException < CelerityException; end
+
+    #
+    # This exception is thrown if an attempt is made to access an object that is in a read-only state
+    #
+
+    class ObjectReadOnlyException < CelerityException; end
+
+    #
+    # This exception is thrown if an attempt is made to access an object when the specified value cannot be found
+    #
+
+    class NoValueFoundException < CelerityException; end
+
+    #
+    # This exception gets raised if the how argument is wrong.
+    #
+
+    class MissingWayOfFindingObjectException < CelerityException; end
+
+    #
+    # This exception is raised if an attempt is made to access a table row that doesn't exist
+    #
+
+    class UnknownRowException < CelerityException; end
+
+    #
+    # This exception is raised if an attempt is made to access a table cell that doesn't exist
+    #
+
+    class UnknownCellException < CelerityException; end
+
+    #
+    # This exception is thrown if an http error, such as a 404, 500 etc is encountered while navigating
+    #
+
+    class NavigationException < CelerityException; end
+
+    #
+    # This exception is thrown if an unexpected content type is returned by the server.
+    #
+
+    class UnexpectedPageException < CelerityException; end
+
+    #
+    # This exception is thrown if an unexpected content type is returned by the server.
+    #
+
+    class CookieNotFoundError < CelerityException; end
+
+  end # Exception
+end # Celerity

data/lib/celerity/htmlunit.rb

@@ -0,0 +1,64 @@
+module Celerity
+  Jars = Dir[File.dirname(__FILE__) + '/htmlunit/*.jar']
+  Jars.each { |jar| require(jar) }
+
+  module JsxHelper
+    def method_missing(meth, *args, &blk)
+      m = ["jsxGet_#{meth}", "jsx_get_#{meth}"].find { |m| respond_to?(m) }
+      m ? __send__(m) : super
+    end
+  end
+end
+
+module HtmlUnit
+  include_package 'com.gargoylesoftware.htmlunit'
+
+  module Html
+    include_package 'com.gargoylesoftware.htmlunit.html'
+  end
+
+  module Util
+    include_package 'com.gargoylesoftware.htmlunit.util'
+  end
+
+end
+
+module Java::OrgW3cDom::NamedNodeMap
+  include Enumerable
+
+  def each
+    0.upto(getLength - 1) do |idx|
+      yield item(idx)
+    end
+  end
+end
+
+module Java::JavaLang::Iterable
+  include Enumerable
+
+  def each
+    it = iterator
+    yield it.next while it.hasNext
+  end
+
+end unless Java::JavaLang::Iterable < Enumerable # depends on JRuby version
+
+class Java::ComGargoylesoftwareHtmlunitHtml::HtmlPage
+  def inspect
+    '#<HtmlPage:0x%s(%s)>' % [self.hash.to_s(16), getWebResponse.getWebRequest.getUrl.toString]
+  end
+end
+
+class Java::ComGargoylesoftwareHtmlunitHtml::HtmlElement
+  def inspect
+    '#<%s:0x%s>' % [self.class.name.split("::").last, self.hash.to_s(16)]
+  end
+end
+
+class Java::ComGargoylesoftwareHtmlunitJavascriptHostHtml::HTMLElement
+  include Celerity::JsxHelper
+end
+
+class Java::ComGargoylesoftwareHtmlunitJavascriptHostCss::CSSStyleDeclaration
+  include Celerity::JsxHelper
+end

data/lib/celerity/identifier.rb

@@ -0,0 +1,28 @@
+module Celerity
+
+  class Identifier
+    attr_accessor :text
+    attr_reader :tag, :attributes
+
+    def initialize(tag, attributes = {})
+      @tag        = tag
+      @attributes = attributes
+      @text       = nil
+    end
+
+    def match?(element)
+      return false unless @tag == element.getTagName
+
+      attr_result = @attributes.all? do |key, values|
+        values.any? { |val| Util.matches?(element.getAttribute(key.to_s), val) }
+      end
+
+      if @text
+        attr_result && Util.matches?(element.asText.strip, @text)
+      else
+        attr_result
+      end
+    end
+  end
+
+end

data/lib/celerity/ignoring_web_connection.rb

@@ -0,0 +1,15 @@
+module Celerity
+  class IgnoringWebConnection < HtmlUnit::Util::FalsifyingWebConnection
+
+    def initialize(web_client, pattern)
+      super(web_client)
+      @pattern = pattern
+    end
+
+    def getResponse(request_settings)
+      return super unless request_settings.getUrl.toString =~ @pattern
+      createWebResponse(request_settings, "", "text/html")
+    end
+
+  end
+end