capybara 3.29.0 → 3.37.1

data/lib/capybara/rspec/matchers.rb

@@ -15,45 +15,45 @@ module Capybara
     # RSpec matcher for whether the element(s) matching a given selector exist.
     #
     # @see Capybara::Node::Matchers#assert_selector
-    def have_selector(*args, &optional_filter_block)
-      Matchers::HaveSelector.new(*args, &optional_filter_block)
+    def have_selector(...)
+      Matchers::HaveSelector.new(...)
     end
 
     # RSpec matcher for whether the element(s) matching a group of selectors exist.
     #
     # @see Capybara::Node::Matchers#assert_all_of_selectors
-    def have_all_of_selectors(*args, &optional_filter_block)
-      Matchers::HaveAllSelectors.new(*args, &optional_filter_block)
+    def have_all_of_selectors(...)
+      Matchers::HaveAllSelectors.new(...)
     end
 
     # RSpec matcher for whether no element(s) matching a group of selectors exist.
     #
     # @see Capybara::Node::Matchers#assert_none_of_selectors
-    def have_none_of_selectors(*args, &optional_filter_block)
-      Matchers::HaveNoSelectors.new(*args, &optional_filter_block)
+    def have_none_of_selectors(...)
+      Matchers::HaveNoSelectors.new(...)
     end
 
     # RSpec matcher for whether the element(s) matching any of a group of selectors exist.
     #
     # @see Capybara::Node::Matchers#assert_any_of_selectors
-    def have_any_of_selectors(*args, &optional_filter_block)
-      Matchers::HaveAnySelectors.new(*args, &optional_filter_block)
+    def have_any_of_selectors(...)
+      Matchers::HaveAnySelectors.new(...)
     end
 
     # RSpec matcher for whether the current element matches a given selector.
     #
     # @see Capybara::Node::Matchers#assert_matches_selector
-    def match_selector(*args, &optional_filter_block)
-      Matchers::MatchSelector.new(*args, &optional_filter_block)
+    def match_selector(...)
+      Matchers::MatchSelector.new(...)
     end
 
     %i[css xpath].each do |selector|
       define_method "have_#{selector}" do |expr, **options, &optional_filter_block|
-        Matchers::HaveSelector.new(selector, expr, options, &optional_filter_block)
+        Matchers::HaveSelector.new(selector, expr, **options, &optional_filter_block)
       end
 
       define_method "match_#{selector}" do |expr, **options, &optional_filter_block|
-        Matchers::MatchSelector.new(selector, expr, options, &optional_filter_block)
+        Matchers::MatchSelector.new(selector, expr, **options, &optional_filter_block)
       end
     end
 
@@ -79,7 +79,7 @@ module Capybara
 
     %i[link button field select table].each do |selector|
       define_method "have_#{selector}" do |locator = nil, **options, &optional_filter_block|
-        Matchers::HaveSelector.new(selector, locator, options, &optional_filter_block)
+        Matchers::HaveSelector.new(selector, locator, **options, &optional_filter_block)
       end
     end
 
@@ -94,7 +94,7 @@ module Capybara
     #   @see Capybara::Node::Matchers#has_button?
 
     # @!method have_field(locator = nil, **options, &optional_filter_block)
-    #   RSpec matcher for links.
+    #   RSpec matcher for form fields.
     #
     #   @see Capybara::Node::Matchers#has_field?
 
@@ -110,7 +110,7 @@ module Capybara
 
     %i[checked unchecked].each do |state|
       define_method "have_#{state}_field" do |locator = nil, **options, &optional_filter_block|
-        Matchers::HaveSelector.new(:field, locator, options.merge(state => true), &optional_filter_block)
+        Matchers::HaveSelector.new(:field, locator, **options.merge(state => true), &optional_filter_block)
       end
     end
 
@@ -127,64 +127,65 @@ module Capybara
     # RSpec matcher for text content.
     #
     # @see Capybara::Node::Matchers#assert_text
-    def have_text(*args)
-      Matchers::HaveText.new(*args)
+    def have_text(text_or_type, *args, **options)
+      Matchers::HaveText.new(text_or_type, *args, **options)
     end
     alias_method :have_content, :have_text
 
     def have_title(title, **options)
