capybara-reloads 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 980ec37f08c81b19646193192a014368ada60f31cc52fc64b4bc03584ed40a77
+  data.tar.gz: abca8c70caad1c2e131b22633e926aa1abd5dcc94c13b2cf587ad9fdfbeae7dd
+SHA512:
+  metadata.gz: 96d1a31f3d3a64233fd22e0d7f7bf1a2c6512823225e7fc282443f6f41cc0235c3d6ffaea1ea54dc773b4b876c0c9cc70fd6bc709822415cfe631732b7530eab
+  data.tar.gz: 26b22dac221bf078884da1e5f6649b2d8ebc606875374609f43d99061747a4a9e50b28e1e4b3df207b98e9b4b532db23ad9cffdc23a37e4ac8f4f1baf6009d81

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-12-25
+
+- Initial functionallity for reloading and tracking states. 

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in capybara-reloads.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rubocop", "~> 1.21"

data/Gemfile.lock

@@ -0,0 +1,71 @@
+PATH
+  remote: .
+  specs:
+    capybara-reloads (0.1.0)
+      capybara (~> 3.0)
+      capybara-screenshot (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.1)
+      public_suffix (>= 2.0.2, < 6.0)
+    ast (2.4.2)
+    capybara (3.38.0)
+      addressable
+      matrix
+      mini_mime (>= 0.1.3)
+      nokogiri (~> 1.8)
+      rack (>= 1.6.0)
+      rack-test (>= 0.6.3)
+      regexp_parser (>= 1.5, < 3.0)
+      xpath (~> 3.2)
+    capybara-screenshot (1.0.26)
+      capybara (>= 1.0, < 4)
+      launchy
+    json (2.6.3)
+    launchy (2.5.0)
+      addressable (~> 2.7)
+    matrix (0.4.2)
+    mini_mime (1.1.2)
+    nokogiri (1.13.10-arm64-darwin)
+      racc (~> 1.4)
+    parallel (1.22.1)
+    parser (3.1.3.0)
+      ast (~> 2.4.1)
+    public_suffix (5.0.1)
+    racc (1.6.2)
+    rack (3.0.2)
+    rack-test (2.0.2)
+      rack (>= 1.3)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.6.1)
+    rexml (3.2.5)
+    rubocop (1.41.1)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.1.2.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.23.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.24.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.3.0)
+    xpath (3.2.0)
+      nokogiri (~> 1.8)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  capybara-reloads!
+  rake (~> 13.0)
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.3.23

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,240 @@
+# Capybara::Reloads
+
+Reload the page when a Capybara selector fails. After reload assert the selector again. Repeat until the number of reloads is equal to allow_max_reloads. Store screenshot and html version of the page to allow for easier debug and understanding of why the spec has failed.
+
+When used for a randomly failing spec it will store and show the states before every load.
+
+```ruby
+expect(page).to have_xpath("//..the xpath value", 
+    allow_max_reloads: Capybara::Reloads.recommended_allow_max_reloads)
+```
+
+If the selector is first not matched and matched after reload capybara-reloads will report it as:
+
+```bash
+Failures:
+
+  1) Articles system specs
+     Failure/Error: raise message
+     
+     RuntimeError:
+         The example initially failed, but after 1 reloads it was successful.
+         States are shown below in order:
+     
+       State 0
+       {
+         "html": ".../tmp/capybara/screenshot_2022-12-25-21-57-53.129.html",
+         "image": ".../tmp/capybara/screenshot_2022-12-25-21-57-53.129.png",
+         "exception": "expected to find xpath \"//a[@class='select2-choice']/span[text()='United States']\" but there were no matches",
+         "reloads_made": 0
+       }
+       State 1
+       {
+         "html": ".../tmp/capybara/screenshot_2022-12-25-21-57-53.906.html",
+         "image": ".../tmp/capybara/screenshot_2022-12-25-21-57-53.906.png",
+         "exception": null,
+         "reloads_made": 1
+       }
+     
+     [Screenshot Image]: .../tmp/capybara/failures_r_spec_example_groups_article_807.png
+
+     
+     # .../capybara-reloads/lib/capybara/reloads/node/matchers.rb:54:in `after_success'
+     # .../capybara-reloads/lib/capybara/reloads/node/matchers.rb:28:in `block in with_reload_on_fail'
+     # .../capybara-reloads/lib/capybara/reloads/node/matchers.rb:23:in `loop'
+     # .../capybara-reloads/lib/capybara/reloads/node/matchers.rb:23:in `with_reload_on_fail'
+     # .../capybara-reloads/lib/capybara/reloads/node/matchers.rb:7:in `assert_selector'
+     # .../gems/capybara-3.38.0/lib/capybara/session.rb:773:in `assert_selector'
+     # .../gems/capybara-3.38.0/lib/capybara/rspec/matchers/have_selector.rb:18:in `element_matches?'
+     # .../gems/capybara-3.38.0/lib/capybara/rspec/matchers/base.rb:51:in `matches?'
+     # ./spec/system/articles_spec.rb:101:in `block (3 levels) in <top (required)>'
+     # ./spec/system/articles_spec.rb:157:in `block (3 levels) in <top (required)>'
+     # ./spec/system/articles_spec.rb:135:in `upto'
+     # ./spec/system/articles_spec.rb:135:in `block (2 levels) in <top (required)>'
+     # ./spec/spec_helper.rb:664:in `block (2 levels) in <top (required)>'
+     # .../gems/webmock-3.14.0/lib/webmock/rspec.rb:37:in `block (2 levels) in <top (required)>'
+
+Finished in 13.71 seconds (files took 4.49 seconds to load)
+```
+
+## What's the goal and the job to be done
+
+Sometimes a spec for an application that uses JavaScript fails "randomly". The goal of capybara-reloads is to help identify and resolve specs that are randomly failing due to JavaScript timing, load and reload precularities in non-trivial platform. It helps by saving a screenshot and html version of the page, reloading the page, and trying the selector again. If the second or the third time the selector is matched then the gem reports this.
+
+An alternative to capybara-reloads is:
+
+```ruby
+0.upto(2) do 
+    begin 
+        expect(page).to have_xpath "//..the xpath"
+    rescue Exception=>e
+        save screenshots and html of the page        
+        page.refresh
+    end
+end
+```
+but the above has to be done for every call and makes the spec more difficult to read and maintain. capybara-reloads patches Capybara in a way that makes enabling the reload for every or for specific selector very easy. 
+
+## Reasoning
+
+A non-trivial suite of system specs running over a non-trivial platform often contains specs that fail randomly, generally due to part of the JS not loading properly or not loading at all. 
+
+It is difficult to debug these randomly failing specs.
+
+Capybara provides a mechanism to wait for an expression to be matched agains a page. Check Capybara.default_max_wait_time and the 'wait: ' options on selectors. 
+
+There are cases where waiting for an expression does not help as the JS has not loaded. One reason might be that the JS is loaded through a network request and is inserted on the page without a proper async attribute on the script tag. Another reason might a a bug in a JS around timing issues. Non-trivial apps often load JS from sprockets, webpack, esbuild, vite, network and others where the source is comming from rails gems, npm packages or as hosted scripts. 
+
+The issue with randomly failing spec is that they reduce the trust that a team has in the system specs. Team members might be reluctant to develop and run a proper system specs when a spec fails from time to time. 
+
+During the development of this gem I stumbled upon such a case where the JS on the page was not loaded at all. I ran a spec 100 times and the results were:
+
+- 100 times - 0 failed
+- 100 times - Run 2 and Run 14 failed
+- 100 times - 0 failed
+- 1000 times - Run 353, 370, 409, 575, 624, 721, 959 failed 
+
+capybara-reloads is **not designed to hide this issues**. These are real issues that happen for real user requests. It is very possible that 1 in 100-200 requests from the set above loads a page that is broken for the user. Users generally reload the page and move one. If it happens once in a few hundred requests they might not even notice it.
+
+capybara-reloads is **designed to help identify, track and bring more light to this issue**. In this way teams could have more visibility on the patterns in the suites. They could budget proper time to address these issue when they feel they are important. capybara-reloads also provides a way to track information like images and html versions of the page, to log information and to place brakepoints for when this issues occur.
+
+## Installation
+
+Add to gem file
+
+    $ gem install capybara-reloads
+
+or add to Gemfile
+
+    gem 'capybara-reloads'
+
+## Usage
+
+capybara-reloads is non-intrusive. It will extend Capybara, but will not change behavior and will not cause a reload unless enabled. **To enable it the value of 'allow_max_reloads' should be explicitly set.**
+
+For RSpec add the configuration to spes/spec_helper.rb or spec/rails_helper.rb
+
+### To enable globally for all specs
+
+This will enable capybara-reloads for every matcher.
+
+```ruby
+Capybara::Reloads.allow_max_reloads = 2
+```
+
+It is recommended to use the Capybara::Reloads.recommended_allow_max_reloads value like:
+
+```ruby
+Capybara::Reloads.allow_max_reloads = Capybara::Reloads.recommended_allow_max_reloads
+``` 
+
+### To enable for specific matcher
+
+```ruby
+expect(page).to have_xpath "//..the xpath value", allow_max_reloads: 2
+```
+
+or the recommended
+
+```ruby
+expect(page).to have_xpath("//..the xpath value", 
+    allow_max_reloads: Capybara::Reloads.recommended_allow_max_reloads)
+```
+
+### Stop at a breakpoint only when reload 'fixed it'
+
+The example below configures capybara-reloads with a breakpoint where a debugger will stop only after a selector was first not matched, then page was refreshed and then the selector was matched for the second page. 
+
+```ruby
+Capybara::Reloads.allow_max_reloads = 1
+Capybara::Reloads.reload_fixed_it_callback do |args|
+    debugger
+    Capybara::Reloads.construct_message(args)
+end
+```
+
+## Configuration
+
+```ruby
+# The number of reloads that capybara-reloads will do. It will check if the selector is matched for every returned page.
+# It is a bad idea to have this set to a large number and 1-2 is the recommended on.
+# 
+# Default value is 0 which disables any reloads
+Capybara::Reloads.allow_max_reloads
+
+# The number of max reloads recommended by capybara-reloads author  
+Capybara::Reloads.recommended_allow_max_reloads
+
+# By default when capybara-reloads reloads the page and the matcher is resolved on the new page, we will throw an expection even though the new
+# page makes the specs pass. In this way we clearly inform that this spec fails and should be inspected. 
+# When you are ok with the test continuing you can set 'only_report' to true
+#
+# Require.
+# Default value is false
+Capybara::Reloads::only_report
+
+# A Proc called before reload of the page
+# 
+# It is useful to print a different kind of message, to stop, debug and inspect the state.
+#
+# Capybara::Reloads.before_reload_callback = Proc.new do |args|
+#   args[:base] # contains the instance of Capybara::Node::Base where we assert the matcher
+#   args[:expcetion] # contains the Capybara::ElementNotFound exception that occurred
+# end
+# 
+# Optional. Can be set to nil
+# Default value is provided that prints a message that the page will be reloaded
+Capybara::Reloads.before_reload_callback
+
+# A Proc called to reload the page
+#
+# Capybara::Reloads.reload_callback = Proc.new do |args|
+#   args[:base] # contains the instance of Capybara::Node::Base where we assert the matcher
+# end
+# 
+# Required. 
+# Default value is provided. Check source code of what it is as of current version 
+Capybara::Reloads.reload_callback
+
+# A proc called after capybara-reloads has reloaded the page and the new page passes the test.
+# This means that the reload has 'fixed the test'. By default screenshot and html version 
+# of the page are saved in a 'states' array after every assert of the matcher. 
+# 
+# Capybara::Reloads.reload_callback = Proc.new do |args|
+#   args[:states] # contains the states after every assert of the matcher
+#   # The states object contains
+#   {
+#     :html=>"/path/to/html",
+#     :image=>"/path/to/screenshot",
+#     :exception=>... # The Capybara::ElementNotFound exception that occurred,
+#     :reloads_made=>... # The number of reloads that were made when this state was saved
+#   }
+#   args[:reloads_made] # contains the reloads that were already made before this proc was called
+#   
+#   # This return value should be a message.
+#   # It will be reported or raise based on Capybara::Reloads.only_report
+#   # This gives the chance to add additional things to the report message
+#   # that are important for this spec/suite
+#   # The default message is constructed with Capybara::Reloads.construct_message(args)
+#   message
+# end
+# 
+# Required.
+# Default value is provided. Check source code of what it is as of current version
+# Should return a message
+Capybara::Reloads.reload_fixed_it_callback 
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/thebravoman/capybara-reloads.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/capybara-reloads.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/capybara/reloads/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "capybara-reloads"
+  spec.version = Capybara::Reloads::VERSION
+  spec.authors = ["Kiril Mitov"]
+  spec.email = ["kiril [at] retreaver [dot] com"]
+
+  spec.summary = "Utilities for Capybara to allow us to reload the page and check if examples will then pass."
+  spec.homepage = "https://kmitov.com"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/thebravoman/capybara-reloads"
+  spec.metadata["changelog_uri"] = "https://github.com/thebravoman/capybara-reloads/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "capybara", "~> 3.0"
+  spec.add_dependency "capybara-screenshot", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/capybara/reloads/node/matchers.rb

