watir 1.4.1 → 7.3.0

data/lib/watir/locators/text_field/selector_builder/xpath.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class TextField
+      class SelectorBuilder
+        class XPath < Element::SelectorBuilder::XPath
+          def text_string
+            return super if @adjacent
+
+            @built[:text] = @selector.delete(:text) if @selector.key?(:text)
+            ''
+          end
+
+          def additional_string
+            return '' if @adjacent
+
+            type_string(@selector.delete(:type))
+          end
+
+          def tag_string
+            @selector[:tag_name] = 'input' unless @adjacent
+            super
+          end
+
+          def type_string(type)
+            if type.eql?(true)
+              "[#{negative_type_text}]"
+            elsif Watir::TextField::NON_TEXT_TYPES.include?(type)
+              msg = "TextField Elements can not be located by type: #{type}"
+              raise LocatorException, msg
+            elsif type.nil?
+              "[not(@type) or (#{negative_type_text})]"
+            else
+              "[#{process_attribute(:type, type)}]"
+            end
+          end
+
+          def negative_type_text
+            Watir::TextField::NON_TEXT_TYPES.map { |type|
+              lhs = lhs_for(:type, downcase: true)
+              rhs = SelectorBuilder::XpathSupport.downcase(SelectorBuilder::XpathSupport.escape(type))
+              "#{lhs}!=#{rhs}"
+            }.join(' and ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/watir/locators/text_field/selector_builder.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Watir
+  module Locators
+    class TextField
+      class SelectorBuilder < Element::SelectorBuilder
+      end
+    end
+  end
+end

data/lib/watir/locators.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'watir/locators/element/locator'
+require 'watir/locators/element/selector_builder'
+require 'watir/locators/element/selector_builder/xpath_support'
+require 'watir/locators/element/selector_builder/regexp_disassembler'
+require 'watir/locators/element/selector_builder/xpath'
+require 'watir/locators/element/matcher'
+
+require 'watir/locators/anchor/selector_builder'
+
+require 'watir/locators/button/selector_builder'
+require 'watir/locators/button/selector_builder/xpath'
+require 'watir/locators/button/matcher'
+
+require 'watir/locators/cell/selector_builder'
+require 'watir/locators/cell/selector_builder/xpath'
+
+require 'watir/locators/option/matcher'
+require 'watir/locators/option/selector_builder'
+require 'watir/locators/option/selector_builder/xpath'
+
+require 'watir/locators/row/selector_builder'
+require 'watir/locators/row/selector_builder/xpath'
+
+require 'watir/locators/text_area/selector_builder'
+require 'watir/locators/text_area/selector_builder/xpath'
+
+require 'watir/locators/text_field/selector_builder'
+require 'watir/locators/text_field/selector_builder/xpath'
+require 'watir/locators/text_field/matcher'
+
+module Watir
+  module Locators
+    W3C_FINDERS = %i[css xpath].freeze
+
+    module ClassHelpers
+      def locator_class
+        class_from_string("#{browser.locator_namespace}::#{element_class_name}::Locator") ||
+          class_from_string("Watir::Locators::#{element_class_name}::Locator") ||
+          class_from_string("#{browser.locator_namespace}::Element::Locator") ||
+          Locators::Element::Locator
+      end
+
+      def element_matcher_class
+        class_from_string("#{browser.locator_namespace}::#{element_class_name}::Matcher") ||
+          class_from_string("Watir::Locators::#{element_class_name}::Matcher") ||
+          class_from_string("#{browser.locator_namespace}::Element::Matcher") ||
+          Locators::Element::Matcher
+      end
+
+      def selector_builder_class
+        class_from_string("#{browser.locator_namespace}::#{element_class_name}::SelectorBuilder") ||
+          class_from_string("Watir::Locators::#{element_class_name}::SelectorBuilder") ||
+          class_from_string("#{browser.locator_namespace}::Element::SelectorBuilder") ||
+          Locators::Element::SelectorBuilder
+      end
+
+      def class_from_string(string)
+        Watir.const_get(string) if Watir.const_defined?(string)
+      end
+
+      def element_class_name
+        element_class.to_s.split('::').last
+      end
+
+      def selector_builder
+        @selector_builder ||= selector_builder_class.new(element_class.attribute_list, @query_scope)
+      end
+
+      def locator
+        @element_matcher ||= element_matcher_class.new(@query_scope, @selector.dup)
+        @locator ||= locator_class.new(@element_matcher)
+      end
+    end
+  end
+end

data/lib/watir/logger.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'logger'
+
+# Code adapted from Selenium Implementation
+# https://github.com/SeleniumHQ/selenium/blob/trunk/rb/lib/selenium/webdriver/common/logger.rb
+
+module Watir
+  #
+  # @example Enable full logging
+  #   Watir.logger.level = :debug
+  #
+  # @example Log to file
+  #   Watir.logger.output = 'watir.log'
+  #
+  # @example Use logger manually
+  #   Watir.logger.info('This is info message')
+  #   Watir.logger.warn('This is warning message')
+  #
+  class Logger < Selenium::WebDriver::Logger
+    def initialize
+      super('Watir')
+    end
+
+    def selenium=(val)
+      Selenium::WebDriver.logger.level = val
+    end
+  end
+end

data/lib/watir/navigation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Watir
+  module Navigation
+    #
+    # Goes to the given URL.
+    #
+    # @example
+    #   browser.goto "watir.github.io"
+    #
+    # @param [String] uri The url.
+    # @return [String] The url you end up at.
+    #
+
+    def goto(uri)
+      uri = "http://#{uri}" unless uri&.match?(URI::DEFAULT_PARSER.make_regexp)
+
+      @driver.navigate.to uri
+      @after_hooks.run
+
+      uri
+    end
+
+    #
+    # Navigates back in history.
+    #
+
+    def back
+      @driver.navigate.back
+      @after_hooks.run
+    end
+
+    #
+    # Navigates forward in history.
+    #
+
+    def forward
+      @driver.navigate.forward
+      @after_hooks.run
+    end
+
+    #
+    # Refreshes current page.
+    #
+
+    def refresh
+      @driver.navigate.refresh
+      @after_hooks.run
+    end
+  end # Navigation
+end # Watir

data/lib/watir/radio_set.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Watir
+  class RadioSet
+    extend Forwardable
+    include Exception
+    include Enumerable
+
+    delegate %i[exist? exists? present? visible? browser] => :source
+
+    attr_reader :source, :frame
+
+    def initialize(query_scope, selector)
+      raise ArgumentError, "invalid argument: #{selector.inspect}" unless selector.is_a? Hash
+
+      @source = Radio.new(query_scope, selector)
+      @frame = @source.parent(tag_name: 'form')
+    end
+
+    #
+    # Yields each Radio associated with this set.
+    #
+    # @example
+    #   radio_set = browser.radio_set
+    #   radio_set.each do |radio|
+    #     puts radio.text
+    #   end
+    #
+    # @yieldparam [Watir::RadioSet] element iterate through the radio buttons.
+    #
+
+    def each(&block)
+      radios.each(&block)
+    end
+
+    #
+    # Get the n'th radio button in this set
+    #
+    # @return Watir::Radio
+    #
+
+    def [](idx)
+      radios[idx]
+    end
+
+    #
+    # @return Watir::Radio
+    #
+
+    def radio(opt = {})
+      if !name.empty? && (!opt[:name] || opt[:name] == name)
+        frame.radio(opt.merge(name: name))
+      elsif name.empty?
+        source
+      else
+        raise UnknownObjectException, "#{opt[:name]} does not match name of RadioSet: #{name}"
+      end
+    end
+
+    #
+    # @return Watir::RadioCollection
+    #
+
+    def radios(opt = {})
+      if !name.empty? && (!opt[:name] || opt[:name] == name)
+        element_call(:wait_for_present) { frame.radios(opt.merge(name: name)) }
+      elsif name.empty?
+        single_radio_collection
+      else
+        raise UnknownObjectException, "#{opt[:name]} does not match name of RadioSet: #{name}"
+      end
+    end
+
+    #
+    # Returns true if any radio buttons in the set are enabled.
+    #
+    # @return [Boolean]
+    #
+
+    def enabled?
+      any?(&:enabled?)
+    end
+
+    #
+    # Returns true if all radio buttons in the set are disabled.
+    #
+    # @return [Boolean]
+    #
+
+    def disabled?
+      !enabled?
+    end
+
+    #
+    # Returns the name attribute for the set.
+    #
+    # @return [String]
+    #
+
+    def name
+      @name ||= source.name
+    end
+
+    #
+    # If RadioSet exists, this always returns 'radio'.
+    #
+    # @return [String]
+    #
+
+    def type
+      assert_exists
+      'radio'
+    end
+
+    #
+    # Returns true if the radio set has one or more radio buttons where label matches the given value.
+    #
+    # @param [String, Regexp] str_or_rx
+    # @return [Boolean]
+    #
+
+    def include?(str_or_rx)
+      radio(label: str_or_rx).exist?
+    end
+
+    #
+    # Select the radio button whose value or label matches the given string.
+    #
+    # @param [String, Regexp] str_or_rx
+    # @raise [Watir::Exception::UnknownObjectException] if the Radio does not exist.
+    # @return [String] The value or text of the radio selected.
+    #
+
+    def select(str_or_rx)
+      %i[value label].each do |key|
+        radio = radio(key => str_or_rx)
+        next unless radio.exist?
+
+        radio.click unless radio.selected?
+        return key == :value ? radio.value : radio.text
+      end
+      raise UnknownObjectException, "Unable to locate radio matching #{str_or_rx.inspect}"
+    end
+    alias set select
+
+    #
+    # Returns true if any of the radio button 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)
+      found = frame.radio(label: str_or_rx)
+      return found.selected? if found.exist?
+
+      raise UnknownObjectException, "Unable to locate radio matching #{str_or_rx.inspect}"
+    end
+
+    #
+    # Returns the value of the selected radio button in the set.
+    # Returns nil if no radio is selected.
+    #
+    # @return [String, nil]
+    #
+
+    def value
+      selected&.value
+    end
+
+    #
+    # Returns the text of the selected radio button in the set.
+    # Returns nil if no option is selected.
+    #
+    # @return [String, nil]
+    #
+
+    def text
+      selected&.text
+    end
+
+    #
+    # Returns the selected Radio element.
+    # Returns nil if no radio button is selected.
+    #
+    # @return [Watir::Radio, nil]
+    #
+
+    def selected
+      find(&:selected?)
+    end
+
+    #
+    # Returns true if two elements are equal.
+    #
+    # @example
+    #   browser.radio_set(id: 'new_user_newsletter_yes') == browser.radio_set(id: 'new_user_newsletter_no')
+    #   #=> true
+    #
+
+    def ==(other)
+      other.is_a?(self.class) && radios == other.radios
+    end
+    alias eql? ==
+
+    # Delegating to Private Methods
+    %i[assert_exists element_call].each do |method|
+      define_method(method) do |*args, &blk|
+        source.send(method, *args, &blk)
+      end
+    end
+
+    private
+
+    def single_radio_collection
+      collection = RadioCollection.new(frame, source.selector)
+      collection.first.cache = source.wd
+      collection
+    end
+  end # RadioSet
+
+  module Container
+    def radio_set(opts = {})
+      RadioSet.new(self, opts.merge(tag_name: 'input', type: 'radio'))
+    end
+
+    Watir.tag_to_class[:radio_set] = RadioSet
+  end # Container
+end # Watir

data/lib/watir/row_container.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Watir
+  module RowContainer
+    #
+    # Returns table row.
+    #
+
+    def row(opts)
+      Row.new(self, opts)
+    end
+
+    #
+    # Returns table rows collection.
+    #
+
+    def rows(opts = {})
+      RowCollection.new(self, opts)
+    end
+
+    #
+    # The table as a 2D Array of strings with the text of each cell.
+    #
+    # @return [Array<Array<String>>]
+    #
+
+    def strings
+      wait_for_exists
+
+      rows.inject [] do |res, row|
+        res << row.cells.map(&:text)
+      end
+    end
+    alias to_a strings
+  end # RowContainer
+end # Watir

data/lib/watir/screenshot.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Watir
+  class Screenshot
+    def initialize(browser)
+      @browser = browser
+      @driver = browser.wd
+    end
+
+    #
+    # Saves screenshot to given path.
+    #
+    # @example
+    #   browser.screenshot.save "screenshot.png"
+    #
+    # @param [String] path
+    #
+
+    def save(path)
+      @driver.save_screenshot(path)
+    end
+
+    #
+    # Represents screenshot as PNG image string.
+    #
+    # @example
+    #   browser.screenshot.png
+    #   #=> '\x95\xC7\x8C@1\xC07\x1C(Edb\x15\xB2\vL'
+    #
+    # @return [String]
+    #
+
+    def png
+      @driver.screenshot_as(:png)
+    end
+
+    #
+    # Represents screenshot as Base64 encoded string.
+    #
+    # @example
+    #   browser.screenshot.base64
+    #   #=> '7HWJ43tZDscPleeUuPW6HhN3x+z7vU/lufmH0qNTtTum94IBWMT46evImci1vnFGT'
+    #
+    # @return [String]
+    #
+
+    def base64
+      @driver.screenshot_as(:base64)
+    end
+  end # Screenshot
+end # Watir

data/lib/watir/scroll.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Watir
+  module Scrolling
+    def scroll
+      Scroll.new(self)
+    end
+  end
+
+  class Scroll
+    def initialize(object)
+      @driver = object.browser.wd
+      @object = object
+      @origin = nil
+    end
+
+    # Scrolls by offset.
+    # @param [Fixnum] left Horizontal offset
+    # @param [Fixnum] top Vertical offset
+    #
+    def by(left, top)
+      if @origin
+        @driver.action.scroll_from(@origin, left, top).perform
+      else
+        @object.browser.execute_script('window.scrollBy(arguments[0], arguments[1]);', Integer(left), Integer(top))
+      end
+      self
+    end
+
+    # Scrolls to specified location.
+    # @param [Symbol] param
+    #
+    def to(param = :top)
+      return scroll_to_element if param == :viewport
+
+      args = @object.is_a?(Watir::Element) ? element_scroll(param) : browser_scroll(param)
+      raise ArgumentError, "Don't know how to scroll #{@object} to: #{param}!" if args.nil?
+
+      @object.browser.execute_script(*args)
+      self
+    end
+
+    # Sets an origin point for a future scroll
+    # @param [Integer] x_offset
+    # @param [Integer] y_offset
+    def from(x_offset = 0, y_offset = 0)
+      @origin = if @object.is_a?(Watir::Element)
+                  Selenium::WebDriver::WheelActions::ScrollOrigin.element(@object.we, x_offset, y_offset)
+                else
+                  Selenium::WebDriver::WheelActions::ScrollOrigin.viewport(x_offset, y_offset)
+                end
+      self
+    end
+
+    private
+
+    def scroll_to_element
+      @driver.action.scroll_to(@object.we).perform
+    end
+
+    def element_scroll(param)
+      script = case param
+               when :top, :start
+                 'arguments[0].scrollIntoView();'
+               when :center
+                 <<-JS
+                   var bodyRect = document.body.getBoundingClientRect();
+                   var elementRect = arguments[0].getBoundingClientRect();
+                   var left = (elementRect.left - bodyRect.left) - (window.innerWidth / 2);
+                   var top = (elementRect.top - bodyRect.top) - (window.innerHeight / 2);
+                   window.scrollTo(left, top);
+                 JS
+               when :bottom, :end
+                 'arguments[0].scrollIntoView(false);'
+               else
+                 return nil
+               end
+      [script, @object]
+    end
+
+    def browser_scroll(param)
+      case param
+      when :top, :start
+        'window.scrollTo(0, 0);'
+      when :center
+        y = '(document.body.scrollHeight - window.innerHeight) / 2 + document.body.getBoundingClientRect().top'
+        "window.scrollTo(window.outerWidth / 2, #{y});"
+      when :bottom, :end
+        'window.scrollTo(0, document.body.scrollHeight);'
+      when Array
+        ['window.scrollTo(arguments[0], arguments[1]);', Integer(param[0]), Integer(param[1])]
+      end
+    end
+  end
+end