webaccount 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 760ad4d11b1cfb40c9492b933d511fcd571ba2ad5a2875f6b23d14e1460e19c8
-  data.tar.gz: 208737ad6bd03b897ecb917fdcb96898558f4f048c5a5313485a9b9842d9b79b
+  metadata.gz: 90b5b4da3fa0eee7ac4a4c6c85ce3b59a7640bc7aaff8065b7c8432920d8a255
+  data.tar.gz: 1a5efd14b2d09b0dd2d6eeaef4128272d7e34e18779e62cf968a95455858ee1a
 SHA512:
-  metadata.gz: 8676a98a7ffe8504046408997d1f95cd6aaf908435c98ce245b03071a18af622bb15f4e359d71927af1b29ee91ae9efca65a4bf147d652eefdd71b69fcaeb7f4
-  data.tar.gz: f691c42b066940950c48d64ad2b75959d1bdaa033f52856f4b0eca8c43e63d34126ccc77d11223c8aa63373d8eb53c5bc48a91c5e3e8487e7bbd361a5930cf75
+  metadata.gz: dbf5f58ce0a99f2232796010962a20f39b45a55e8ba0c5c414b2c3c50ea3c8f54fe409ab4b36878d36a5cf849664b187c3119bc3a79e483c50c2e2196f3b55a8
+  data.tar.gz: 935406e37e640aafd799a60a422314282874d0ffc5369fe398dde3b0948987da01583fc649ffdb47ebf58c421c0881fcf2a00dbeabeb5595ad1e92cac890b37c

data/CHANGELOG