@@ -0,0 +1,70 @@
+module Capybara
+  module Reloads
+    module Node
+      module Matchers
+
+        def assert_selector(*args, &optional_filter_block)
+          with_reload_on_fail(args.last.delete(:allow_max_reloads)) do
+            super
+          end
+        end
+
+        private
+
+        def with_reload_on_fail allow_max_reloads_arg
+          local_max_reloads = allow_max_reloads_arg || Capybara::Reloads.allow_max_reloads
+          unless local_max_reloads.is_a?(Numeric) || local_max_reloads == nil
+            raise "'allow_max_reloads' must be Numeric or nil"
+          end
+          local_max_reloads == local_max_reloads || 0
+          result = nil
+          reloads_made = 0
+          @previous_states = []
+          loop do
+            begin
+              result = yield
+              # there is a result. We don't have to retry
+              # If previously there were errors get the current state and report
+              after_success reloads_made
+              break
+            rescue Capybara::ElementNotFound => e
+              record_state e, reloads_made
+              if reloads_made == local_max_reloads
+                raise e
+              end
+              reloads_made+=1
+              args = {base: self, exception: e}
+              # Allows us to change the way we report that a refresh should happend
+              if Capybara::Reloads.before_reload_callback != nil
+                Capybara::Reloads.before_reload_callback.call(args)
+              end
+              Capybara::Reloads.reload_callback.call(args)
+            end
+          end
+          result
+        end
+
+        def after_success reloads_made
+          if @previous_states.size > 0
+            record_state nil, reloads_made
+            message = Capybara::Reloads.reload_fixed_it_callback.call(states: @previous_states, reloads_made: reloads_made)
+            if Capybara::Reloads.only_report
+              puts message
+            else
+              raise message
+            end
+            @previous_states = []
+          end
+        end
+
+        def record_state exception, reloads_made
+          html_and_image = Capybara::Screenshot.screenshot_and_save_page
+          # html_and_image is of the form
+          # {:html=>"...screenshot_2022-12-25-17-42-37.712.html", :image=>"...screenshot_2022-12-25-17-42-37.712.png"}
+          @previous_states << html_and_image.merge({exception: exception, reloads_made: reloads_made})
+        end
+
+      end
+    end
+  end
+end