-      Matchers::HaveTitle.new(title, options)
+      Matchers::HaveTitle.new(title, **options)
     end
 
     # RSpec matcher for the current path.
     #
     # @see Capybara::SessionMatchers#assert_current_path
-    def have_current_path(path, **options)
-      Matchers::HaveCurrentPath.new(path, options)
+    def have_current_path(path, **options, &optional_filter_block)
+      Matchers::HaveCurrentPath.new(path, **options, &optional_filter_block)
     end
 
     # RSpec matcher for element style.
     #
     # @see Capybara::Node::Matchers#matches_style?
-    def match_style(styles, **options)
-      Matchers::MatchStyle.new(styles, options)
+    def match_style(styles = nil, **options)
+      styles, options = options, {} if styles.nil?
+      Matchers::MatchStyle.new(styles, **options)
     end
 
     ##
     # @deprecated
     #
-    def have_style(styles, **options)
-      warn 'DEPRECATED: have_style is deprecated, please use match_style'
+    def have_style(styles = nil, **options)
+      Capybara::Helpers.warn "DEPRECATED: have_style is deprecated, please use match_style : #{Capybara::Helpers.filter_backtrace(caller)}"
       match_style(styles, **options)
     end
 
     %w[selector css xpath text title current_path link button
        field checked_field unchecked_field select table
        sibling ancestor].each do |matcher_type|
-      define_method "have_no_#{matcher_type}" do |*args, &optional_filter_block|
-        Matchers::NegatedMatcher.new(send("have_#{matcher_type}", *args, &optional_filter_block))
+      define_method "have_no_#{matcher_type}" do |*args, **kw_args, &optional_filter_block|
+        Matchers::NegatedMatcher.new(send("have_#{matcher_type}", *args, **kw_args, &optional_filter_block))
       end
     end
     alias_method :have_no_content, :have_no_text
 
     %w[selector css xpath].each do |matcher_type|
-      define_method "not_match_#{matcher_type}" do |*args, &optional_filter_block|
-        Matchers::NegatedMatcher.new(send("match_#{matcher_type}", *args, &optional_filter_block))
+      define_method "not_match_#{matcher_type}" do |*args, **kw_args, &optional_filter_block|
+        Matchers::NegatedMatcher.new(send("match_#{matcher_type}", *args, **kw_args, &optional_filter_block))
       end
     end
 
     # RSpec matcher for whether sibling element(s) matching a given selector exist.
     #
     # @see Capybara::Node::Matchers#assert_sibling
-    def have_sibling(*args, &optional_filter_block)
-      Matchers::HaveSibling.new(*args, &optional_filter_block)
+    def have_sibling(...)
+      Matchers::HaveSibling.new(...)
     end
 
     # RSpec matcher for whether ancestor element(s) matching a given selector exist.
     #
     # @see Capybara::Node::Matchers#assert_ancestor
-    def have_ancestor(*args, &optional_filter_block)
-      Matchers::HaveAncestor.new(*args, &optional_filter_block)
+    def have_ancestor(...)
+      Matchers::HaveAncestor.new(...)
     end
 
     ##

data/lib/capybara/rspec.rb

@@ -9,6 +9,8 @@ require 'capybara/rspec/matcher_proxies'
 RSpec.configure do |config|
   config.include Capybara::DSL, type: :feature
   config.include Capybara::RSpecMatchers, type: :feature
+  config.include Capybara::DSL, type: :system
+  config.include Capybara::RSpecMatchers, type: :system
   config.include Capybara::RSpecMatchers, type: :view
 
   # The before and after blocks must run instantaneously, because Capybara

data/lib/capybara/selector/builders/css_builder.rb

@@ -74,9 +74,9 @@ module Capybara
             end.join
           end
         else
-          cls = Array(classes).group_by { |cl| cl.match?(/^!(?!!!)/) }
+          cls = Array(classes).reject { |c| c.is_a? Regexp }.group_by { |cl| cl.match?(/^!(?!!!)/) }
           [(cls[false].to_a.map { |cl| ".#{Capybara::Selector::CSS.escape(cl.sub(/^!!/, ''))}" } +
-          cls[true].to_a.map { |cl| ":not(.#{Capybara::Selector::CSS.escape(cl.slice(1..-1))})" }).join]
+          cls[true].to_a.map { |cl| ":not(.#{Capybara::Selector::CSS.escape(cl.slice(1..))})" }).join]
         end
       end
     end

