class Capybara::Queries::SelectorQuery

Constants

VALID_KEYS
VALID_MATCH

Attributes

expression[R]
locator[R]
options[R]
selector[R]

Public Class Methods

new(*args, session_options:, enable_aria_label: session_options.enable_aria_label, test_id: session_options.test_id, **options, &filter_block) click to toggle source
Calls superclass method Capybara::Queries::BaseQuery.new
# File lib/capybara/queries/selector_query.rb, line 9
def initialize(*args,
               session_options:,
               enable_aria_label: session_options.enable_aria_label,
               test_id: session_options.test_id,
               **options,
               &filter_block)
  @resolved_node = nil
  @options = options.dup
  super(@options)
  self.session_options = session_options

  @selector = find_selector(args[0].is_a?(Symbol) ? args.shift : args[0])
  @locator = args.shift
  @filter_block = filter_block

  raise ArgumentError, "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?

  @expression = selector.call(@locator, @options.merge(selector_config: { enable_aria_label: enable_aria_label, test_id: test_id }))

  warn_exact_usage

  assert_valid_keys
end

Public Instance Methods

applied_description() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 55
def applied_description
  description(true)
end
css() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 92
def css
  filtered_css(apply_expression_filters(@expression))
end
description(applied = false) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 36
def description(applied = false)
  desc = +''
  if !applied || applied_filters
    desc << 'visible ' if visible == :visible
    desc << 'non-visible ' if visible == :hidden
  end
  desc << "#{label} #{locator.inspect}"
  if !applied || applied_filters
    desc << " with#{' exact' if exact_text == true} text #{options[:text].inspect}" if options[:text]
    desc << " with exact text #{exact_text}" if exact_text.is_a?(String)
  end
  desc << " with id #{options[:id]}" if options[:id]
  desc << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
  desc << selector.description(node_filters: !applied || (applied_filters == :node), **options)
  desc << ' that also matches the custom filter block' if @filter_block && (!applied || (applied_filters == :node))
  desc << " within #{@resolved_node.inspect}" if describe_within?
  desc
end
exact?() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 77
def exact?
  supports_exact? ? options.fetch(:exact, session_options.exact) : false
end
failure_message() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 111
def failure_message
  +"expected to find #{applied_description}" << count_message
end
label() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 34
def label; selector.label || selector.name; end
match() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 81
def match
  options.fetch(:match, session_options.match)
end
matches_filters?(node) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 59
def matches_filters?(node)
  return true if (@resolved_node&.== node) && options[:allow_self]
  @applied_filters ||= :system
  return false unless matches_text_filter?(node) && matches_exact_text_filter?(node) && matches_visible_filter?(node)
  @applied_filters = :node
  matches_node_filters?(node) && matches_filter_block?(node)
rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : [])
  false
end
name() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 33
def name; selector.name; end
negative_failure_message() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 115
def negative_failure_message
  +"expected not to find #{applied_description}" << count_message
end
resolve_for(node, exact = nil) click to toggle source

@api private

# File lib/capybara/queries/selector_query.rb, line 97
def resolve_for(node, exact = nil)
  @applied_filters = false
  @resolved_node = node
  node.synchronize do
    children = find_nodes_by_selector_format(node, exact).map(&method(:to_element))
    Capybara::Result.new(children, self)
  end
end
supports_exact?() click to toggle source

@api private

# File lib/capybara/queries/selector_query.rb, line 107
def supports_exact?
  @expression.respond_to? :to_xpath
end
visible() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 69
def visible
  case (vis = options.fetch(:visible) { @selector.default_visibility(session_options.ignore_hidden_elements) })
  when true then :visible
  when false then :all
  else vis
  end
end
xpath(exact = nil) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 85
def xpath(exact = nil)
  exact = exact? if exact.nil?
  expr = apply_expression_filters(@expression)
  expr = exact ? expr.to_xpath(:exact) : expr.to_s if expr.respond_to?(:to_xpath)
  filtered_xpath(expr)
end

Private Instance Methods

