celerity 0.0.1

data/lib/celerity/elements/select_list.rb

@@ -0,0 +1,84 @@
+module Celerity
+  #
+  # Input: Select
+  #
+  # This class is the way in which select boxes are manipulated
+  # Normally a user would not need to create this object as it is returned by the Watir::Container#select_list method
+  class SelectList < InputElement
+    TAGS = [ Identifier.new('select') ]
+  
+    def get_all_contents
+      assert_exists
+      @object.getOptions.map { |e| e.asText }
+    end
+    alias_method :getAllContents, :get_all_contents
+  
+    def get_selected_items
+      assert_exists
+      @object.getSelectedOptions.map { |e| e.asText }
+    end
+    alias_method :getSelectedItems, :get_selected_items
+  
+    def clear_selection
+      # assert_exists called by SelectList#type here
+      @object.getSelectedOptions.each { |e| e.setSelected(false) } unless type() == 'select-one'
+    end
+    alias_method :clearSelection, :clear_selection
+  
+    def select(value)
+      assert_exists
+      raise NoValueFoundException, "unknown option with value #{value.inspect}" unless include?(value)
+      @object.getOptions.select { |e| matches?(e.asText, value) }.each do |option|
+        @container.update_page(option.click)
+      end
+    end
+    alias_method :select_value, :select
+    alias_method :set, :select
+  
+    def include?(value)
+      assert_exists
+      !!@object.getOptions.find { |e| matches?(e.asText, value) }
+    end
+    alias_method :includes?, :include?
+  
+    def selected?(value)
+      assert_exists
+      # This should probably raise NoValueFoundException as well?
+      raise UnknownObjectException, "unknown option with value #{value.inspect}" unless include?(value)
+      !!@object.getOptions.find { |e| matches?(e.asText, value) && e.isSelected }
+    end
+
+    def type
+      assert_exists
+      'select-' + (@object.isAttributeDefined('multiple') ? 'multiple' : 'one')
+    end
+  
+    def value
+      assert_exists
+      if (optn = @object.getSelectedOptions.to_a.first)
+        optn.getValueAttribute
+      end
+    end
+  
+    def option(attribute, value)
+      assert_exists
+      Option.new(self, attribute, value)
+    end
+  end
+
+  class Option < Element
+    TAGS = ['option']
+    ATTRIBUTES = BASE_ATTRIBUTES | [:selected, :disabled, :label, :value]
+
+    def select
+      assert_exists
+      # click?
+      @object.setSelected(true)
+    end
+  
+    def selected?
+      assert_exists
+      @object.isSelected
+    end
+  end
+end

data/lib/celerity/elements/table.rb

@@ -0,0 +1,94 @@
+module Celerity
+
+  class Table < Element
+    include Container
+    TAGS = ['table']
+    ATTRIBUTES = BASE_ATTRIBUTES | [:summary, :width, :border, :frame, :rules, :cellspacing, :cellpadding, :align, :bgcolor]
+    DEFAULT_HOW = :name
+    
+    def locate
+      @object = @container.locate_tagged_element(self, @how, @what)
+      if @object # cant call the 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
+    
+    def rows
+      assert_exists
+      return TableRows.new(self, :object, @rows)
+    end
+    
+    def cells
+      assert_exists
+      return TableCells.new(self, :object, @cells)
+    end
+    
+    def each
+      assert_exists
+      0.upto(@object.getRowCount-1) { |index| yield TableRow.new(self, :object, @rows[index]) }
+    end
+    
+    def [](index)
+      assert_exists
+      return TableRow.new(self, :object, @rows[index-1])
+    end
+    
+    def row_count
+      assert_exists
+      @object.getRowCount
+    end
+    
+    def column_count(index = 1)
+      assert_exists
+      @object.getRow(index-1).getCells.length
+    end
+    
+    # This method returns the table as a 2 dimensional array. Dont expect too much if there are nested tables, colspan etc.
+    # Raises an UnknownObjectException if the table doesn't exist.
+    # http://www.w3.org/TR/html4/struct/tables.html
+    def to_a
+      assert_exists
+      y = []
+      table_rows = @object.getRows
+      for table_row in table_rows
+        x = []
+        for td in table_row.getCells
+          x << td.asText
+        end
+        y << x
+      end
+      return y
+    end
+    
+    def table_body(index = 1)
+      return @object.getBodies.get(index)
+    end
+    private :table_body
+    
+    def body(how, what)
+      assert_exists
+      return TableBody.new(@container, how, what, self)
+    end
+    
+    def bodies
+      assert_exists
+      return TableBodies.new(self)
+    end
+    
+    def column_values(columnnumber)
+      return (1..row_count).collect { |index| self[index][columnnumber].text }
+    end
+    
+    def row_values(rownumber)
+      return (1..column_count(rownumber)).collect { |index| self[rownumber][index].text }
+    end
+    
+  end
+  
+end

