capybara 3.35.0 → 3.40.0

data/lib/capybara/dsl.rb

@@ -47,17 +47,11 @@ module Capybara
     end
 
     Session::DSL_METHODS.each do |method|
-      if RUBY_VERSION >= '2.7'
-        class_eval <<~METHOD, __FILE__, __LINE__ + 1
-          def #{method}(...)
-            page.method("#{method}").call(...)
-          end
-        METHOD
-      else
-        define_method method do |*args, &block|
-          page.send method, *args, &block
+      class_eval <<~METHOD, __FILE__, __LINE__ + 1
+        def #{method}(...)
+          page.method("#{method}").call(...)
         end
-      end
+      METHOD
     end
   end
 

data/lib/capybara/helpers.rb

@@ -73,28 +73,23 @@ module Capybara
     def filter_backtrace(trace)
       return 'No backtrace' unless trace
 
-      filter = %r{lib/capybara/|lib/rspec/|lib/minitest/}
+      filter = %r{lib/capybara/|lib/rspec/|lib/minitest/|delegate.rb}
       new_trace = trace.take_while { |line| line !~ filter }
-      new_trace = trace.reject { |line| line =~ filter } if new_trace.empty?
+      new_trace = trace.grep_v(filter) if new_trace.empty?
       new_trace = trace.dup if new_trace.empty?
 
-      new_trace.first.split(/:in /, 2).first
+      new_trace.first.split(':in ', 2).first
     end
 
     def warn(message, uplevel: 1)