@@ -0,0 +1,115 @@
+# CHANGELOG
+
+## 20261011
+
+0.5.0: + WebAccount#driver, public, so that the logged-in browser can be driven from outside.
+
+driver was private, so once login() had done its work the session it made could be used only by a sub-class. Something which wants the pages behind a login without being a WebAccount, a spider fetching and screenshotting them, had no way to reach the browser holding the session.
+
+1. ~ WebAccount#driver(): public, after shutdown(); what it does is unchanged, the browser being made once, with browser() and driver_options(), upon first being asked for.
+2. + test/webaccount_test.rb: driver public, made once, and made with the browser and driver options given, with Selenium::WebDriver.for swapped for a stand-in so that no browser is wanted. All three fail against 0.4.1.
+3. ~ README.md: + Driving the browser once logged in.
+4. ~ VERSION: /0.4.1/0.5.0/
+
+
+## 20260822
+
+0.4.1: + LICENSE, which the gemspec has claimed without one being present.
+
+1. + LICENSE: the MIT text, copyright 2020-2026 thoran. spec.license has named MIT with no licence text in the repository, so the gem shipped a licence nobody could read.
+2. ~ webaccount.gemspec: + 'LICENSE' to spec.files, without which the file sits in the repository and still does not ship.
+3. + README.md: a License section, saying MIT, last.
+4. ~ VERSION: /0.4.0/0.4.1/
+
+
+## 20260717
+
+0.4.0: Selenium 4 compatibility, achieved mostly by deletion, since Selenium 4 has absorbed most of what these extensions were written for.
+
+Breaking:
+a. - WebAccount#user_agent_alias, #user_agent_alias=: Replaced by the browser: argument to new(). A sub-class which set or over-rode user_agent_alias must now pass browser: or over-ride #browser().
+b. ~ webaccount.gemspec: Require selenium-webdriver >= 4.0 and Ruby >= 3.3. This release depends on Selenium 4 behaviour and will not work on Selenium 3.
+c. ~ Thoran::Selenium::WebDriver::Driver::ElementPresentQ#element_present?(): No longer waits. The implicit wait removed in 16 below gave it up to 5s for an element to appear; it is now an instantaneous check, so a sub-class which relied on it as a wait will now silently get false rather than true. Wrap it in a Selenium::WebDriver::Wait, as login() does.
+d. /lib/WebAccount.rb/lib/webaccount.rb/: require 'webaccount', which is what the README has always documented and what the gem name implies, raised a LoadError on a case-sensitive file system. It now works, and it is require 'WebAccount' which raises instead. require 'web_account' is unaffected.
+
+1. - Thoran::Selenium::WebDriver::Remote::W3C::Bridge::ConvertLocators: The namespace no longer exists in Selenium 4, which raised a NameError on require, and locator conversion is now native.
+2. - Thoran::Selenium::WebDriver::SearchContext::ElementsPresentQ: find_elements_by() returns an empty array rather than raising, so elements_present?() was unconditionally true.
+3. - Thoran::Selenium::WebDriver::Setup: Firefox::Binary is gone from Selenium 4 and there was never a Chrome or Safari equivalent, so only the browser name branch remained, which is Selenium::WebDriver.for().
+4. - Thoran::String::ToConst: Only ever used by Setup, and Object.const_get() has handled nested constants since Ruby 2.0.
+5. - Thoran::Array::AllButFirst: Only ever used by ToConst.
+6. - Thoran::Array::FirstX: Only ever used by AllButFirst.
+7. ~ Thoran::Selenium: - the three deleted requires.
+8. ~ Thoran::Selenium::WebDriver::Driver::Attempt#attempt(): Yield self, so the documented block argument is the driver rather than nil; use retry rather than loop/break; re-raise rather than calling quit on @driver, which was never assigned, and exiting the process.
+9. ~ Thoran::Selenium::WebDriver::Driver::Attempt#attempt(): - Timeout::Error, which nothing in Selenium 4 raises, so the rescue was dead. Selenium's own timeouts, and those of Selenium::WebDriver::Wait, are Selenium::WebDriver::Error::TimeoutError. Timeout::Error also only resolved at all because selenium-webdriver happens to require 'timeout' for Firefox.
+10. + Thoran::Selenium::WebDriver::Driver::Attempt::TRANSIENT_ERRORS: The errors a flaky page actually raises: ElementClickInterceptedError, ElementNotInteractableError, NoSuchElementError, StaleElementReferenceError, TimeoutError, UnexpectedAlertOpenError, and UnknownError. Only the last two were caught before. InvalidSelectorError and NoSuchDriverError are deliberately excluded, being programming and environment errors respectively, so retrying only delays the report.
+11. ~ Thoran::Selenium::WebDriver::Driver::ElementPresentQ#element_present?(): Use the public find_elements() rather than the private bridge.
+12. /Thoran::Selenium::WebDriver::SearchContext::ElementPresentQ/Thoran::Selenium::WebDriver::Driver::ElementPresentQ/: It patches Driver, as Driver::Attempt does, so it now sits alongside it. Selenium::WebDriver::SearchContext is the find_element()/find_elements() contract which Driver, Element, and ShadowRoot implement, rather than a home for conveniences built on top of it, and Selenium itself has no presence predicate to follow.
+13. + WebAccount#default_browser(), #default_driver_options(): Return :chrome and nil, for over-riding in a sub-class.
+14. + WebAccount#browser(), #driver_options(): Fall back to the defaults. browser() also normalises a String or a capitalised Symbol, since Selenium::WebDriver.for() matches on a lowercase Symbol.
+15. ~ WebAccount#driver(): Construct the driver directly, with browser() and driver_options(), rather than via the deleted Selenium::WebDriver.setup().
+16. ~ WebAccount#driver(): - the implicit wait, since mixing implicit and explicit waits made driver_wait() poll every 5s rather than every 0.2s. See c above.
+17. + WebAccount#find(): Extracted from the four finder methods.
+18. + WebAccount#find_wait(), #default_find_timeout(): A Wait of its own for find(), at 5s. Sharing driver_wait() would have given a missing element 180s to not appear, where the implicit wait removed in 16 raised at 5s. Selenium::WebDriver::Wait ignores NoSuchElementError by default, so find() polls rather than raising, and 5s restores the previous contract.
+19. ~ WebAccount#driver_wait(): /180/30/, via the new #default_wait_timeout(). 180s was tolerable only because the implicit wait removed in 16 made each poll cost 5s, so it bought 36 polls; at the 0.2s interval it now buys 900 polls of the same page. 30s covers a submit, the authentication behind it, and the redirect, and is 90s worst case through attempt()'s three tries rather than 9 minutes.
+20. + WebAccount#username_field_selector(), #password_field_selector(), #login_page_submit_button_selector(), #logout_button_selector(): Fall back to the defaults in one place.
+21. ~ WebAccount#username_field(), #password_field(), #login_page_submit_button(), #logout_button(): Use find() and the selector methods.
+22. ~ WebAccount#logout_button(): Fix @logout_page_submit_button_selector, which was never assigned, so a supplied logout button selector was always ignored in favour of the default.
+23. ~ WebAccount#login(): Use logout_button_selector(), which no longer raises when no selector was supplied.
+24. ~ WebAccount#login(): - attempts = 0, which was unused.
+25. /WebAccount#default_username_field/WebAccount#default_username_field_selector/
+26. /WebAccount#default_password_field/WebAccount#default_password_field_selector/
+27. ~ lib/web_account.rb: /require_relative './WebAccount'/require_relative './webaccount'/, per d above.
+28. ~ WebAccount::VERSION: /0.3.1/0.4.0/
+29. + lib/webaccount.rb: require_relative './WebAccount/VERSION', so that WebAccount::VERSION is defined by requiring the library. It was previously loaded only by the gemspec.
+30. ~ lib/webaccount.rb: /require 'Thoran/Selenium'/require_relative './Thoran/Selenium'/. Thoran/Selenium ships in this gem, so requiring it by $LOAD_PATH meant it only loaded when lib was on the path, and left it to path order in a namespace which several other gems here also ship. require './lib/webaccount' now works.
+31. ~ lib/webaccount.rb: /# WebAccount.rb/# webaccount.rb/ in the header, per d above.
+32. ~ webaccount.gemspec: /spec.license = 'Ruby'/spec.license = 'MIT'/, per the more recent gems.
+33. + test/Thoran/Selenium/WebDriver/Driver/Attempt_test.rb: Cover attempt() against a dummy including the module: the value and receiver yielded, which errors are retried and which are not, the attempt count, and the warning. The transient and non-transient errors are listed in the test rather than read from TRANSIENT_ERRORS, so that the test states the intent rather than agreeing with the implementation. Nothing else in WebAccount is reachable to test: browser(), driver_options(), and the four selector methods are all private, and login(), find(), and logout() need a browser and a settled timeout.
+34. + Rakefile: rake test, per the other gems.
+35. ~ .gitignore (*.lock): Running bundle writes a Gemfile.lock, which is not committed for a gem.
+36. ~ webaccount.gemspec: + minitest, minitest-spec-context, and rake as development dependencies, and + Rakefile and test/ to spec.files.
+37. ~ webaccount.gemspec: Match the layout of the more recent gemspecs: + the dependencies=/development_dependencies= sugar; + spec.require_paths, which was missing; list spec.files explicitly, so that CHANGELOG, Gemfile, and README.md are packaged rather than lib alone; and - spec.date, which Rubygems sets itself and which was stale in every release so far.
+38. ~ README.md: + Choosing a browser, Driver options, and Timeouts; note that logged_out_xpath is required by logout() and shutdown(); prefer find() to driver.find_element() in the sub-classing example, since that example was relying on the implicit wait removed in 16; and fix a stray quotation mark, a missing comma, and a fork URL pointing at month.rb.
+
+Known: These are all one question, which is what login(), logout(), and logged_out?() should do
+when the page does not do what was expected: raise, or report. They want one answer between
+them rather than three, they are not compatibility problems, and 0.5's fixtures and
+integration tests are what would pin them, so they are left alone here.
+
+i. WebAccount#logged_out?() returns truthy or raises: Wait#until does not return false, so
+  the `if logged_out?` in logout() is dead code and logout() always either raises or logs out.
+ii. WebAccount#login() raises Selenium::WebDriver::Error::TimeoutError rather than returning
+  false when the logout button never appears, so a wrong password is an exception rather than
+  a return value. As in 0.3.1.
+iii. WebAccount#logged_out?() with no logged_out_xpath raises
+  Selenium::WebDriver::Error::InvalidSelectorError, from find_elements(:xpath, nil) reaching
+  the bridge, which sends nil.to_s. shutdown() calls logout(), so this is reachable from the
+  README's implicit-defaults usage.
+iv. Thoran::Selenium::WebDriver::Driver::ElementPresentQ#element_present?() rests on
+  find_elements() returning an empty array rather than raising, which is what the deleted
+  ElementsPresentQ in 2 above got wrong. Only a driver can confirm it, so it is untested until
+  0.5.
+
+
+## 20240407
+
+0.3.1: ./lib/README.md --> ./README.md
+
+
+## 20240407
+
+0.3.0: Can now use all of Selenium's page selectors (:css, :id, :name:, :xpath) instead of just :id and/or overriding methods in the sub-class.
+1. + WebAccount#default_username_field(): For use in username_field if username_field_selector is nil.
+2. ~ WebAccount#username_field(): Will optionally use the default_username_field if nothing is supplied.
+3. + WebAccount#default_password_field():  For use in password_field if username_field_selector is nil.
+4. ~ WebAccount#password_field(): Will optionally use the default_username_field if nothing is supplied.
+5. + WebAccount#default_login_page_submit_button_selector(): For use in login_page_submit_button if login_page_submit_button is nil.
+6. ~ WebAccount#login_page_submit_button(): Will optionally use the default_login_page_submit_button_selector if nothing is supplied.
+7. + WebAccount#default_logout_button_selector():  For use in logout_button if logout_button is nil.
+8. + WebAccount#logout_button(): Consistent with other elements having a method and will also optionally use the default_logout_button_selector if nothing is supplied.
+9. ~ WebAccount#login(): Use new generic selector for detecting logged-in state.
+10. ~ WebAccount#logout(): Use new logout_button() method instead of in-lining Selenium.
+11. ~ WebAccount::VERSION: /0.2.5/0.3.0/
+12. ~ webaccount.gemspec: Change the date, fix the summary, and the description.
+13. + CHANGELOG.txt
+14. + README.md

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://www.rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2026 thoran
+
+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,198 @@
+# WebAccount
+
+## Description
+
+Easily log into web accounts by supplying just a username and password, the URL of the login page, and a few selectors for page elements to a sub-class of WebAccount.
+
+## Installation
+
+Add this line to your application's Gemfile:
+```ruby
+gem 'webaccount'
+```
+And then execute:
+```shell
+$ bundle
+```
+Or install it yourself as:
+```shell
+$ gem install webaccount
+```
+
+## Usage
+
+### Instantiation
+
+#### 1. With implicit defaults
+```ruby
+  require 'webaccount'
+
+  class MyAccount < WebAccount; end
+
+  MyAccount.new(username: username, password: password)
+  # => #<MyAccount @username=username, @password=password, @login_page_url=nil,
+  # @login_page_password_field_selector=nil, @login_page_username_field_selector=nil,
+  # @login_page_submit_button_selector=nil,
+  # @logout_button_selector=nil, @logged_out_xpath=nil>
+```
+
+#### 2. With explicit defaults, then in the comment the ultimate defaults if those values remain nil
+```ruby
+  require 'webaccount'
+
+  class MyAccount < WebAccount
+    PAGE_SELECTORS = {
+      login_page_url: nil, # There are no defaults, so something like 'https://mysite.com/login' is required.
+      login_page_username_field_selector: nil, # Will default to: {name: 'username'}
+      login_page_password_field_selector: nil, # Will default to: {name: 'password'}
+      login_page_submit_button_selector: nil, # Will default to: {xpath: '//input[@type="submit" and @value="Login"]'}
+      logout_button_selector: nil, # Will default to: {xpath: '//input[@type="submit" and @value="Logout"]'}
+      logged_out_xpath: nil, # No default value for this, and logout and shutdown require it.
+    }
+  end
+
+  MyAccount.new(
+    **{username: username, password: password}\
+      .merge(MyAccount::PAGE_SELECTORS)
+  )
+  # => #<MyAccount @username=username, @password=password...>
+```
+
+#### 3. With supplied values
+```ruby
+  require 'webaccount'
+
+  class MyAccount < WebAccount
+    PAGE_SELECTORS = {
+      login_page_url: 'https://mysite.com/login',
+      login_page_username_field_selector: {id: 'username'},
+      login_page_password_field_selector: {id: 'password'},
+      login_page_submit_button_selector: {xpath: '//button[@type="submit" and @value="Login"]'},
+      logout_button_selector: {css: '#button-logout'},
+      logged_out_xpath: '//div[@class="logged-out"]',
+    }
+  end
+
+  MyAccount.new(
+    **{username: username, password: password}
+      .merge(MyAccount::PAGE_SELECTORS)
+  )
+  # => #<MyAccount @username=username, @password=password...>
+```
+
+### Choosing a browser
+
+`browser` is passed to `Selenium::WebDriver.for`, so it accepts whatever Selenium does: `:chrome`, `:firefox`, `:safari`, `:edge`, `:ie`. It defaults to `:chrome`, and a String or a capitalised Symbol is fine.
+```ruby
+  MyAccount.new(username: username, password: password, browser: :firefox)
+```
+
+### Driver options
+
+`driver_options` is passed to `Selenium::WebDriver.for` as `options:`. It defaults to nil, which is what Selenium itself defaults to, so leaving it alone gets you a stock browser.
+```ruby
+  options = Selenium::WebDriver::Chrome::Options.new
+  options.add_argument('--headless=new')
+
+  MyAccount.new(username: username, password: password, driver_options: options)
+```
+Or in a sub-class, if every instance should be configured the same way:
+```ruby
+  class MyAccount < WebAccount
+    private
+
+    def default_driver_options
+      Selenium::WebDriver::Chrome::Options.new.tap do |options|
+        options.add_argument('--headless=new')
+      end
+    end
+  end
+```
+
+### Timeouts
+
+There are two, both overridable in a sub-class:
+
+| Method | Default | Waits for |
+| --- | --- | --- |
+| `default_find_timeout` | 5s | An element on a page which has already loaded. |
+| `default_wait_timeout` | 30s | Navigation: a submit, the authentication behind it, and the redirect. |
+
+```ruby
+  class SlowAccount < WebAccount
+    private
+
+    def default_wait_timeout
+      60
+    end
+  end
+```
+
+### Logging in, out, and shutting down
+```ruby
+  require 'webaccount'
+
+  class MyAccount < WebAccount; end
+
+  my_account = MyAccount.new(username: username, password: password)
+  my_account.login
+  my_account.logout
+  my_account.shutdown # If necessary it logs out and then kills the selenium session.
+```
+
+### Driving the browser once logged in
+
+`driver` is the logged-in browser, a `Selenium::WebDriver::Driver`, for whatever WebAccount doesn't do itself: fetching pages behind the login, reading them, or taking screenshots of them.
+```ruby
+  my_account = MyAccount.new(username: username, password: password)
+  my_account.login
+  my_account.driver.get('https://mysite.com/members/page')
+  my_account.driver.page_source
+  my_account.driver.save_screenshot('page.png')
+  my_account.shutdown
+```
+
+### Overriding the login method to customise logins
+```ruby
+  require 'webaccount'
+
+  class MyAccount < WebAccount
+    def login
+      # Put custom login code here.
+    end
+  end
+```
+
+### Create new methods for selection and navigation
+
+Prefer `find` over `driver.find_element`: it waits up to `default_find_timeout` for the element, whereas `driver.find_element` raises the moment the element isn't there.
+```ruby
+  require 'webaccount'
+
+  class MyAccount < WebAccount
+    def list_page_link
+      find(id: 'list')
+    end
+
+    def list_page
+      login unless logged_in?
+      list_page_link.click
+    end
+  end
+
+  my_account = MyAccount.new(username: username, password: password)
+  my_account.list_page
+```
+
+## Contributing
+
+1. Fork it: https://github.com/thoran/WebAccount/fork
+2. Create your feature branch: `git checkout -b my-new-feature`
+3. Commit your changes: `git commit -am 'Add some feature'`
+4. Push to the branch: `git push origin my-new-feature`
+5. Create a new pull request
+
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,9 @@
+# Rakefile
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/lib/Thoran/Selenium/WebDriver/Driver/Attempt/attempt.rb

