capybara 2.18.0 → 3.40.0

data/lib/capybara/selector/filter_set.rb

@@ -1,56 +1,78 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filter'
 
 module Capybara
   class Selector
     class FilterSet
-      attr_reader :descriptions
+      attr_reader :node_filters, :expression_filters
 
       def initialize(name, &block)
         @name = name
-        @descriptions = []
-        instance_eval(&block)
-      end
-
-      def filter(name, *types_and_options, &block)
-        add_filter(name, Filters::NodeFilter, *types_and_options, &block)
+        @node_filters = {}
+        @expression_filters = {}
+        @descriptions = Hash.new { |hsh, key| hsh[key] = [] }
+        instance_eval(&block) if block
       end
 
-      def expression_filter(name, *types_and_options, &block)
-        add_filter(name, Filters::ExpressionFilter, *types_and_options, &block)
+      def node_filter(names, *types, **options, &block)
+        Array(names).each do |name|
+          add_filter(name, Filters::NodeFilter, *types, **options, &block)
+        end
       end
+      alias_method :filter, :node_filter
 
-      def describe(&block)
-        descriptions.push block
+      def expression_filter(name, *types, **options, &block)
+        add_filter(name, Filters::ExpressionFilter, *types, **options, &block)
       end
 
-      def description(options={})
-        options_with_defaults = options.dup
-        filters.each do |name, filter|
-          options_with_defaults[name] = filter.default if filter.default? && !options_with_defaults.has_key?(name)
+      def describe(what = nil, &block)
+        case what
+        when nil
+          undeclared_descriptions.push block
+        when :node_filters
+          node_filter_descriptions.push block
+        when :expression_filters
+          expression_filter_descriptions.push block
+        else
+          raise ArgumentError, 'Unknown description type'
         end
-
-        @descriptions.map do |desc|
-          desc.call(options_with_defaults).to_s
-        end.join
       end
 
-      def filters
-        @filters ||= {}
+      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
       end
 
-      def node_filters
-        filters.reject { |_n, f| f.nil? || f.is_a?(Filters::ExpressionFilter) }.freeze
+      def descriptions
+        Capybara::Helpers.warn 'DEPRECATED: FilterSet#descriptions is deprecated without replacement'
+        [undeclared_descriptions, node_filter_descriptions, expression_filter_descriptions].flatten
       end
 
-      def expression_filters
-        filters.select { |_n, f| f.nil? || f.is_a?(Filters::ExpressionFilter)  }.freeze
+      def import(name, filters = nil)
+        filter_selector = filters.nil? ? ->(*) { true } : ->(filter_name, _) { filters.include? filter_name }
+
+        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
-
         def all
-          @filter_sets ||= {}
+          @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)
@@ -62,13 +84,38 @@ module Capybara
         end
       end
 
-      private
+    protected
+
+      def undeclared_descriptions
+        @descriptions[:undeclared]
+      end
+
+      def node_filter_descriptions
+        @descriptions[:node_filters]
+      end
+
+      def expression_filter_descriptions
+        @descriptions[:expression_filters]
+      end
+
+    private
+
+      def options_with_defaults(options)
+        expression_filters
+          .chain(node_filters)
+          .filter_map { |name, filter| [name, filter.default] if filter.default? }
+          .to_h.merge!(options)
+      end
+
+      def add_filter(name, filter_class, *types, matcher: nil, **options, &block)
+        types.each { |type| options[type] = true }
+        if matcher && options[:default]
+          raise 'ArgumentError', ':default option is not supported for filters with a :matcher option'
+        end
 
-      def add_filter(name, filter_class, *types_and_options, &block)
-        options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
-        types_and_options.each { |k| options[k] = true}
-        filters[name] = filter_class.new(name, block, options)
+        filter = filter_class.new(name, matcher, block, **options)
+        (filter_class <= Filters::ExpressionFilter ? @expression_filters : @node_filters)[name] = filter
       end
     end
   end
-end
+end

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

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
+
 module Capybara
   class Selector
     module Filters
       class Base
-        def initialize(name, block, options={})
+        def initialize(name, matcher, block, **options)
           @name = name
+          @matcher = matcher
           @block = block
           @options = options
-          @options[:valid_values] = [true,false] if options[:boolean]
+          @options[:valid_values] = [true, false] if options[:boolean]
         end
 
         def default?
-          @options.has_key?(:default)
+          @options.key?(:default)
         end
 
         def default
@@ -19,13 +21,55 @@ module Capybara
         end
 
         def skip?(value)
