capybara 3.32.2

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+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.attr(:type) == 'radio'
+    ]
+    locate_field(xpath, locator, **options)
+  end
+
+  filter_set(:_field, %i[checked unchecked disabled name])
+
+  node_filter(%i[option with]) do |node, value|
+    val = node.value
+    (value.is_a?(Regexp) ? value.match?(val) : val == value.to_s).tap do |res|
+      add_error("Expected value to be #{value.inspect} but it was #{val.inspect}") unless res
+    end
+  end
+
+  describe_node_filters do |option: nil, with: nil, **|
+    desc = +''
+    desc << " with value #{option.inspect}" if option
+    desc << " with value #{with.inspect}" if with
+    desc
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:select, locator_type: [String, Symbol]) do
+  label 'select box'
+
+  xpath do |locator, **options|
+    xpath = XPath.descendant(:select)
+    locate_field(xpath, locator, **options)
+  end
+
+  filter_set(:_field, %i[disabled multiple name placeholder])
+
+  node_filter(:options) do |node, options|
+    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)]
+    end
+  end
+
+  node_filter(:selected) do |node, selected|
+    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 = 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
+  end
+
+  describe_expression_filters do |with_options: nil, **|
+    desc = +''
+    desc << " with at least options #{with_options.inspect}" if with_options
+    desc
+  end
+
+  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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:table, locator_type: [String, Symbol]) do
+  xpath do |locator, caption: nil, **|
+    xpath = XPath.descendant(:table)
+    unless locator.nil?
+      locator_matchers = (XPath.attr(:id) == locator.to_s) | XPath.descendant(:caption).is(locator.to_s)
+      locator_matchers |= XPath.attr(test_id) == locator if test_id
+      xpath = xpath[locator_matchers]
+    end
+    xpath = xpath[XPath.descendant(:caption) == caption] if caption
+    xpath
+  end
+
+  expression_filter(:with_cols, valid_values: [Array]) do |xpath, cols|
+    col_conditions = cols.map do |col|
+      if col.is_a? Hash
+        col.reduce(nil) do |xp, (header, cell_str)|
+          header = XPath.descendant(:th)[XPath.string.n.is(header)]
+          td = XPath.descendant(:tr)[header].descendant(:td)
+          cell_condition = XPath.string.n.is(cell_str)
+          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
+        cells_xp = col.reduce(nil) do |prev_cell, cell_str|
+          cell_condition = XPath.string.n.is(cell_str)
+
+          if prev_cell
+            prev_cell = XPath.ancestor(:tr)[1].preceding_sibling(:tr).join(prev_cell)
+            cell_condition &= (prev_cell & prev_col_position?(prev_cell))
+          end
+
+          XPath.descendant(:td)[cell_condition]
+        end
+        XPath.descendant(:tr).join(cells_xp)
+      end
+    end.reduce(:&)
+    xpath[col_conditions]
+  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 }
+
+    rows = cols.transpose
+    col_conditions = rows.map { |row| match_row(row, match_size: true) }.reduce(:&)
+    xpath[match_row_count(rows.size)][col_conditions]
+  end
+
+  expression_filter(:with_rows, valid_values: [Array]) do |xpath, rows|
+    rows_conditions = rows.map { |row| match_row(row) }.reduce(:&)
+    xpath[rows_conditions]
+  end
+
+  expression_filter(:rows, valid_values: [Array]) do |xpath, rows|
+    rows_conditions = rows.map { |row| match_row(row, match_size: true) }.reduce(:&)
+    xpath[match_row_count(rows.size)][rows_conditions]
+  end
+
+  describe_expression_filters do |caption: nil, **|
+    " with caption \"#{caption}\"" if caption
+  end
+
+  def prev_col_position?(cell)
+    XPath.position.equals(cell_position(cell))
+  end
+
+  def cell_position(cell)
+    cell.preceding_sibling(:td).count.plus(1)
+  end
+
+  def match_row(row, match_size: false)
+    xp = XPath.descendant(:tr)[
+      if row.is_a? Hash
+        row_match_cells_to_headers(row)
+      else
+        XPath.descendant(:td)[row_match_ordered_cells(row)]
+      end
+    ]
+    xp = xp[XPath.descendant(:td).count.equals(row.size)] if match_size
+    xp
+  end
+
+  def match_row_count(size)
+    XPath.descendant(:tbody).descendant(:tr).count.equals(size) |
+      (XPath.descendant(:tr).count.equals(size) & ~XPath.descendant(:tbody))
+  end
+
+  def row_match_cells_to_headers(row)
+    row.map do |header, cell|
+      header_xp = XPath.ancestor(:table)[1].descendant(:tr)[1].descendant(:th)[XPath.string.n.is(header)]
+      XPath.descendant(:td)[
+        XPath.string.n.is(cell) & XPath.position.equals(header_xp.preceding_sibling.count.plus(1))
+      ]
+    end.reduce(:&)
+  end
+
+  def row_match_ordered_cells(row)
+    row_conditions = row.map do |cell|
+      XPath.self(:td)[XPath.string.n.is(cell)]
+    end
+    row_conditions.reverse.reduce do |cond, cell|
+      cell[XPath.following_sibling[cond]]
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:table_row, locator_type: [Array, Hash]) do
+  xpath do |locator|
+    xpath = XPath.descendant(:tr)
+    if locator.is_a? Hash
+      locator.reduce(xpath) do |xp, (header, cell)|
+        header_xp = XPath.ancestor(:table)[1].descendant(:tr)[1].descendant(:th)[XPath.string.n.is(header)]
+        cell_xp = XPath.descendant(:td)[
+          XPath.string.n.is(cell) & XPath.position.equals(header_xp.preceding_sibling.count.plus(1))
+        ]
+        xp[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] }
+      xpath[initial_td[tds]]
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:xpath, locator_type: [:to_xpath, String], raw_locator: true) do
+  xpath { |xpath| xpath }
+end