data/lib/capybara/selector/builders/xpath_builder.rb

@@ -15,6 +15,8 @@ module Capybara
       def add_attribute_conditions(**conditions)
         @expression = conditions.inject(expression) do |xp, (name, value)|
           conditions = name == :class ? class_conditions(value) : attribute_conditions(name => value)
+          return xp if conditions.nil?
+
           if xp.is_a? XPath::Expression
             xp[conditions]
           else
@@ -47,9 +49,9 @@ module Capybara
         when XPath::Expression, Regexp
           attribute_conditions(class: classes)
         else
-          Array(classes).map do |klass|
+          Array(classes).reject { |c| c.is_a? Regexp }.map do |klass|
             if klass.match?(/^!(?!!!)/)
-              !XPath.attr(:class).contains_word(klass.slice(1..-1))
+              !XPath.attr(:class).contains_word(klass.slice(1..))
             else
               XPath.attr(:class).contains_word(klass.sub(/^!!/, ''))
             end

data/lib/capybara/selector/css.rb

@@ -15,7 +15,7 @@ module Capybara
       end
 
       def self.escape_char(char)
-        char.match?(%r{[ -/:-~]}) ? "\\#{char}" : format('\\%06x', char.ord)
+        char.match?(%r{[ -/:-~]}) ? "\\#{char}" : format('\\%06<hex>x', hex: char.ord)
       end
 
       def self.split(css)
@@ -43,7 +43,7 @@ module Capybara
               when '"', "'"
                 selector << parse_string(char, str)
               when '\\'
-                selector << char + str.getc
+                selector << (char + str.getc)
               when ','
                 selectors << selector.strip
                 selector.clear

data/lib/capybara/selector/definition/button.rb

@@ -4,43 +4,65 @@ Capybara.add_selector(:button, locator_type: [String, Symbol]) do
   xpath(:value, :title, :type, :name) do |locator, **options|
     input_btn_xpath = XPath.descendant(:input)[XPath.attr(:type).one_of('submit', 'reset', 'image', 'button')]
     btn_xpath = XPath.descendant(:button)
+    aria_btn_xpath = XPath.descendant[XPath.attr(:role).equals('button')]
     image_btn_xpath = XPath.descendant(:input)[XPath.attr(:type) == 'image']
 
     unless locator.nil?
       locator = locator.to_s
-      locator_matchers = XPath.attr(:id).equals(locator) |
-                         XPath.attr(:name).equals(locator) |
-                         XPath.attr(:value).is(locator) |
-                         XPath.attr(:title).is(locator)
-      locator_matchers |= XPath.attr(:'aria-label').is(locator) if enable_aria_label
-      locator_matchers |= XPath.attr(test_id) == locator if test_id
+      locator_matchers = combine_locators(locator, config: self)
+      btn_matchers = locator_matchers |
+                     XPath.string.n.is(locator) |
+                     XPath.descendant(:img)[XPath.attr(:alt).is(locator)]
 
+      label_contains_xpath = locate_label(locator).descendant[labellable_elements]
       input_btn_xpath = input_btn_xpath[locator_matchers]
-
-      btn_xpath = btn_xpath[locator_matchers |
-                            XPath.string.n.is(locator) |
-                            XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
+      btn_xpath = btn_xpath[btn_matchers]
+      aria_btn_xpath = aria_btn_xpath[btn_matchers]
 
       alt_matches = XPath.attr(:alt).is(locator)
       alt_matches |= XPath.attr(:'aria-label').is(locator) if enable_aria_label
       image_btn_xpath = image_btn_xpath[alt_matches]
     end
 
-    %i[value title type name].inject(input_btn_xpath.union(btn_xpath).union(image_btn_xpath)) do |memo, ef|
-      memo[find_by_attr(ef, options[ef])]
+    btn_xpaths = [input_btn_xpath, btn_xpath, image_btn_xpath, label_contains_xpath].compact
+    btn_xpaths << aria_btn_xpath if enable_aria_role
+
+    %i[value title type].inject(btn_xpaths.inject(&:union)) do |memo, ef|
+      memo.where(find_by_attr(ef, options[ef]))
     end
   end
 
   node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| !(value ^ node.disabled?) }
   expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
 
