capybara 2.18.0 → 3.40.0

data/lib/capybara/node/simple.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Capybara
   module Node
-
     ##
     #
     # A {Capybara::Node::Simple} is a simpler version of {Capybara::Node::Base} which
@@ -28,8 +28,9 @@ module Capybara
       #
       # @return [String]    The text of the element
       #
-      def text(type=nil)
-        native.text
+      def text(_type = nil, normalize_ws: false)
+        txt = native.text
+        normalize_ws ? txt.gsub(/[[:space:]]+/, ' ').strip : txt
       end
 
       ##
@@ -45,7 +46,7 @@ module Capybara
         attr_name = name.to_s
         if attr_name == 'value'
           value
-        elsif 'input' == tag_name and 'checkbox' == native[:type] and 'checked' == attr_name
+        elsif (tag_name == 'input') && (native[:type] == 'checkbox') && (attr_name == 'checked')
           native['checked'] == 'checked'
         else
           native[attr_name]
@@ -78,13 +79,13 @@ module Capybara
         if tag_name == 'textarea'
           native['_capybara_raw_value']
         elsif tag_name == 'select'
-          if native['multiple'] == 'multiple'
-            native.xpath(".//option[@selected='selected']").map { |option| option[:value] || option.content  }
+          selected_options = find_xpath('.//option[@selected]')
+          if multiple?
+            selected_options.map(&method(:option_value))
           else
-            option = native.xpath(".//option[@selected='selected']").first || native.xpath(".//option").first
-            option[:value] || option.content if option
+            option_value(selected_options.first || find_xpath('.//option').first)
           end
-        elsif tag_name == 'input' && %w(radio checkbox).include?(native[:type])
+        elsif tag_name == 'input' && %w[radio checkbox].include?(native[:type])
           native[:value] || 'on'
         else
           native[:value]
@@ -99,15 +100,17 @@ module Capybara
       # @param  [Boolean] check_ancestors  Whether to inherit visibility from ancestors
       # @return [Boolean]     Whether the element is visible
       #
-      def visible?(check_ancestors = true)
-        return false if (tag_name == 'input') && (native[:type]=="hidden")
+      def visible?(check_ancestors = true) # rubocop:disable Style/OptionalBooleanParameter
+        return false if (tag_name == 'input') && (native[:type] == 'hidden')
+        return false if tag_name == 'template'
 
         if check_ancestors
-          #check size because oldest supported nokogiri doesnt support xpath boolean() function
-          native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or @hidden or name()='script' or name()='head']").size() == 0
+          !find_xpath(VISIBILITY_XPATH)
         else
-          #no need for an xpath if only checking the current element
-          !(native.has_attribute?('hidden') || (native[:style] =~ /display:\s?none/) || %w(script head).include?(tag_name))
+          # No need for an xpath if only checking the current element
+          !(native.key?('hidden') ||
+            /display:\s?none/.match?(native[:style] || '') ||
+            %w[script head style].include?(tag_name))
         end
       end
 
@@ -127,7 +130,8 @@ module Capybara
       #
       # @return [Boolean]     Whether the element is disabled
       def disabled?
-        native.has_attribute?('disabled')
+        native.has_attribute?('disabled') &&
+          %w[button input select textarea optgroup option menuitem fieldset].include?(tag_name)
       end
 
       ##
@@ -140,11 +144,19 @@ module Capybara
         native.has_attribute?('selected')
       end
 
-      def synchronize(seconds=nil)
+      def multiple?
+        native.has_attribute?('multiple')
+      end
+
+      def readonly?
+        native.has_attribute?('readonly')
+      end
+
+      def synchronize(_seconds = nil)
         yield # simple nodes don't need to wait
       end
 
-      def allow_reload!
+      def allow_reload!(*)
         # no op
       end
 
@@ -152,12 +164,7 @@ module Capybara
       #
       # @return [String]     The title of the document
       def title
-        if native.respond_to? :title
-          native.title
-        else
-          #old versions of nokogiri don't have #title - remove in 3.0
-          native.xpath('/html/head/title | /html/title').first.text
-        end
+        native.title
       end
 
       def inspect
@@ -165,12 +172,12 @@ module Capybara
       end
 
       # @api private
-      def find_css(css)
+      def find_css(css, **_options)
         native.css(css)
       end
 
       # @api private
-      def find_xpath(xpath)
+      def find_xpath(xpath, **_options)
         native.xpath(xpath)
       end
 
