jarib-celerity 0.0.5

data/lib/celerity/elements/table.rb

@@ -0,0 +1,117 @@
+module Celerity
+
+  class Table < Element
+    include Enumerable
+    include Container
+
+    TAGS = [ Identifier.new('table') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | [:summary, :width, :border, :frame, :rules,
+                                    :cellspacing, :cellpadding, :align, :bgcolor]
+    DEFAULT_HOW = :id
+
+    def locate
+      super
+      if @object # cant call assert_exists here, as an exists? method call will fail
+        @rows = @object.getRows
+        @cells = []
+        @rows.each do |row|
+          row.getCells.each do |c|
+            @cells << c
+          end
+        end
+      end
+    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 - INDEX_OFFSET) >= @rows.length
+        raise UnknownRowException, "Unable to locate a row at index #{index}"
+      end
+
+      TableRow.new(self, :object, @rows[index - 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 - INDEX_OFFSET) >= @cells.length
+        raise UnknownCellException, "Unable to locate a cell at index #{index}"
+      end
+      TableCell.new(self, :object, @cells[index - 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 = INDEX_OFFSET)
+      assert_exists
+      @object.getRow(index - 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)
+      (1..row_count).map { |index| self[index][column_number].text }
+    end
+
+    def row_values(row_number)
+      (1..column_count(row_number)).map { |index| self[row_number][index].text }
+    end
+
+  end
+
+end

data/lib/celerity/elements/table_cell.rb

@@ -0,0 +1,28 @@
+module Celerity
+
+  class TableCell < Element
+    include Celerity::Exception
+    include Container
+
+    TAGS = [ Identifier.new('td') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | CELLHALIGN_ATTRIBUTES |
+                 CELLVALIGN_ATTRIBUTES | [:abbr, :axis, :headers, :scope, :rowspan, :colspan]
+
+    DEFAULT_HOW = :id
+
+    alias_method :to_s, :text # why?
+
+    def colspan
+      assert_exists
+      attribute_value = @object.getAttributeValue('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,41 @@
+module Celerity
+  class TableElement < Element
+    include Enumerable
+
+    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 - 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,36 @@
+module Celerity
+  class TableRow < Element
+    include Enumerable
+
+    TAGS = [ Identifier.new('tr') ]
+    DEFAULT_HOW = :id
+
+    def locate
+      super
+      @cells = @object.getCells if @object
+    end
+
+    # Yields each TableCell in this row cell to the given block.
+    def each
+      assert_exists
+      @cells.each { |cell| yield TableCell.new(self, :object, cell) }
+    end
+
+    def child_cell(index)
+      assert_exists
+
+      if (index - INDEX_OFFSET) >= @cells.length
+        raise UnknownCellException, "Unable to locate a cell at index #{index}"
+      end
+
+      TableCell.new(self, :object, @cells[index - INDEX_OFFSET])
+    end
+    alias_method :[], :child_cell
+
+    def column_count
+      assert_exists
+      @cells.length
+    end
+
+  end
+end

data/lib/celerity/elements/text_field.rb

@@ -0,0 +1,127 @@
+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
+
+    # 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)
+    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
+    alias_method :get_contents, :value
+
+    # 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.getAttributeValue('type')
+
+      if NON_TEXT_TYPES.include?(type)
+        type
+      else
+        'text'
+      end
+    end
+
+    # This bascially just moves the text to the other text field using TextField#append
+    # Should check if the HtmlUnit API 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
+
+    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, @container.page.getPageEncoding).toCharArray.each do |char|
+        @container.update_page @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
+
+  # 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
+  end
+
+end

data/lib/celerity/exception.rb

@@ -0,0 +1,40 @@
+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
+  end
+end

data/lib/celerity/extra/method_generator.rb

@@ -0,0 +1,158 @@
+require "rubygems"
+require "uri"
+require "active_support"
+
+#--
+# http://api.rubyonrails.com/classes/Inflector.html#M001621
+#++
+class String # :nodoc:
+  def underscore
+     gsub(/::/, '/').
+     gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+     gsub(/([a-z\d])([A-Z])/,'\1_\2').
+     tr("-", "_").
+     downcase
+  end
+end
+
+module Celerity
+  # Experimental - generate a method definition for accessing elements on the current page.
+  class MethodGenerator
+
+    ELEMENTS = %w[text_field select_list radio checkbox button].map { |e| e.to_sym }
+    BUGGY_ELEMENTS = %w[radio checkbox].map { |e| e.to_sym }
+
+    def initialize(ie, opts = {})
+      @ie      = ie
+      @opts    = opts
+      @browser = @opts[:browser] || '@ie'
+
+      @docs = "  # Fills in the page at #{@ie.url}\n  #\n"
+      @docs << "  # Parameters:\n  #\n"
+      @doc_elements = []
+
+      @method = "  def #{@opts[:method_name] || 'generated_method'}(opts = {})\n\n"
+    end
+
+    def parse
+      ELEMENTS.each do |elem|
+        @method << "    # buggy!\n" if BUGGY_ELEMENTS.include?(elem)
+        add_elements(elem)
+      end
+      add_elements(:link) if @opts[:include_links]
+      @method << "  end\n\n"
+
+      # fix docs
+      max = @doc_elements.map { |symbol, _| symbol.to_s.size }.max
+      @doc_elements.each do |sym, desc|
+        @docs << "  #  #{sym.to_s.ljust(max)} => #{desc}\n"
+      end
+      @docs << "  #\n"*2
+      @docs + @method
+    end
+
+    private
+
+    def add_elements(symbol)
+      symbol = symbol.to_sym
+      symbol_pluralized = symbol.to_s.pluralize.to_sym
+      @ie.send(symbol_pluralized).each_with_index do |elem, idx|
+        self.send("add_#{symbol}".to_sym, elem, idx)
+      end
+
+      @method << "\n"
+    end
+
+    def add_text_field(elem, idx)
+      how, what = find_identifier(elem) || [:index, (idx + 1).to_s]
+      @method << "    #{@browser}.text_field(#{how.inspect}, #{what.inspect}).value = "
+      symbol = (how == :index) ? ":text_field_#{what.underscore}" : ":#{what.underscore}"
+      @method << "opts[#{symbol}]\n"
+      @doc_elements << [symbol, "value for text field #{what.inspect}"]
+    end
+
+    def add_select_list(elem, idx)
+      how, what = find_identifier(elem) || [:index, (idx + 1).to_s]
+      @method << "    #{@browser}.select_list(#{how.inspect}, #{what.inspect}).select("
+      symbol = (how == :index) ? ":select_list_#{what.underscore}" : ":#{what.underscore}"
+      @method << "opts[#{symbol}])\n"
+      @doc_elements << [symbol, "option to select for select list #{what.inspect}"]
+    end
+
+    def add_radio(elem, idx)
+      how, what = find_identifier(elem) || [:index, (idx + 1).to_s]
+      @method << "    #{@browser}.radio(#{how.inspect}, #{what.inspect}, "
+
+      if (value = elem.value).empty?
+        symbol = (how == :index) ? ":radio_#{what.underscore}" : ":#{what.underscore}"
+      else
+        symbol = ":#{what.underscore}_#{value.underscore}"
+        @method << "#{value.inspect}).set if opts[#{symbol}]\n"
+      end
+
+      @doc_elements << [symbol, "set the radio with id/value #{what.inspect}"]
+    end
+
+    def add_checkbox(elem, idx)
+      how, what = find_identifier(elem) || [:index, (idx + 1).to_s]
+      @method << "    #{@browser}.checkbox(#{how.inspect}, #{what.inspect}, "
+      symbol = (how == :index) ? ":checkbox_#{what.underscore}" : ":#{what.underscore}"
+      @method << "#{elem.value.inspect}).set if opts[#{symbol}]\n"
+
+      @doc_elements << [symbol, "set the checkbox with id/value #{what.inspect}"]
+    end
+
+    def add_button(elem, idx)
+      how, what = find_identifier(elem) || [:index, (idx + 1).to_s]
+      @method << "    #{@browser}.button(#{how.inspect}, #{what.inspect}).click\n"
+    end
+
+    def add_link(elem, idx)
+      if (href = elem.href) =~ /javascript/
+        how, what = :index, (idx + 1).to_s
+      else
+        how = :url
+
+        begin
+          uri = URI.parse(href)
+          what = Regexp.new(Regexp.escape(uri.to_s.sub(/.*#{uri.host}\//, '')))
+        rescue URI::InvalidURIError
+          what = href
+        end
+      end
+      @method << "    #{@browser}.link(#{how.inspect}, #{what.inspect}).click\n"
+    end
+
+    def find_identifier(element)
+      # could use ATTRIBUTES if they were 'weighted' somehow?
+      attrs = element.class::ATTRIBUTES
+      [:id, :name].each do |attribute|
+        return [attribute, element.send(attribute)] if attrs.include?(attribute) && !element.send(attribute).empty?
+      end
+      nil
+    end
+
+  end # MethodGenerator
+
+  class Browser
+    # Experimental - generate a method definition for accessing elements on the current page
+    # Not loaded by default - need to require 'celerity/extra/method_generator'
+    def generate_method(opts = {})
+      MethodGenerator.new(self, opts).parse
+    end
+  end # Browser
+
+end # Celerity
+
+
+
+# if __FILE__ == $0
+#   require File.dirname(__FILE__) + "/../spec/spec_helper"
+#   $stdout.sync = true
+#   @ie = Browser.new
+#   @ie.goto(TEST_HOST + "/forms_with_input_elements.html")
+#
+#   puts MethodGenerator.new(@ie).parse
+#   @ie.goto(TEST_HOST + "/forms3.html")
+#   puts MethodGenerator.new(@ie).parse
+# end