+  node_filter(:name) { |node, value| !value.is_a?(Regexp) || value.match?(node[:name]) }
+  expression_filter(:name) do |xpath, val|
+    builder(xpath).add_attribute_conditions(name: val)
+  end
+
   describe_expression_filters do |disabled: nil, **options|
     desc = +''
     desc << ' that is not disabled' if disabled == false
-    desc << describe_all_expression_filters(options)
+    desc << describe_all_expression_filters(**options)
   end
 
   describe_node_filters do |disabled: nil, **|
     ' that is disabled' if disabled == true
   end
+
+  def combine_locators(locator, config:)
+    [
+      XPath.attr(:id).equals(locator),
+      XPath.attr(:name).equals(locator),
+      XPath.attr(:value).is(locator),
+      XPath.attr(:title).is(locator),
+      (XPath.attr(:id) == XPath.anywhere(:label)[XPath.string.n.is(locator)].attr(:for)),
+      (XPath.attr(:'aria-label').is(locator) if config.enable_aria_label),
+      (XPath.attr(config.test_id) == locator if config.test_id)
+    ].compact.inject(&:|)
+  end
+
+  def labellable_elements
+    (XPath.self(:input) & XPath.attr(:type).one_of('submit', 'reset', 'image', 'button')) | XPath.self(:button)
+  end
 end

data/lib/capybara/selector/definition/checkbox.rb

@@ -2,10 +2,10 @@
 
 Capybara.add_selector(:checkbox, locator_type: [String, Symbol]) do
   xpath do |locator, allow_self: nil, **options|
