watir 1.4.1 → 7.3.0

data/lib/watir/cookies.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Watir
+  class Cookies
+    def initialize(control)
+      @control = control
+    end
+
+    #
+    # Returns array of cookies.
+    #
+    # @example
+    #   browser.cookies.to_a
+    #   #=> {:name=>"my_session", :value=>"BAh7B0kiD3Nlc3Npb25faWQGOgZFRkk", :domain=>"mysite.com"}
+    #
+    # @return [Array<Hash>]
+    #
+
+    def to_a
+      @control.all_cookies.map do |e|
+        e.merge(expires: e[:expires]&.to_time)
+      end
+    end
+
+    #
+    # Returns a cookie by name.
+    #
+    # @example
+    #   browser.cookies[:my_session]
+    #   #=> {:name=>"my_session", :value=>"BAh7B0kiD3Nlc3Npb25faWQGOgZFRkk", :domain=>"mysite.com"}
+    #
+    # @param [Symbol] name
+    # @return <Hash> or nil if not found
+    #
+
+    def [](name)
+      to_a.find { |c| c[:name] == name.to_s }
+    end
+
+    #
+    # Adds new cookie.
+    #
+    # @example
+    #   browser.cookies.add 'my_session', 'BAh7B0kiD3Nlc3Npb25faWQGOgZFRkk', secure: true, http_only: true
+    #
+    # @param [String] name
+    # @param [String] value
+    # @param [Hash] opts
+    # @option opts [Boolean] :secure
+    # @option opts [Boolean] :http_only
+    # @option opts [String] :path
+    # @option opts [String] :same_site
+    # @option opts [Time, DateTime, NilClass] :expires
+    # @option opts [String] :domain
+    #
+    # @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie
+
+    def add(name, value, opts = {})
+      cookie = {
+        name: name,
+        value: value
+      }
+      cookie[:secure] = opts[:secure] if opts.key?(:secure)
+      cookie[:http_only] = opts[:http_only] if opts.key?(:http_only)
+      cookie[:path] = opts[:path] if opts.key?(:path)
+      cookie[:same_site] = opts[:same_site] if opts.key?(:same_site)
+      expires = opts[:expires]
+      if expires
+        cookie[:expires] = expires.is_a?(String) ? ::Time.parse(expires) : expires
+      end
+      cookie[:domain] = opts[:domain] if opts.key?(:domain)
+
+      @control.add_cookie cookie
+    end
+
+    #
+    # Deletes cookie by given name.
+    #
+    # @example
+    #   browser.cookies.delete 'my_session'
+    #
+    # @param [String] name
+    #
+
+    def delete(name)
+      @control.delete_cookie(name)
+    end
+
+    #
+    # Deletes all cookies.
+    #
+    # @example
+    #   browser.cookies.clear
+    #
+
+    def clear
+      @control.delete_all_cookies
+    end
+
+    #
+    # Save cookies to file
+    #
+    # @example
+    #   browser.cookies.save '.cookies'
+    #
+    # @param [String] file
+    #
+
+    def save(file = '.cookies')
+      File.write(file, to_a.to_yaml)
+    end
+
+    #
+    # Load cookies from file
+    #
+    # @example
+    #   browser.cookies.load '.cookies'
+    #
+    # @param [String] file
+    #
+
+    def load(file = '.cookies')
+      YAML.safe_load_file(file, permitted_classes: [::Symbol, ::Time]).each do |c|
+        add(c.delete(:name), c.delete(:value), c)
+      end
+    end
+  end # Cookies
+end # Watir