data/lib/capybara/selector/filter.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'capybara/selector/filter'
+
+module Capybara
+  class Selector
+    class FilterSet
+      attr_reader :node_filters, :expression_filters
+
+      def initialize(name, &block)
+        @name = name
+        @node_filters = {}
+        @expression_filters = {}
+        @descriptions = Hash.new { |hsh, key| hsh[key] = [] }
+        instance_eval(&block)
+      end
+
+      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 expression_filter(name, *types, **options, &block)
+        add_filter(name, Filters::ExpressionFilter, *types, **options, &block)
+      end
+
+      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
+      end
+
+      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 descriptions
+        warn 'DEPRECATED: FilterSet#descriptions is deprecated without replacement'
+        [undeclared_descriptions, node_filter_descriptions, expression_filter_descriptions].flatten
+      end
+
+      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 ||= {} # 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
+
+        def remove(name)
+          all.delete(name.to_sym)
+        end
+      end
+
+    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)
+        options = options.dup
+        [expression_filters, node_filters].each do |filters|
+          filters.select { |_n, filter| filter.default? }.each do |name, filter|
+            options[name] = filter.default unless options.key?(name)
+          end
+        end
+        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
+
+        filter = filter_class.new(name, matcher, block, **options)
+        (filter_class <= Filters::ExpressionFilter ? @expression_filters : @node_filters)[name] = filter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Capybara
+  class Selector
+    module Filters
+      class Base
+        def initialize(name, matcher, block, **options)
+          @name = name
+          @matcher = matcher
+          @block = block
+          @options = options
+          @options[:valid_values] = [true, false] if options[:boolean]
+        end
+
+        def default?
+          @options.key?(:default)
+        end
+
+        def default
+          @options[:default]
+        end
+
+        def skip?(value)
+          @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
+
+        def filter_context(context)
+          context || @block.binding.receiver
+        end
+
+        def valid_value?(value)
+          return true unless @options.key?(:valid_values)
+
+          Array(@options[:valid_values]).any? { |valid| valid === value } # rubocop:disable Style/CaseEquality
+        end
+      end
+    end
+  end
+end