-    xpath = XPath.axis(allow_self ? :"descendant-or-self" : :descendant, :input)[
+    xpath = XPath.axis(allow_self ? :'descendant-or-self' : :descendant, :input)[
       XPath.attr(:type) == 'checkbox'
     ]
-    locate_field(xpath, locator, options)
+    locate_field(xpath, locator, **options)
   end
 
   filter_set(:_field, %i[checked unchecked disabled name])
@@ -20,7 +20,7 @@ Capybara.add_selector(:checkbox, locator_type: [String, Symbol]) do
   describe_node_filters do |option: nil, with: nil, **|
     desc = +''
     desc << " with value #{option.inspect}" if option
-    desc << " with value #{with.inspec}" if with
+    desc << " with value #{with.inspect}" if with
     desc
   end
 end

data/lib/capybara/selector/definition/css.rb

@@ -2,7 +2,9 @@
 
 Capybara.add_selector(:css, locator_type: [String, Symbol], raw_locator: true) do
   css do |css|
-    warn "DEPRECATED: Passing a symbol (#{css.inspect}) as the CSS locator is deprecated - please pass a string instead." if css.is_a? Symbol
+    if css.is_a? Symbol
+      Capybara::Helpers.warn "DEPRECATED: Passing a symbol (#{css.inspect}) as the CSS locator is deprecated - please pass a string instead : #{Capybara::Helpers.filter_backtrace(caller)}"
+    end
     css
   end
 end

data/lib/capybara/selector/definition/datalist_input.rb

@@ -5,7 +5,7 @@ Capybara.add_selector(:datalist_input, locator_type: [String, Symbol]) do
 
   xpath do |locator, **options|
     xpath = XPath.descendant(:input)[XPath.attr(:list)]
-    locate_field(xpath, locator, options)
+    locate_field(xpath, locator, **options)
   end
 
   filter_set(:_field, %i[disabled name placeholder])
@@ -19,7 +19,7 @@ Capybara.add_selector(:datalist_input, locator_type: [String, Symbol]) do
 
   expression_filter(:with_options) do |expr, options|
     options.inject(expr) do |xpath, option|
-      xpath[XPath.attr(:list) == XPath.anywhere(:datalist)[expression_for(:datalist_option, option)].attr(:id)]
+      xpath.where(XPath.attr(:list) == XPath.anywhere(:datalist)[expression_for(:datalist_option, option)].attr(:id))
     end
   end
 

data/lib/capybara/selector/definition/datalist_option.rb

@@ -16,7 +16,7 @@ Capybara.add_selector(:datalist_option, locator_type: [String, Symbol]) do
   describe_expression_filters do |disabled: nil, **options|
     desc = +''
     desc << ' that is not disabled' if disabled == false
-    desc << describe_all_expression_filters(options)
+    desc << describe_all_expression_filters(**options)
   end
 
   describe_node_filters do |**options|

data/lib/capybara/selector/definition/element.rb

@@ -18,8 +18,9 @@ Capybara.add_selector(:element, locator_type: [String, Symbol]) do
   end
 
   describe_expression_filters do |**options|
-    booleans, values = options.partition { |_k, v| [true, false].include? v }.map(&:to_h)
-    desc = describe_all_expression_filters(values)
+    boolean_values = [true, false]
+    booleans, values = options.partition { |_k, v| boolean_values.include? v }.map(&:to_h)
+    desc = describe_all_expression_filters(**values)
     desc + booleans.map do |k, v|
       v ? " with #{k} attribute" : "without #{k} attribute"
     end.join

data/lib/capybara/selector/definition/field.rb

@@ -7,7 +7,7 @@ Capybara.add_selector(:field, locator_type: [String, Symbol]) do
     invalid_types = %w[submit image]
     invalid_types << 'hidden' unless options[:type].to_s == 'hidden'
     xpath = XPath.descendant(:input, :textarea, :select)[!XPath.attr(:type).one_of(*invalid_types)]
-    locate_field(xpath, locator, options)
+    locate_field(xpath, locator, **options)
   end
 
   expression_filter(:type) do |expr, type|

data/lib/capybara/selector/definition/file_field.rb

@@ -3,10 +3,10 @@
 Capybara.add_selector(:file_field, locator_type: [String, Symbol]) do
   label 'file field'
   xpath do |locator, allow_self: nil, **options|
-    xpath = XPath.axis(allow_self ? :"descendant-or-self" : :descendant, :input)[
+    xpath = XPath.axis(allow_self ? :'descendant-or-self' : :descendant, :input)[
       XPath.attr(:type) == 'file'
     ]
-    locate_field(xpath, locator, options)
+    locate_field(xpath, locator, **options)
   end
 
   filter_set(:_field, %i[disabled multiple name])

data/lib/capybara/selector/definition/fillable_field.rb

@@ -3,10 +3,10 @@
 Capybara.add_selector(:fillable_field, locator_type: [String, Symbol]) do
   label 'field'
   xpath do |locator, allow_self: nil, **options|
-    xpath = XPath.axis(allow_self ? :"descendant-or-self" : :descendant, :input, :textarea)[
+    xpath = XPath.axis(allow_self ? :'descendant-or-self' : :descendant, :input, :textarea)[
       !XPath.attr(:type).one_of('submit', 'image', 'radio', 'checkbox', 'hidden', 'file')
     ]
-    locate_field(xpath, locator, options)
+    locate_field(xpath, locator, **options)
   end
 
   expression_filter(:type) do |expr, type|
@@ -18,7 +18,7 @@ Capybara.add_selector(:fillable_field, locator_type: [String, Symbol]) do
     end
   end
 
-  filter_set(:_field, %i[disabled multiple name placeholder valid])
+  filter_set(:_field, %i[disabled multiple name placeholder valid validation_message])
 
   node_filter(:with) do |node, with|
     val = node.value

data/lib/capybara/selector/definition/label.rb

@@ -2,7 +2,7 @@
 
 Capybara.add_selector(:label, locator_type: [String, Symbol]) do
   label 'label'
-  xpath(:for) do |locator, options|
+  xpath(:for) do |locator, **options|
     xpath = XPath.descendant(:label)
     unless locator.nil?
       locator_matchers = XPath.string.n.is(locator.to_s) | (XPath.attr(:id) == locator.to_s)
@@ -10,7 +10,9 @@ Capybara.add_selector(:label, locator_type: [String, Symbol]) do
       xpath = xpath[locator_matchers]
     end
     if options.key?(:for)
-      if (for_option = options[:for].is_a?(Capybara::Node::Element) ? options[:for][:id] : options[:for])
+      for_option = options[:for]
+      for_option = for_option[:id] if for_option.is_a?(Capybara::Node::Element)
+      if for_option && (for_option != '')
         with_attr = builder(XPath.self).add_attribute_conditions(for: for_option)
         wrapped = !XPath.attr(:for) &
                   builder(XPath.self.descendant(*labelable_elements)).add_attribute_conditions(id: for_option)
@@ -51,7 +53,7 @@ Capybara.add_selector(:label, locator_type: [String, Symbol]) do
     end
   end
   describe_node_filters do |**options|
-    " for element #{options[:for]}" if options[:for]&.is_a?(Capybara::Node::Element)
+    " for element #{options[:for]}" if options[:for].is_a?(Capybara::Node::Element)
   end
 
   def labelable_elements

data/lib/capybara/selector/definition/link.rb

@@ -5,6 +5,13 @@ Capybara.add_selector(:link, locator_type: [String, Symbol]) do
     xpath = XPath.descendant(:a)
     xpath = builder(xpath).add_attribute_conditions(href: href) unless href == false
 
+    if enable_aria_role
+      role_path = XPath.descendant[XPath.attr(:role).equals('link')]
+      role_path = builder(role_path).add_attribute_conditions(href: href) unless [true, false].include? href
+
+      xpath += role_path
+    end
+
     unless locator.nil?
       locator = locator.to_s
       matchers = [XPath.attr(:id) == locator,
@@ -18,6 +25,7 @@ Capybara.add_selector(:link, locator_type: [String, Symbol]) do
 
     xpath = xpath[find_by_attr(:title, title)]
     xpath = xpath[XPath.descendant(:img)[XPath.attr(:alt) == alt]] if alt
+
     xpath
   end
 

data/lib/capybara/selector/definition/radio_button.rb

@@ -3,10 +3,10 @@
 Capybara.add_selector(:radio_button, locator_type: [String, Symbol]) do
   label 'radio button'
   xpath do |locator, allow_self: nil, **options|
-    xpath = XPath.axis(allow_self ? :"descendant-or-self" : :descendant, :input)[
+    xpath = XPath.axis(allow_self ? :'descendant-or-self' : :descendant, :input)[
       XPath.attr(:type) == 'radio'
     ]
-    locate_field(xpath, locator, options)
+    locate_field(xpath, locator, **options)
   end
 
   filter_set(:_field, %i[checked unchecked disabled name])
@@ -21,7 +21,7 @@ Capybara.add_selector(:radio_button, locator_type: [String, Symbol]) do
   describe_node_filters do |option: nil, with: nil, **|
     desc = +''
     desc << " with value #{option.inspect}" if option
-    desc << " with value #{with.inspec}" if with
+    desc << " with value #{with.inspect}" if with
     desc
   end
 end

data/lib/capybara/selector/definition/select.rb

@@ -5,41 +5,47 @@ Capybara.add_selector(:select, locator_type: [String, Symbol]) do
 
   xpath do |locator, **options|
     xpath = XPath.descendant(:select)
-    locate_field(xpath, locator, options)
+    locate_field(xpath, locator, **options)
   end
 
   filter_set(:_field, %i[disabled multiple name placeholder])
 
   node_filter(:options) do |node, options|
-    actual = if node.visible?
-      node.all(:xpath, './/option', wait: false).map(&:text)
-    else
-      node.all(:xpath, './/option', visible: false, wait: false).map { |option| option.text(:all) }
-    end
+    actual = options_text(node)
     (options.sort == actual.sort).tap do |res|
       add_error("Expected options #{options.inspect} found #{actual.inspect}") unless res
     end
   end
 
+  node_filter(:enabled_options) do |node, options|
+    actual = options_text(node) { |o| !o.disabled? }
+    (options.sort == actual.sort).tap do |res|
+      add_error("Expected enabled options #{options.inspect} found #{actual.inspect}") unless res
+    end
+  end
+
+  node_filter(:disabled_options) do |node, options|
+    actual = options_text(node, &:disabled?)
+    (options.sort == actual.sort).tap do |res|
+      add_error("Expected disabled options #{options.inspect} found #{actual.inspect}") unless res
+    end
+  end
+
   expression_filter(:with_options) do |expr, options|
     options.inject(expr) do |xpath, option|
-      xpath[expression_for(:option, option)]
+      xpath.where(expression_for(:option, option))
     end
   end
 
   node_filter(:selected) do |node, selected|
-    actual = node.all(:xpath, './/option', visible: false, wait: false)
-                 .select(&:selected?)
-                 .map { |option| option.text(:all) }
+    actual = options_text(node, visible: false, &:selected?)
     (Array(selected).sort == actual.sort).tap do |res|
       add_error("Expected #{selected.inspect} to be selected found #{actual.inspect}") unless res
     end
   end
 
   node_filter(:with_selected) do |node, selected|
-    actual = node.all(:xpath, './/option', visible: false, wait: false)
-                 .select(&:selected?)
-                 .map { |option| option.text(:all) }
+    actual = options_text(node, visible: false, &:selected?)
     (Array(selected) - actual).empty?.tap do |res|
       add_error("Expected at least #{selected.inspect} to be selected found #{actual.inspect}") unless res
     end
@@ -51,12 +57,25 @@ Capybara.add_selector(:select, locator_type: [String, Symbol]) do
     desc
   end
 
-  describe_node_filters do |options: nil, selected: nil, with_selected: nil, disabled: nil, **|
+  describe_node_filters do |
+    options: nil, disabled_options: nil, enabled_options: nil,
+    selected: nil, with_selected: nil,
+    disabled: nil, **|
     desc = +''
     desc << " with options #{options.inspect}" if options
+    desc << " with disabled options #{disabled_options.inspect}}" if disabled_options
+    desc << " with enabled options #{enabled_options.inspect}" if enabled_options
     desc << " with #{selected.inspect} selected" if selected
     desc << " with at least #{with_selected.inspect} selected" if with_selected
     desc << ' which is disabled' if disabled
     desc
   end
+
+  def options_text(node, **opts, &filter_block)
+    opts[:wait] = false
+    opts[:visible] = false unless node.visible?
+    node.all(:xpath, './/option', **opts, &filter_block).map do |o|
+      o.text((:all if opts[:visible] == false))
+    end
+  end
 end

data/lib/capybara/selector/definition/table.rb

@@ -19,7 +19,10 @@ Capybara.add_selector(:table, locator_type: [String, Symbol]) do
           header = XPath.descendant(:th)[XPath.string.n.is(header)]
           td = XPath.descendant(:tr)[header].descendant(:td)
           cell_condition = XPath.string.n.is(cell_str)
-          cell_condition &= prev_col_position?(XPath.ancestor(:table)[1].join(xp)) if xp
+          if xp
+            prev_cell = XPath.ancestor(:table)[1].join(xp)
+            cell_condition &= (prev_cell & prev_col_position?(prev_cell))
+          end
           td[cell_condition]
         end
       else
@@ -28,7 +31,7 @@ Capybara.add_selector(:table, locator_type: [String, Symbol]) do
 
           if prev_cell
             prev_cell = XPath.ancestor(:tr)[1].preceding_sibling(:tr).join(prev_cell)
-            cell_condition &= prev_col_position?(prev_cell)
+            cell_condition &= (prev_cell & prev_col_position?(prev_cell))
           end
 
           XPath.descendant(:td)[cell_condition]
@@ -40,7 +43,7 @@ Capybara.add_selector(:table, locator_type: [String, Symbol]) do
   end
 
   expression_filter(:cols, valid_values: [Array]) do |xpath, cols|
-    raise ArgumentError, ':cols must be an Array of Arrays' unless cols.all? { |col| col.is_a? Array }
+    raise ArgumentError, ':cols must be an Array of Arrays' unless cols.all?(Array)
 
     rows = cols.transpose
     col_conditions = rows.map { |row| match_row(row, match_size: true) }.reduce(:&)

data/lib/capybara/selector/definition/table_row.rb

@@ -9,12 +9,12 @@ Capybara.add_selector(:table_row, locator_type: [Array, Hash]) do
         cell_xp = XPath.descendant(:td)[
           XPath.string.n.is(cell) & XPath.position.equals(header_xp.preceding_sibling.count.plus(1))
         ]
-        xp[cell_xp]
+        xp.where(cell_xp)
       end
     else
       initial_td = XPath.descendant(:td)[XPath.string.n.is(locator.shift)]
       tds = locator.reverse.map { |cell| XPath.following_sibling(:td)[XPath.string.n.is(cell)] }
-                   .reduce { |xp, cell| xp[cell] }
+                   .reduce { |xp, cell| xp.where(cell) }
       xpath[initial_td[tds]]
     end
   end