applied_filters() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 121
def applied_filters
  @applied_filters ||= false
end
apply_expression_filters(expression) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 275
def apply_expression_filters(expression)
  unapplied_options = options.keys - valid_keys
  expression_filters.inject(expression) do |expr, (name, ef)|
    if ef.matcher?
      unapplied_options.select { |option_name| ef.handles_option?(option_name) }.inject(expr) do |memo, option_name|
        unapplied_options.delete(option_name)
        ef.apply_filter(memo, option_name, options[option_name])
      end
    elsif options.key?(name)
      unapplied_options.delete(name)
      ef.apply_filter(expr, name, options[name])
    elsif ef.default?
      ef.apply_filter(expr, name, ef.default)
    else
      expr
    end
  end
end
assert_valid_keys() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 201
def assert_valid_keys
  unless VALID_MATCH.include?(match)
    raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(', ')}"
  end
  unhandled_options = @options.keys.reject do |option_name|
    valid_keys.include?(option_name) ||
      expression_filters.any? { |_name, ef| ef.handles_option? option_name } ||
      node_filters.any? { |_name, nf| nf.handles_option? option_name }
  end

  return if unhandled_options.empty?
  invalid_names = unhandled_options.map(&:inspect).join(', ')
  valid_names = (valid_keys - [:allow_self]).map(&:inspect).join(', ')
  raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
end
css_from_classes() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 246
def css_from_classes
  if options[:class].is_a?(XPath::Expression)
    raise ArgumentError, 'XPath expressions are not supported for the :class filter with CSS based selectors'
  end

  classes = Array(options[:class]).group_by { |cl| cl.start_with? '!' }
  (classes[false].to_a.map { |cl| ".#{Capybara::Selector::CSS.escape(cl)}" } +
   classes[true].to_a.map { |cl| ":not(.#{Capybara::Selector::CSS.escape(cl.slice(1))})" }).join
end
css_from_id() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 256
def css_from_id
  if options[:id].is_a?(XPath::Expression)
    raise ArgumentError, 'XPath expressions are not supported for the :id filter with CSS based selectors'
  end
  "##{::Capybara::Selector::CSS.escape(options[:id])}"
end
custom_keys() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 197
def custom_keys
  @custom_keys ||= node_filters.keys + expression_filters.keys
end
describe_within?() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 303
def describe_within?
  @resolved_node && !document?(@resolved_node) && !simple_root?(@resolved_node)
end
document?(node) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 307
def document?(node)
  node.is_a?(::Capybara::Node::Document)
end
exact_text() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 299
def exact_text
  options.fetch(:exact_text, session_options.exact_text)
end
expression_filters() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 191
def expression_filters
  filters = @selector.expression_filters
  filters.merge ::Capybara::Selector::FilterSet.all[options[:filter_set]].expression_filters if options.key?(:filter_set)
  filters
end
filtered_css(expr) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 230
def filtered_css(expr)
  ::Capybara::Selector::CSS.split(expr).map do |sel|
    sel += css_from_id if use_default_id_filter?
    sel += css_from_classes if use_default_class_filter?
    sel
  end.join(', ')
end
filtered_xpath(expr) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 217
def filtered_xpath(expr)
  if use_default_id_filter?
    id_xpath = if options[:id].is_a? XPath::Expression
      XPath.attr(:id)[options[:id]]
    else
      XPath.attr(:id) == options[:id]
    end
    expr = "(#{expr})[#{id_xpath}]"
  end
  expr = "(#{expr})[#{xpath_from_classes}]" if use_default_class_filter?
  expr
end
find_nodes_by_selector_format(node, exact) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 134
def find_nodes_by_selector_format(node, exact)
  if selector.format == :css
    node.find_css(css)
  else
    node.find_xpath(xpath(exact))
  end
end
find_selector(locator) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 125
def find_selector(locator)
  selector = if locator.is_a?(Symbol)
    Selector.all.fetch(locator) { |sel_type| raise ArgumentError, "Unknown selector type (:#{sel_type})" }
  else
    Selector.all.values.find { |sel| sel.match?(locator) }
  end
  selector || Selector.all[session_options.default_selector]
