capybara 2.7.0 → 3.35.3

data/lib/capybara/rspec.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
-require 'capybara/dsl'
+
 require 'rspec/core'
+require 'capybara/dsl'
 require 'capybara/rspec/matchers'
 require 'capybara/rspec/features'
+require 'capybara/rspec/matcher_proxies'
 
 RSpec.configure do |config|
-  config.include Capybara::DSL, :type => :feature
-  config.include Capybara::RSpecMatchers, :type => :feature
-  config.include Capybara::RSpecMatchers, :type => :view
-
-  # A work-around to support accessing the current example that works in both
-  # RSpec 2 and RSpec 3.
-  fetch_current_example = RSpec.respond_to?(:current_example) ?
-    proc { RSpec.current_example } : proc { |context| context.example }
+  config.include Capybara::DSL, type: :feature
+  config.include Capybara::RSpecMatchers, type: :feature
+  config.include Capybara::DSL, type: :system
+  config.include Capybara::RSpecMatchers, type: :system
+  config.include Capybara::RSpecMatchers, type: :view
 
   # The before and after blocks must run instantaneously, because Capybara
   # might not actually be used in all examples where it's included.
@@ -22,12 +21,11 @@ RSpec.configure do |config|
       Capybara.use_default_driver
     end
   end
-  config.before do
+
+  config.before do |example|
     if self.class.include?(Capybara::DSL)
-      example = fetch_current_example.call(self)
       Capybara.current_driver = Capybara.javascript_driver if example.metadata[:js]
       Capybara.current_driver = example.metadata[:driver] if example.metadata[:driver]
     end
   end
 end
-

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'xpath'
+
+module Capybara
+  class Selector
+    # @api private
+    class CSSBuilder
+      def initialize(expression)
+        @expression = expression || ''
+      end
+
+      attr_reader :expression
+
+      def add_attribute_conditions(**attributes)
+        @expression = attributes.inject(expression) do |css, (name, value)|
+          conditions = if name == :class
+            class_conditions(value)
+          elsif value.is_a? Regexp
+            regexp_conditions(name, value)
+          else
+            [attribute_conditions(name => value)]
+          end
+
+          ::Capybara::Selector::CSS.split(css).map do |sel|
+            next sel if conditions.empty?
+
+            conditions.map { |cond| sel + cond }.join(', ')
+          end.join(', ')
+        end
+      end
+
+    private
+
+      def regexp_conditions(name, value)
+        Selector::RegexpDisassembler.new(value).alternated_substrings.map do |strs|
+          strs.map do |str|
+            "[#{name}*='#{str}'#{' i' if value.casefold?}]"
+          end.join
+        end
+      end
+
+      def attribute_conditions(attributes)
+        attributes.map do |attribute, value|
+          case value
+          when XPath::Expression
+            raise ArgumentError, "XPath expressions are not supported for the :#{attribute} filter with CSS based selectors"
+          when Regexp
+            Selector::RegexpDisassembler.new(value).substrings.map do |str|
+              "[#{attribute}*='#{str}'#{' i' if value.casefold?}]"
+            end.join
+          when true
+            "[#{attribute}]"
+          when false
+            ':not([attribute])'
+          else
+            if attribute == :id
+              "##{::Capybara::Selector::CSS.escape(value)}"
+            else
+              "[#{attribute}='#{value}']"
+            end
+          end
+        end.join
+      end
+
+      def class_conditions(classes)
+        case classes
+        when XPath::Expression
+          raise ArgumentError, 'XPath expressions are not supported for the :class filter with CSS based selectors'
+        when Regexp
+          Selector::RegexpDisassembler.new(classes).alternated_substrings.map do |strs|
+            strs.map do |str|
+              "[class*='#{str}'#{' i' if classes.casefold?}]"
+            end.join
+          end
+        else
+          cls = Array(classes).reject { |c| c.is_a? Regexp }.group_by { |cl| cl.match?(/^!(?!!!)/) }
+          [(cls[false].to_a.map { |cl| ".#{Capybara::Selector::CSS.escape(cl.sub(/^!!/, ''))}" } +
+          cls[true].to_a.map { |cl| ":not(.#{Capybara::Selector::CSS.escape(cl.slice(1..-1))})" }).join]
+        end
+      end
+    end
+  end
+end

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..-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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'capybara/selector/selector'
+
+module Capybara
+  class Selector
+    class CSS
+      def self.escape(str)
+        value = str.dup
+        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(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]/.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

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

@@ -0,0 +1,63 @@
+# 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)]
+
+      input_btn_xpath = input_btn_xpath[locator_matchers] + locate_label(locator).descendant(input_btn_xpath)
+      btn_xpath = btn_xpath[btn_matchers] + locate_label(locator).descendant(btn_xpath)
+      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] + locate_label(locator).descendant(image_btn_xpath)
+    end
+
+    btn_xpaths = [input_btn_xpath, btn_xpath, image_btn_xpath]
+    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
+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