oki-celerity 0.8.1.dev

data/lib/celerity/elements/form.rb

@@ -0,0 +1,22 @@
+module Celerity
+  class Form < Element
+    include Container
+
+    TAGS = [Identifier.new('form')]
+
+    # HTML 4.01 Transitional DTD
+    ATTRIBUTES = BASE_ATTRIBUTES | [
+                                      :'accept-charset',
+                                      :accept,
+                                      :action,
+                                      :enctype,
+                                      :method,
+                                      :name,
+                                      :onreset,
+                                      :onsubmit,
+                                      :target,
+                                    ]
+    DEFAULT_HOW = :name
+
+  end # Form
+end # Celerity

data/lib/celerity/elements/frame.rb

@@ -0,0 +1,86 @@
+module Celerity
+  class Frame < Element
+    include Container
+    include XpathSupport
+
+    attr_accessor :page
+
+    TAGS = [Identifier.new('frame'), Identifier.new('iframe')]
+    ATTRIBUTES = BASE_ATTRIBUTES | [
+                                      :frameborder,
+                                      :longdesc,
+                                      :marginheight,
+                                      :marginwidth,
+                                      :name,
+                                      :noresize,
+                                      :scrolling,
+                                      :src,
+                                    ]
+    DEFAULT_HOW = :name
+
+    #
+    # Override the default locate to handle frame and inline frames.
+    # @api private
+    #
+
+    def locate
+      super
+      if @object
+        @inline_frame_object = @object.getEnclosedWindow.getFrameElement
+        self.page            = @object.getEnclosedPage
+        if (frame = self.page.getDocumentElement)
+          @object = frame
+        end
+      end
+    end
+
+    #
+    # Override assert_exists to raise UnknownFrameException (for Watir compatibility)
+    # @api private
+    #
+
+    def assert_exists
+      locate
+      unless @object
+        raise UnknownFrameException, "unable to locate frame, using #{identifier_string}"
+      end
+    end
+
+    #
+    # Executes the given JavaScript string in this frame. (Celerity only)
+    #
+
+    def execute_script(source)
+      assert_exists
+      @page.executeJavaScript(source.to_s).getJavaScriptResult
+    end
+
+    #
+    # Updates the brwoser page with the page from this frame's top window.
+    # Used internally.
+    #
+    # @api private
+    #
+
+    def update_page(value)
+      @browser.page = value.getEnclosingWindow.getTopWindow.getEnclosedPage
+    end
+
+    def to_s
+      assert_exists
+      Celerity::Util.create_string @inline_frame_object
+    end
+
+    def method_missing(meth, *args, &blk)
+      meth = selector_to_attribute(meth)
+      if self.class::ATTRIBUTES.include?(meth)
+        assert_exists
+        @inline_frame_object.getAttribute(meth.to_s)
+      else
+        Log.warn "Element\#method_missing calling super with #{meth.inspect}"
+        super
+      end
+    end
+
+  end # Frame
+end # Celerity

data/lib/celerity/elements/image.rb

@@ -0,0 +1,89 @@
+module Celerity
+
+  class Image < Element
+    include ClickableElement
+
+    TAGS = [ Identifier.new('img') ]
+
+    ATTRIBUTES = BASE_ATTRIBUTES | [
+                                      :align,
+                                      :alt,
+                                      :border,
+                                      :height,
+                                      :hspace,
+                                      :ismap,
+                                      :longdesc,
+                                      :name,
+                                      :src,
+                                      :usemap,
+                                      :vspace,
+                                      :width,
+                                    ]
+    DEFAULT_HOW = :src
+
+    #
+    # returns the file created date of the image
+    #
+
+    def file_created_date
+      assert_exists
+      web_response = @object.getWebResponse(true)
+      Time.parse(web_response.getResponseHeaderValue("Last-Modified").to_s)
+    end
+
+    #
+    # returns the file size of the image in bytes
+    #
+
+    def file_size
+      assert_exists
+      web_response = @object.getWebResponse(true)
+      web_response.getContentAsBytes.length
+    end
+
+    #
+    # returns the width in pixels of the image, as a string
+    #
+
+    def width
+      assert_exists
+      @object.getWidth
+    end
+
+    #
+    # returns the height in pixels of the image, as a string
+    #
+
+    def height
+      assert_exists
+      @object.getHeight
+    end
+
+    #
+    # returns true if the image is loaded
+    #
+
+    def loaded?
+      assert_exists
+      begin
+        @object.getImageReader
+        true
+      rescue
+        false
+      end
+    end
+
+    #
+    # Saves the image to the given file
+    #
+
+    def save(filename)
+      assert_exists
+      image_reader = @object.getImageReader
+      file = java.io.File.new(filename)
+      buffered_image = image_reader.read(0);
+      javax.imageio.ImageIO.write(buffered_image, image_reader.getFormatName(), file);
+    end
+
+  end # Image
+end # Celerity

