celerity_thingista 0.9.2

data/lib/celerity/elements/table.rb

@@ -0,0 +1,154 @@
+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
+    alias_method :tds, :cells
+
+    #
+    # 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,54 @@
+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
+
+    def cells
+      to_a
+    end
+    alias_method :tds, :cells
+
+    #
+    # 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