@@ -1,8 +1,8 @@
-# Thoran/Selenium/WebDriver/Attempt/attempt.rb
-# Thoran::Selenium::WebDriver::Attempt.attempt
+# Thoran/Selenium/WebDriver/Driver/Attempt/attempt.rb
+# Thoran::Selenium::WebDriver::Driver::Attempt#attempt
 
-# 20200419
-# 0.0.1
+# 20260717
+# 0.1.0
 
 # Examples:
 # 1. driver.attempt do |driver|
@@ -13,31 +13,41 @@
 # end
 
 # Changes:
-# 1. + Thoran namespace.
+# 1. Yield self, so that the documented block argument is the driver rather than nil.
+# 2. Use retry rather than loop/break.
+# 3. Re-raise rather than calling quit on @driver, which was never assigned, and exiting the process.
+# 4. - Timeout::Error: Nothing in Selenium 4 raises it. Its own timeouts, and those of
+#   Selenium::WebDriver::Wait, are Selenium::WebDriver::Error::TimeoutError.
+# 5. + The errors a flaky page actually raises, none of which were caught before.
+#   Deliberately excluded: Error::InvalidSelectorError and Error::NoSuchDriverError, which
+#   are programming and environment errors respectively, so retrying only delays the report.
 
 module Thoran
   module Selenium
     module WebDriver
       module Driver
         module Attempt
