watir 5.0.0 → 6.0.0.beta1

data/lib/watir/elements/iframe.rb

@@ -0,0 +1,163 @@
+module Watir
+  class IFrame < HTMLElement
+
+    def locate
+      @parent.assert_exists
+
+      selector = @selector.merge(tag_name: frame_tag)
+      element_validator = element_validator_class.new
+      selector_builder = selector_builder_class.new(@parent, selector, self.class.attribute_list)
+      locator = locator_class.new(@parent, selector, selector_builder, element_validator)
+
+      element = locator.locate
+      element or raise UnknownFrameException, "unable to locate #{@selector[:tag_name]} using #{selector_string}"
+
+      FramedDriver.new(element, driver)
+    end
+
+    def switch_to!
+      locate.send :switch!
+    end
+
+    def assert_exists
+      if @selector.key? :element
+        raise UnknownFrameException, "wrapping a Selenium element as a Frame is not currently supported"
+      end
+
+      super
+    end
+
+    #
+    # Returns text of iframe body.
+    #
+    # @return [String]
+    #
+
+    def text
+      body.text
+    end
+
+    #
+    # Returns HTML code of iframe.
+    #
+    # @return [String]
+    #
+
+    def html
+      assert_exists
+      wd.page_source
+    end
+
+    def execute_script(*args)
+      browser.execute_script(*args)
+    end
+
+    private
+
+    def frame_tag
+      'iframe'
+    end
+
+  end # IFrame
+
+
+  class IFrameCollection < ElementCollection
+
+    def to_a
+      # In case `#all_elements` returns empty array, but `#elements`
+      # returns non-empty array (i.e. any frame has loaded between these two calls),
+      # index will return nil. That's why `#all_elements` should always
+      # be called after `#elements.`
+      element_indexes = elements.map { |el| all_elements.index(el) }
+      element_indexes.map { |idx| element_class.new(@parent, tag_name: @selector[:tag_name], index: idx) }
+    end
+
+    private
+
+    def all_elements
+      selector = { tag_name: @selector[:tag_name] }
+
+      element_validator = element_validator_class.new
+      selector_builder = selector_builder_class.new(@parent, selector, element_class.attribute_list)
+      locator = locator_class.new(@parent, selector, selector_builder, element_validator)
+
+      locator.locate_all
+    end
+
+  end # IFrameCollection
+
+
+  class Frame < IFrame
+
+    private
+
+    def frame_tag
+      'frame'
+    end
+
+  end # Frame
+
+
+  class FrameCollection < IFrameCollection
+  end # FrameCollection
+
+
+  module Container
+
+    def frame(*args)
+      Frame.new(self, extract_selector(args).merge(tag_name: "frame"))
+    end
+
+    def frames(*args)
+      FrameCollection.new(self, extract_selector(args).merge(tag_name: "frame"))
+    end
+
+  end # Container
+
+
+  # @api private
+  #
+  # another hack..
+  #
+
+  class FramedDriver
+    def initialize(element, driver)
+      @element = element
+      @driver = driver
+    end
+
+    def ==(other)
+      wd == other.wd
+    end
+    alias_method :eql?, :==
+
+    def send_keys(*args)
+      switch!
+      @driver.switch_to.active_element.send_keys(*args)
+    end
+
+    protected
+
+    def wd
+      @element
+    end
+
+    private
+
+    def method_missing(meth, *args, &blk)
+      if @driver.respond_to?(meth)
+        switch!
+        @driver.send(meth, *args, &blk)
+      else
+        @element.send(meth, *args, &blk)
+      end
+    end
+
+    def switch!
+      @driver.switch_to.frame @element
+    rescue Selenium::WebDriver::Error::NoSuchFrameError => e
+      raise Exception::UnknownFrameException, e.message
+    end
+
+  end # FramedDriver
+end # Watir

data/lib/watir/elements/image.rb

@@ -0,0 +1,62 @@
+module Watir
+  class Image < HTMLElement
+
+    #
+    # Returns true if image is loaded.
+    #
+    # @return [Boolean]
+    #
+
+    def loaded?
+      return false unless complete?
+
+      driver.execute_script(
+        'return typeof arguments[0].naturalWidth != "undefined" && arguments[0].naturalWidth > 0',
+        @element
+      )
+    end
+
+    #
+    # Returns the image's width in pixels.
+    #
+    # @return [Fixnum] width
+    #
+
+    def width
+      assert_exists
+      driver.execute_script "return arguments[0].width", @element
+    end
+
+    #
+    # Returns the image's height in pixels.
+    #
+    # @return [Fixnum] width
+    #
+
+    def height
+      assert_exists
+      driver.execute_script "return arguments[0].height", @element
+    end
+
+    def file_created_date
+      assert_exists
+      raise NotImplementedError, "not currently supported by Selenium"
+    end
+
+    def file_size
+      assert_exists
+      raise NotImplementedError, "not currently supported by Selenium"
+    end
+
+    def save(path)
+      assert_exists
+      raise NotImplementedError, "not currently supported by Selenium"
+    end
+
+  end # Image
+
+  module Container
+     alias_method :image, :img
+     alias_method :images, :imgs
+  end # Container
+end # Watir

