capybara 3.3.0 → 3.40.0

data/lib/capybara/node/simple.rb

@@ -28,8 +28,9 @@ module Capybara
       #
       # @return [String]    The text of the element
       #
-      def text(_type = nil)
-        native.text
+      def text(_type = nil, normalize_ws: false)
+        txt = native.text
+        normalize_ws ? txt.gsub(/[[:space:]]+/, ' ').strip : txt
       end
 
       ##
@@ -78,11 +79,11 @@ module Capybara
         if tag_name == 'textarea'
           native['_capybara_raw_value']
         elsif tag_name == 'select'
+          selected_options = find_xpath('.//option[@selected]')
           if multiple?
-            native.xpath(".//option[@selected='selected']").map { |option| option[:value] || option.content }
+            selected_options.map(&method(:option_value))
           else
-            option = native.xpath(".//option[@selected='selected']").first || native.xpath(".//option").first
-            option[:value] || option.content if option
+            option_value(selected_options.first || find_xpath('.//option').first)
           end
         elsif tag_name == 'input' && %w[radio checkbox].include?(native[:type])
           native[:value] || 'on'
@@ -99,14 +100,17 @@ module Capybara
       # @param  [Boolean] check_ancestors  Whether to inherit visibility from ancestors
       # @return [Boolean]     Whether the element is visible
       #
-      def visible?(check_ancestors = true)
-        return false if (tag_name == 'input') && (native[:type] == "hidden")
+      def visible?(check_ancestors = true) # rubocop:disable Style/OptionalBooleanParameter
+        return false if (tag_name == 'input') && (native[:type] == 'hidden')
+        return false if tag_name == 'template'
 
         if check_ancestors
-          !native.xpath("boolean(./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or @hidden or name()='script' or name()='head'])")
+          !find_xpath(VISIBILITY_XPATH)
         else
           # No need for an xpath if only checking the current element
-          !(native.has_attribute?('hidden') || (native[:style] =~ /display:\s?none/) || %w[script head].include?(tag_name))
+          !(native.key?('hidden') ||
+            /display:\s?none/.match?(native[:style] || '') ||
+            %w[script head style].include?(tag_name))
         end
       end
 
@@ -126,7 +130,8 @@ module Capybara
       #
       # @return [Boolean]     Whether the element is disabled
       def disabled?
-        native.has_attribute?('disabled')
+        native.has_attribute?('disabled') &&
+          %w[button input select textarea optgroup option menuitem fieldset].include?(tag_name)
       end
 
       ##
@@ -143,11 +148,15 @@ module Capybara
         native.has_attribute?('multiple')
       end
 
+      def readonly?
+        native.has_attribute?('readonly')
+      end
+
       def synchronize(_seconds = nil)
         yield # simple nodes don't need to wait
       end
 
-      def allow_reload!
+      def allow_reload!(*)
         # no op
       end
 
@@ -163,12 +172,12 @@ module Capybara
       end
 
       # @api private
-      def find_css(css)
+      def find_css(css, **_options)
         native.css(css)
       end
 
       # @api private
-      def find_xpath(xpath)
+      def find_xpath(xpath, **_options)
         native.xpath(xpath)
       end
 
@@ -176,6 +185,32 @@ module Capybara
       def session_options
         Capybara.session_options
       end
+
+      # @api private
+      def initial_cache
+        {}
+      end
+
+      def ==(other)
+        eql?(other) || (other.respond_to?(:native) && native == other.native)
+      end
+
+    private
+
+      def option_value(option)
+        return nil if option.nil?
+
+        option[:value] || option.content
+      end
+
+      VISIBILITY_XPATH = XPath.generate do |x|
+        x.ancestor_or_self[
+          x.attr(:style)[x.contains('display:none') | x.contains('display: none')] |
+          x.attr(:hidden) |
+          x.qname.one_of('script', 'head') |
+          (~x.self(:summary) & XPath.parent(:details)[!XPath.attr(:open)])
+        ].boolean
+      end.to_s.freeze
     end
   end
 end