+          TRANSIENT_ERRORS = [
+            ::Selenium::WebDriver::Error::ElementClickInterceptedError,
+            ::Selenium::WebDriver::Error::ElementNotInteractableError,
+            ::Selenium::WebDriver::Error::NoSuchElementError,
+            ::Selenium::WebDriver::Error::StaleElementReferenceError,
+            ::Selenium::WebDriver::Error::TimeoutError,
+            ::Selenium::WebDriver::Error::UnexpectedAlertOpenError,
+            ::Selenium::WebDriver::Error::UnknownError,
+          ].freeze
 
-          def attempt(max_attempts = 3, &block)
+          def attempt(max_attempts = 3)
             attempts = 0
-            loop do
-              begin
-                yield
-                break
-              rescue Timeout::Error, ::Selenium::WebDriver::Error::UnknownError, ::Selenium::WebDriver::Error::NoSuchElementError => e
-                attempts += 1
-                if attempts >= max_attempts
-                  @driver.quit
-                  puts "Giving up after #{max_attempts} attempts to #{__method__} because #{e}."
-                  exit
-                end
-              end
+            begin
+              yield self
+            rescue *TRANSIENT_ERRORS => e
+              attempts += 1
+              warn "Attempt #{attempts} of #{max_attempts} failed: #{e.class}"
+              retry if attempts < max_attempts
+              raise
             end
           end