data/lib/capybara/reloads/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Reloads
+    VERSION = "0.1.0"
+  end
+end

data/lib/capybara/reloads.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "reloads/version"
+require_relative "reloads/node/matchers"
+
+module Capybara
+  module Reloads
+    class Error < StandardError; end
+      @@recommended_allow_max_reloads = 2
+
+    # By default Capybara::Reloads should have no impact
+    # It should be explicitly enabled, by setting to the recommended_allow_max_reloads with
+    # Capybara::Reloads.allow_max_reloads = CapybaraReload.recommended_allow_max_reloads
+    @@allow_max_reloads = 0
+
+    # The goal of Capybara::Reloads is to help identify places where the JS does not load
+    # not to hide them. By default Capybara::Reloads will try to reload to see if the error
+    # we can continue, but even if we do it will by default report this as an error.
+    # In this way we have clearly shown that this example depends on reloading the page
+    # and this is the real error here. Not that we can't find an element on the page
+    # but that this element is found sometimes and if we refresh it will be found
+    # more often than not
+    #
+    # To make Capybara::Reloads continue use only_report
+    @@only_report = false
+
+    @@before_reload_callback = Proc.new do |args|
+      puts "Refreshing the page as an exception occurred: #{args[:exception].message}"
+    end
+
+    @@reload_callback = Proc.new do |args|
+      base = args[:base]
+      base.session.refresh
+    end
+
+    @@reload_fixed_it_callback = Proc.new do |args|
+      Capybara::Reloads.construct_message(args)
+    end
+
+    # @param args
+    # @params states
+    # @params reloads_made
+    def self.construct_message args
+       message = <<-MESSAGE
+  The example initially failed, but after #{args[:reloads_made]} reloads it was successful.
+  States are shown below in order:
+  MESSAGE
+      args[:states].each_with_index do |state, index|
+        message += "\n"
+        message += "State #{index}\n"
+        message += JSON.pretty_generate(state)
+      end
+      message
+    end
+
+    def self.recommended_allow_max_reloads
+      @@recommended_allow_max_reloads
+    end
+
+    def self.allow_max_reloads
+      @@allow_max_reloads
+    end
+
+    def self.allow_max_reloads=(reloads)
+      if reloads > @@recommended_allow_max_reloads
+        puts "You are setting Capybara::Reloads.allow_max_reloads to be #{reloads}."
+        puts "This is more than the recommended value of #{@@recommended_allow_max_reloads} (Capybara::Reloads.recommended_allow_max_reloads)."
+        puts "Please refer to documentation about why this might be a bad idea."
+      end
+      @@allow_max_reloads = reloads
+    end
+
+    def self.only_report
+      @@only_report
+    end
+
+    def self.only_report=(value)
+      @@only_report = value
+    end
+
+    def self.before_reload_callback
+      @@before_reload_callback
+    end
+
+    def self.before_reload_callback=(the_proc)
+      @@before_reload_callback = the_proc
+    end
+
+    def self.reload_callback
+      @@reload_callback
+    end
+
+    def self.reload_callback=(the_proc)
+      @@reload_callback = the_proc
+    end
+
+    def self.reload_fixed_it_callback
+      @@reload_fixed_it_callback
+    end
+
+  end
+end
+
+Capybara::Node::Base.send(:prepend, Capybara::Reloads::Node::Matchers)

data/sig/capybara/reloads.rbs

@@ -0,0 +1,6 @@
+module Capybara
+  module Reloads
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: capybara-reloads
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kiril Mitov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-12-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: capybara-screenshot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description:
+email:
+- kiril [at] retreaver [dot] com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- capybara-reloads.gemspec
+- lib/capybara/reloads.rb
+- lib/capybara/reloads/node/matchers.rb
+- lib/capybara/reloads/version.rb
+- sig/capybara/reloads.rbs
+homepage: https://kmitov.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://kmitov.com
+  source_code_uri: https://github.com/thebravoman/capybara-reloads
+  changelog_uri: https://github.com/thebravoman/capybara-reloads/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Utilities for Capybara to allow us to reload the page and check if examples
+  will then pass.
+test_files: []