drnic-celerity 0.0.6.17

data/lib/celerity/elements/link.rb

@@ -0,0 +1,30 @@
+module Celerity
+  class Link < Element
+    include ClickableElement
+
+    TAGS = [ Identifier.new('a') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | [:charset, :type, :name, :href, :hreflang,
+                                    :target, :rel, :rev, :accesskey, :shape,
+                                    :coords, :tabindex, :onfocus, :onblur]
+    DEFAULT_HOW = :href
+
+    #
+    # Returns the absolute URL for this link (Celerity-specific)
+    #
+    # (Watir/IE does this for href(), but we don't want that.)
+    #
+
+    def absolute_url
+      assert_exists
+      href = @object.getAttribute('href')
+
+      unless href.empty? || URI.parse(href).absolute?
+        href = URI.join(browser.url, href).to_s
+      end
+
+      href
+    end
+
+
+  end # Link
+end # Celerity

data/lib/celerity/elements/meta.rb

@@ -0,0 +1,7 @@
+module Celerity
+  class Meta < Element
+    ATTRIBUTES  = [:name, :id, :'http-equiv', :content, :scheme] | HTML_401_TRANSITIONAL[:i18n]
+    DEFAULT_HOW = :id
+    TAGS = [ Identifier.new('meta') ]
+  end
+end

data/lib/celerity/elements/non_control_elements.rb

@@ -0,0 +1,106 @@
+module Celerity
+
+  #
+  # Superclass for for Span, Pre, Div, H1, ...
+  #
+
+  class NonControlElement < Element
+    include Exception
+    include ClickableElement
+
+    ATTRIBUTES = BASE_ATTRIBUTES
+    DEFAULT_HOW = :id
+  end
+
+  #
+  #--
+  #  classes ordered alphabetically
+  #++
+  #
+
+  class Area < NonControlElement
+    ATTRIBUTES = ATTRIBUTES | [:shape, :coords, :href, :nohref, :alt, :tabindex, :accesskey, :onfocus, :onblur]
+    TAGS = [ Identifier.new('area') ]
+  end
+
+  class Dd < NonControlElement
+    TAGS = [ Identifier.new('dd')]
+  end
+
+  class Div < NonControlElement
+    TAGS = [ Identifier.new('div')]
+  end
+
+  class Dl < NonControlElement
+    TAGS = [ Identifier.new('dl')]
+  end
+
+  class Dt < NonControlElement
+    TAGS = [ Identifier.new('dt')]
+  end
+
+  class Em < NonControlElement
+    TAGS = [ Identifier.new('em')]
+  end
+
+  class H1 < NonControlElement
+    TAGS = [ Identifier.new('h1') ]
+  end
+
+  class H2 < NonControlElement
+    TAGS = [ Identifier.new('h2') ]
+  end
+
+  class H3 < NonControlElement
+    TAGS = [ Identifier.new('h3') ]
+  end
+
+  class H4 < NonControlElement
+    TAGS = [ Identifier.new('h4') ]
+  end
+
+  class H5 < NonControlElement
+    TAGS = [ Identifier.new('h5') ]
+  end
+
+  class H6 < NonControlElement
+    TAGS = [ Identifier.new('h6') ]
+  end
+
+  class Li < NonControlElement
+    TAGS = [ Identifier.new('li') ]
+  end
+
+  class Map < NonControlElement
+    TAGS = [ Identifier.new('map') ]
+  end
+
+  class Ol < NonControlElement
+    TAGS = [ Identifier.new('ol') ]
+  end
+
+  class P < NonControlElement
+    TAGS = [ Identifier.new('p') ]
+  end
+
+  class Pre < NonControlElement
+    TAGS = [ Identifier.new('pre')]
+  end
+
+  class Span < NonControlElement
+    TAGS = [ Identifier.new('span') ]
+  end
+
+  class Strong < NonControlElement
+    TAGS = [ Identifier.new('strong') ]
+  end
+
+  # class Title < NonControlElement
+  #   TAGS = [ Identifier.new('title') ]
+  # end
+
+  class Ul < NonControlElement
+    TAGS = [ Identifier.new('ul') ]
+  end
+
+end

data/lib/celerity/elements/option.rb

@@ -0,0 +1,32 @@
+module Celerity
+
+  #
+  # Represents an option in a select list.
+  #
+
+  class Option < Element
+    include ClickableElement
+    include DisabledElement
+
+    TAGS = [ Identifier.new('option') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | [:selected, :disabled, :label, :value]
+    DEFAULT_HOW = :text
+
+    alias_method :select, :click
+
+    #
+    # Is this option selected?
+    #
+
+    def selected?
+      assert_exists
+      @object.isSelected
+    end
+
+    def label
+      # overrides Container#label
+      assert_exists
+      @object.getLabelAttribute
+    end
+  end
+end

data/lib/celerity/elements/radio_check.rb

@@ -0,0 +1,115 @@
+module Celerity
+
+  #
+  # Common superclass for radios and check boxes.
+  #
+
+  class RadioCheckCommon < InputElement
+    DEFAULT_HOW = :name
+
+    #
+    # Can optionally take a value parameter as a third arg, so we override initialize
+    #
+
+    def initialize(container, type, *args)
+      @type = type
+      case args.size
+      when 2
+        super(container, args[0] => args[1])
+      when 3
+        super(container, args[0] => args[1], :value => args[2])
+      else
+        super(container, *args)
+      end
+    end
+
+    #
+    # returns true if the element is checked
+    # @return [true, false]
+    #
+
+    def set?
+      assert_exists
+      @object.isChecked
+    end
+    alias_method :checked?, :set?
+
+    #
+    # Unset this element.
+    #
+
+    def clear
+      set(false)
+    end
+  end
+
+  #
+  # This class is the representation of a radio button.
+  #
+
+  class Radio < RadioCheckCommon
+    TAGS = [Identifier.new('input', :type => %w[radio])]
+
+    #
+    # @api private
+    #
+
+    def initialize(container, *args)
+      super(container, %w[radio], *args)
+    end
+
+    #
+    # Set the radio button to the given value.
+    #
+    #   radio.set?        #=> false
+    #   radio.set
+    #   radio.set?        #=> true
+    #   radio.set(false)
+    #   radio.set?        #=> false
+    #
+
+    def set(value = true)
+      assert_exists
+      assert_enabled
+      value ? @object.click : @object.setChecked(value)
+    end
+
+  end
+
+  #
+  # This class is the representation of a check box.
+  #
+
+  class CheckBox < RadioCheckCommon
+    TAGS = [Identifier.new('input', :type => %w[checkbox])]
+
+    #
+    # @api private
+    #
+
+    def initialize(container, *args)
+      super(container, %w[checkbox], *args)
+    end
+
+    #
+    # Set the checkbox to the given value.
+    #
+    #   checkbox.set?         #=> false
+    #   checkbox.set
+    #   checkbox.set?         #=> true
+    #   checkbox.set(false)
+    #   checkbox.set?         #=> false
+    #
+
+    def set(value = true)
+      assert_exists
+      assert_enabled
+
+      if (value && !set?) || (!value && set?)
+        Log.debug(@object.inspect)
+        @object.click
+      end
+    end
+  end
+
+end

data/lib/celerity/elements/select_list.rb

@@ -0,0 +1,142 @@
+module Celerity
+  class SelectList < InputElement
+    TAGS = [ Identifier.new('select') ]
+    DEFAULT_HOW = :name
+
+    #
+    # @return [Array<String>] An array of strings representing the text value of the select list's options.
+    #
+
+    def options
+      assert_exists
+      @object.getOptions.map do |e|
+        e.asText.empty? ? e.getLabelAttribute : e.asText
+      end
+    end
+
+    #
+    # @return [Array<String>] An array of strings representing the text value of the currently selected options.
+    #
+
+    def selected_options
+      assert_exists
+      @object.getSelectedOptions.map { |e| e.asText.empty? ? e.getLabelAttribute : e.asText }
+    end
+
+    #
+    # Clear all selected options
+    #
+
+    def clear
+      # assert_exists called by SelectList#type here
+      # TODO: should update page for each option changed?
+      @object.getSelectedOptions.each { |e| e.setSelected(false) } unless type() == 'select-one'
+    end
+
+    #
+    # Select the option(s) whose text or label matches the given string.
+    # If several options match the value given, all will be selected.
+    #
+    # @param [String, Regexp] value A value.
+    # @raise [Celerity::Exception::NoValueFoundException] if the value does not exist.
+    # @return [String] The option selected. If multiple options match, returns the first match
+    #
+    #
+
+    def select(value)
+      assert_exists
+
+      selected = nil
+      @object.getOptions.select do |option|
+        next unless matches_option?(option, value)
+
+        selected ||= option.asText
+        option.click
+      end
+
+      unless selected
+        raise NoValueFoundException, "unknown option with value #{value.inspect} for select_list #{@conditions.inspect}"
+      end
+
+      selected
+    end
+    alias_method :set, :select
+
+    #
+    # Selects the option(s) whose value attribute matches the given string.
+    # @param [String, Regexp] value A value.
+    # @raise [Celerity::Exception::NoValueFoundException] if the value does not exist.
+    # @return [String] The option selected. If multiple options match, returns the first match
+    #
+
+    def select_value(value)
+      assert_exists
+      selected = @object.getOptions.map { |e| e.click if matches?(e.getValueAttribute, value) }.compact.first
+
+      unless selected
+        raise NoValueFoundException, "unknown option with value #{value.inspect} for select_list #{@conditions.inspect}"
+      end
+
+      selected.asText
+    end
+
+    #
+    # Returns true if the select list has one or more options matching the given value.
+    #
+    # @param [String, Regexp] value A value.
+    # @return [true, false]
+    #
+
+    def include?(value)
+      assert_exists
+      !!@object.getOptions.find { |e| matches_option?(e, value) }
+    end
+
+    #
+    # Returns true if any of the selected options match the given value.
+    #
+    # @param [String, Regexp] value A value.
+    # @raise [Celerity::Exception::UnknownObjectException] if the value does not exist.
+    # @return [true, false]
+    #
+
+    def selected?(value)
+      assert_exists
+      raise UnknownObjectException, "unknown option with value #{value.inspect} for select_list #{@conditions.inspect}" unless include?(value)
+      !!@object.getOptions.find { |e| matches_option?(e, value) && e.isSelected }
+    end
+
+    #
+    # Returns 'select-multiple' if the select list has the 'multiple' attribute,
+    # defined, otherwise 'select-one'.
+    #
+    # @return [String]
+    #
+
+    def type
+      assert_exists
+      'select-' + (@object.hasAttribute('multiple') ? 'multiple' : 'one')
+    end
+
+    #
+    # Returns the value of the first selected option in the select list.
+    # Returns nil if no option is selected.
+    #
+    # @return [String, nil]
+    #
+
+    def value
+      assert_exists
+      if (option = @object.getSelectedOptions.to_a.first)
+        option.getValueAttribute
+      end
+    end
+
+    private
+
+    def matches_option?(option, value)
+      matches?(option.asText, value) || (option.hasAttribute("label") && matches?(option.getLabelAttribute, value))
+    end
+
+  end # SelectList
+end # Celerity

data/lib/celerity/elements/table.rb

@@ -0,0 +1,144 @@
+module Celerity
+
+  class Table < Element
+    include ClickableElement
+    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
+
+      @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)
+      (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 # Table
+end # Celerity