capybara 3.11.1 → 3.12.0

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

@@ -6,49 +6,64 @@ module Capybara
   class Selector
     # @api private
     class XPathBuilder
-      class << self
-        def attribute_conditions(attributes)
-          attributes.map do |attribute, value|
-            case value
-            when XPath::Expression
-              XPath.attr(attribute)[value]
-            when Regexp
-              XPath.attr(attribute)[regexp_to_xpath_conditions(value)]
-            when true
-              XPath.attr(attribute)
-            when false, nil
-              !XPath.attr(attribute)
-            else
-              XPath.attr(attribute) == value.to_s
-            end
-          end.reduce(:&)
-        end
+      def initialize(expression)
+        @expression = expression || ''
+      end
+
+      attr_reader :expression
 
-        def class_conditions(classes)
-          case classes
-          when XPath::Expression, Regexp
-            attribute_conditions(class: classes)
+      def add_attribute_conditions(**conditions)
+        @expression = conditions.inject(expression) do |xp, (name, value)|
+          conditions = name == :class ? class_conditions(value) : attribute_conditions(name => value)
+          if xp.is_a? XPath::Expression
+            xp[conditions]
           else
-            Array(classes).map do |klass|
-              if klass.start_with?('!') && !klass.start_with?('!!!')
-                !XPath.attr(:class).contains_word(klass.slice(1..-1))
-              else
-                XPath.attr(:class).contains_word(klass.sub(/^!!/, ''))
-              end
-            end.reduce(:&)
+            "(#{xp})[#{conditions}]"
           end
         end
+      end
+
+    private
 
-      private
+      def attribute_conditions(attributes)
+        attributes.map do |attribute, value|
+          case value
+          when XPath::Expression
+            XPath.attr(attribute)[value]
+          when Regexp
+            XPath.attr(attribute)[regexp_to_xpath_conditions(value)]
+          when true
+            XPath.attr(attribute)
+          when false, nil
+            !XPath.attr(attribute)
+          else
+            XPath.attr(attribute) == value.to_s
+          end
+        end.reduce(:&)
+      end
 
-        def regexp_to_xpath_conditions(regexp)
-          condition = XPath.current
-          condition = condition.uppercase if regexp.casefold?
-          Selector::RegexpDisassembler.new(regexp).alternated_substrings.map do |strs|
-            strs.map { |str| condition.contains(str) }.reduce(:&)
-          end.reduce(:|)
+      def class_conditions(classes)
+        case classes
+        when XPath::Expression, Regexp
+          attribute_conditions(class: classes)
+        else
+          Array(classes).map do |klass|
+            if klass.start_with?('!') && !klass.start_with?('!!!')
+              !XPath.attr(:class).contains_word(klass.slice(1..-1))
+            else
+              XPath.attr(:class).contains_word(klass.sub(/^!!/, ''))
+            end
+          end.reduce(:&)
         end
       end
+
+      def regexp_to_xpath_conditions(regexp)
+        condition = XPath.current
+        condition = condition.uppercase if regexp.casefold?
+        Selector::RegexpDisassembler.new(regexp).alternated_substrings.map do |strs|
+          strs.map { |str| condition.contains(str) }.reduce(:&)
+        end.reduce(:|)
+      end
     end
   end
 end

data/lib/capybara/selector/css.rb

@@ -31,22 +31,22 @@ module Capybara
         def split(css)
           selectors = []
           StringIO.open(css.to_s) do |str|
-            selector = ''
+            selector = +''
             while (char = str.getc)
               case char
               when '['
-                selector += parse_square(str)
+                selector << parse_square(str)
               when '('
-                selector += parse_paren(str)
+                selector << parse_paren(str)
               when '"', "'"
-                selector += parse_string(char, str)
+                selector << parse_string(char, str)
               when '\\'
-                selector += char + str.getc
+                selector << char + str.getc
               when ','
                 selectors << selector.strip
-                selector = ''
+                selector.clear
               else
-                selector += char
+                selector << char
               end
             end
             selectors << selector.strip

data/lib/capybara/selector/filter.rb

@@ -2,3 +2,4 @@
 
 require 'capybara/selector/filters/node_filter'
 require 'capybara/selector/filters/expression_filter'