@@ -178,6 +185,32 @@ module Capybara
       def session_options
         Capybara.session_options
       end
+
+      # @api private
+      def initial_cache
+        {}
+      end
+
+      def ==(other)
+        eql?(other) || (other.respond_to?(:native) && native == other.native)
+      end
+
+    private
+
+      def option_value(option)
+        return nil if option.nil?
+
+        option[:value] || option.content
+      end
+
+      VISIBILITY_XPATH = XPath.generate do |x|
+        x.ancestor_or_self[
+          x.attr(:style)[x.contains('display:none') | x.contains('display: none')] |
+          x.attr(:hidden) |
+          x.qname.one_of('script', 'head') |
+          (~x.self(:summary) & XPath.parent(:details)[!XPath.attr(:open)])
+        ].boolean
+      end.to_s.freeze
     end
   end
 end

data/lib/capybara/node/whitespace_normalizer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Node
+    ##
+    #
+    # {Capybara::Node::WhitespaceNormalizer} provides methods that
+    # help to normalize the spacing of text content inside of
+    # {Capybara::Node::Element}s by removing various unicode
+    # spacing and directional markings.
+    #
+    module WhitespaceNormalizer
+      # Unicode for NBSP, or  
+      NON_BREAKING_SPACE = "\u00a0"
+      LINE_SEPERATOR = "\u2028"
+      PARAGRAPH_SEPERATOR = "\u2029"
+
+      # All spaces except for NBSP
+      BREAKING_SPACES = "[[:space:]&&[^#{NON_BREAKING_SPACE}]]".freeze
+
+      # Whitespace we want to substitute with plain spaces
+      SQUEEZED_SPACES = " \n\f\t\v#{LINE_SEPERATOR}#{PARAGRAPH_SEPERATOR}".freeze
+
+      # Any whitespace at the front of text
+      LEADING_SPACES = /\A#{BREAKING_SPACES}+/
+
+      # Any whitespace at the end of text
+      TRAILING_SPACES = /#{BREAKING_SPACES}+\z/
+
+      # "Invisible" space character
+      ZERO_WIDTH_SPACE = "\u200b"
+
+      # Signifies text is read left to right
+      LEFT_TO_RIGHT_MARK = "\u200e"
+
+      # Signifies text is read right to left
+      RIGHT_TO_LEFT_MARK = "\u200f"
+
+      # Characters we want to truncate from text
+      REMOVED_CHARACTERS = [ZERO_WIDTH_SPACE, LEFT_TO_RIGHT_MARK, RIGHT_TO_LEFT_MARK].join
+
+      # Matches multiple empty lines
+      EMPTY_LINES = /[\ \n]*\n[\ \n]*/
+
+      ##
+      #
+      # Normalizes the spacing of a node's text to be similar to
+      # what matchers might expect.
+      #
+      # @param text [String]
+      # @return [String]
+      #
+      def normalize_spacing(text)
+        text
+          .delete(REMOVED_CHARACTERS)
+          .tr(SQUEEZED_SPACES, ' ')
+          .squeeze(' ')
+          .sub(LEADING_SPACES, '')
+          .sub(TRAILING_SPACES, '')
+          .tr(NON_BREAKING_SPACE, ' ')
+      end
+
+      ##
+      #
+      # Variant on {Capybara::Node::Normalizer#normalize_spacing} that
+      # targets the whitespace of visible elements only.
+      #
+      # @param text [String]
+      # @return [String]
+      #
+      def normalize_visible_spacing(text)
+        text
+          .squeeze(' ')
+          .gsub(EMPTY_LINES, "\n")
+          .sub(LEADING_SPACES, '')
+          .sub(TRAILING_SPACES, '')
+          .tr(NON_BREAKING_SPACE, ' ')
+      end
+    end
+  end
+end

data/lib/capybara/queries/active_element_query.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Capybara
+  # @api private
+  module Queries
+    class ActiveElementQuery < BaseQuery
+      def initialize(**options)
+        @options = options
+        super(@options)
+      end
+
+      def resolve_for(session)
+        node = session.driver.active_element
+        [Capybara::Node::Element.new(session, node, nil, self)]
+      end
+    end
+  end
+end

data/lib/capybara/queries/ancestor_query.rb

@@ -1,23 +1,26 @@
 # frozen_string_literal: true
+
 module Capybara
   module Queries