-      return Kernel.warn(message, uplevel: uplevel) if RUBY_VERSION >= '2.6'
-
-      # TODO: Remove when we drop support for Ruby 2.5
-      # Workaround for emulating `warn '...', uplevel: n` in Ruby 2.5 or lower.
-      if (match = /^(?<file>.+?):(?<line>\d+)(?::in `.*')?/.match(caller[uplevel]))
-        location = [match[:file], match[:line]].join(':')
-        Kernel.warn "#{location}: #{message}"
-      else
-        Kernel.warn message
-      end
+      Kernel.warn(message, uplevel: uplevel)
     end
 
-    if defined?(Process::CLOCK_MONOTONIC)
+    if defined?(Process::CLOCK_MONOTONIC_RAW)
+      def monotonic_time; Process.clock_gettime Process::CLOCK_MONOTONIC_RAW; end
+    elsif defined?(Process::CLOCK_MONOTONIC_PRECISE)
+      def monotonic_time; Process.clock_gettime Process::CLOCK_MONOTONIC_PRECISE; end
+    elsif defined?(Process::CLOCK_MONOTONIC)
       def monotonic_time; Process.clock_gettime Process::CLOCK_MONOTONIC; end
     else
       def monotonic_time; Time.now.to_f; end

data/lib/capybara/minitest/spec.rb

@@ -95,6 +95,18 @@ module Capybara
       # @!method wont_have_field
       #   See {Capybara::Node::Matchers#has_no_field?}
 
+      ##
+      # Expectation that there is element
+      #
+      # @!method must_have_element
+      #   See {Capybara::Node::Matchers#has_element?}
+
+      ##
+      # Expectation that there is no element
+      #
+      # @!method wont_have_element
+      #   See {Capybara::Node::Matchers#has_no_element?}
+
       ##
       # Expectation that there is link
       #
@@ -230,15 +242,15 @@ module Capybara
          %W[refute_matches_#{assertion} wont_match_#{assertion}]]
       end).each do |(meth, new_name)|
         class_eval <<-ASSERTION, __FILE__, __LINE__ + 1
-          def #{new_name} *args, **kw_args, &block
-            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).#{new_name}(*args, **kw_args, &block)
+          def #{new_name}(...)
+            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).#{new_name}(...)
           end
         ASSERTION
 
         ::Minitest::Expectation.class_eval <<-ASSERTION, __FILE__, __LINE__ + 1
-          def #{new_name} *args, **kw_args, &block
+          def #{new_name}(...)
             raise "Calling ##{new_name} outside of test." unless ctx
-            ctx.#{meth}(target, *args, **kw_args, &block)
+            ctx.#{meth}(target, ...)
           end
         ASSERTION
       end
@@ -246,9 +258,9 @@ module Capybara
 
       ##
       # @deprecated
-      def must_have_style(*args, **kw_args, &block)
+      def must_have_style(...)
         warn 'must_have_style is deprecated, please use must_match_style'
-        must_match_style(*args, **kw_args, &block)
+        must_match_style(...)
       end
     end
   end

data/lib/capybara/minitest.rb

@@ -190,6 +190,19 @@ module Capybara
       # @!method assert_no_css
       #   See {Capybara::Node::Matchers#has_no_css?}
 
+      ##
+      # Assert that provided element exists
+      #
+      # @!method assert_element
+      #   See {Capybara::Node::Matchers#has_element?}
+
+      ##
+      # Assert that provided element does not exist
+      #
+      # @!method assert_no_element
+      # @!method refute_element
+      #   See {Capybara::Node::Matchers#has_no_element?}
+
       ##
       # Assert that provided link exists
       #
@@ -281,7 +294,7 @@ module Capybara
       # @!method assert_no_table
       #   See {Capybara::Node::Matchers#has_no_table?}
 
-      %w[xpath css link button field select table].each do |selector_type|
+      %w[xpath css element link button field select table].each do |selector_type|
         define_method "assert_#{selector_type}" do |*args, &optional_filter_block|
           subject, args = determine_subject(args)
           locator, options = extract_locator(args)

data/lib/capybara/node/actions.rb

@@ -92,8 +92,9 @@ module Capybara
       end
 
       # @!macro label_click
-      #   @option options [Boolean] allow_label_click
+      #   @option options [Boolean, Hash] allow_label_click
       #     Attempt to click the label to toggle state if element is non-visible. Defaults to {Capybara.configure automatic_label_click}.
+      #     If set to a Hash it is passed as options to the `click` on the label
 
       ##
       #
@@ -277,7 +278,7 @@ module Capybara
       # @return [Capybara::Node::Element]  The file field element
       def attach_file(locator = nil, paths, make_visible: nil, **options) # rubocop:disable Style/OptionalArguments
         if locator && block_given?
-          raise ArgumentError, '``#attach_file` does not support passing both a locator and a block'
+          raise ArgumentError, '`#attach_file` does not support passing both a locator and a block'
         end
 
         Array(paths).each do |path|
@@ -314,7 +315,7 @@ module Capybara
 
           begin
             find(:datalist_input, from, **options)
-          rescue Capybara::ElementNotFound => dlinput_error # rubocop:disable Naming/RescuedExceptionsVariableName
+          rescue Capybara::ElementNotFound => dlinput_error
             raise Capybara::ElementNotFound, "#{select_error.message} and #{dlinput_error.message}"
           end
         end
@@ -371,14 +372,18 @@ module Capybara
 
           begin
             el ||= find(selector, locator, **options.merge(visible: :all))
-            el.session.find(:label, for: el, visible: true, match: :first).click unless el.checked? == checked
+            unless el.checked? == checked
+              el.session
+                .find(:label, for: el, visible: true, match: :first)
+                .click(**(Hash.try_convert(allow_label_click) || {}))
+            end
           rescue StandardError # swallow extra errors - raise original
             raise e
           end
         end
       end
 
-      UPDATE_STYLE_SCRIPT = <<~'JS'
+      UPDATE_STYLE_SCRIPT = <<~JS
         this.capybara_style_cache = this.style.cssText;
         var css = arguments[0];
         for (var prop in css){
@@ -388,27 +393,27 @@ module Capybara
         }
       JS
 
-      RESET_STYLE_SCRIPT = <<~'JS'
+      RESET_STYLE_SCRIPT = <<~JS
         if (this.hasOwnProperty('capybara_style_cache')) {
           this.style.cssText = this.capybara_style_cache;
           delete this.capybara_style_cache;
         }
       JS
 
-      DATALIST_OPTIONS_SCRIPT = <<~'JS'
+      DATALIST_OPTIONS_SCRIPT = <<~JS
         Array.prototype.slice.call((this.list||{}).options || []).
           filter(function(el){ return !el.disabled }).
           map(function(el){ return { "value": el.value, "label": el.label} })
       JS
 
-      CAPTURE_FILE_ELEMENT_SCRIPT = <<~'JS'
+      CAPTURE_FILE_ELEMENT_SCRIPT = <<~JS
         document.addEventListener('click', function file_catcher(e){
           if (e.target.matches("input[type='file']")) {
             window._capybara_clicked_file_input = e.target;
             this.removeEventListener('click', file_catcher);
             e.preventDefault();
           }
-        })
+        }, {capture: true})
       JS
     end
   end