data/lib/watir/element_collection.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Watir
+  #
+  # Base class for element collections.
+  #
+
+  class ElementCollection
+    include Enumerable
+    include Exception
+    include JSSnippets
+    include Waitable
+    include Locators::ClassHelpers
+
+    def initialize(query_scope, selector)
+      @query_scope = query_scope
+      @selector = selector
+      @to_a = nil
+
+      build unless @selector.key?(:element)
+    end
+
+    #
+    # Relocates elements then yields each element in resulting collection.
+    #
+    # @example
+    #   divs = browser.divs(class: 'kls')
+    #   divs.each do |div|
+    #     puts div.text
+    #   end
+    #
+    # @yieldparam [Watir::Element] element Iterate through the elements in this collection.
+    #
+
+    def each(&blk)
+      reset!
+      to_a.each(&blk)
+    end
+
+    alias length count
+    alias size count
+
+    alias empty? none?
+
+    alias exist? any?
+    alias exists? any?
+
+    def build
+      selector_builder.build(@selector.dup)
+    end
+
+    #
+    # Get the element at the given index or range.
+    #
+    # Any call to an ElementCollection that includes an adjacent selector
+    # can not be lazy loaded because it must store the correct type
+    #
+    # Ranges can not be lazy loaded
+    #
+    # @param [Integer, Range] value Index (0-based) or Range of desired element(s)
+    # @return [Watir::Element, Watir::ElementCollection] Returns an instance of a Watir::Element subclass
+    #
+
+    def [](value)
+      if value.is_a?(Range)
+        to_a[value]
+      elsif @selector.key? :adjacent
+        to_a[value] || element_class.new(@query_scope, invalid_locator: true)
+      elsif @to_a && @to_a[value]
+        @to_a[value]
+      else
+        element_class.new(@query_scope, @selector.merge(index: value))
+      end
+    end
+
+    #
+    # First element of the collection
+    #
+    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
+    #
+
+    def first
+      self[0]
+    end
+
+    #
+    # Last element of the collection
+    #
+    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
+    #
+
+    def last
+      self[-1]
+    end
+
+    #
+    # This collection as an Array.
+    #
+    # @return [Array<Watir::Element>]
+    #
+
+    def to_a
+      hash = {}
+      @to_a ||=
+        elements_with_tags.map.with_index do |(el, tag_name), idx|
+          selector = @selector.dup
+          selector[:index] = idx unless idx.zero?
+          element = element_class.new(@query_scope, selector)
+          if [HTMLElement, Input].include? element.class
+            construct_subtype(element, hash, tag_name).tap { |e| e.cache = el }
+          else
+            element.tap { |e| e.cache = el }
+          end
+        end
+    end
+
+    #
+    # Locate all elements and return self.
+    #
+    # @return ElementCollection
+    #
+
+    def locate
+      to_a
+      self
+    end
+
+    #
+    # Returns browser.
+    #
+    # @return [Watir::Browser]
+    #
+
+    def browser
+      @query_scope.browser
+    end
+
+    #
+    # Returns true if two element collections are equal.
+    #
+    # @example
+    #   browser.select_list(name: "new_user_languages").options == browser.select_list(id: "new_user_languages").options
+    #   #=> true
+    #
+    # @example
+    #   browser.select_list(name: "new_user_role").options == browser.select_list(id: "new_user_languages").options
+    #   #=> false
+    #
+
+    def ==(other)
+      to_a == other.to_a
+    end
+    alias eql? ==
+
+    #
+    # Removes cache of previously located elements in the collection.
+    #
+    # @example
+    #   options = browser.select_list(name: "new_user_languages").options
+    #   options.reset!
+    #   options[0]
+    #   #=> nil
+    #
+
+    def reset!
+      @to_a = nil
+    end
+
+    private
+
+    def elements
+      ensure_context
+      if selector_builder.built.key?(:scope)
+        @query_scope.send(:element_call) { locate_all }
+      else
+        locate_all
+      end
+    end
+
+    def elements_with_tags
+      els = elements
+      if @selector[:tag_name]
+        els.map { |e| [e, @selector[:tag_name]] }
+      else
+        retries = 0
+        begin
+          els.zip(execute_js(:getElementTags, els))
+        rescue Selenium::WebDriver::Error::StaleElementReferenceError
+          retries += 1
+          sleep 0.5
+          retry unless retries > 2
+          raise LocatorException, "Unable to locate element collection from #{@selector} due to changing page"
+        end
+      end
+    end
+
+    def ensure_context
+      if @query_scope.is_a?(Browser) || (!@query_scope.located? && @query_scope.is_a?(IFrame))
+        @query_scope.browser.locate
+      elsif @query_scope.located? && @query_scope.stale?
+        @query_scope.locate
+      end
+      @query_scope.switch_to! if @query_scope.is_a?(IFrame)
+    end
+
+    def locate_all
+      locator.locate_all(selector_builder.built)
+    end
+
+    def element_class
+      Watir.const_get(self.class.name.sub(/Collection$/, ''))
+    end
+
+    def construct_subtype(element, hash, tag_name)
+      selector = element.selector
+      hash[tag_name] ||= 0
+      hash[tag_name] += 1
+      selector[:index] = hash[tag_name] - 1
+      selector[:tag_name] = tag_name
+      Watir.element_class_for(tag_name).new(@query_scope, selector)
+    end
+  end # ElementCollection
+end # Watir

