jarib-celerity 0.0.5

data/lib/celerity/elements/button.rb

@@ -0,0 +1,34 @@
+module Celerity
+  #
+  # Input: Button
+  #
+  # Class representing button elements
+  #
+  class Button < InputElement
+    TAGS = [ Identifier.new('button'),
+             Identifier.new('input', :type => %w[submit reset image button]) ]
+    # A little wierd attribute list due to button being both <button> and <input type="submit|reset|image|button" />
+    ATTRIBUTES = BASE_ATTRIBUTES | [:type, :disabled, :tabindex, :accesskey, :onfocus, :onblur] | [:src, :usemap, :ismap]
+    DEFAULT_HOW = :value
+
+    # @api private
+    def locate
+      # ugly..
+      # this is done to make <button> and <input>-buttons look similar
+      if (val = @conditions[:value])
+        locator = ElementLocator.new(@container, self.class)
+        button_ident = Identifier.new('button')
+        button_ident.text = val
+        input_ident = Identifier.new('input', :type => %w[submit reset image button], :value => [val])
+        locator.idents = [button_ident, input_ident]
+        conditions = @conditions.dup
+        conditions.delete(:value)
+        @object = locator.find_by_conditions(conditions)
+      else
+        super
+      end
+    end
+
+  end
+
+end

data/lib/celerity/elements/file_field.rb

@@ -0,0 +1,17 @@
+module Celerity
+  # For fields that accept file uploads
+  class FileField < InputElement
+    TAGS = [ Identifier.new('input', :type => %w[file]) ]
+    DEFAULT_HOW = :name
+
+    # Set the file field to the given path
+    def set(path)
+      assert_exists
+      path = path.to_s
+      @container.update_page @object.setValueAttribute(path)
+      unless @object.getContentType
+        @object.setContentType(Celerity::Util.content_type_for(path))
+      end
+    end
+  end
+end

data/lib/celerity/elements/form.rb

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

data/lib/celerity/elements/frame.rb

@@ -0,0 +1,53 @@
+module Celerity
+  class Frame < Element
+    include Container
+    attr_accessor :page
+
+    TAGS = [Identifier.new('frame'), Identifier.new('iframe')]
+    ATTRIBUTES = BASE_ATTRIBUTES | [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :noresize, :scrolling]
+    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
+        if (frame = @object.getEnclosedPage.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
+
+    def update_page(value)
+      @browser.page = value.getEnclosingWindow.getTopWindow.getEnclosedPage
+    end
+
+    def to_s
+      assert_exists
+      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.getAttributeValue(meth.to_s)
+      else
+        Log.warn "Element\#method_missing calling super with #{meth.inspect}"
+        super
+      end
+    end
+
+  end
+
+end

data/lib/celerity/elements/image.rb

@@ -0,0 +1,57 @@
+module Celerity
+
+  class Image < Element
+    include ClickableElement
+
+    TAGS = [ Identifier.new('img') ]
+    ATTRIBUTES = BASE_ATTRIBUTES | [:src, :alt, :longdesc, :name, :height, :width, :usemap, :ismap, :align, :border, :hspace, :vspace]
+    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 filesize of the image
+    def file_size
+      assert_exists
+      web_response = @object.getWebResponse(true)
+      web_response.getResponseBody.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
+
+end

data/lib/celerity/elements/label.rb

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

data/lib/celerity/elements/link.rb

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

data/lib/celerity/elements/meta.rb

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

data/lib/celerity/elements/non_control_elements.rb

@@ -0,0 +1,93 @@
+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 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 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,18 @@
+module Celerity
+  # Represents a select list option.
+  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
+
+    def selected?
+      assert_exists
+      @object.isSelected
+    end
+  end
+end

data/lib/celerity/elements/radio_check.rb

@@ -0,0 +1,85 @@
+module Celerity
+  # Common superclass for radios and check boxes.
+  class RadioCheckCommon < InputElement
+    DEFAULT_HOW = :name
+
+    # these can optionally take a value parameter as a third arg, so needs
+    # to be special-handled.
+    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?
+
+    def clear
+      set(false)
+    end
+  end
+
+  # This class is the celerity 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
+      @container.update_page(value ? @object.click : @object.setChecked(value))
+    end
+
+  end
+
+  # This class is the celerity 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)
+        @container.update_page(@object.click)
+      end
+    end
+  end
+
+end

data/lib/celerity/elements/select_list.rb

@@ -0,0 +1,81 @@
+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 }
+    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 }
+    end
+
+    # Clear all selected options
+    # TODO: should update page for each option changed?
+    def clear
+      # assert_exists called by SelectList#type here
+      @object.getSelectedOptions.each { |e| e.setSelected(false) } unless type() == 'select-one'
+    end
+
+    # Select the option(s) matching the given value.
+    # 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.
+    def select(value)
+      assert_exists
+      raise NoValueFoundException, "unknown option with value #{value.inspect} for select_list #{@conditions.inspect}" unless include?(value)
+      @object.getOptions.select { |e| matches?(e.asText, value) }.each do |option|
+        @container.update_page option.click
+      end
+    end
+    alias_method :set, :select
+
+    # 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?(e.asText, 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?(e.asText, value) && e.isSelected }
+    end
+
+    # Returns 'select-multiple' if the select list has the 'multiple' attribute,
+    # defined, otherwise 'select-one'.
+    #
+    # @return [String]
+    # TODO: Move to watir_compatibility or delete it 2008-05-23 Alexander
+    def type
+      assert_exists
+      'select-' + (@object.isAttributeDefined('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 (optn = @object.getSelectedOptions.to_a.first)
+        optn.getValueAttribute
+      end
+    end
+
+  end
+end