capybara 2.18.0 → 3.40.0

data/lib/capybara/node/base.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Capybara
   module Node
-
     ##
     #
     # A {Capybara::Node::Base} represents either an element on a page through the subclass
@@ -67,51 +67,57 @@ module Capybara
       # time has passed. On rubies/platforms which don't support access to a monotonic process clock
       # if the return value of `Time.now` is stubbed out, Capybara will raise `Capybara::FrozenInTime`.
       #
-      # @param  [Integer] seconds         Number of seconds to retry this block
-      # @param options [Hash]
-      # @option options [Array<Exception>] :errors (driver.invalid_element_errors +
+      # @param  [Integer] seconds  (current sessions default_max_wait_time) Maximum number of seconds to retry this block
+      # @param  [Array<Exception>] errors (driver.invalid_element_errors +
       #   [Capybara::ElementNotFound]) exception types that cause the block to be rerun
       # @return [Object]                  The result of the given block
       # @raise  [Capybara::FrozenInTime]  If the return value of `Time.now` appears stuck
       #
-      def synchronize(seconds=session_options.default_max_wait_time, options = {})
-        start_time = Capybara::Helpers.monotonic_time
+      def synchronize(seconds = nil, errors: nil)
+        return yield if session.synchronized
 
-        if session.synchronized
+        seconds = session_options.default_max_wait_time if [nil, true].include? seconds
+        interval = session_options.default_retry_interval
+        session.synchronized = true
+        timer = Capybara::Helpers.timer(expire_in: seconds)
+        begin
           yield
-        else
-          session.synchronized = true
-          begin
-            yield
-          rescue => e
-            session.raise_server_error!
-            raise e unless driver.wait?
-            raise e unless catch_error?(e, options[:errors])
-            raise e if (Capybara::Helpers.monotonic_time - start_time) >= seconds
-            sleep(0.05)
-            raise Capybara::FrozenInTime, "time appears to be frozen, Capybara does not work with libraries which freeze time, consider using time travelling instead" if Capybara::Helpers.monotonic_time == start_time
+        rescue StandardError => e
+          session.raise_server_error!
+          raise e unless catch_error?(e, errors)
+
+          if driver.wait?
+            raise e if timer.expired?
+
+            sleep interval
+            reload if session_options.automatic_reload
+          else
+            old_base = @base
             reload if session_options.automatic_reload
-            retry
-          ensure
-            session.synchronized = false
+            raise e if old_base == @base
           end
+          retry
+        ensure
+          session.synchronized = false
         end
       end
 
       # @api private
-      def find_css(css)
-        base.find_css(css)
+      def find_css(css, **options)
+        if base.method(:find_css).arity == 1
+          base.find_css(css)
+        else
+          base.find_css(css, **options)
+        end
       end
 
       # @api private
-      def find_xpath(xpath)
-        base.find_xpath(xpath)
-      end
-
-      # @deprecated Use query_scope instead
-      def parent
-        warn "DEPRECATED: #parent is deprecated in favor of #query_scope - Note: #parent was not the elements parent in the document so it's most likely not what you wanted anyway"
-        query_scope
+      def find_xpath(xpath, **options)
+        if base.method(:find_xpath).arity == 1
+          base.find_xpath(xpath)
+        else
+          base.find_xpath(xpath, **options)
+        end
       end
 
       # @api private
@@ -119,13 +125,15 @@ module Capybara
         session.config
       end
 
+      def to_capybara_node
+        self
+      end
+
     protected
 
       def catch_error?(error, errors = nil)
         errors ||= (driver.invalid_element_errors + [Capybara::ElementNotFound])
-        errors.any? do |type|
-          error.is_a?(type)
-        end
+        errors.any? { |type| error.is_a?(type) }
       end
 
       def driver

data/lib/capybara/node/document.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Capybara
   module Node
-
     ##
     #
     # A {Capybara::Document} represents an HTML document. Any operation
@@ -20,8 +20,8 @@ module Capybara
       #
       # @return [String]    The text of the document
       #
-      def text(type=nil)
-        find(:xpath, '/html').text(type)
+      def text(type = nil, normalize_ws: false)
+        find(:xpath, '/html').text(type, normalize_ws: normalize_ws)
       end
 
       ##
@@ -31,6 +31,18 @@ module Capybara
       def title
         session.driver.title
       end
+
+      def execute_script(*args)
+        find(:xpath, '/html').execute_script(*args)
+      end
+
+      def evaluate_script(*args)
+        find(:xpath, '/html').evaluate_script(*args)
+      end
+
+      def scroll_to(*args, quirks: false, **options)
+        find(:xpath, quirks ? '//body' : '/html').scroll_to(*args, **options)
+      end
     end
   end
 end

data/lib/capybara/node/document_matchers.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Capybara
   module Node
     module DocumentMatchers
@@ -6,17 +7,19 @@ module Capybara
       # Asserts that the page has the given title.
       #
       # @!macro title_query_params
-      #   @overload $0(string, options = {})
+      #   @overload $0(string, **options)
       #     @param string [String]           The string that title should include
-      #   @overload $0(regexp, options = {})
+      #   @overload $0(regexp, **options)
       #     @param regexp [Regexp]           The regexp that title should match to
       #   @option options [Numeric] :wait (Capybara.default_max_wait_time) Maximum time that Capybara will wait for title to eq/match given string/regexp argument
       #   @option options [Boolean] :exact (false) When passed a string should the match be exact or just substring
       # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
       # @return [true]
       #
-      def assert_title(title, options = {})
-        _verify_title(title,options) { |query| raise Capybara::ExpectationNotMet, query.failure_message unless query.resolves_for?(self) }
+      def assert_title(title, **options)
+        _verify_title(title, options) do |query|
+          raise Capybara::ExpectationNotMet, query.failure_message unless query.resolves_for?(self)
+        end
       end
 
       ##
@@ -26,8 +29,10 @@ module Capybara
       # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
       # @return [true]
       #
-      def assert_no_title(title, options = {})
-        _verify_title(title,options) { |query| raise Capybara::ExpectationNotMet, query.negative_failure_message if query.resolves_for?(self) }
+      def assert_no_title(title, **options)
+        _verify_title(title, options) do |query|
+          raise Capybara::ExpectationNotMet, query.negative_failure_message if query.resolves_for?(self)
+        end
       end
 
       ##
@@ -36,10 +41,8 @@ module Capybara
       # @macro title_query_params
       # @return [Boolean]
       #
-      def has_title?(title, options = {})
-        assert_title(title, options)
-      rescue Capybara::ExpectationNotMet
-        return false
+      def has_title?(title, **options)
+        make_predicate(options) { assert_title(title, **options) }
       end
 
       ##
@@ -48,22 +51,17 @@ module Capybara
       # @macro title_query_params
       # @return [Boolean]
       #
-      def has_no_title?(title, options = {})
-        assert_no_title(title, options)
-      rescue Capybara::ExpectationNotMet
-        return false
+      def has_no_title?(title, **options)
+        make_predicate(options) { assert_no_title(title, **options) }
       end
 
-      private
+    private
 
       def _verify_title(title, options)
-        query = Capybara::Queries::TitleQuery.new(title, options)
-        synchronize(query.wait) do
-          yield(query)
-        end
-        return true
+        query = Capybara::Queries::TitleQuery.new(title, **options)
+        synchronize(query.wait) { yield(query) }
+        true
       end
-
     end
   end
 end