capybara 3.13.2 → 3.40.0

data/lib/capybara/node/simple.rb

@@ -100,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)
+      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
           !find_xpath(VISIBILITY_XPATH)
         else
           # No need for an xpath if only checking the current element
-          !(native.key?('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
 
@@ -127,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
 
       ##
@@ -144,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
 
@@ -183,6 +191,10 @@ module Capybara
         {}
       end
 
+      def ==(other)
+        eql?(other) || (other.respond_to?(:native) && native == other.native)
+      end
+
     private
 
       def option_value(option)
@@ -195,7 +207,8 @@ module Capybara
         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.qname.one_of('script', 'head') |
+          (~x.self(:summary) & XPath.parent(:details)[!XPath.attr(:open)])
         ].boolean
       end.to_s.freeze
     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(applied = false)
+      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

@@ -79,7 +79,8 @@ module Capybara
         if count
           message << " #{occurrences count}"
         elsif between
-          message << " between #{between.first} and #{between.end ? between.last : 'infinite'} times"
+          message << " between #{between.begin ? between.first : 1} and " \
+                     "#{between.end ? between.last : 'infinite'} times"
         elsif maximum
           message << " at most #{occurrences maximum}"
         elsif minimum
@@ -98,7 +99,7 @@ module Capybara
 
         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}"
+        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?,
           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 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}"