data/lib/capybara/node/base.rb

@@ -77,6 +77,7 @@ module Capybara
         return yield if session.synchronized
 
         seconds = session_options.default_max_wait_time if [nil, true].include? seconds
+        interval = session_options.default_retry_interval
         session.synchronized = true
         timer = Capybara::Helpers.timer(expire_in: seconds)
         begin
@@ -88,7 +89,7 @@ module Capybara
           if driver.wait?
             raise e if timer.expired?
 
-            sleep(0.01)
+            sleep interval
             reload if session_options.automatic_reload
           else
             old_base = @base

data/lib/capybara/node/document.rb

@@ -40,8 +40,8 @@ module Capybara
         find(:xpath, '/html').evaluate_script(*args)
       end
 
-      def scroll_to(*args, **options)
-        find(:xpath, '//body').scroll_to(*args, **options)
+      def scroll_to(*args, quirks: false, **options)
+        find(:xpath, quirks ? '//body' : '/html').scroll_to(*args, **options)
       end
     end
   end

data/lib/capybara/node/element.rb

@@ -115,7 +115,7 @@ module Capybara
       #
       # @return [Capybara::Node::Element]  The element
       def set(value, **options)
-        if ENV['CAPYBARA_THOROUGH'] && readonly?
+        if ENV.fetch('CAPYBARA_THOROUGH', nil) && readonly?
           raise Capybara::ReadOnlyElementError, "Attempt to set readonly element with value: #{value}"
         end
 
@@ -472,6 +472,17 @@ module Capybara
         self
       end
 
+      ##
+      #
+      # Return the shadow_root for the current element
+      #
+      # @return [Capybara::Node::Element]  The shadow root
+
+      def shadow_root
+        root = synchronize { base.shadow_root }
+        root && Capybara::Node::Element.new(session, root, nil, nil)
+      end
+
       ##
       #
       # Execute the given JS in the context of the element not returning a result. This is useful for scripts that return
@@ -550,7 +561,7 @@ module Capybara
         return self unless @allow_reload
 
         begin
-          reloaded = @query.resolve_for(query_scope.reload)[@query_idx.to_i]
+          reloaded = @query.resolve_for(query_scope ? query_scope.reload : session)[@query_idx.to_i]
           @base = reloaded.base if reloaded
         rescue StandardError => e
           raise e unless catch_error?(e)

data/lib/capybara/node/finders.rb

@@ -18,11 +18,11 @@ module Capybara
       #
       # @!macro system_filters
       #   @option options [String, Regexp] text      Only find elements which contain this text or match this regexp
-      #   @option options [String, Boolean] exact_text
+      #   @option options [String, Regexp, String] exact_text
       #     When String the elements contained text must match exactly, when Boolean controls whether the `text` option must match exactly.
       #     Defaults to {Capybara.configure exact_text}.
       #   @option options [Boolean] normalize_ws
-      #     Whether the `text`/`exact_text` options are compared against elment text with whitespace normalized or as returned by the driver.
+      #     Whether the `text`/`exact_text` options are compared against element text with whitespace normalized or as returned by the driver.
       #     Defaults to {Capybara.configure default_normalize_ws}.
       #   @option options [Boolean, Symbol] visible
       #     Only find elements with the specified visibility. Defaults to behavior indicated by {Capybara.configure ignore_hidden_elements}.
@@ -50,6 +50,13 @@ module Capybara
       #
       def find(*args, **options, &optional_filter_block)
         options[:session_options] = session_options
+        count_options = options.slice(*Capybara::Queries::BaseQuery::COUNT_KEYS)
+        unless count_options.empty?
+          Capybara::Helpers.warn(
+            "'find' does not support count options (#{count_options}) ignoring. " \
+            "Called from: #{Capybara::Helpers.filter_backtrace(caller)}"
+          )
+        end
         synced_resolve Capybara::Queries::SelectorQuery.new(*args, **options, &optional_filter_block)
       end
 
@@ -142,6 +149,8 @@ module Capybara
       #   @option options [String, Regexp] id         Match links with the id provided
       #   @option options [String] title              Match links with the title provided
       #   @option options [String] alt                Match links with a contained img element whose alt matches
+      #   @option options [String, Boolean] download  Match links with the download provided
+      #   @option options [String] target             Match links with the target provided
       #   @option options [String, Array<String>, Regexp] class    Match links that match the class(es) provided
       # @return [Capybara::Node::Element]   The found element
       #