data/lib/watir/elements/button.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Watir
+  #
+  # Class representing button elements.
+  #
+  # This class covers both <button> and <input type="submit|reset|image|button" /> elements.
+  #
+
+  class Button < HTMLElement
+    inherit_attributes_from Input
+
+    VALID_TYPES = %w[button reset submit image].freeze
+
+    #
+    # Returns the text of the button.
+    #
+    # For input elements, returns the "value" attribute.
+    # For button elements, returns the inner text.
+    #
+    # @return [String]
+    #
+
+    def text
+      tag_name == 'input' ? value : super
+    end
+  end # Button
+end # Watir

data/lib/watir/elements/cell.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Watir
+  #
+  # Custom class representing table cell (th or td).
+  #
+
+  class Cell < TableCell
+  end # Cell
+
+  class CellCollection < TableCellCollection
+    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(:cellIndex).to_i }
+    end
+  end
+end # Watir

data/lib/watir/elements/checkbox.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Watir
+  class CheckBox < Input
+    #
+    # Sets checkbox to the given value.
+    #
+    # @example
+    #   checkbox = browser.checkbox(id: 'new_user_interests_cars')
+    #   checkbox.set?        #=> false
+    #   checkbox.set
+    #   checkbox.set?        #=> true
+    #   checkbox.set(false)
+    #   checkbox.set?        #=> false
+    #
+    # @param [Boolean] bool
+    #
+
+    def set(bool = true)
+      set? == bool ? assert_enabled : click
+    end
+    alias check set
+
+    #
+    # Returns true if the element is checked
+    # @return [Boolean]
+    #
+
+    def set?
+      element_call { @element.selected? }
+    end
+    alias checked? set?
+
+    #
+    # Unsets checkbox.
+    #
+
+    def clear
+      set false
+    end
+    alias uncheck clear
+  end # CheckBox
+
+  module Container
+    def checkbox(opts = {})
+      CheckBox.new(self, opts.merge(tag_name: 'input', type: 'checkbox'))
+    end
+
+    def checkboxes(opts = {})
+      CheckBoxCollection.new(self, opts.merge(tag_name: 'input', type: 'checkbox'))
+    end
+  end # Container
+
+  class CheckBoxCollection < InputCollection
+  end # CheckBoxCollection
+end # Watir

data/lib/watir/elements/date_field.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Watir
+  class DateField < Input
+    #
+    # Enter the provided value.
+    #
+
+    def set!(date)
+      date = Date.parse date if date.is_a?(String)
+
+      message = "DateField##{__callee__} only accepts instances that respond to #strftime"
+      raise ArgumentError, message unless date.respond_to?(:strftime)
+
+      date_string = date.strftime('%Y-%m-%d')
+      element_call(:wait_for_writable) do
+        execute_js(:setValue, @element, date_string)
+        execute_js(:fireEvent, @element, :change)
+      end
+    end
+    alias set set!
+    alias value= set
+  end # DateField
+
+  module Container
+    def date_field(opts = {})
+      DateField.new(self, opts.merge(tag_name: 'input', type: 'date'))
+    end
+
+    def date_fields(opts = {})
+      DateFieldCollection.new(self, opts.merge(tag_name: 'input', type: 'date'))
+    end
+  end # Container
+
+  class DateFieldCollection < InputCollection
+    private
+
+    def element_class
+      DateField
+    end
+  end # DateFieldCollection
+end # Watir

data/lib/watir/elements/date_time_field.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Watir
+  class DateTimeField < Input
+    #
+    # Enter the provided value.
+    #
+
+    def set!(date)
+      date = ::Time.parse date if date.is_a?(String)
+
+      message = "DateTimeField##{__callee__} only accepts instances that respond to #strftime"
+      raise ArgumentError, message unless date.respond_to?(:strftime)
+
+      date_time_string = date.strftime('%Y-%m-%dT%H:%M')
+      element_call(:wait_for_writable) do
+        execute_js(:setValue, @element, date_time_string)
+        execute_js(:fireEvent, @element, :change)
+      end
+    end
+    alias set set!
+    alias value= set
+  end # DateTimeField
+
+  module Container
+    def date_time_field(opts = {})
+      DateTimeField.new(self, opts.merge(tag_name: 'input', type: 'datetime-local'))
+    end
+
+    def date_time_fields(opts = {})
+      DateTimeFieldCollection.new(self, opts.merge(tag_name: 'input', type: 'datetime-local'))
+    end
+  end # Container
+
+  class DateTimeFieldCollection < InputCollection
+    private
+
+    def element_class
+      DateTimeField
+    end
+  end # DateTimeFieldCollection
+end # Watir

data/lib/watir/elements/dlist.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Watir
+  class DList < HTMLElement
+    def to_hash
+      keys = dts.map(&:text)
+      values = dds.map(&:text)
+
+      keys.zip(values).to_h
+    end
+  end # DList
+end # Watir