-          @options.has_key?(:skip_if) && value == @options[:skip_if]
+          @options.key?(:skip_if) && value == @options[:skip_if]
+        end
+
+        def format
+          @options[:format]
+        end
+
+        def matcher?
+          !@matcher.nil?
+        end
+
+        def boolean?
+          !!@options[:boolean]
+        end
+
+        def handles_option?(option_name)
+          if matcher?
+            @matcher.match? option_name
+          else
+            @name == option_name
+          end
+        end
+
+      private
+
+        def apply(subject, name, value, skip_value, ctx)
+          return skip_value if skip?(value)
+
+          unless valid_value?(value)
+            raise ArgumentError,
+                  "Invalid value #{value.inspect} passed to #{self.class.name.split('::').last} #{name}" \
+                  "#{" : #{name}" if @name.is_a?(Regexp)}"
+          end
+
+          if @block.arity == 2
+            filter_context(ctx).instance_exec(subject, value, &@block)
+          else
+            filter_context(ctx).instance_exec(subject, name, value, &@block)
+          end
         end
 
-        private
+        def filter_context(context)
+          context || @block.binding.receiver
+        end
 
         def valid_value?(value)
-          !@options.has_key?(:valid_values) || Array(@options[:valid_values]).include?(value)
+          return true unless @options.key?(:valid_values)
+
+          Array(@options[:valid_values]).any? { |valid| valid === value } # rubocop:disable Style/CaseEquality
         end
       end
     end

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

@@ -1,40 +1,22 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filters/base'
 
 module Capybara
   class Selector
     module Filters
       class ExpressionFilter < Base
-        def apply_filter(expr, value)
-          return expr if skip?(value)
-
-          if !valid_value?(value)
-            msg = "Invalid value #{value.inspect} passed to expression filter #{@name} - "
-            if default?
-              warn msg + "defaulting to #{default}"
-              value = default
-            else
-              warn msg + "skipping"
-              return expr
-            end
-          end
-
-          @block.call(expr, value)
+        def apply_filter(expr, name, value, selector)
+          apply(expr, name, value, expr, selector)
         end
       end
 
       class IdentityExpressionFilter < ExpressionFilter
-        def initialize
-        end
-
-        def default?
-          false
-        end
-
-        def apply_filter(expr, _value)
-          return expr
-        end
+        def initialize(name); super(name, nil, nil); end
+        def default?; false; end
+        def matcher?; false; end
+        def apply_filter(expr, _name, _value, _ctx); expr; end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,29 @@
+# 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, exact:)
+          apply(node, value, true, context, exact: exact, format: context&.default_format)
+        rescue Capybara::ElementNotFound
+          false
+        end
+
+      private
+
+        def apply(subject, value, skip_value, ctx, **options)
+          return skip_value if skip?(value)
+
+          filter_context(ctx).instance_exec(subject, value, **options, &@block)
+        end
+      end
+    end
+  end
+end

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

@@ -1,25 +1,29 @@
 # frozen_string_literal: true
+
 require 'capybara/selector/filters/base'
 
 module Capybara
   class Selector
     module Filters
       class NodeFilter < Base
-        def matches?(node, value)
-          return true if skip?(value)
-
-          if !valid_value?(value)
-            msg = "Invalid value #{value.inspect} passed to filter #{@name} - "
-            if default?
-              warn msg + "defaulting to #{default}"
-              value = default
-            else
-              warn msg + "skipping"
-              return 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
 
-          @block.call(node, value)
+        def matches?(node, name, value, context = nil)
+          apply(node, name, value, true, context)
+        rescue Capybara::ElementNotFound
+          false
         end
       end
     end

data/lib/capybara/selector/regexp_disassembler.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require 'regexp_parser'
+
+module Capybara
+  class Selector
+    # @api private
+    class RegexpDisassembler
+      def initialize(regexp)
+        @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 = 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 combine(strs)
+        suffixes = [[]]
+        strs.reverse_each do |str|
+          if str.is_a? Set
+            prefixes = str.flat_map { |s| combine(s) }
+            suffixes = prefixes.product(suffixes).map { |pair| pair.flatten(1) }
+          else
+            suffixes.each { |arr| arr.unshift str }
+          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)
+        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 if exp.ignore?
+
+            next strings.push(nil) if exp.optional? && !process_alternatives
+
+            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
+
+        def strings(process_alternatives)
+          if indeterminate?
+            [nil]
+          elsif terminal?
+            terminal_strings
+          elsif optional?
+            optional_strings
+          else
+            repeated_strings(process_alternatives)
+          end
+        end
+
+        def terminal_strings
+          text = case @exp.type
+          when :literal then @exp.text
+          when :escape then @exp.char
+          else
+            return [nil]
+          end
+
+          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
+
+        def ignore?
+          [Regexp::Expression::Assertion::NegativeLookahead,
+           Regexp::Expression::Assertion::NegativeLookbehind].any? { |klass| @exp.is_a? klass }
+        end
+
+      private
+
+        def indeterminate?
+          %i[meta set].include?(type)
+        end
+
+        def min_repeat
+          @exp.repetitions.begin
+        end
+
+        def max_repeat
+          @exp.repetitions.end
+        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
+
+        def each
+          @exp.each { |exp| yield Expression.new(exp) }
+        end
+      end
+      private_constant :Expression
+    end
+  end
+end