-
         end
       end
     end

data/lib/Thoran/Selenium/WebDriver/Driver/ElementPresentQ/element_presentQ.rb

@@ -0,0 +1,37 @@
+# Thoran/Selenium/WebDriver/Driver/ElementPresentQ/element_presentQ.rb
+# Thoran::Selenium::WebDriver::Driver::ElementPresentQ#element_present?
+
+# 20260717
+# 0.1.0
+
+# Examples:
+# 1. driver.element_present?(:xpath, '//a[@id="submit"]')
+# 2. driver.element_present?(:css, '#button-logout')
+
+# Changes:
+# 1. Use the public find_elements() rather than the private bridge.
+# 2. ^Driver, alongside Driver::Attempt, since this patches Driver too. Selenium's
+#   SearchContext is the find_element()/find_elements() contract, which Driver, Element,
+#   and ShadowRoot implement, rather than a home for conveniences built on top of it.
+
+module Thoran
+  module Selenium
+    module WebDriver
+      module Driver
+        module ElementPresentQ
+          def element_present?(selector_type, selector)
+            !find_elements(selector_type, selector).empty?
+          end
+        end
+      end
+    end
+  end
+end
+
+module Selenium
+  module WebDriver
+    class Driver
+      include Thoran::Selenium::WebDriver::Driver::ElementPresentQ
+    end
+  end
+end