data/lib/celerity/elements/label.rb

@@ -0,0 +1,16 @@
+module Celerity
+
+  class Label < Element
+    include ClickableElement
+
+    TAGS = [ Identifier.new('label') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | [
+                                      :accesskey,
+                                      :for,
+                                      :onblur,
+                                      :onfocus,
+                                    ]
+    DEFAULT_HOW = :text
+  end
+
+end

data/lib/celerity/elements/link.rb

@@ -0,0 +1,43 @@
+module Celerity
+  class Link < Element
+    include ClickableElement
+
+    TAGS = [ Identifier.new('a') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | [
+                                      :accesskey,
+                                      :charset,
+                                      :coords,
+                                      :href,
+                                      :hreflang,
+                                      :name,
+                                      :onblur,
+                                      :onfocus,
+                                      :rel,
+                                      :rev,
+                                      :shape,
+                                      :tabindex,
+                                      :target,
+                                      :type,
+                                    ]
+    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,14 @@
+module Celerity
+  class Meta < Element
+    ATTRIBUTES  = HTML_401_TRANSITIONAL[:i18n] | [
+                                                    :'http-equiv',
+                                                    :content,
+                                                    :id,
+                                                    :name,
+                                                    :scheme,
+                                                   ]
+
+    DEFAULT_HOW = :id
+    TAGS = [ Identifier.new('meta') ]
+  end
+end

data/lib/celerity/elements/non_control_elements.rb

@@ -0,0 +1,124 @@
+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 | [
+                                :accesskey,
+                                :alt,
+                                :coords,
+                                :href,
+                                :nohref,
+                                :onblur,
+                                :onfocus,
+                                :shape,
+                                :tabindex,
+                              ]
+    TAGS = [ Identifier.new('area') ]
+  end
+
+  class Dd < NonControlElement
+    TAGS = [ Identifier.new('dd')]
+  end
+
+  class Del < NonControlElement
+    TAGS = [ Identifier.new('del')]
+  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 Ins < NonControlElement
+    TAGS = [ Identifier.new('ins') ]
+  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,38 @@
+module Celerity
+
+  #
+  # Represents an option in a select list.
+  #
+
+  class Option < Element
+    include ClickableElement
+    include DisabledElement
+
+    TAGS = [ Identifier.new('option') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | [
+                                      :disabled,
+                                      :label,
+                                      :selected,
+                                      :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,114 @@
+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?)
+        @object.click
+      end
+    end
+  end
+
+end

data/lib/celerity/elements/select_list.rb

@@ -0,0 +1,146 @@
+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 { |e| e.asText.empty? ? e.getLabelAttribute : e.asText }
+    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
+      @object.getSelectedOptions.each { |e| e.setSelected(false) } if multiple?
+    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 Util.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 true if the select list supports multiple selections
+    #
+
+    def multiple?
+      type == "select-multiple"
+    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)
+      Util.matches?(option.asText, value) || (option.hasAttribute("label") && Util.matches?(option.getLabelAttribute, value))
+    end
+
+  end # SelectList
+end # Celerity