-    class AncestorQuery < MatchQuery
+    class AncestorQuery < Capybara::Queries::SelectorQuery
       # @api private
       def resolve_for(node, exact = nil)
         @child_node = node
+
         node.synchronize do
-          match_results = super(node.session.current_scope, exact)
-          node.all(:xpath, XPath.ancestor) do |el|
-            match_results.include?(el)
-          end
+          scope = node.respond_to?(:session) ? node.session.current_scope : node.find(:xpath, '/*')
+          match_results = super(scope, exact)
+          ancestors = node.find_xpath(XPath.ancestor.to_s)
+                          .map(&method(:to_element))
+                          .select { |el| match_results.include?(el) }
+          Capybara::Result.new(ordered_results(ancestors), self)
         end
       end
 
-      def description
+      def description(applied = false) # rubocop:disable Style/OptionalBooleanParameter
+        child_query = @child_node&.instance_variable_get(:@query)
         desc = super
-        if @child_node && (child_query = @child_node.instance_variable_get(:@query))
-          desc += " that is an ancestor of #{child_query.description}"
-        end
+        desc += " that is an ancestor of #{child_query.description}" if child_query
         desc
       end
     end

data/lib/capybara/queries/base_query.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 module Capybara
   # @api private
   module Queries
     class BaseQuery
-      COUNT_KEYS = [:count, :minimum, :maximum, :between]
+      COUNT_KEYS = %i[count minimum maximum between].freeze
 
       attr_reader :options
       attr_writer :session_options
@@ -20,8 +21,11 @@ module Capybara
         self.class.wait(options, session_options.default_max_wait_time)
       end
 
-      def self.wait(options, default=Capybara.default_max_wait_time)
-        options.fetch(:wait, default) || 0
+      def self.wait(options, default = Capybara.default_max_wait_time)
+        # if no value or nil for the :wait option is passed it should default to the default
+        wait = options.fetch(:wait, nil)
+        wait = default if wait.nil?
+        wait || 0
       end
 
       ##
@@ -30,11 +34,7 @@ module Capybara
       # Returns false if query does not have any count options specified.
       #
       def expects_none?
-        if COUNT_KEYS.any? { |k| options.has_key? k }
-          matches_count?(0)
-        else
-          false
-        end
+        count_specified? ? matches_count?(0) : false
       end
 
       ##
@@ -47,11 +47,12 @@ module Capybara
       # @param [Integer] count     The actual number. Should be coercible via Integer()
       #
       def matches_count?(count)
-        return (Integer(options[:count]) == count)     if options[:count]
+        return (Integer(options[:count]) == count) if options[:count]
         return false if options[:maximum] && (Integer(options[:maximum]) < count)
         return false if options[:minimum] && (Integer(options[:minimum]) > count)
-        return false if options[:between] && !(options[:between] === count)
-        return true
+        return false if options[:between] && !options[:between].include?(count)
+
+        true
       end
 
       ##
@@ -59,36 +60,46 @@ module Capybara
       # Generates a failure message from the query description and count options.
       #
       def failure_message
-        String.new("expected to find #{description}") << count_message
+        +"expected to find #{description}" << count_message
       end
 
       def negative_failure_message
-        String.new("expected not to find #{description}") << count_message
+        +"expected not to find #{description}" << count_message
       end
 
-      private
+    private
+
+      def count_specified?
+        COUNT_KEYS.any? { |key| options.key? key }
+      end
 
       def count_message
-        message = String.new()
-        if options[:count]
-          message << " #{options[:count]} #{Capybara::Helpers.declension('time', 'times', options[:count])}"
-        elsif options[:between]
-          message << " between #{options[:between].first} and #{options[:between].last} times"
-        elsif options[:maximum]
-          message << " at most #{options[:maximum]} #{Capybara::Helpers.declension('time', 'times', options[:maximum])}"
-        elsif options[:minimum]
-          message << " at least #{options[:minimum]} #{Capybara::Helpers.declension('time', 'times', options[:minimum])}"
+        message = +''
+        count, between, maximum, minimum = options.values_at(:count, :between, :maximum, :minimum)
+        if count
+          message << " #{occurrences count}"
+        elsif between
+          message << " between #{between.begin ? between.first : 1} and " \
+                     "#{between.end ? between.last : 'infinite'} times"
+        elsif maximum
+          message << " at most #{occurrences maximum}"
+        elsif minimum
+          message << " at least #{occurrences minimum}"
         end
         message
       end
 