data/lib/celerity/elements/table_body.rb

@@ -0,0 +1,38 @@
+module Celerity
+  
+  class TableBody < Element
+    TAGS = ['tbody']
+
+    def locate
+      if @how == :object
+        @object = @what
+      else
+          @object = @container.locate_tagged_element(self, @how, @what)
+      end
+      if @object # cant call the 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
+
+    def [](index)
+      assert_exists
+      return TableRow.new(self, :object, @rows[index-1])
+    end
+
+    def length
+      assert_exists
+      return @object.getRows.length
+    end
+    
+    def each
+      0.upto(length-1) { |index| yield TableRow.new(self, :object, @rows[index]) }
+    end
+
+  end
+end

data/lib/celerity/elements/table_cell.rb

@@ -0,0 +1,30 @@
+module Celerity
+  
+  class TableCell < Element
+    include Celerity::Exception
+    include Container
+
+    TAGS = ['td']
+    ATTRIBUTES = BASE_ATTRIBUTES | [:abbr, :axis, :headers, :scope, :rowspan, :colspan] | CELLHALIGN_ATTRIBUTES | CELLVALIGN_ATTRIBUTES
+    
+    def locate
+      if @how == :object
+        @object = @what
+      else
+          @object = @container.locate_tagged_element(self, @how, @what)
+      end
+    end
+
+    def colspan
+      assert_exists
+      attribute_value = @object.getAttributeValue('colspan').to_i
+      if attribute_value > 0
+        attribute_value
+      else
+        1
+      end
+    end
+
+    alias_method :to_s, :text
+  end
+end

data/lib/celerity/elements/table_row.rb

@@ -0,0 +1,34 @@
+module Celerity
+  
+  class TableRow < Element
+    TAGS = ['tr']
+
+    def locate
+      if @how == :object
+        @object = @what
+      else
+          @object = @container.locate_tagged_element(self, @how, @what)
+      end
+      if @object # cant call the assert_exists here, as an exists? method call will fail
+        @cells = @object.getCells
+      end
+    end
+
+    def each
+      locate
+      0.upto(@cells.length-1) { |index| yield TableCell.new(self, :object, @cells[index]) }
+    end
+
+    def [](index)
+      assert_exists
+      raise UnknownCellException, "Unable to locate a cell at index #{index}" if @cells.length < index
+      return TableCell.new(self, :object, @cells[index-1])
+    end
+
+    def column_count
+      locate
+      @cells.length
+    end
+
+  end
+end

data/lib/celerity/elements/text_field.rb

@@ -0,0 +1,80 @@
+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
+    TAGS = [ Identifier.new('textarea'), 
+             Identifier.new('input', :type => %w(text password))  ]
+
+    def clear
+      assert_exists
+      case @object.getTagName
+      when 'textarea'
+        @object.setText('')
+      when 'input'
+        @object.setValueAttribute('')
+      end
+    end
+  
+    def set(value)
+      assert_enabled
+      assert_not_readonly
+      clear
+      # not sure what else to do here
+      if @object.class == com.gargoylesoftware.htmlunit.html.HtmlPasswordInput
+        @object.setValueAttribute(value.to_s)
+      else
+        value.to_s.to_java_bytes.each do |char| 
+          @container.update_page @object.type(char) 
+        end
+      end
+    end
+    
+    def value=(value)
+      assert_enabled
+      assert_not_readonly
+      clear
+      case @object.getTagName
+      when 'textarea'
+        @object.setText(value.to_s)
+      when 'input'
+        @object.setValueAttribute(value.to_s)
+      end
+    end
+
+    def append(value)
+      assert_enabled
+      assert_not_readonly
+      value.to_s.to_java_bytes.each { |char| @container.update_page @object.type(char) }
+    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
+    alias_method :dragContentsTo, :drag_contents_to
+  
+    def get_contents
+      self.value
+    end
+    alias_method :getContents, :get_contents
+
+    def verify_contains(expected)
+      assert_exists
+      !!contains_text(expected)
+    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 Watir::Container#hidden method
+  class Hidden < TextField
+    TAGS = [ Identifier.new('input', :type => %w(hidden)) ]
+  end
+  
+end

