watir 1.4.1 → 7.3.0

data/lib/watir/elements/iframe.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Watir
+  class IFrame < HTMLElement
+    #
+    # Move Driver context into the iframe
+    #
+
+    def switch_to!
+      locate unless located?
+      wd.switch!
+    end
+
+    #
+    # Returns text of iframe body.
+    # #body ensures context so this method does not have to
+    #
+    # @return [String]
+    #
+
+    def text
+      body.text
+    end
+
+    #
+    # Returns HTML code of iframe.
+    #
+    # @return [String]
+    #
+
+    def html
+      wd.page_source
+    end
+
+    #
+    # Delegate sending keystrokes to FramedDriver
+    #
+
+    def send_keys(*args)
+      wd.send_keys(*args)
+    end
+
+    #
+    # Executes JavaScript snippet in context of frame.
+    #
+    # @see Watir::Browser#execute_script
+    #
+
+    def execute_script(script, *args, function_name: nil)
+      args.map! do |e|
+        Watir.logger.info "Executing Script on Frame: #{function_name}" if function_name
+        e.is_a?(Element) ? e.wait_until(&:exists?).wd : e
+      end
+      returned = driver.execute_script(script, *args)
+
+      browser.wrap_elements_in(self, returned)
+    end
+
+    #
+    # Provides access to underlying Selenium Objects as delegated by FramedDriver
+    #
+    # @return [Watir::FramedDriver]
+    #
+
+    def wd
+      super
+      FramedDriver.new(@element, browser)
+    end
+
+    #
+    # Cast this Element instance to a more specific subtype.
+    # Cached element needs to be the IFrame element, not the FramedDriver
+    #
+
+    def to_subtype
+      super.tap { |el| el.cache = @element }
+    end
+
+    private
+
+    def unknown_exception
+      UnknownFrameException
+    end
+  end # IFrame
+
+  class IFrameCollection < ElementCollection
+  end # IFrameCollection
+
+  class Frame < IFrame
+  end # Frame
+
+  class FrameCollection < IFrameCollection
+  end # FrameCollection
+
+  module Container
+    def frame(opts = {})
+      Frame.new(self, opts.merge(tag_name: 'frame'))
+    end
+
+    def frames(opts = {})
+      FrameCollection.new(self, opts.merge(tag_name: 'frame'))
+    end
+  end # Container
+
+  #
+  # @api private
+  #
+
+  class FramedDriver
+    include Exception
+
+    def initialize(element, browser)
+      @element = element
+      @browser = browser
+      @driver = browser.wd
+    end
+
+    def ==(other)
+      wd == other.wd
+    end
+    alias eql? ==
+
+    def send_keys(*args)
+      switch!
+      @driver.switch_to.active_element.send_keys(*args)
+    end
+
+    def switch!
+      @driver.switch_to.frame @element
+      @browser.default_context = false
+    rescue Selenium::WebDriver::Error::NoSuchFrameError => e
+      raise UnknownFrameException, e.message
+    end
+
+    def wd
+      @element
+    end
+
+    def respond_to_missing?(meth, _include_private)
+      @driver.respond_to?(meth) || @element.respond_to?(meth) || super(meth, false)
+    end
+
+    def method_missing(meth, *args, &blk)
+      if %i[find_element find_elements].include?(meth)
+        @driver.send(meth, *args, &blk)
+      elsif @driver.respond_to?(meth)
+        switch!
+        @driver.send(meth, *args, &blk)
+      elsif @element.respond_to?(meth)
+        @element.send(meth, *args, &blk)
+      else
+        super
+      end
+    end
+  end # FramedDriver
+end # Watir

data/lib/watir/elements/image.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Watir
+  class Image < HTMLElement
+    #
+    # Returns true if image is loaded.
+    #
+    # @return [Boolean]
+    #
+
+    def loaded?
+      return false unless complete?
+
+      element_call { execute_js(:isImageLoaded, @element) }
+    end
+  end # Image
+
+  module Container
+    alias image img
+    alias images imgs
+  end # Container
+end # Watir

data/lib/watir/elements/input.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Watir
+  class Input < HTMLElement
+    #
+    # Returns label element associated with Input element.
+    #
+    # @return [Watir::Label]
+    #
+
+    def label
+      parent(tag_name: 'form').label(for: id)
+    end
+  end # Input
+end # Watir

data/lib/watir/elements/link.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Watir
+  module Container
+    alias link a
+    alias links as
+  end # Container
+end # Watir