data/lib/capybara/node/whitespace_normalizer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Node
+    ##
+    #
+    # {Capybara::Node::WhitespaceNormalizer} provides methods that
+    # help to normalize the spacing of text content inside of
+    # {Capybara::Node::Element}s by removing various unicode
+    # spacing and directional markings.
+    #
+    module WhitespaceNormalizer
+      # Unicode for NBSP, or  
+      NON_BREAKING_SPACE = "\u00a0"
+      LINE_SEPERATOR = "\u2028"
+      PARAGRAPH_SEPERATOR = "\u2029"
+
+      # All spaces except for NBSP
+      BREAKING_SPACES = "[[:space:]&&[^#{NON_BREAKING_SPACE}]]".freeze
+
+      # Whitespace we want to substitute with plain spaces
+      SQUEEZED_SPACES = " \n\f\t\v#{LINE_SEPERATOR}#{PARAGRAPH_SEPERATOR}".freeze
+
+      # Any whitespace at the front of text
+      LEADING_SPACES = /\A#{BREAKING_SPACES}+/
+
+      # Any whitespace at the end of text
+      TRAILING_SPACES = /#{BREAKING_SPACES}+\z/
+
+      # "Invisible" space character
+      ZERO_WIDTH_SPACE = "\u200b"
+
+      # Signifies text is read left to right
+      LEFT_TO_RIGHT_MARK = "\u200e"
+
+      # Signifies text is read right to left
+      RIGHT_TO_LEFT_MARK = "\u200f"
+
+      # Characters we want to truncate from text
+      REMOVED_CHARACTERS = [ZERO_WIDTH_SPACE, LEFT_TO_RIGHT_MARK, RIGHT_TO_LEFT_MARK].join
+
+      # Matches multiple empty lines
+      EMPTY_LINES = /[\ \n]*\n[\ \n]*/
+
+      ##
+      #
+      # Normalizes the spacing of a node's text to be similar to
+      # what matchers might expect.
+      #
+      # @param text [String]
+      # @return [String]
+      #
+      def normalize_spacing(text)
+        text
+          .delete(REMOVED_CHARACTERS)
+          .tr(SQUEEZED_SPACES, ' ')
+          .squeeze(' ')
+          .sub(LEADING_SPACES, '')
+          .sub(TRAILING_SPACES, '')
+          .tr(NON_BREAKING_SPACE, ' ')
+      end
+
+      ##
+      #
+      # Variant on {Capybara::Node::Normalizer#normalize_spacing} that
+      # targets the whitespace of visible elements only.
+      #
+      # @param text [String]
+      # @return [String]
+      #
+      def normalize_visible_spacing(text)
+        text
+          .squeeze(' ')
+          .gsub(EMPTY_LINES, "\n")
+          .sub(LEADING_SPACES, '')
+          .sub(TRAILING_SPACES, '')
+          .tr(NON_BREAKING_SPACE, ' ')
+      end
+    end
+  end
+end

data/lib/capybara/queries/active_element_query.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Capybara
+  # @api private
+  module Queries
+    class ActiveElementQuery < BaseQuery
+      def initialize(**options)
+        @options = options
+        super(@options)
+      end
+
+      def resolve_for(session)
+        node = session.driver.active_element
+        [Capybara::Node::Element.new(session, node, nil, self)]
+      end
+    end
+  end
+end

data/lib/capybara/queries/ancestor_query.rb

@@ -6,24 +6,23 @@ module Capybara
       # @api private
       def resolve_for(node, exact = nil)
         @child_node = node
+
         node.synchronize do
-          match_results = super(node.session.current_scope, exact)
-          node.all(:xpath, XPath.ancestor) { |el| match_results.include?(el) }
+          scope = node.respond_to?(:session) ? node.session.current_scope : node.find(:xpath, '/*')
+          match_results = super(scope, exact)
+          ancestors = node.find_xpath(XPath.ancestor.to_s)
+                          .map(&method(:to_element))
+                          .select { |el| match_results.include?(el) }
+          Capybara::Result.new(ordered_results(ancestors), self)
         end
       end
 
-      def description
+      def description(applied = false) # rubocop:disable Style/OptionalBooleanParameter
         child_query = @child_node&.instance_variable_get(:@query)
         desc = super
         desc += " that is an ancestor of #{child_query.description}" if child_query
         desc
       end
-
-    private
-
-      def valid_keys
-        super - COUNT_KEYS
-      end
     end
   end
 end

data/lib/capybara/queries/base_query.rb

@@ -23,9 +23,9 @@ module Capybara
 
       def self.wait(options, default = Capybara.default_max_wait_time)
         # if no value or nil for the :wait option is passed it should default to the default
-        w = options.fetch(:wait, nil)
-        w = default if w.nil?
-        w || 0
+        wait = options.fetch(:wait, nil)
+        wait = default if wait.nil?
+        wait || 0
       end
 
       ##
