capybara 3.10.1 → 3.11.0

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

@@ -44,9 +44,9 @@ module Capybara
         def regexp_to_xpath_conditions(regexp)
           condition = XPath.current
           condition = condition.uppercase if regexp.casefold?
-          Selector::RegexpDisassembler.new(regexp).substrings.map do |str|
-            condition.contains(str)
-          end.reduce(:&)
+          Selector::RegexpDisassembler.new(regexp).alternated_substrings.map do |strs|
+            strs.map { |str| condition.contains(str) }.reduce(:&)
+          end.reduce(:|)
         end
       end
     end

data/lib/capybara/selector/css.rb

@@ -21,11 +21,11 @@ module Capybara
       end
 
       S = '\u{80}-\u{D7FF}\u{E000}-\u{FFFD}\u{10000}-\u{10FFFF}'
-      H = /[0-9a-fA-F]/
-      UNICODE  = /\\#{H}{1,6}[ \t\r\n\f]?/
-      NONASCII = /[#{S}]/
-      ESCAPE   = /#{UNICODE}|\\[ -~#{S}]/
-      NMSTART = /[_a-zA-Z]|#{NONASCII}|#{ESCAPE}/
+      H = /[0-9a-fA-F]/.freeze
+      UNICODE  = /\\#{H}{1,6}[ \t\r\n\f]?/.freeze
+      NONASCII = /[#{S}]/.freeze
+      ESCAPE   = /#{UNICODE}|\\[ -~#{S}]/.freeze
+      NMSTART = /[_a-zA-Z]|#{NONASCII}|#{ESCAPE}/.freeze
 
       class Splitter
         def split(css)

data/lib/capybara/selector/filters/base.rb

@@ -28,6 +28,10 @@ module Capybara
           !@matcher.nil?
         end
 
+        def boolean?
+          !!@options[:boolean]
+        end
+
         def handles_option?(option_name)
           if matcher?
             option_name =~ @matcher
@@ -38,17 +42,21 @@ module Capybara
 
       private
 
-        def apply(subject, name, value, skip_value)
+        def apply(subject, name, value, skip_value, ctx)
           return skip_value if skip?(value)
           raise ArgumentError, "Invalid value #{value.inspect} passed to #{self.class.name.split('::').last} #{name}#{" : #{@name}" if @name.is_a?(Regexp)}" unless valid_value?(value)
 
           if @block.arity == 2
-            @block.call(subject, value)
+            filter_context(ctx).instance_exec(subject, value, &@block)
           else
-            @block.call(subject, name, value)
+            filter_context(ctx).instance_exec(subject, name, value, &@block)
           end
         end
 
+        def filter_context(context)
+          context || @block.binding.receiver
+        end
+
         def valid_value?(value)
           return true unless @options.key?(:valid_values)
 

data/lib/capybara/selector/filters/expression_filter.rb

@@ -6,8 +6,8 @@ module Capybara
   class Selector
     module Filters
       class ExpressionFilter < Base
-        def apply_filter(expr, name, value)
-          apply(expr, name, value, expr)
+        def apply_filter(expr, name, value, selector)
+          apply(expr, name, value, expr, selector)
         end
       end
 
@@ -15,7 +15,7 @@ module Capybara
         def initialize(name); super(name, nil, nil); end
         def default?; false; end
         def matcher?; false; end
-        def apply_filter(expr, _name, _value); expr; end
+        def apply_filter(expr, _name, _value, _ctx); expr; end
       end
     end
   end

data/lib/capybara/selector/filters/node_filter.rb

@@ -6,8 +6,22 @@ module Capybara
   class Selector
     module Filters
       class NodeFilter < Base
-        def matches?(node, name, value)
-          apply(node, name, value, true)
+        def initialize(name, matcher, block, **options)
+          super
+          @block = if boolean?
+            proc do |node, value|
+              error_cnt = errors.size
+              block.call(node, value).tap do |res|
+                add_error("Expected #{name} #{value} but it wasn't") if !res && error_cnt == errors.size
+              end
+            end
+          else
+            block
+          end
+        end
+
+        def matches?(node, name, value, context = nil)
+          apply(node, name, value, true, context)
         rescue Capybara::ElementNotFound
           false
         end

data/lib/capybara/selector/regexp_disassembler.rb

@@ -10,56 +10,155 @@ module Capybara
         @regexp = regexp
       end
 
+      def alternated_substrings
+        @alternated_substrings ||= begin
+          or_strings = process(alternation: true)
+          remove_or_covered(or_strings)
+          or_strings.any?(&:empty?) ? [] : or_strings
+        end
+      end
+
       def substrings
         @substrings ||= begin
-          strs = extract_strings(Regexp::Parser.parse(@regexp), [+''])
-          strs.map!(&:upcase) if @regexp.casefold?
-          strs.reject(&:empty?).uniq
+          strs = process(alternation: false).first
+          remove_and_covered(strs)
         end
       end
 
     private
 
+      def remove_and_covered(strings)
+        # delete_if is documented to modify the array after every block iteration - this doesn't appear to be true
+        # uniq the strings to prevent identical strings from removing each other
+        strings.uniq!
+
+        # If we have "ab" and "abcd" required - only need to check for "abcd"
+        strings.delete_if do |sub_string|
+          strings.any? do |cover_string|
+            next if sub_string.equal? cover_string
+
+            cover_string.include?(sub_string)
+          end
+        end
+      end
+
+      def remove_or_covered(or_series)
+        # If we are going to match `("a" and "b") or ("ade" and "bce")` it only makes sense to match ("a" and "b")
+
+        # Ensure minimum sets of strings are being or'd
+        or_series.each { |strs| remove_and_covered(strs) }
+
+        # Remove any of the alternated string series that fully contain any other string series
+        or_series.delete_if do |and_strs|
+          or_series.any? do |and_strs2|
+            next if and_strs.equal? and_strs2
+
+            remove_and_covered(and_strs + and_strs2) == and_strs
+          end
+        end
+      end
+
+      def process(alternation:)
+        strs = extract_strings(Regexp::Parser.parse(@regexp), alternation: alternation)
+        strs = collapse(combine(strs).map(&:flatten))
+        strs.each { |str| str.map!(&:upcase) } if @regexp.casefold?
+        strs
+      end
+
       def min_repeat(exp)
         exp.quantifier&.min || 1
       end
 
+      def max_repeat(exp)
+        exp.quantifier&.max || 1
+      end
+
       def fixed_repeat?(exp)
-        min_repeat(exp) == (exp.quantifier&.max || 1)
+        min_repeat(exp) == max_repeat(exp)
       end
 
       def optional?(exp)
         min_repeat(exp).zero?
       end
 
-      def extract_strings(expression, strings)
-        expression.each do |exp|
-          if optional?(exp)
-            strings.push(+'')
+      def combine(strs)
+        suffixes = [[]]
+        strs.reverse_each do |str|
+          if str.is_a? Set
+            prefixes = str.each_with_object([]) { |s, memo| memo.concat combine(s) }
+
+            result = []
+            prefixes.product(suffixes) { |pair| result << pair.flatten(1) }
+            suffixes = result
+          else
+            suffixes.each do |arr|
+              arr.unshift str
+            end
+          end
+        end
+        suffixes
+      end
+
+      def collapse(strs)
+        strs.map do |substrings|
+          substrings.slice_before(&:nil?).map(&:join).reject(&:empty?).uniq
+        end
+      end
+
+      def extract_strings(expression, alternation: false)
+        strings = []
+        expression.each do |exp| # rubocop:disable Metrics/BlockLength
+          if optional?(exp) && !alternation
+            strings.push(nil)
+            next
+          end
+
+          if %i[meta].include?(exp.type) && !exp.terminal? && alternation
+            strings.push(alternative_strings(exp))
             next
           end
 
           if %i[meta set].include?(exp.type)
-            strings.push(+'')
+            strings.push(nil)
             next
           end
 
           if exp.terminal?
-            case exp.type
-            when :literal
-              strings.last << (exp.text * min_repeat(exp))
-            when :escape
-              strings.last << (exp.char * min_repeat(exp))
+            text = case exp.type
+            when :literal then exp.text
+            when :escape then exp.char
+            else
+              strings.push(nil)
+              next
+            end
+
+            if optional?(exp)
+              strings.push(Set.new([[''], [text]]))
+              strings.push(nil) unless max_repeat(exp) == 1
+              next
             else
-              strings.push(+'')
+              strings.push(text * min_repeat(exp))
             end
+          elsif optional?(exp)
+            strings.push(Set.new([[''], extract_strings(exp, alternation: true)]))
+            strings.push(nil) unless max_repeat(exp) == 1
+            next
           else
-            min_repeat(exp).times { extract_strings(exp, strings) }
+            min_repeat(exp).times { strings.concat extract_strings(exp, alternation: alternation) }
           end
-          strings.push(+'') unless fixed_repeat?(exp)
+          strings.push(nil) unless fixed_repeat?(exp)
         end
         strings
       end
+
+      def alternative_strings(expression)
+        alternatives = expression.alternatives.map { |sub_exp| extract_strings(sub_exp, alternation: true) }
+        if alternatives.all?(&:any?)
+          Set.new(alternatives)
+        else
+          nil
+        end
+      end
     end
   end
 end

data/lib/capybara/selector/selector.rb

@@ -19,18 +19,18 @@ module Capybara
   #     * Locator: A CSS selector
   #
   #   * **:id** - Select element by id
-  #     * Locator: The id of the element to match
+  #     * Locator: (String, Regexp, XPath::Expression) The id of the element to match
   #
   #   * **:field** - Select field elements (input [not of type submit, image, or hidden], textarea, select)
   #     * Locator: Matches against the id, Capybara.test_id attribute, name, or placeholder
   #     * Filters:
-  #       * :id (String) — Matches the id attribute
+  #       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
   #       * :name (String) — Matches the name attribute
   #       * :placeholder (String) — Matches the placeholder attribute
   #       * :type (String) — Matches the type attribute of the field or element type for 'textarea' and 'select'
   #       * :readonly (Boolean)
   #       * :with (String) — Matches the current value of the field
-  #       * :class (String, Array<String>) — Matches the class(es) provided
+  #       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #       * :checked (Boolean) — Match checked fields?
   #       * :unchecked (Boolean) — Match unchecked fields?
   #       * :disabled (Boolean) — Match disabled field?
@@ -39,25 +39,25 @@ module Capybara
   #   * **:fieldset** - Select fieldset elements
   #     * Locator: Matches id or contents of wrapped legend
   #     * Filters:
-  #       * :id (String) — Matches id attribute
+  #       * :id (String, Regexp, XPath::Expression) — Matches id attribute
   #       * :legend (String) — Matches contents of wrapped legend
-  #       * :class (String, Array<String>) — Matches the class(es) provided
+  #       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #
   #   * **:link** - Find links ( <a> elements with an href attribute )
   #     * Locator: Matches the id or title attributes, or the string content of the link, or the alt attribute of a contained img element
   #     * Filters:
-  #       * :id (String) — Matches the id attribute
+  #       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
   #       * :title (String) — Matches the title attribute
   #       * :alt (String) — Matches the alt attribute of a contained img element
-  #       * :class (String) — Matches the class(es) provided
+  #       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #       * :href (String, Regexp, nil) — Matches the normalized href of the link, if nil will find <a> elements with no href attribute
   #
   #   * **:button** - Find buttons ( input [of type submit, reset, image, button] or button elements )
   #     * Locator: Matches the id, Capybara.test_id attribute, value, or title attributes, string content of a button, or the alt attribute of an image type button or of a descendant image of a button
   #     * Filters:
-  #       * :id (String) — Matches the id attribute
+  #       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
   #       * :title (String) — Matches the title attribute
-  #       * :class (String) — Matches the class(es) provided
+  #       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #       * :value (String) — Matches the value of an input button
   #       * :type
   #
@@ -67,21 +67,21 @@ module Capybara
   #   * **:fillable_field** - Find text fillable fields ( textarea, input [not of type submit, image, radio, checkbox, hidden, file] )
   #     * Locator: Matches against the id, Capybara.test_id attribute, name, or placeholder
   #     * Filters:
-  #       * :id (String) — Matches the id attribute
+  #       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
   #       * :name (String) — Matches the name attribute
   #       * :placeholder (String) — Matches the placeholder attribute
   #       * :with (String) — Matches the current value of the field
   #       * :type (String) — Matches the type attribute of the field or element type for 'textarea'
-  #       * :class (String, Array<String>) — Matches the class(es) provided
+  #       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #       * :disabled (Boolean) — Match disabled field?
   #       * :multiple (Boolean) — Match fields that accept multiple values
   #
   #   * **:radio_button** - Find radio buttons
   #     * Locator: Match id, Capybara.test_id attribute, name, or associated label text
   #     * Filters:
-  #       * :id (String) — Matches the id attribute
+  #       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
   #       * :name (String) — Matches the name attribute
-  #       * :class (String, Array<String>) — Matches the class(es) provided
+  #       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #       * :checked (Boolean) — Match checked fields?
   #       * :unchecked (Boolean) — Match unchecked fields?
   #       * :disabled (Boolean) — Match disabled field?
@@ -90,9 +90,9 @@ module Capybara
   #   * **:checkbox** - Find checkboxes
   #     * Locator: Match id, Capybara.test_id attribute, name, or associated label text
   #     * Filters:
-  #       * *:id (String) — Matches the id attribute
+  #       * *:id (String, Regexp, XPath::Expression) — Matches the id attribute
   #       * *:name (String) — Matches the name attribute
-  #       * *:class (String, Array<String>) — Matches the class(es) provided
+  #       * *:class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #       * *:checked (Boolean) — Match checked fields?
   #       * *:unchecked (Boolean) — Match unchecked fields?
   #       * *:disabled (Boolean) — Match disabled field?
@@ -101,10 +101,10 @@ module Capybara
   #   * **:select** - Find select elements
   #     * Locator: Match id, Capybara.test_id attribute, name, placeholder, or associated label text
   #     * Filters:
-  #       * :id (String) — Matches the id attribute
+  #       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
   #       * :name (String) — Matches the name attribute
   #       * :placeholder (String) — Matches the placeholder attribute
-  #       * :class (String, Array<String>) — Matches the class(es) provided
+  #       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #       * :disabled (Boolean) — Match disabled field?
   #       * :multiple (Boolean) — Match fields that accept multiple values
   #       * :options (Array<String>) — Exact match options
@@ -131,9 +131,9 @@ module Capybara
   #   * **:file_field** - Find file input elements
   #     * Locator: Match id, Capybara.test_id attribute, name, or associated label text
   #     * Filters:
-  #       * :id (String) — Matches the id attribute
+  #       * :id (String, Regexp, XPath::Expression) — Matches the id attribute
   #       * :name (String) — Matches the name attribute
-  #       * :class (String, Array<String>) — Matches the class(es) provided
+  #       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #       * :disabled (Boolean) — Match disabled field?
   #       * :multiple (Boolean) — Match field that accepts multiple values
   #
@@ -145,16 +145,16 @@ module Capybara
   #   * **:table** - Find table elements
   #     * Locator: id or caption text of table
   #     * Filters:
-  #       * :id (String) — Match id attribute of table
+  #       * :id (String, Regexp, XPath::Expression) — Match id attribute of table
   #       * :caption (String) — Match text of associated caption
-  #       * :class (String, Array<String>) — Matches the class(es) provided
+  #       * :class ((String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #
   #   * **:frame** - Find frame/iframe elements
   #     * Locator: Match id or name
   #     * Filters:
-  #       * :id (String) — Match id attribute
+  #       * :id (String, Regexp, XPath::Expression) — Match id attribute
   #       * :name (String) — Match name attribute
-  #       * :class (String, Array<String>) — Matches the class(es) provided
+  #       * :class (String, Array<String>, Regexp, XPath::Expression) — Matches the class(es) provided
   #
   #   * **:element**
   #     * Locator: Type of element ('div', 'a', etc) - if not specified defaults to '*'
@@ -191,6 +191,7 @@ module Capybara
       @format = nil
       @expression = nil
       @expression_filters = {}
+      @locator_filter = nil
       @default_visibility = nil
       @config = {
         enable_aria_label: false,
@@ -347,6 +348,11 @@ module Capybara
 
     def_delegators :@filter_set, :node_filter, :expression_filter, :filter
 
+    def locator_filter(&block)
+      @locator_filter = block if block
+      @locator_filter
+    end
+
     def filter_set(name, filters_to_use = nil)
       @filter_set.import(name, filters_to_use)
     end
@@ -389,6 +395,10 @@ module Capybara
       vis.nil? ? fallback : vis
     end
 
+    def add_error(error_msg)
+      errors << error_msg
+    end
+
     # @api private
     def builder
       case format
@@ -401,8 +411,20 @@ module Capybara
       end
     end
 
+    # @api private
+    def with_filter_errors(errors)
+      Thread.current["capybara_#{object_id}_errors"] = errors
+      yield
+    ensure
+      Thread.current["capybara_#{object_id}_errors"] = nil
+    end
+
   private
 
+    def errors
+      Thread.current["capybara_#{object_id}_errors"] || []
+    end
+
     def enable_aria_label
       @config[:enable_aria_label]
     end
@@ -430,15 +452,19 @@ module Capybara
     def describe_all_expression_filters(**opts)
       expression_filters.map do |ef_name, ef|
         if ef.matcher?
-          opts.keys.map do |key|
-            " with #{ef_name}[#{key} => #{opts[key]}]" if ef.handles_option?(key) && !::Capybara::Queries::SelectorQuery::VALID_KEYS.include?(key)
-          end.join
+          handled_custom_keys(ef, opts.keys).map { |key| " with #{ef_name}[#{key} => #{opts[key]}]" }.join
         elsif opts.key?(ef_name)
           " with #{ef_name} #{opts[ef_name]}"
         end
       end.join
     end
 
+    def handled_custom_keys(filter, keys)
+      keys.select do |key|
+        filter.handles_option?(key) && !::Capybara::Queries::SelectorQuery::VALID_KEYS.include?(key)
+      end
+    end
+
     def find_by_attr(attribute, value)
       finder_name = "find_by_#{attribute}_attr"
       if respond_to?(finder_name, true)