data/lib/Thoran/Selenium.rb

@@ -1,11 +1,14 @@
 # Thoran/Selenium.rb
 # Thoran::Selenium
 
-# 20200418
-# 0.0.0
+# 20260717
+# 0.1.0
+
+# Changes:
+# 1. - Selenium::WebDriver::Remote::W3C::Bridge::ConvertLocators
+# 2. - Selenium::WebDriver::SearchContext::ElementsPresentQ
+# 3. - Selenium::WebDriver::Setup
+# 4. /Selenium::WebDriver::SearchContext::ElementPresentQ/Selenium::WebDriver::Driver::ElementPresentQ/
 
 require_relative './Selenium/WebDriver/Driver/Attempt/attempt'
-require_relative './Selenium/WebDriver/Remote/W3C/Bridge/ConvertLocators/convert_locators'
-require_relative './Selenium/WebDriver/SearchContext/ElementPresentQ/element_presentQ'
-require_relative './Selenium/WebDriver/SearchContext/ElementsPresentQ/elements_presentQ'
-require_relative './Selenium/WebDriver/Setup/setup'
+require_relative './Selenium/WebDriver/Driver/ElementPresentQ/element_presentQ'

data/lib/web_account.rb

@@ -3,4 +3,4 @@
 # Notes:
 # 1. This is to enable an alternate means of loading: require 'web_account'.
 
-require_relative 'WebAccount'
+require_relative './webaccount'

data/lib/webaccount/VERSION.rb

@@ -0,0 +1,6 @@
+# WebAccount/VERSION.rb
+# WebAccount::VERSION
+
+class WebAccount
+  VERSION = '0.5.0'
+end