@@ -51,6 +51,7 @@ module Capybara
         return false if options[:maximum] && (Integer(options[:maximum]) < count)
         return false if options[:minimum] && (Integer(options[:minimum]) > count)
         return false if options[:between] && !options[:between].include?(count)
+
         true
       end
 
@@ -69,30 +70,36 @@ module Capybara
     private
 
       def count_specified?
-        COUNT_KEYS.any? { |k| options.key? k }
+        COUNT_KEYS.any? { |key| options.key? key }
       end
 
       def count_message
-        message = +""
-        if options[:count]
-          message << " #{options[:count]} #{Capybara::Helpers.declension('time', 'times', options[:count])}"
-        elsif options[:between]
-          message << " between #{options[:between].first} and #{options[:between].last} times"
-        elsif options[:maximum]
-          message << " at most #{options[:maximum]} #{Capybara::Helpers.declension('time', 'times', options[:maximum])}"
-        elsif options[:minimum]
-          message << " at least #{options[:minimum]} #{Capybara::Helpers.declension('time', 'times', options[:minimum])}"
+        message = +''
+        count, between, maximum, minimum = options.values_at(:count, :between, :maximum, :minimum)
+        if count
+          message << " #{occurrences count}"
+        elsif between
+          message << " between #{between.begin ? between.first : 1} and " \
+                     "#{between.end ? between.last : 'infinite'} times"
+        elsif maximum
+          message << " at most #{occurrences maximum}"
+        elsif minimum
+          message << " at least #{occurrences minimum}"
         end
         message
       end
 
+      def occurrences(count)
+        "#{count} #{Capybara::Helpers.declension('time', 'times', count)}"
+      end
+
       def assert_valid_keys
         invalid_keys = @options.keys - valid_keys
         return if invalid_keys.empty?
 
-        invalid_names = invalid_keys.map(&:inspect).join(", ")
-        valid_names = valid_keys.map(&:inspect).join(", ")
-        raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
+        invalid_names = invalid_keys.map(&:inspect).join(', ')
+        valid_names = valid_keys.map(&:inspect).join(', ')
+        raise ArgumentError, "Invalid option(s) #{invalid_names}, should be one of #{valid_names}"
       end
     end
   end

data/lib/capybara/queries/current_path_query.rb

@@ -6,26 +6,30 @@ module Capybara
   # @api private
   module Queries
     class CurrentPathQuery < BaseQuery
-      def initialize(expected_path, **options)
+      def initialize(expected_path, **options, &optional_filter_block)
         super(options)
         @expected_path = expected_path
         @options = {
-          url: !@expected_path.is_a?(Regexp) && !::Addressable::URI.parse(@expected_path || "").hostname.nil?,
+          url: !@expected_path.is_a?(Regexp) && !::Addressable::URI.parse(@expected_path || '').hostname.nil?,
           ignore_query: false
         }.merge(options)
+        @filter_block = optional_filter_block
         assert_valid_keys
       end
 
       def resolves_for?(session)
         uri = ::Addressable::URI.parse(session.current_url)
-        uri.query = nil if uri && options[:ignore_query]
-        @actual_path = options[:url] ? uri.to_s : uri&.request_uri
+        @actual_path = (options[:ignore_query] ? uri&.omit(:query) : uri).then do |u|
+          options[:url] ? u&.to_s : u&.request_uri
+        end
 
-        if @expected_path.is_a? Regexp
-          @actual_path.to_s.match(@expected_path)
+        res = if @expected_path.is_a? Regexp
+          @actual_path.to_s.match?(@expected_path)
         else
           ::Addressable::URI.parse(@expected_path) == ::Addressable::URI.parse(@actual_path)
         end
+
+        res && matches_filter_block?(uri)
       end
 
       def failure_message
@@ -38,6 +42,12 @@ module Capybara
 
     private
 
+      def matches_filter_block?(url)
+        return true unless @filter_block
+
+        @filter_block.call(url)
+      end
+
       def failure_message_helper(negated = '')
         verb = @expected_path.is_a?(Regexp) ? 'match' : 'equal'
         "expected #{@actual_path.inspect}#{negated} to #{verb} #{@expected_path.inspect}"

data/lib/capybara/queries/match_query.rb

@@ -14,6 +14,7 @@ module Capybara
         unless invalid_options.empty?
           raise ArgumentError, "Match queries don't support quantity options. Invalid keys - #{invalid_options.join(', ')}"
         end
+
         super
       end