data/lib/watir/elements/input.rb

@@ -0,0 +1,7 @@
+module Watir
+  class Input < HTMLElement
+
+    alias_method :readonly?, :read_only?
+
+  end # Input
+end # Watir

data/lib/watir/elements/link.rb

@@ -0,0 +1,18 @@
+module Watir
+  module Container
+    alias_method :link,  :a
+    alias_method :links, :as
+  end # Container
+
+
+  class Anchor < HTMLElement
+
+    #
+    # @todo temporarily add href attribute
+    #
+    # @see https://www.w3.org/Bugs/Public/show_bug.cgi?id=23192
+    #
+    attribute String, :href, :href
+
+  end # Anchor
+end # Watir

data/lib/watir/elements/option.rb

@@ -0,0 +1,74 @@
+module Watir
+
+  #
+  # Represents an option in a select list.
+  #
+
+  class Option < HTMLElement
+
+    #
+    # Selects this option.
+    #
+    # @example
+    #   browser.select(id: "foo").options.first.select
+    #
+
+    alias_method :select, :click
+
+    #
+    # Toggles the selected state of this option.
+    #
+    # @example
+    #   browser.select(id: "foo").options.first.toggle
+    #
+
+    alias_method :toggle, :click
+
+    #
+    # Clears (i.e. toggles selected state) option.
+    #
+    # @example
+    #   browser.select(id: "foo").options.first.clear
+    #
+
+    def clear
+      click if selected?
+    end
+
+    #
+    # Is this option selected?
+    #
+    # @return [Boolean]
+    #
+
+    def selected?
+      assert_exists
+      element_call { @element.selected? }
+    end
+
+    #
+    # Returns the text of option.
+    #
+    # Note that the text is either one of the following respectively:
+    #   * label attribute
+    #   * text attribute
+    #   * inner element text
+    #
+    # @return [String]
+    #
+
+    def text
+      # A little unintuitive - we'll return the 'label' or 'text' attribute if
+      # they exist, otherwise the inner text of the element
+
+      attribute = [:label, :text].find { |a| attribute? a }
+
+      if attribute
+        attribute_value(attribute)
+      else
+        super
+      end
+    end
+
+  end # Option
+end # Watir

data/lib/watir/elements/radio.rb

@@ -0,0 +1,42 @@
+module Watir
+  class Radio < Input
+
+    #
+    # Selects this radio button.
+    #
+
+    def set
+      click unless set?
+    end
+
+    #
+    # Is this radio set?
+    #
+    # @return [Boolean]
+    #
+
+    def set?
+      assert_exists
+      element_call { @element.selected? }
+    end
+
+  end # Radio
+
+  module Container
+    def radio(*args)
+      Radio.new(self, extract_selector(args).merge(tag_name: "input", type: "radio"))
+    end
+
+    def radios(*args)
+      RadioCollection.new(self, extract_selector(args).merge(tag_name: "input", type: "radio" ))
+    end
+  end # Container
+
+  class RadioCollection < InputCollection
+    private
+
+    def element_class
+      Radio
+    end
+  end # RadioCollection
+end # Watir

data/lib/watir/elements/row.rb

@@ -0,0 +1,17 @@
+module Watir
+
+  #
+  # Custom class representing table row (tr).
+  #
+
+  class Row < TableRow
+  end # Row
+
+  class RowCollection < TableRowCollection
+    def elements
+      # we do this craziness since the xpath used will find direct child rows
+      # before any rows inside thead/tbody/tfoot...
+      super.sort_by { |e| e.attribute(:rowIndex).to_i }
+    end
+  end
+end # Watir

data/lib/watir/elements/select.rb