end
matches_exact_text_filter?(node) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 323
def matches_exact_text_filter?(node)
  return true unless exact_text.is_a?(String)
  matches_text_exactly?(node, exact_text)
end
matches_filter_block?(node) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 174
def matches_filter_block?(node)
  return true unless @filter_block
  if node.respond_to?(:session)
    node.session.using_wait_time(0) { @filter_block.call(node) }
  else
    @filter_block.call(node)
  end
end
matches_node_filters?(node) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 154
def matches_node_filters?(node)
  unapplied_options = options.keys - valid_keys

  node_filters.all? do |filter_name, filter|
    if filter.matcher?
      unapplied_options.select { |option_name| filter.handles_option?(option_name) }.all? do |option_name|
        unapplied_options.delete(option_name)
        filter.matches?(node, option_name, options[option_name])
      end
    elsif options.key?(filter_name)
      unapplied_options.delete(filter_name)
      filter.matches?(node, filter_name, options[filter_name])
    elsif filter.default?
      filter.matches?(node, filter_name, filter.default)
    else
      true
    end
  end
end
matches_text_exactly?(node, value) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 336
def matches_text_exactly?(node, value)
  regexp = value.is_a?(Regexp) ? value : /\A#{Regexp.escape(value.to_s)}\z/
  matches_text_regexp?(node, regexp)
end
matches_text_filter?(node) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 315
def matches_text_filter?(node)
  value = options[:text]
  return true unless value
  return matches_text_exactly?(node, value) if exact_text == true
  regexp = value.is_a?(Regexp) ? value : Regexp.escape(value.to_s)
  matches_text_regexp?(node, regexp)
end
matches_text_regexp?(node, regexp) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 345
def matches_text_regexp?(node, regexp)
  text_visible = visible
  text_visible = :all if text_visible == :hidden
  !!node.text(text_visible, normalize_ws: normalize_ws).match(regexp)
end
matches_visible_filter?(node) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 328
def matches_visible_filter?(node)
  case visible
  when :visible then node.visible?
  when :hidden then !node.visible?
  else true
  end
end
node_filters() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 183
def node_filters
  if options.key?(:filter_set)
    ::Capybara::Selector::FilterSet.all[options[:filter_set]].node_filters
  else
    @selector.node_filters
  end
end
normalize_ws() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 341
def normalize_ws
  options.fetch(:normalize_ws, session_options.default_normalize_ws)
end
simple_root?(node) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 311
def simple_root?(node)
  node.is_a?(::Capybara::Node::Simple) && node.path == '/'
end
to_element(node) click to toggle source
# File lib/capybara/queries/selector_query.rb, line 142
def to_element(node)
  if @resolved_node.is_a?(Capybara::Node::Base)
    Capybara::Node::Element.new(@resolved_node.session, node, @resolved_node, self)
  else
    Capybara::Node::Simple.new(node)
  end
end
use_default_class_filter?() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 242
def use_default_class_filter?
  options.key?(:class) && !custom_keys.include?(:class)
end
use_default_id_filter?() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 238
def use_default_id_filter?
  options.key?(:id) && !custom_keys.include?(:id)
end
valid_keys() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 150
def valid_keys
  VALID_KEYS + custom_keys
end
warn_exact_usage() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 294
def warn_exact_usage
  return unless options.key?(:exact) && !supports_exact?
  warn "The :exact option only has an effect on queries using the XPath#is method. Using it with the query \"#{expression}\" has no effect."
end
xpath_from_classes() click to toggle source
# File lib/capybara/queries/selector_query.rb, line 263
def xpath_from_classes
  return XPath.attr(:class)[options[:class]] if options[:class].is_a?(XPath::Expression)

  Array(options[:class]).map do |klass|
    if klass.start_with?('!')
      !XPath.attr(:class).contains_word(klass.slice(1))
    else
      XPath.attr(:class).contains_word(klass)
    end
  end.reduce(:&)
end