data/lib/watir/elements/list.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Watir
+  module List
+    include Enumerable
+
+    #
+    # Yields each LI associated with this list.
+    #
+    # @example
+    #   list = browser.ol
+    #   list.each do |li|
+    #     puts li.text
+    #   end
+    #
+    # @yieldparam [Watir::LI] element Iterate through the items for this List.
+    #
+
+    def each(&block)
+      list_items.each(&block)
+    end
+
+    alias length count
+    alias size count
+    alias items count
+    alias empty? none?
+
+    #
+    # Returns item from this list at given index.
+    #
+    # @param [Integer] idx
+    # @return Watir::LI
+    #
+
+    def [](idx)
+      list_items[idx]
+    end
+
+    def list_items
+      LICollection.new(self, adjacent: :child, tag_name: 'li')
+    end
+  end # List
+
+  class OList < HTMLElement
+    include List
+  end
+
+  class UList < HTMLElement
+    include List
+  end
+end # Watir

data/lib/watir/elements/option.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Watir
+  #
+  # Represents an option in a select list.
+  #
+
+  class Option < HTMLElement
+    #
+    # Selects this option.
+    #
+    # @example
+    #   browser.select(id: "foo").options.first.select
+    #
+
+    alias select click
+
+    #
+    # Toggles the selected state of this option.
+    #
+    # @example
+    #   browser.select(id: "foo").options.first.toggle
+    #
+
+    alias 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?
+      element_call { @element.selected? }
+    end
+
+    #
+    # Returns the text of option.
+    #
+    # getAttribute atom pulls the text value if the label does not exist
+    #
+    # @return [String]
+    #
+
+    def text
+      attribute_value(:label)
+    end
+  end # Option
+end # Watir

data/lib/watir/elements/radio.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Watir
+  class Radio < Input
+    def build
+      @selector[:label] = @selector.delete(:text) if @selector.key?(:text)
+      super
+    end
+
+    #
+    # Selects this radio button.
+    #
+
+    def set(bool = true)
+      click if bool && !set?
+    end
+    alias select set
+
+    #
+    # Is this radio set?
+    #
+    # @return [Boolean]
+    #
+
+    def set?
+      element_call { @element.selected? }
+    end
+    alias selected? set?
+
+    #
+    # Returns the text of the associated label.
+    # Returns empty string if no label is found.
+    #
+    # @return [String]
+    #
+
+    def text
+      l = label
+      l.exist? ? l.text : ''
+    end
+  end # Radio
+
+  module Container
+    def radio(opts = {})
+      Radio.new(self, opts.merge(tag_name: 'input', type: 'radio'))
+    end
+
+    def radios(opts = {})
+      RadioCollection.new(self, opts.merge(tag_name: 'input', type: 'radio'))
+    end
+  end # Container
+
+  class RadioCollection < InputCollection
+    private
+
+    def build
+      @selector[:label] = @selector.delete(:text) if @selector.key?(:text)
+      super
+    end
+
+    def element_class
+      Radio
+    end
+  end # RadioCollection
+end # Watir

data/lib/watir/elements/row.rb

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