@@ -0,0 +1,238 @@
+module Watir
+  class Select < HTMLElement
+    include Watir::Exception
+
+    #
+    # Clears all selected options.
+    #
+
+    def clear
+      assert_exists
+
+      raise Error, "you can only clear multi-selects" unless multiple?
+
+      options.each do |o|
+        click_option(o) if o.selected?
+      end
+    end
+
+    #
+    # Gets all the options in the select list
+    #
+    # @return [Watir::OptionCollection]
+    #
+
+    def options
+      assert_exists
+      super
+    end
+
+    #
+    # Returns true if the select list has one or more options where text or label matches the given value.
+    #
+    # @param [String, Regexp] str_or_rx
+    # @return [Boolean]
+    #
+
+    def include?(str_or_rx)
+      assert_exists
+
+      element_call do
+        @element.find_elements(:tag_name, 'option').any? do |e|
+          str_or_rx === e.text || str_or_rx === e.attribute(:label)
+        end
+      end
+    end
+
+    #
+    # Select the option(s) whose text or label matches the given string.
+    # If this is a multi-select and several options match the value given, all will be selected.
+    #
+    # @param [String, Regexp] str_or_rx
+    # @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
+    # @return [String] The text of the option selected. If multiple options match, returns the first match.
+    #
+
+    def select(str_or_rx)
+      select_by :text, str_or_rx
+    end
+
+    #
+    # Selects the option(s) whose value attribute matches the given string.
+    #
+    # @see +select+
+    #
+    # @param [String, Regexp] str_or_rx
+    # @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
+    # @return [String] The option selected. If multiple options match, returns the first match
+    #
+
+    def select_value(str_or_rx)
+      select_by :value, str_or_rx
+    end
+
+    #
+    # Returns true if any of the selected options' text or label matches the given value.
+    #
+    # @param [String, Regexp] str_or_rx
+    # @raise [Watir::Exception::UnknownObjectException] if the options do not exist
+    # @return [Boolean]
+    #
+
+    def selected?(str_or_rx)
+      assert_exists
+
+      match_found = false
+
+      element_call do
+        @element.find_elements(:tag_name, 'option').each do |e|
+          matched = str_or_rx === e.text || str_or_rx === e.attribute(:label)
+          if matched
+            return true if e.selected?
+            match_found = true
+          end
+        end
+      end
+
+      raise(UnknownObjectException, "Unable to locate option matching #{str_or_rx.inspect}") unless match_found
+
+      false
+    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
+      o = options.find { |e| e.selected? } || return
+      o.value
+    end
+
+
+    #
+    # Returns an array of currently selected options.
+    #
+    # @return [Array<Watir::Option>]
+    #
+
+    def selected_options
+      options.select { |e| e.selected? }
+    end
+
+    private
+
+    def select_by(how, str_or_rx)
+      assert_exists
+
+      case str_or_rx
+      when String, Numeric
+        select_by_string(how, str_or_rx.to_s)
+      when Regexp
+        select_by_regexp(how, str_or_rx)
+      else
+        raise TypeError, "expected String or Regexp, got #{str_or_rx.inspect}:#{str_or_rx.class}"
+      end
+    end
+
+    def select_by_string(how, string)
+      xpath = option_xpath_for(how, string)
+
+      if multiple?
+        elements = element_call do
+          @element.find_elements(:xpath, xpath)
+        end
+        no_value_found(string) if elements.empty?
+
+        elements.each { |e| click_option(e) unless e.selected? }
+        elements.first.text
+      else
+        begin
+          e = element_call do
+            @element.find_element(:xpath, xpath)
+          end
+        rescue Selenium::WebDriver::Error::NoSuchElementError
+          no_value_found(string)
+        end
+
+        click_option(e) unless e.selected?
+        safe_text(e)
+      end
+    end
+
+    def select_by_regexp(how, exp)
+      elements = element_call do
+        @element.find_elements(:tag_name, 'option')
+      end
+      no_value_found(nil, "no options in select list") if elements.empty?
+
+      if multiple?
+        found = elements.select do |e|
+          next unless matches_regexp?(how, e, exp)
+          click_option(e) unless e.selected?
+          true
+        end
+
+        no_value_found(exp) if found.empty?
+
+        found.first.text
+      else
+        element = elements.find { |e| matches_regexp?(how, e, exp) }
+        no_value_found(exp) unless element
+
+        click_option(element) unless element.selected?
+        safe_text(element)
+      end
+    end
+
+    def option_xpath_for(how, string)
+      string = XpathSupport.escape string
+
+      case how
+      when :text
+        ".//option[normalize-space()=#{string} or @label=#{string}]"
+      when :value
+        ".//option[@value=#{string}]"
+      else
+        raise Error, "unknown how: #{how.inspect}"
+      end
+    end
+
+    def matches_regexp?(how, element, exp)
+      case how
+      when :text
+        element.text =~ exp || element.attribute(:label) =~ exp
+      when :value
+        element.attribute(:value) =~ exp
+      else
+        raise Error, "unknown how: #{how.inspect}"
+      end
+    end
+
+    def click_option(element)
+      element = Option.new(self, element: element) unless element.is_a?(Option)
+      element.click
+    end
+
+    def safe_text(element)
+      element.text
+    rescue Selenium::WebDriver::Error::StaleElementReferenceError, Selenium::WebDriver::Error::UnhandledAlertError
+      # guard for scenario where selecting the element changes the page, making our element obsolete
+
+      ''
+    end
+
+    def no_value_found(arg, msg = nil)
+      raise NoValueFoundException, msg || "#{arg.inspect} not found in select list"
+    end
+  end # Select
+
+  module Container
+    alias_method :select_list,  :select
+    alias_method :select_lists, :selects
+
+    Watir.tag_to_class[:select_list] = Select
+  end # Container
+end # Watir