+require 'capybara/selector/filters/locator_filter'

data/lib/capybara/selector/filter_set.rb

@@ -40,9 +40,9 @@ module Capybara
       def description(node_filters: true, expression_filters: true, **options)
         opts = options_with_defaults(options)
         description = +''
-        description += undeclared_descriptions.map { |desc| desc.call(opts).to_s }.join
-        description += expression_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if expression_filters
-        description += node_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if node_filters
+        description << undeclared_descriptions.map { |desc| desc.call(opts).to_s }.join
+        description << expression_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if expression_filters
+        description << node_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if node_filters
         description
       end
 
@@ -52,15 +52,16 @@ module Capybara
       end
 
       def import(name, filters = nil)
-        f_set = self.class.all[name]
         filter_selector = filters.nil? ? ->(*) { true } : ->(filter_name, _) { filters.include? filter_name }
 
-        expression_filters.merge!(f_set.expression_filters.select(&filter_selector))
-        node_filters.merge!(f_set.node_filters.select(&filter_selector))
-
-        f_set.undeclared_descriptions.each { |desc| describe(&desc) }
-        f_set.expression_filter_descriptions.each { |desc| describe(:expression_filters, &desc) }
-        f_set.node_filter_descriptions.each { |desc| describe(:node_filters, &desc) }
+        self.class[name].tap do |f_set|
+          expression_filters.merge!(f_set.expression_filters.select(&filter_selector))
+          node_filters.merge!(f_set.node_filters.select(&filter_selector))
+          f_set.undeclared_descriptions.each { |desc| describe(&desc) }
+          f_set.expression_filter_descriptions.each { |desc| describe(:expression_filters, &desc) }
+          f_set.node_filter_descriptions.each { |desc| describe(:node_filters, &desc) }
+        end
+        self
       end
 
       class << self
@@ -68,6 +69,10 @@ module Capybara
           @filter_sets ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
         end
 
+        def [](name)
+          all.fetch(name.to_sym) { |set_name| raise ArgumentError, "Unknown filter set (:#{set_name})" }
+        end
+
         def add(name, &block)
           all[name.to_sym] = FilterSet.new(name.to_sym, &block)
         end
@@ -107,11 +112,8 @@ module Capybara
         types.each { |type| options[type] = true }
         raise 'ArgumentError', ':default option is not supported for filters with a :matcher option' if matcher && options[:default]
 
-        if filter_class <= Filters::ExpressionFilter
-          @expression_filters[name] = filter_class.new(name, matcher, block, options)
-        else
-          @node_filters[name] = filter_class.new(name, matcher, block, options)
-        end
+        filter = filter_class.new(name, matcher, block, options)
+        (filter_class <= Filters::ExpressionFilter ? @expression_filters : @node_filters)[name] = filter
       end
     end
   end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'capybara/selector/filters/base'
+
+module Capybara
+  class Selector
+    module Filters
+      class LocatorFilter < NodeFilter
+        def initialize(block, **options)
+          super(nil, nil, block, options)
+        end
+
+        def matches?(node, value, context = nil)
+          super(node, nil, value, context)
+        end
+      end
+    end
+  end
+end

data/lib/capybara/selector/regexp_disassembler.rb

@@ -65,22 +65,6 @@ module Capybara
         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) == max_repeat(exp)
-      end
-
-      def optional?(exp)
-        min_repeat(exp).zero?
-      end
-
       def combine(strs)
         suffixes = [[]]
         strs.reverse_each do |str|
@@ -91,9 +75,7 @@ module Capybara
             prefixes.product(suffixes) { |pair| result << pair.flatten(1) }
             suffixes = result
           else
-            suffixes.each do |arr|
-              arr.unshift str
-            end
+            suffixes.each { |arr| arr.unshift str }
           end
         end
         suffixes
@@ -106,59 +88,120 @@ module Capybara
       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
+        Expression.new(expression).extract_strings(alternation)
+      end
+
+      # @api private
+      class Expression
+        def initialize(exp)
+          @exp = exp
+        end
+
+        def extract_strings(process_alternatives)
+          strings = []
+          each do |exp|
+            next strings.push(nil) if exp.optional? && !process_alternatives
 