data/lib/capybara/node/matchers.rb

@@ -322,6 +322,31 @@ module Capybara
         has_no_selector?(:css, path, **options, &optional_filter_block)
       end
 
+      ##
+      #
+      # Checks if the page or current node has a element with the given
+      # local name.
+      #
+      # @param [String] locator           The local name of a element to check for
+      # @option options [String, Regexp]  The attributes values of matching elements
+      # @return [Boolean]                 Whether it exists
+      #
+      def has_element?(locator = nil, **options, &optional_filter_block)
+        has_selector?(:element, locator, **options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Checks if the page or current node has no element with the given
+      # local name.
+      #
+      # @param (see #has_element?)
+      # @return [Boolean]            Whether it doesn't exist
+      #
+      def has_no_element?(locator = nil, **options, &optional_filter_block)
+        has_no_selector?(:element, locator, **options, &optional_filter_block)
+      end
+
       ##
       #
       # Checks if the page or current node has a link with the given

data/lib/capybara/node/simple.rb

@@ -110,7 +110,7 @@ module Capybara
           # No need for an xpath if only checking the current element
           !(native.key?('hidden') ||
             /display:\s?none/.match?(native[:style] || '') ||
-            %w[script head].include?(tag_name))
+            %w[script head style].include?(tag_name))
         end
       end
 
@@ -191,6 +191,10 @@ module Capybara
         {}
       end
 
+      def ==(other)
+        eql?(other) || (other.respond_to?(:native) && native == other.native)
+      end
+
     private
 
       def option_value(option)

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

@@ -8,7 +8,8 @@ module Capybara
         @child_node = node
 
         node.synchronize do
-          match_results = super(node.session.current_scope, exact)
+          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) }

data/lib/capybara/queries/base_query.rb

@@ -79,8 +79,8 @@ module Capybara
         if count
           message << " #{occurrences count}"
         elsif between
-          message << " between #{between.begin ? between.first : 1} 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

data/lib/capybara/queries/current_path_query.rb

@@ -19,7 +19,7 @@ module Capybara
 
       def resolves_for?(session)
         uri = ::Addressable::URI.parse(session.current_url)
-        @actual_path = (options[:ignore_query] ? uri&.omit(:query) : uri).yield_self do |u|
+        @actual_path = (options[:ignore_query] ? uri&.omit(:query) : uri).then do |u|
           options[:url] ? u&.to_s : u&.request_uri
         end
 

data/lib/capybara/queries/selector_query.rb

@@ -9,7 +9,7 @@ module Capybara
 
       SPATIAL_KEYS = %i[above below left_of right_of near].freeze
       VALID_KEYS = SPATIAL_KEYS + COUNT_KEYS +
