celerity_thingista 0.9.2

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 unless option.isSelected
+      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