-          if %i[meta].include?(exp.type) && !exp.terminal? && alternation
-            strings.push(alternative_strings(exp))
-            next
+            next strings.push(exp.alternative_strings) if exp.alternation? && process_alternatives
+
+            strings.concat(exp.strings(process_alternatives))
           end
+          strings
+        end
+
+      protected
+
+        def alternation?
+          (type == :meta) && !terminal?
+        end
+
+        def optional?
+          min_repeat.zero?
+        end
+
+        def terminal?
+          @exp.terminal?
+        end
 
-          if %i[meta set].include?(exp.type)
-            strings.push(nil)
-            next
+        def strings(process_alternatives)
+          if indeterminate?
+            [nil]
+          elsif terminal?
+            terminal_strings
+          elsif optional?
+            optional_strings
+          else
+            repeated_strings(process_alternatives)
           end
+        end
 
-          if exp.terminal?
-            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(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
+        def terminal_strings
+          text = case @exp.type
+          when :literal then @exp.text
+          when :escape then @exp.char
           else
-            min_repeat(exp).times { strings.concat extract_strings(exp, alternation: alternation) }
+            return [nil]
           end
-          strings.push(nil) unless fixed_repeat?(exp)
+
+          optional? ? options_set(text) : repeat_set(text)
+        end
+
+        def optional_strings
+          options_set(extract_strings(true))
+        end
+
+        def repeated_strings(process_alternatives)
+          repeat_set extract_strings(process_alternatives)
+        end
+
+        def alternative_strings
+          alts = alternatives.map { |sub_exp| sub_exp.extract_strings(alternation: true) }
+          alts.all?(&:any?) ? Set.new(alts) : nil
+        end
+
+      private
+
+        def indeterminate?
+          %i[meta set].include?(type)
+        end
+
+        def min_repeat
+          @exp.quantifier&.min || 1
+        end
+
+        def max_repeat
+          @exp.quantifier&.max || 1
+        end
+
+        def fixed_repeat?
+          min_repeat == max_repeat
+        end
+
+        def type
+          @exp.type
+        end
+
+        def repeat_set(str)
+          strs = Array(str * min_repeat)
+          strs.push(nil) unless fixed_repeat?
+          strs
+        end
+
+        def options_set(strs)
+          strs = [Set.new([[''], Array(strs)])]
+          strs.push(nil) unless max_repeat == 1
+          strs
+        end
+
+        def alternatives
+          @exp.alternatives.map { |exp| Expression.new(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
+        def each
+          @exp.each { |exp| yield Expression.new(exp) }
         end
       end
+      private_constant :Expression
     end
   end
 end

data/lib/capybara/selector/selector.rb

@@ -169,17 +169,25 @@ module Capybara
         @selectors ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
       end
 
+      def [](name)
+        all.fetch(name.to_sym) { |sel_type| raise ArgumentError, "Unknown selector type (:#{sel_type})" }
+      end
+
       def add(name, &block)
         all[name.to_sym] = Capybara::Selector.new(name.to_sym, &block)
       end
 
       def update(name, &block)
-        all[name.to_sym].instance_eval(&block)
+        self[name].instance_eval(&block)
       end
 
       def remove(name)
         all.delete(name.to_sym)
       end
+
+      def for(locator)
+        all.values.find { |sel| sel.match?(locator) }
+      end
     end
 
     def initialize(name, &block)
@@ -348,8 +356,9 @@ module Capybara
 
     def_delegators :@filter_set, :node_filter, :expression_filter, :filter
 
-    def locator_filter(&block)
-      @locator_filter = block if block
+    def locator_filter(*types, **options, &block)
+      types.each { |type| options[type] = true }
+      @locator_filter = Filters::LocatorFilter.new(block, options) if block
       @locator_filter
     end
 
@@ -400,7 +409,7 @@ module Capybara
     end
 
     # @api private
-    def builder
+    def builder(expr = nil)
       case format
       when :css
         Capybara::Selector::CSSBuilder
@@ -408,7 +417,7 @@ module Capybara
         Capybara::Selector::XPathBuilder
       else
         raise NotImplementedError, "No builder exists for selector of type #{format}"
-      end
+      end.new(expr)
     end
 
     # @api private