capybara 2.18.0 → 3.39.2

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'xpath'
+
+module Capybara
+  class Selector
+    # @api private
+    class XPathBuilder
+      def initialize(expression)
+        @expression = expression || ''
+      end
+
+      attr_reader :expression
+
+      def add_attribute_conditions(**conditions)
+        @expression = conditions.inject(expression) do |xp, (name, value)|
+          conditions = name == :class ? class_conditions(value) : attribute_conditions(name => value)
+          return xp if conditions.nil?
+
+          if xp.is_a? XPath::Expression
+            xp[conditions]
+          else
+            "(#{xp})[#{conditions}]"
+          end
+        end
+      end
+
+    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 class_conditions(classes)
+        case classes
+        when XPath::Expression, Regexp
+          attribute_conditions(class: classes)
+        else
+          Array(classes).reject { |c| c.is_a? Regexp }.map do |klass|
+            if klass.match?(/^!(?!!!)/)
+              !XPath.attr(:class).contains_word(klass.slice(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

@@ -1,30 +1,102 @@
+# frozen_string_literal: true
+
+require 'capybara/selector/selector'
+
 module Capybara
   class Selector
     class CSS
       def self.escape(str)
-        out = String.new("")
         value = str.dup
-        out << value.slice!(0...1) if value =~ /^[-_]/
-        out << if value[0] =~ NMSTART
-          value.slice!(0...1)
-        else
-          escape_char(value.slice!(0...1))
-        end
-        out << value.gsub(/[^a-zA-Z0-9_-]/) {|c| escape_char c}
+        out = +''
+        out << value.slice!(0...1) if value.match?(/^[-_]/)
+        out << (value[0].match?(NMSTART) ? value.slice!(0...1) : escape_char(value.slice!(0...1)))
+        out << value.gsub(/[^a-zA-Z0-9_-]/) { |char| escape_char char }
         out
       end
 
-      def self.escape_char(c)
-        return "\\%06x" % c.ord() unless c =~ %r{[ -/:-~]}
-        "\\#{c}"
+      def self.escape_char(char)
+        char.match?(%r{[ -/:-~]}) ? "\\#{char}" : format('\\%06<hex>x', hex: char.ord)
+      end
+
+      def self.split(css)
+        Splitter.new.split(css)
       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)
+          selectors = []
+          StringIO.open(css.to_s) do |str|
+            selector = +''
+            while (char = str.getc)
+              case char
+              when '['
+                selector << parse_square(str)
+              when '('
+                selector << parse_paren(str)
+              when '"', "'"
+                selector << parse_string(char, str)
+              when '\\'
+                selector << (char + str.getc)
+              when ','
+                selectors << selector.strip
+                selector.clear
+              else
+                selector << char
+              end
+            end
+            selectors << selector.strip
+          end
+          selectors
+        end
+
+      private
+
+        def parse_square(strio)
+          parse_block('[', ']', strio)
+        end
+
+        def parse_paren(strio)
+          parse_block('(', ')', strio)
+        end
+
+        def parse_block(start, final, strio)
+          block = start
+          while (char = strio.getc)
+            case char
+            when final
+              return block + char
+            when '\\'
+              block += char + strio.getc
+            when '"', "'"
+              block += parse_string(char, strio)
+            else
+              block += char
+            end
+          end
+          raise ArgumentError, "Invalid CSS Selector - Block end '#{final}' not found"
+        end
+
+        def parse_string(quote, strio)
+          string = quote
+          while (char = strio.getc)
+            string += char
+            case char
+            when quote
+              return string
+            when '\\'
+              string += strio.getc
+            end
+          end
+          raise ArgumentError, 'Invalid CSS Selector - string end not found'
+        end
+      end
     end
   end
-end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:button, locator_type: [String, Symbol]) do
+  xpath(:value, :title, :type, :name) do |locator, **options|
+    input_btn_xpath = XPath.descendant(:input)[XPath.attr(:type).one_of('submit', 'reset', 'image', 'button')]
+    btn_xpath = XPath.descendant(:button)
+    aria_btn_xpath = XPath.descendant[XPath.attr(:role).equals('button')]
+    image_btn_xpath = XPath.descendant(:input)[XPath.attr(:type) == 'image']
+
+    unless locator.nil?
+      locator = locator.to_s
+      locator_matchers = combine_locators(locator, config: self)
+      btn_matchers = locator_matchers |
+                     XPath.string.n.is(locator) |
+                     XPath.descendant(:img)[XPath.attr(:alt).is(locator)]
+
+      label_contains_xpath = locate_label(locator).descendant[labellable_elements]
+      input_btn_xpath = input_btn_xpath[locator_matchers]
+      btn_xpath = btn_xpath[btn_matchers]
+      aria_btn_xpath = aria_btn_xpath[btn_matchers]
+
+      alt_matches = XPath.attr(:alt).is(locator)
+      alt_matches |= XPath.attr(:'aria-label').is(locator) if enable_aria_label
+      image_btn_xpath = image_btn_xpath[alt_matches]
+    end
+
+    btn_xpaths = [input_btn_xpath, btn_xpath, image_btn_xpath, label_contains_xpath].compact
+    btn_xpaths << aria_btn_xpath if enable_aria_role
+
+    %i[value title type].inject(btn_xpaths.inject(&:union)) do |memo, ef|
+      memo.where(find_by_attr(ef, options[ef]))
+    end
+  end
+
+  node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| !(value ^ node.disabled?) }
+  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
+
+  node_filter(:name) { |node, value| !value.is_a?(Regexp) || value.match?(node[:name]) }
+  expression_filter(:name) do |xpath, val|
+    builder(xpath).add_attribute_conditions(name: val)
+  end
+
+  describe_expression_filters do |disabled: nil, **options|
+    desc = +''
+    desc << ' that is not disabled' if disabled == false
+    desc << describe_all_expression_filters(**options)
+  end
+
+  describe_node_filters do |disabled: nil, **|
+    ' that is disabled' if disabled == true
+  end
+
+  def combine_locators(locator, config:)
+    [
+      XPath.attr(:id).equals(locator),
+      XPath.attr(:name).equals(locator),
+      XPath.attr(:value).is(locator),
+      XPath.attr(:title).is(locator),
+      (XPath.attr(:id) == XPath.anywhere(:label)[XPath.string.n.is(locator)].attr(:for)),
+      (XPath.attr(:'aria-label').is(locator) if config.enable_aria_label),
+      (XPath.attr(config.test_id) == locator if config.test_id)
+    ].compact.inject(&:|)
+  end
+
+  def labellable_elements
+    (XPath.self(:input) & XPath.attr(:type).one_of('submit', 'reset', 'image', 'button')) | XPath.self(:button)
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:checkbox, locator_type: [String, Symbol]) do
+  xpath do |locator, allow_self: nil, **options|
+    xpath = XPath.axis(allow_self ? :'descendant-or-self' : :descendant, :input)[
+      XPath.attr(:type) == 'checkbox'
+    ]
+    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/css.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:css, locator_type: [String, Symbol], raw_locator: true) do
+  css do |css|
+    if css.is_a? Symbol
+      Capybara::Helpers.warn "DEPRECATED: Passing a symbol (#{css.inspect}) as the CSS locator is deprecated - please pass a string instead : #{Capybara::Helpers.filter_backtrace(caller)}"
+    end
+    css
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:datalist_input, locator_type: [String, Symbol]) do
+  label 'input box with datalist completion'
+
+  xpath do |locator, **options|
+    xpath = XPath.descendant(:input)[XPath.attr(:list)]
+    locate_field(xpath, locator, **options)
+  end
+
+  filter_set(:_field, %i[disabled name placeholder])
+
+  node_filter(:options) do |node, options|
+    actual = node.find("//datalist[@id=#{node[:list]}]", visible: :all).all(:datalist_option, wait: false).map(&:value)
+    (options.sort == actual.sort).tap do |res|
+      add_error("Expected #{options.inspect} options found #{actual.inspect}") unless res
+    end
+  end
+
+  expression_filter(:with_options) do |expr, options|
+    options.inject(expr) do |xpath, option|
+      xpath.where(XPath.attr(:list) == XPath.anywhere(:datalist)[expression_for(:datalist_option, option)].attr(:id))
+    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, **|
+    " with options #{options.inspect}" if options
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:datalist_option, locator_type: [String, Symbol]) do
+  label 'datalist option'
+  visible(:all)
+
+  xpath do |locator|
+    xpath = XPath.descendant(:option)
+    xpath = xpath[XPath.string.n.is(locator.to_s) | (XPath.attr(:value) == locator.to_s)] unless locator.nil?
+    xpath
+  end
+
+  node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
+  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
+
+  describe_expression_filters do |disabled: nil, **options|
+    desc = +''
+    desc << ' that is not disabled' if disabled == false
+    desc << describe_all_expression_filters(**options)
+  end
+
+  describe_node_filters do |**options|
+    ' that is disabled' if options[:disabled]
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:element, locator_type: [String, Symbol]) do
+  xpath do |locator, **|
+    XPath.descendant.where(locator ? XPath.local_name == locator.to_s : nil)
+  end
+
+  expression_filter(:attributes, matcher: /.+/) do |xpath, name, val|
+    builder(xpath).add_attribute_conditions(name => val)
+  end
+
+  node_filter(:attributes, matcher: /.+/) do |node, name, val|
+    next true unless val.is_a?(Regexp)
+
+    (val.match? node[name]).tap do |res|
+      add_error("Expected #{name} to match #{val.inspect} but it was #{node[name]}") unless res
+    end
+  end
+
+  describe_expression_filters do |**options|
+    boolean_values = [true, false]
+    booleans, values = options.partition { |_k, v| boolean_values.include? v }.map(&:to_h)
+    desc = describe_all_expression_filters(**values)
+    desc + booleans.map do |k, v|
+      v ? " with #{k} attribute" : "without #{k} attribute"
+    end.join
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:field, locator_type: [String, Symbol]) do
+  visible { |options| :hidden if options[:type].to_s == 'hidden' }
+
+  xpath do |locator, **options|
+    invalid_types = %w[submit image]
+    invalid_types << 'hidden' unless options[:type].to_s == 'hidden'
+    xpath = XPath.descendant(:input, :textarea, :select)[!XPath.attr(:type).one_of(*invalid_types)]
+    locate_field(xpath, locator, **options)
+  end
+
+  expression_filter(:type) do |expr, type|
+    type = type.to_s
+    if %w[textarea select].include?(type)
+      expr.self(type.to_sym)
+    else
+      expr[XPath.attr(:type) == type]
+    end
+  end
+
+  filter_set(:_field) # checked/unchecked/disabled/multiple/name/placeholder
+
+  node_filter(:readonly, :boolean) { |node, value| !(value ^ node.readonly?) }
+
+  node_filter(:with) do |node, with|
+    val = node.value
+    (with.is_a?(Regexp) ? with.match?(val) : val == with.to_s).tap do |res|
+      add_error("Expected value to be #{with.inspect} but was #{val.inspect}") unless res
+    end
+  end
+
+  describe_expression_filters do |type: nil, **|
+    " of type #{type.inspect}" if type
+  end
+
+  describe_node_filters do |**options|
+    " with value #{options[:with].to_s.inspect}" if options.key?(:with)
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:fieldset, locator_type: [String, Symbol]) do
+  xpath do |locator, legend: nil, **|
+    locator_matchers = (XPath.attr(:id) == locator.to_s) | XPath.child(:legend)[XPath.string.n.is(locator.to_s)]
+    locator_matchers |= XPath.attr(test_id) == locator.to_s if test_id
+    xpath = XPath.descendant(:fieldset)[locator && locator_matchers]
+    xpath = xpath[XPath.child(:legend)[XPath.string.n.is(legend)]] if legend
+    xpath
+  end
+
+  node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
+  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:file_field, locator_type: [String, Symbol]) do
+  label 'file field'
+  xpath do |locator, allow_self: nil, **options|
+    xpath = XPath.axis(allow_self ? :'descendant-or-self' : :descendant, :input)[
+      XPath.attr(:type) == 'file'
+    ]
+    locate_field(xpath, locator, **options)
+  end
+
+  filter_set(:_field, %i[disabled multiple name])
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:fillable_field, locator_type: [String, Symbol]) do
+  label 'field'
+  xpath do |locator, allow_self: nil, **options|
+    xpath = XPath.axis(allow_self ? :'descendant-or-self' : :descendant, :input, :textarea)[
+      !XPath.attr(:type).one_of('submit', 'image', 'radio', 'checkbox', 'hidden', 'file')
+    ]
+    locate_field(xpath, locator, **options)
+  end
+
+  expression_filter(:type) do |expr, type|
+    type = type.to_s
+    if type == 'textarea'
+      expr.self(type.to_sym)
+    else
+      expr[XPath.attr(:type) == type]
+    end
+  end
+
+  filter_set(:_field, %i[disabled multiple name placeholder valid validation_message])
+
+  node_filter(:with) do |node, with|
+    val = node.value
+    (with.is_a?(Regexp) ? with.match?(val) : val == with.to_s).tap do |res|
+      add_error("Expected value to be #{with.inspect} but was #{val.inspect}") unless res
+    end
+  end
+
+  describe_node_filters do |**options|
+    " with value #{options[:with].to_s.inspect}" if options.key?(:with)
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:frame, locator_type: [String, Symbol]) do
+  xpath do |locator, name: nil, **|
+    xpath = XPath.descendant(:iframe).union(XPath.descendant(:frame))
+    unless locator.nil?
+      locator_matchers = (XPath.attr(:id) == locator.to_s) | (XPath.attr(:name) == locator.to_s)
+      locator_matchers |= XPath.attr(test_id) == locator if test_id
+      xpath = xpath[locator_matchers]
+    end
+    xpath[find_by_attr(:name, name)]
+  end
+
+  describe_expression_filters do |name: nil, **|
+    " with name #{name}" if name
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:id, locator_type: [String, Symbol, Regexp]) do
+  xpath { |id| builder(XPath.descendant).add_attribute_conditions(id: id) }
+  locator_filter { |node, id| id.is_a?(Regexp) ? id.match?(node[:id]) : true }
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:label, locator_type: [String, Symbol]) do
+  label 'label'
+  xpath(:for) do |locator, **options|
+    xpath = XPath.descendant(:label)
+    unless locator.nil?
+      locator_matchers = XPath.string.n.is(locator.to_s) | (XPath.attr(:id) == locator.to_s)
+      locator_matchers |= XPath.attr(test_id) == locator if test_id
+      xpath = xpath[locator_matchers]
+    end
+    if options.key?(:for)
+      for_option = options[:for]
+      for_option = for_option[:id] if for_option.is_a?(Capybara::Node::Element)
+      if for_option && (for_option != '')
+        with_attr = builder(XPath.self).add_attribute_conditions(for: for_option)
+        wrapped = !XPath.attr(:for) &
+                  builder(XPath.self.descendant(*labelable_elements)).add_attribute_conditions(id: for_option)
+        xpath = xpath[with_attr | wrapped]
+      end
+    end
+    xpath
+  end
+
+  node_filter(:for) do |node, field_or_value|
+    case field_or_value
+    when Capybara::Node::Element
+      if (for_val = node[:for])
+        field_or_value[:id] == for_val
+      else
+        field_or_value.find_xpath('./ancestor::label[1]').include? node.base
+      end
+    when Regexp
+      if (for_val = node[:for])
+        field_or_value.match? for_val
+      else
+        node.find_xpath(XPath.descendant(*labelable_elements).to_s)
+            .any? { |n| field_or_value.match? n[:id] }
+      end
+    else
+      # Non element/regexp values were handled through the expression filter
+      true
+    end
+  end
+
+  describe_expression_filters do |**options|
+    next unless options.key?(:for) && !options[:for].is_a?(Capybara::Node::Element)
+
+    if options[:for].is_a? Regexp
+      " for element with id matching #{options[:for].inspect}"
+    else
+      " for element with id of \"#{options[:for]}\""
+    end
+  end
+  describe_node_filters do |**options|
+    " for element #{options[:for]}" if options[:for].is_a?(Capybara::Node::Element)
+  end
+
+  def labelable_elements
+    %i[button input keygen meter output progress select textarea]
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:link, locator_type: [String, Symbol]) do
+  xpath do |locator, href: true, alt: nil, title: nil, target: nil, **|
+    xpath = XPath.descendant(:a)
+    xpath = builder(xpath).add_attribute_conditions(href: href) unless href == false
+
+    if enable_aria_role
+      role_path = XPath.descendant[XPath.attr(:role).equals('link')]
+      role_path = builder(role_path).add_attribute_conditions(href: href) unless [true, false].include? href
+
+      xpath += role_path
+    end
+
+    unless locator.nil?
+      locator = locator.to_s
+      matchers = [XPath.attr(:id) == locator,
+                  XPath.string.n.is(locator),
+                  XPath.attr(:title).is(locator),
+                  XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
+      matchers << XPath.attr(:'aria-label').is(locator) if enable_aria_label
+      matchers << XPath.attr(test_id).equals(locator) if test_id
+      xpath = xpath[matchers.reduce(:|)]
+    end
+
+    xpath = xpath[find_by_attr(:title, title)]
+    xpath = xpath[XPath.descendant(:img)[XPath.attr(:alt) == alt]] if alt
+    xpath = xpath[find_by_attr(:target, target)] if target
+
+    xpath
+  end
+
+  node_filter(:href) do |node, href|
+    # If not a Regexp it's been handled in the main XPath
+    (href.is_a?(Regexp) ? node[:href].match?(href) : true).tap do |res|
+      add_error "Expected href to match #{href.inspect} but it was #{node[:href].inspect}" unless res
+    end
+  end
+
+  expression_filter(:download, valid_values: [true, false, String]) do |expr, download|
+    builder(expr).add_attribute_conditions(download: download)
+  end
+
+  describe_expression_filters do |download: nil, **options|
+    desc = +''
+    if (href = options[:href])
+      desc << " with href #{'matching ' if href.is_a? Regexp}#{href.inspect}"
+    elsif options.key?(:href) && href != false # is nil specified?
+      desc << ' with no href attribute'
+    end
+    desc << " with download attribute#{" #{download}" if download.is_a? String}" if download
+    desc << ' without download attribute' if download == false
+    desc
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+Capybara.add_selector(:link_or_button, locator_type: [String, Symbol]) do
+  label 'link or button'
+  xpath do |locator, **options|
+    %i[link button].map do |selector|
+      expression_for(selector, locator, **options)
+    end.reduce(:union)
+  end
+
+  node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| !(value ^ node.disabled?) }
+
+  describe_node_filters do |disabled: nil, **|
+    ' that is disabled' if disabled == true
+  end
+end