+      def occurrences(count)
+        "#{count} #{Capybara::Helpers.declension('time', 'times', count)}"
+      end
+
       def assert_valid_keys
         invalid_keys = @options.keys - valid_keys
-        unless invalid_keys.empty?
-          invalid_names = invalid_keys.map(&:inspect).join(", ")
-          valid_names = valid_keys.map(&:inspect).join(", ")
-          raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
-        end
+        return if invalid_keys.empty?
+
+        invalid_names = invalid_keys.map(&:inspect).join(', ')
+        valid_names = valid_keys.map(&:inspect).join(', ')
+        raise ArgumentError, "Invalid option(s) #{invalid_names}, should be one of #{valid_names}"
       end
     end
   end

data/lib/capybara/queries/current_path_query.rb

@@ -1,40 +1,35 @@
 # frozen_string_literal: true
+
 require 'addressable/uri'
 
 module Capybara
   # @api private
   module Queries
     class CurrentPathQuery < BaseQuery
-      def initialize(expected_path, options = {})
+      def initialize(expected_path, **options, &optional_filter_block)
         super(options)
         @expected_path = expected_path
-        warn "DEPRECATED: The :only_path option is deprecated in favor of the :ignore_query option" if options.has_key?(:only_path)
-
         @options = {
-          url: !@expected_path.is_a?(Regexp) && !::Addressable::URI.parse(@expected_path || "").hostname.nil?,
-          only_path: false,
-          ignore_query: false }.merge(options)
+          url: !@expected_path.is_a?(Regexp) && !::Addressable::URI.parse(@expected_path || '').hostname.nil?,
+          ignore_query: false
+        }.merge(options)
+        @filter_block = optional_filter_block
         assert_valid_keys
       end
 
       def resolves_for?(session)
         uri = ::Addressable::URI.parse(session.current_url)
-        uri.query = nil if uri && options[:ignore_query]
-        @actual_path = if options[:url]
-          uri.to_s
-        else
-          if options[:only_path]
-            uri && uri.path
-          else
-            uri && uri.request_uri
-          end
+        @actual_path = (options[:ignore_query] ? uri&.omit(:query) : uri).then do |u|
+          options[:url] ? u&.to_s : u&.request_uri
         end
 
-        if @expected_path.is_a? Regexp
-          @actual_path.to_s.match(@expected_path)
+        res = if @expected_path.is_a? Regexp
+          @actual_path.to_s.match?(@expected_path)
         else
           ::Addressable::URI.parse(@expected_path) == ::Addressable::URI.parse(@actual_path)
         end
+
+        res && matches_filter_block?(uri)
       end
 
       def failure_message
@@ -45,22 +40,21 @@ module Capybara
         failure_message_helper(' not')
       end
 
-      private
+    private
+
+      def matches_filter_block?(url)
+        return true unless @filter_block
+
+        @filter_block.call(url)
+      end
 
       def failure_message_helper(negated = '')
-        verb = (@expected_path.is_a?(Regexp))? 'match' : 'equal'
+        verb = @expected_path.is_a?(Regexp) ? 'match' : 'equal'
         "expected #{@actual_path.inspect}#{negated} to #{verb} #{@expected_path.inspect}"
       end
 
       def valid_keys
-        [:wait, :url, :only_path, :ignore_query]
-      end
-
-      def assert_valid_keys
-        super
-        if options[:url] && options[:only_path]
-          raise ArgumentError, "the :url and :only_path options cannot both be true"
-        end
+        %i[wait url ignore_query]
       end
     end
   end

data/lib/capybara/queries/match_query.rb

@@ -1,19 +1,26 @@
+# frozen_string_literal: true
+
 module Capybara
   module Queries
     class MatchQuery < Capybara::Queries::SelectorQuery
       def visible
-        if options.has_key?(:visible)
-          super
-        else
-          :all
-        end
+        options.key?(:visible) ? super : :all
       end
 
-      private
+    private
+
+      def assert_valid_keys
+        invalid_options = @options.keys & COUNT_KEYS
+        unless invalid_options.empty?
+          raise ArgumentError, "Match queries don't support quantity options. Invalid keys - #{invalid_options.join(', ')}"
+        end
+
+        super
+      end
 
       def valid_keys
         super - COUNT_KEYS
       end
     end
   end
-end
+end