data/lib/watir/elements/select.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Watir
+  class Select < HTMLElement
+    #
+    # Clears all selected options.
+    #
+
+    def clear
+      raise Exception::Error, 'you can only clear multi-selects' unless multiple_select_list?
+
+      selected_options.each(&:click)
+    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)
+      option(text: str_or_rx).exist? || option(label: str_or_rx).exist? || option(value: str_or_rx).exist?
+    end
+
+    #
+    # Select the option whose text or label matches the given string.
+    #
+    # @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, text: nil, value: nil, label: nil)
+      key, value = parse_select_args(str_or_rx, text, value, label)
+
+      if value.size > 1 || value.first.is_a?(Array)
+        value.flatten.map { |v| select_all_by key, v }.first
+      else
+        select_matching([find_option(key, value.flatten.first)])
+      end
+    end
+    alias set select
+
+    #
+    # Uses JavaScript to select the option whose text matches the given string.
+    #
+    # @param [String, Regexp] str_or_rx
+    # @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
+    #
+
+    def select!(*str_or_rx, text: nil, value: nil, label: nil)
+      key, value = parse_select_args(str_or_rx, text, value, label)
+
+      if value.size > 1 || value.first.is_a?(Array)
+        value.flatten.map { |v| select_by! key, v, :multiple }.first
+      else
+        value.flatten.map { |v| select_by! key, v, :single }.first
+      end
+    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, text: nil, value: nil, label: nil)
+      key, value = parse_select_args(str_or_rx, text, value, label)
+
+      find_option(key, value.first).selected?
+    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
+      selected_options.first&.value
+    end
+
+    #
+    # Returns the text of the first selected option in the select list.
+    # Returns nil if no option is selected.
+    #
+    # @return [String, nil]
+    #
+
+    # TODO: What is default behavior without #first ?
+    def text
+      selected_options.first&.text
+    end
+
+    # Returns an array of currently selected options.
+    #
+    # @return [Array<Watir::Option>]
+    #
+
+    def selected_options
+      element_call { execute_js :selectedOptions, self }
+    end
+
+    private
+
+    def multiple_select_list?
+      @multiple_select = @multiple_select.nil? ? multiple? : @multiple_select
+    end
+
+    def parse_select_args(str_or_rx, text, value, label)
+      selectors = {}
+      selectors[:any] = str_or_rx unless str_or_rx.empty?
+      selectors[:text] = [text] if text
+      selectors[:value] = [value] if value
+      selectors[:label] = [label] if label
+
+      raise ArgumentError, "too many arguments used for Select#select: #{selectors}" if selectors.size > 1
+
+      selectors.first
+    end
+
+    def select_by!(key, str_or_rx, number)
+      str_or_rx = type_check(str_or_rx)
+
+      js_rx = process_str_or_rx(str_or_rx)
+      approaches = key == :any ? %w[Text Label Value] : [key.to_s.capitalize]
+
+      approaches.each do |approach|
+        element_call { execute_js("selectOptions#{approach}", self, js_rx, number.to_s) }
+        return selected_options.first.text if matching_option?(approach.downcase, str_or_rx)
+      end
+
+      raise_no_value_found(str_or_rx)
+    end
+
+    def process_str_or_rx(str_or_rx)
+      case str_or_rx
+      when String
+        "^#{str_or_rx}$"
+      when Regexp
+        str_or_rx.inspect.sub('\\A', '^')
+                 .sub('\\Z', '$')
+                 .sub('\\z', '$')
+                 .sub(%r{^/}, '')
+                 .sub(%r{/[a-z]*$}, '')
+                 .gsub(/\(\?#.+\)/, '')
+                 .gsub(/\(\?-\w+:/, '(')
+      else
+        raise TypeError, "expected String or Regexp, got #{str_or_rx.inspect}:#{str_or_rx.class}"
+      end
+    end
+
+    def matching_option?(how, what)
+      selected_options.each do |opt|
+        value = opt.send(how)
+        next unless what.is_a?(String) ? value == what : value =~ what
+        return true if opt.enabled?
+
+        raise ObjectDisabledException, "option matching #{what} by #{how} on #{inspect} is disabled"
+      end
+      false
+    end
+
+    def select_all_by(key, str_or_rx)
+      raise Error, 'you can only use #select_all on multi-selects' unless multiple_select_list?
+
+      select_matching(find_options(key, str_or_rx))
+    end
+
+    def find_option(key, str_or_rx)
+      val = type_check(str_or_rx)
+
+      option(key => val).wait_until(&:exists?)
+    rescue Wait::TimeoutError
+      raise_no_value_found(str_or_rx)
+    end
+
+    def find_options(key, str_or_rx)
+      val = type_check(str_or_rx)
+
+      options(key => val).wait_until(&:exists?)
+    rescue Wait::TimeoutError
+      raise_no_value_found(str_or_rx)
+    end
+
+    def type_check(str_or_rx)
+      str_or_rx = str_or_rx.to_s if str_or_rx.is_a?(Numeric)
+      return str_or_rx if [String, Regexp].any? { |k| str_or_rx.is_a?(k) }
+
+      raise TypeError, "expected String, Numeric or Regexp, got #{str_or_rx.inspect}:#{str_or_rx.class}"
+    end
+
+    # TODO: Consider locating the Select List before throwing the exception
+    def raise_no_value_found(str_or_rx)
+      raise NoValueFoundException, "#{str_or_rx.inspect} not found in #{inspect}"
+    end
+
+    def select_matching(elements)
+      elements.each { |e| e.click unless e.selected? }
+      elements.first.exists? ? elements.first.text : ''
+    end
+  end # Select
+
+  module Container
+    alias select_list select
+    alias select_lists selects
+
+    Watir.tag_to_class[:select_list] = Select
+  end # Container
+end # Watir