capybara 3.8.1 → 3.33.0

data/lib/capybara/node/simple.rb

@@ -102,12 +102,15 @@ module Capybara
       #
       def visible?(check_ancestors = true)
         return false if (tag_name == 'input') && (native[:type] == 'hidden')
+        return false if tag_name == 'template'
 
         if check_ancestors
-          !find_xpath("boolean(./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or @hidden or name()='script' or name()='head'])")
+          !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))
+          !(native.key?('hidden') ||
+            /display:\s?none/.match?(native[:style] || '') ||
+            %w[script head].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
 
       ##
@@ -148,7 +152,7 @@ module Capybara
         yield # simple nodes don't need to wait
       end
 
-      def allow_reload!
+      def allow_reload!(*)
         # no op
       end
 
@@ -164,12 +168,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,12 +182,27 @@ module Capybara
         Capybara.session_options
       end
 
+      # @api private
+      def initial_cache
+        {}
+      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/queries/ancestor_query.rb

@@ -6,9 +6,13 @@ module Capybara
       # @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) { |el| match_results.include?(el) }
+          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
 
@@ -18,12 +22,6 @@ module Capybara
         desc += " that is an ancestor of #{child_query.description}" if child_query
         desc
       end
-
-    private
-
-      def valid_keys
-        super - COUNT_KEYS
-      end
     end
   end
 end

data/lib/capybara/queries/base_query.rb

@@ -51,6 +51,7 @@ module Capybara
         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].include?(count)
+
         true
       end
 
@@ -76,24 +77,29 @@ module Capybara
         message = +''
         count, between, maximum, minimum = options.values_at(:count, :between, :maximum, :minimum)
         if count
-          message << " #{count} #{Capybara::Helpers.declension('time', 'times', count)}"
+          message << " #{occurrences count}"
         elsif between
-          message << " between #{between.first} and #{between.last} times"
+          message << " between #{between.begin ? between.first : 1} and" \
+                     " #{between.end ? between.last : 'infinite'} times"
         elsif maximum
-          message << " at most #{maximum} #{Capybara::Helpers.declension('time', 'times', maximum)}"
+          message << " at most #{occurrences maximum}"
         elsif minimum
-          message << " at least #{minimum} #{Capybara::Helpers.declension('time', 'times', 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
         return if 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}"
+        raise ArgumentError, "Invalid option(s) #{invalid_names}, should be one of #{valid_names}"
       end
     end
   end

data/lib/capybara/queries/current_path_query.rb

@@ -18,11 +18,11 @@ module Capybara
 
       def resolves_for?(session)
         uri = ::Addressable::URI.parse(session.current_url)
-        uri.query = nil if uri && options[:ignore_query]
-        @actual_path = options[:url] ? uri.to_s : uri&.request_uri
+        uri&.query = nil if options[:ignore_query]
+        @actual_path = options[:url] ? uri&.to_s : uri&.request_uri
 
         if @expected_path.is_a? Regexp
-          @actual_path.to_s.match(@expected_path)
+          @actual_path.to_s.match?(@expected_path)
         else
           ::Addressable::URI.parse(@expected_path) == ::Addressable::URI.parse(@actual_path)
         end

data/lib/capybara/queries/match_query.rb

@@ -14,6 +14,7 @@ module Capybara
         unless invalid_options.empty?
           raise ArgumentError, "Match queries don't support quantity options. Invalid keys - #{invalid_options.join(', ')}"
         end
+
         super
       end