-                   %i[text id class style visible obscured exact exact_text normalize_ws match wait filter_set]
+                   %i[text id class style visible obscured exact exact_text normalize_ws match wait filter_set focused]
       VALID_MATCH = %i[first smart prefer_exact one].freeze
 
       def initialize(*args,
@@ -27,6 +27,12 @@ module Capybara
         @order = order
         @filter_cache = Hash.new { |hsh, key| hsh[key] = {} }
 
+        if @options[:text].is_a?(Regexp) && [true, false].include?(@options[:exact_text])
+          Capybara::Helpers.warn(
+            "Boolean 'exact_text' option is not supported when 'text' option is a Regexp - ignoring"
+          )
+        end
+
         super(@options)
         self.session_options = session_options
 
@@ -64,7 +70,8 @@ module Capybara
           desc << 'non-visible ' if visible == :hidden
         end
 
-        desc << "#{label} #{locator.inspect}"
+        desc << label.to_s
+        desc << " #{locator.inspect}" unless locator.nil?
 
         if show_for[:any]
           desc << " with#{' exact' if exact_text == true} text #{options[:text].inspect}" if options[:text]
@@ -73,6 +80,8 @@ module Capybara
 
         desc << " with id #{options[:id]}" if options[:id]
         desc << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
+        desc << ' that is focused' if options[:focused]
+        desc << ' that is not focused' if options[:focused] == false
 
         desc << case options[:style]
         when String
@@ -264,7 +273,7 @@ module Capybara
       end
 
       def valid_keys
-        VALID_KEYS + custom_keys
+        (VALID_KEYS + custom_keys).uniq
       end
 
       def matches_node_filters?(node, errors)
@@ -371,6 +380,10 @@ module Capybara
         options.key?(:style) && !custom_keys.include?(:style)
       end
 
+      def use_default_focused_filter?
+        options.key?(:focused) && !custom_keys.include?(:focused)
+      end
+
       def use_spatial_filter?
         options.values_at(*SPATIAL_KEYS).compact.any?
       end
@@ -435,6 +448,7 @@ module Capybara
           matches_id_filter?(node) &&
           matches_class_filter?(node) &&
           matches_style_filter?(node) &&
+          matches_focused_filter?(node) &&
           matches_text_filter?(node) &&
           matches_exact_text_filter?(node)
       end
@@ -494,6 +508,12 @@ module Capybara
         end
       end
 
+      def matches_focused_filter?(node)
+        return true unless use_default_focused_filter?
+
+        (node == node.session.active_element) == options[:focused]
+      end
+
       def need_to_process_classes?
         case options[:class]
         when Regexp then true
@@ -528,16 +548,19 @@ module Capybara
       def matches_text_filter?(node)
         value = options[:text]
         return true unless value
-        return matches_text_exactly?(node, value) if exact_text == true
+        return matches_text_exactly?(node, value) if exact_text == true && !value.is_a?(Regexp)
 
         regexp = value.is_a?(Regexp) ? value : Regexp.escape(value.to_s)
         matches_text_regexp?(node, regexp)
       end
 
       def matches_exact_text_filter?(node)
-        return true unless exact_text.is_a?(String)
-
-        matches_text_exactly?(node, exact_text)
+        case exact_text
+        when String, Regexp
+          matches_text_exactly?(node, exact_text)
+        else
+          true
+        end
       end
 
       def matches_visibility_filters?(node)
@@ -548,7 +571,9 @@ module Capybara
         when :visible
           node.initial_cache[:visible] || (node.initial_cache[:visible].nil? && node.visible?)
         when :hidden
-          (node.initial_cache[:visible] == false) || (node.initial_cache[:visbile].nil? && !node.visible?)
+          # TODO: check why the 'visbile' cache spelling mistake wasn't caught in a test
+          # (node.initial_cache[:visible] == false) || (node.initial_cache[:visbile].nil? && !node.visible?)
+          (node.initial_cache[:visible] == false) || (node.initial_cache[:visible].nil? && !node.visible?)
         else
           true
         end
@@ -565,17 +590,21 @@ module Capybara
 
       def matches_text_exactly?(node, value)
         regexp = value.is_a?(Regexp) ? value : /\A#{Regexp.escape(value.to_s)}\z/
-        matches_text_regexp?(node, regexp)
+        matches_text_regexp(node, regexp).then { |m| m&.pre_match == '' && m&.post_match == '' }
       end
 
       def normalize_ws
         options.fetch(:normalize_ws, session_options.default_normalize_ws)
       end
 
-      def matches_text_regexp?(node, regexp)
+      def matches_text_regexp(node, regexp)
         text_visible = visible
         text_visible = :all if text_visible == :hidden
-        node.text(text_visible, normalize_ws: normalize_ws).match?(regexp)
+        node.text(text_visible, normalize_ws: normalize_ws).match(regexp)
+      end
+
+      def matches_text_regexp?(node, regexp)
+        !matches_text_regexp(node, regexp).nil?
       end
 
       def default_visibility

data/lib/capybara/queries/sibling_query.rb

@@ -7,7 +7,8 @@ module Capybara
       def resolve_for(node, exact = nil)
         @sibling_node = node
         node.synchronize do
-          match_results = super(node.session.current_scope, exact)
+          scope = node.respond_to?(:session) ? node.session.current_scope : node.find(:xpath, '/*')
+          match_results = super(scope, exact)
           siblings = node.find_xpath((XPath.preceding_sibling + XPath.following_sibling).to_s)
                          .map(&method(:to_element))
                          .select { |el| match_results.include?(el) }

data/lib/capybara/queries/text_query.rb

@@ -13,7 +13,7 @@ module Capybara
         self.session_options = session_options
 
         if expected_text.nil? && !exact?
-          warn 'Checking for expected text of nil is confusing and/or pointless since it will always match. '\
+          warn 'Checking for expected text of nil is confusing and/or pointless since it will always match. ' \
                "Please specify a string or regexp instead. #{Capybara::Helpers.filter_backtrace(caller)}"
         end