data/lib/celerity/exception.rb

@@ -0,0 +1,48 @@
+module Celerity
+  module Exception
+
+    # Root class for all Celerity Exceptions
+    class CelerityException < RuntimeError  
+        def initialize(message="")
+            super(message)
+        end
+    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 part of finding an object is missing
+    class MissingWayOfFindingObjectException < CelerityException; end
+      
+    # this exception is raised if an attempt is made to access a table cell that doesnt 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 raised if a timeout is exceeded
+    class TimeOutException < CelerityException
+      def initialize(duration, timeout)
+        @duration, @timeout = duration, timeout
+        super
+      end 
+      attr_reader :duration, :timeout
+    end
+    
+  end
+end

data/lib/celerity/ie.rb

@@ -0,0 +1,126 @@
+module Celerity
+  class IE
+    include Container
+    attr_accessor :page, :object
+    
+    def self.start(uri)
+      browser = new
+      browser.goto(uri)
+      browser
+    end
+    
+    def initialize(opts = {})
+      browser = RUBY_PLATFORM =~ /java/ ? ::HtmlUnit::BrowserVersion::FIREFOX_2 : ::HtmlUnit::BrowserVersion.FIREFOX_2
+      @webclient = ::HtmlUnit::WebClient.new(browser)
+      @webclient.setThrowExceptionOnScriptError(false) unless $DEBUG || opts[:enable_javascript_exceptions]
+      @webclient.setCssEnabled(false) if opts[:disable_css] 
+      @page_container = self
+      @error_checkers = []
+    end
+
+    def goto(uri)
+      uri = "http://#{uri}" unless uri =~ %r{^http://}
+      set_page @webclient.getPage(uri)
+      uri
+    end
+    
+    def close
+      @page = nil
+    end
+
+    def set_page(value)
+      # Log.debug(value.pretty_inspect)
+      @page = value
+      @object = @page.getDocumentElement
+      run_error_checks
+    end
+
+    def url
+      assert_exists
+      @page.getWebResponse.getUrl.toString
+    end
+    
+    def base_url
+      "http://" + URI.parse( url() ).host
+    end
+
+    def title
+      @page.getTitleText
+    end
+
+    def html
+      @page ? @page.getDocumentElement.asXml : ''
+    end
+
+    def text
+      # nicer way to do this?
+      assert_exists
+      @page.getFirstByXPath("//body").asText
+    end
+    
+    def back
+      raise NotImplementedError
+    end
+    
+    def refresh
+      raise NotImplementedError
+    end
+
+    def exist?
+      !!@page
+    end
+    alias_method :exists?, :exist?
+
+    # check that we have a @page object
+    # need to find a better way to handle this
+    def assert_exists
+      raise UnknownObjectException, "no page loaded" unless exist?
+    end
+    
+    def contains_text(expected_text)
+      return "" unless exist?
+      case expected_text
+      when Regexp
+        text().match(expected_text)
+      when String
+        text().index(expected_text)
+      else
+        raise ArgumentError, "Argument #{expected_text.inspect} should be a String or Regexp."
+      end
+    end
+    
+    def run_error_checks
+      @error_checkers.each { |e| e.call(self) }
+    end
+    
+    def add_checker(checker = nil, &block)
+      if block_given?
+        @error_checkers << block
+      elsif Proc === checker
+        @error_checkers << checker
+      else
+        raise ArgumentError, "argument must be a Proc or a block"
+      end
+    end
+    
+    def disable_checker(checker)
+      @error_checkers.delete(checker)
+    end
+        
+    # these are just for Watir compatability - should we keep them?
+    class << self
+      attr_accessor :speed, :attach_timeout, :visible
+      alias_method :start_window, :start
+      def reset_attach_timeout; @attach_timeout = 2.0; end
+      def each; end
+      def quit; end
+      def set_fast_speed; @speed = :fast; end
+      def set_slow_speed; @speed = :slow; end  
+    end
+
+    attr_accessor :visible
+    def bring_to_front; true; end
+    def speed=(s); end
+    
+  end # IE
+end # Celerity