brut 0.0.13 → 0.0.21

data/lib/brut/i18n/base_methods.rb

@@ -1,6 +1,11 @@
-# Interface for translations.  This is prefered over using Ruby's I18n directly.
-# This is intended to be mixed-in to any class that requires this, so that you can more
-# expediently access the `t` method.
+# Interface for translations, preferred over Ruby's I18n classes. Note that this is a
+# base module and not intended to be directly used in your classes.  Include one of
+# the other modules in this namespace:
+#
+# * {Brut::I18n::ForHTML} for components or pages, or anything use Phlex
+# * {Brut::I18n::ForCLI} for CLI apps
+# * {Brut::I18n::ForBackEnd} for back-end classes that aren't generating HTML
+#
 module Brut::I18n::BaseMethods
 
   # Access a translation and insert interpolated elemens as needed. This will use the provided key to determine
@@ -18,12 +23,12 @@ module Brut::I18n::BaseMethods
   # to `t("email.required", field: "E-mail address")` would generate `"E-mail address is required"`.
   #
   # @param [String,Symbol,Array<String>,Array<Symbol>] key used to create one or more keys to be translated.
-  #        This value's behavior is designed to a balance predictabilitiy in what actual key is chosen
+  #        This value's behavior is designed to balance predictabilitiy in what actual key is chosen
   #        but without needless repetition on a page.  If this value is provided, and is an array, the values
   #        are joined with "." to form a key.  If the value is not an array, that value is used directly.
   #        Given this key, two values are checked for a translation: the key itself and 
   #        the key inside "general.".  If this value is *not* provided, it is expected
-  #        taht the `**rest` hash includes page: or component:.  See that parameter and the example.
+  #        that the `**rest` hash includes page: or component:.  See that parameter and the example.
   #
   # @param [Hash] rest values to use for interpolation of the key's translation. If `key` is omitted,
   #               this hash should have a value for either `page:` or `component:` (not both).  If
@@ -34,6 +39,16 @@ module Brut::I18n::BaseMethods
   #               Note that if the page– or component–specific key is not found, this will check
   #               `general.«page: value»`.
   # @option interpolated_values [Numeric] count Special interpolation to control pluralization.
+  # @yield Nothing is yielded if a block is given, however the value returned is used for the `%{block}`
+  #        interpolation value.
+  # @yieldreturn [String] The value to use for the `%{block}` interpolation value.  There is some nuance to
+  #                       how this works.  The value returned is given to `capture`, and that value
+  #                       is given to `safe`.  Outside of an HTML-rendering context, these methods
+  #                       simply pass through the contents of the block.  In an HTML-rendering
+  #                       context, however, these methods are assumed to be from
+  #                       [`Phlex::HTML`](https://phlex.fun).  `capture` will create a new Phlex
+  #                       context and capture any HTML built inside the block.  That HTML is assumed
+  #                       to be safe, thus `safe` is called to communicate this to Phlex.
   #
   # @raise [I18n::MissingTranslation] if no translation is found
   # @raise [I18n::MissingInterpolationArgument] if interpolation arguments are missing, or if the key
@@ -84,7 +99,7 @@ module Brut::I18n::BaseMethods
   #   t(page: :new_widget) # => Create new Widget
   #   # in your code for WidgetsPage
   #   t(page: :new_widget) # => Create New
-  #   # in your code for SomeOtherEPage
+  #   # in your code for SomeOtherPage
   #   t(page: :new_widget) # => Make a New Widget
   #
   # @example Using page: with an array
@@ -101,7 +116,31 @@ module Brut::I18n::BaseMethods
   #   }
   #   # in your code for HomePage
   #   t(page: [ :captions, :new ]) # => New Widgets
-  def t(key=:look_in_rest,**rest)
+  #
+  # @example Using a block with Phlex
+  #   # in your translations file
+  #   en: {
+  #     greeting: "Hello there %{name}, you may %{block}",
+  #   }
+  #   # Inside a component where
+  #   # Brut::I18n::ForHTML has been included
+  #   def view_template
+  #     h1 do
+  #       raw(t(:greeting), name: user.name) do
+  #         a(href: "https://support.example.com") do
+  #           "contact support"
+  #         end
+  #       end
+  #     end
+  #   end
+  #   # This will produce this HTML, assuming user.name is "Pat":
+  #   <h1>
+  #     Hell there Pat, you may
+  #     <a href="https://support.example.com">
+  #       contact support
+  #     </a>
+  #   </h1>
+  def t(key=:look_in_rest,**rest,&block)
     if key == :look_in_rest
 
       page      = rest.delete(:page)
@@ -126,13 +165,14 @@ module Brut::I18n::BaseMethods
       key = Array(key).join('.')
       key = [key,"general.#{key}"]
     end
-    if block_given?
+    if !block.nil?
       if rest[:block]
         raise ArgumentError,"t was given a block and a block: param. You can't do both "
       end
-      rest[:block] = html_safe(yield.to_s.strip)
+      block_contents = safe(capture(&block))
+      rest[:block] = block_contents
     end
-    html_safe(t_direct(key,**rest))
+    t_direct(key,**rest)
   rescue I18n::MissingInterpolationArgument => ex
     if ex.key.to_s == "block"
       raise ArgumentError,"One of the keys #{key.join(", ")} contained a %{block} interpolation value: '#{ex.string}'. This means you must use t_html *and* yield a block to it"
@@ -168,7 +208,7 @@ module Brut::I18n::BaseMethods
     }
     escaped_interpolated_values = interpolated_values.map { |key,value|
       if value.kind_of?(String)
-        [ key, Brut::FrontEnd::Template.escape_html(value) ]
+        [ key, CGI.escapeHTML(value) ]
       else
         [ key, value ]
       end

data/lib/brut/i18n/for_back_end.rb

@@ -0,0 +1,8 @@
+# Use this to access translations in any back-end code.
+# This implementation does support blocks yielded to {#t}, however
+# their values are not necessarily HTML-escaped.
+module Brut::I18n::ForBackEnd
+  include Brut::I18n::BaseMethods
+  def safe(string) = string
+  def capture(&block) = block.()
+end

data/lib/brut/i18n/for_cli.rb

@@ -1,4 +1,8 @@
+# Use this to access translations in any CLI.
+# This implementation does support blocks yielded to {#t}, however
+# their values are not necessarily HTML-escaped.
 module Brut::I18n::ForCLI
   include Brut::I18n::BaseMethods
-  def html_safe(string) = string
+  def safe(string) = string
+  def capture(&block) = block.()
 end

data/lib/brut/i18n/for_html.rb

@@ -1,4 +1,12 @@
+# I18n for components or pages, which are assumed to be Phlex components.
+# To use this outside of a Phlex context, you must define these two
+# methods to ensure proper HTML escaping happens:
+#
+# * `safe` to accept a string and return a string.
+# * `capture` to accept a block and return its contents as a string.
 module Brut::I18n::ForHTML
   include Brut::I18n::BaseMethods
-  def html_safe(string) = Brut::FrontEnd::Templates::HTMLSafeString.from_string(string)
+  def t(...)
+    safe(super)
+  end
 end

data/lib/brut/i18n/http_accept_language.rb

@@ -1,8 +1,19 @@
+# Manages the value for the HTTP
+# [Accept-Language](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Accept-Language)
+# header. Generally, you would not interact with this class directly, however it is used
+# by Brut to make a guess as to which Locale a browser is reporting.
 class Brut::I18n::HTTPAcceptLanguage
+  # A locale with the weight (value for q=) it was given in the Accept-Language header
   WeightedLocale = Data.define(:locale, :q) do
+    # Returns the primary locale for whatever locale
+    # this is holding.  For example, the primary locale 
+    # of "en-US" is "en".
     def primary_locale = self.locale.gsub(/\-.*$/,"")
+
+    # True if this locale is a primary locale
     def primary? = self.primary_locale == self.locale
 
+    # Return a new WeightedLocale that is the primary locale.
     def primary_only
       self.class.new(locale: self.primary_locale, q: self.q)
     end
@@ -12,6 +23,11 @@ class Brut::I18n::HTTPAcceptLanguage
     end
   end
 
+  # Parse the value stored in the session.
+  #
+  # @param [String] session_value the value stored in the session.
+  # @return [Brut::I18n::HTTPAcceptLanguage] a usable object. If the provided value
+  #         is blank, #{Brut::I18n::HTTPAcceptLanguage::AlwaysEnglish} is returned.
   def self.from_session(session_value)
     values = session_value.to_s.split(/,/).map { |value|
       locale,q = value.split(/;/)
@@ -24,6 +40,19 @@ class Brut::I18n::HTTPAcceptLanguage
     end
   end
 
+  # Parse the value provided by the browser via 
+  # {Brut::FrontEnd::Handlers::LocaleDetectionHandler} via
+  # the `brut-locale-detection` custom element (which
+  # uses `Intl.DateTimeFormat().resolvedOptions()` to determine
+  # the locale).
+  #
+  # Because this value is not in the same format as the Accept-Language
+  # header, it's `q` is assumed to be 1.
+  #
+  # @param [String] value the value provided by the brower.
+  #
+  # @return [Brut::I18n::HTTPAcceptLanguage] a usable object. If the provided value
+  #         is blank, #{Brut::I18n::HTTPAcceptLanguage::AlwaysEnglish} is returned.
   def self.from_browser(value)
     value = value.to_s.strip
     if value == ""
@@ -33,6 +62,10 @@ class Brut::I18n::HTTPAcceptLanguage
     end
   end
 
+  # Parse from the HTTP Accept-Language header.
+  #
+  # @return [Brut::I18n::HTTPAcceptLanguage] a usable object. If the provided value
+  #         is blank, #{Brut::I18n::HTTPAcceptLanguage::AlwaysEnglish} is returned.
   def self.from_header(header_value)
     header_value = header_value.to_s.strip
     if header_value == "*" || header_value == ""
@@ -50,14 +83,28 @@ class Brut::I18n::HTTPAcceptLanguage
     end
   end
 
+  # Ordered list of locales, from highest-weighted to lowest.
   attr_reader :weighted_locales
+  # @param [Array<Brut::I18n::HTTPAcceptLanguage::WeightedLocale>] weighted_locales locales to use. They do not
+  #        need to be ordered
   def initialize(weighted_locales)
     @weighted_locales = weighted_locales.sort_by(&:q).reverse
   end
+
+  # True if the values inside this object represent known locales, and not a guess based on missing information.
+  # In general, this returns true if the values came from the Accept-Language header, or from the browser.
   def known? = true
+
+  # Serialize for storage in the session
+  #
+  # @return [String] a string that can be stored in the session and later deserialized via {.from_session}.
   def for_session = @weighted_locales.map { |weighted_locale| "#{weighted_locale.locale};#{weighted_locale.q}" }.join(",")
   def to_s = self.for_session
 
+  # A subclass that represents the use of English and only English.  This is
+  # used when attempts to determine the locale fail.  Instances of this class
+  # are considered "unknown" ({#known?} returns false), which allows Brut
+  # to replace this with a known value later on.
   class AlwaysEnglish < Brut::I18n::HTTPAcceptLanguage
     def initialize
       super([ WeightedLocale.new(locale: "en", q: 1) ])

data/lib/brut/i18n.rb

@@ -1,6 +1,7 @@
 # I18n holds all the code useful for translating and localizing information. It's based on Ruby's I18n.
 module Brut::I18n
   autoload(:BaseMethods, "brut/i18n/base_methods")
+  autoload(:ForBackEnd, "brut/i18n/for_back_end")
   autoload(:ForCLI, "brut/i18n/for_cli")
   autoload(:ForHTML, "brut/i18n/for_html")
   autoload(:HTTPAcceptLanguage, "brut/i18n/http_accept_language")

data/lib/brut/instrumentation/open_telemetry.rb

@@ -1,3 +1,7 @@
+# Class to interact with the OpenTelemetry standard in a simpler way than
+# the provided Ruby gem does.  In general, you should use this class
+# via `Brut.container.instrumentation`, and you should *not* use the 
+# OpenTelemetry ruby library directly.  You probably wouldn't want to, anyway.
 class Brut::Instrumentation::OpenTelemetry
   # Create a span around the given block of code.
   #
@@ -39,11 +43,32 @@ class Brut::Instrumentation::OpenTelemetry
                            timestamp:)
   end
 
+  # Record an exception.  In general, use this only if:
+  #
+  # * You need to have the parent span record this particular exception
+  # * You are not going to re-raise the exception.
+  #
+  # Otherwise, look at {#record_and_reraise_exception!}.
+  #
+  # @param [Exception] ex the exception to record.
+  # @param [Hash] attributes any attributes to attach that will show up in your OTel provider
   def record_exception(ex,attributes=nil)
     current_span = OpenTelemetry::Trace.current_span
     current_span.record_exception(ex,attributes: NormalizedAttributes.new(nil,attributes).to_h)
   end
 
+  # Record an exception and re-raise it. This is useful if you want
+  # the exception recorded as part of the parent span, but still plan
+  # to let it raise.  Don't do this for every exception you intend to raise.
+  # @param [Exception] ex the exception to record.
+  # @param [Hash] attributes any attributes to attach that will show up in your OTel provider
+  # @raise [Exception] the exception passed in.
+  def record_and_reraise_exception(ex,attributes=nil)
+    reecord_exception(ex,attributes)
+    raise ex
+  end
+
+
   # Adds attributes to the span, converting the hash or keyword arguments to strings. This will use
   # the app's Otel prefix for all attributes, so you do not have to prefix them.
   # If you need to set standard attributes, you should use {Brut::Instrumentation::OpenTelemetry::Span#add_prefixed_attributes} instead.

data/lib/brut/instrumentation.rb

@@ -1,10 +1,8 @@
+# Namespace for instrumentation setup and support.  Brut strives to provide useful
+# instrumentation by default.
+#
 module Brut::Instrumentation
   autoload(:OpenTelemetry,"brut/instrumentation/open_telemetry")
   autoload(:LoggerSpanExporter,"brut/instrumentation/logger_span_exporter")
-
-  # Convenience method to add attributes to create a span without accessing the instrumentation instance directly.
-  def span(name,**attributes,&block)
-    Brut.container.instrumentation.span(name,**attributes,&block)
-  end
 end
 

data/lib/brut/sinatra_helpers.rb

@@ -9,6 +9,7 @@ module Brut::SinatraHelpers
     sinatra_app.path("/__brut/locale_detection",method: :post)
     sinatra_app.path("/__brut/instrumentation",method: :get)
     sinatra_app.set :host_authorization, permitted_hosts: Brut.container.permitted_hosts
+    sinatra_app.set :show_exceptions, false
   end
 
   # @private
@@ -77,15 +78,16 @@ module Brut::SinatraHelpers
 
         Brut.container.instrumentation.span(page_class.name) do |span|
           span.add_prefixed_attributes("brut", type: :page, class: page_class)
-          request_context = Thread.current.thread_variable_get(:request_context)
-          constructor_args = request_context.as_constructor_args(
+          constructor_args = Brut::FrontEnd::RequestContext.current.as_constructor_args(
             page_class,
             request_params: params,
             route: brut_route,
           )
           span.add_prefixed_attributes("brut.initializer.args", constructor_args.map { |k,v| [k.to_s,v.class.name] }.to_h)
           page_instance = page_class.new(**constructor_args)
+
           result = page_instance.handle!
+
           span.add_prefixed_attributes("brut", result_class: result.class)
           case result
           in URI => uri
@@ -177,7 +179,6 @@ module Brut::SinatraHelpers
             form_class: form_class,
           )
 
-          request_context = Thread.current.thread_variable_get(:request_context)
           handler = handler_class.new
           form = if form_class.nil?
                    nil
@@ -185,7 +186,7 @@ module Brut::SinatraHelpers
                    form_class.new(params: params)
                  end
 
-          process_args = request_context.as_method_args(handler,:handle,request_params: params,form: form,route:brut_route)
+          process_args = Brut::FrontEnd::RequestContext.current.as_method_args(handler,:handle,request_params: params,form: form,route:brut_route)
 
           result = handler.handle!(**process_args)
 
@@ -193,12 +194,17 @@ module Brut::SinatraHelpers
           in URI => uri
             redirect to(uri.to_s)
           in Brut::FrontEnd::Component => component_instance
-            render_html(component_instance).to_s
-          in [ Brut::FrontEnd::Component => component_instance, Brut::FrontEnd::HttpStatus => http_status ]
+            component_instance.call.to_s
+          in [
+            Brut::FrontEnd::Component  => component_instance,
+            Brut::FrontEnd::HttpStatus => http_status,
+          ]
+
             [
               http_status.to_i,
-              render_html(component_instance).to_s,
+              component_instance.call.to_s,
             ]
+
           in Brut::FrontEnd::HttpStatus => http_status
             http_status.to_i
           in Brut::FrontEnd::Download => download

data/lib/brut/spec_support/component_support.rb

@@ -8,11 +8,19 @@ module Brut::SpecSupport::ComponentSupport
   include Brut::SpecSupport::FlashSupport
   include Brut::SpecSupport::SessionSupport
   include Brut::SpecSupport::ClockSupport
-  include Brut::I18n::ForHTML
+  include Brut::I18n::BaseMethods
 
-  # Render a component into its text representation.  This mimics what happens when a component is used
-  # inside a template.  You typically don't want this, but should use {#render_and_parse}, since that will
-  # parse the HTML.
+  # Render a component or page into its text representation.  This mimics what happens when Brut renders
+  # the page or component.  Note that pages don't always return Strings, for example if `before_render`
+  # returns a redirect.
+  #
+  # When testing a component, call {#render_and_parse} instead of this. When testing a page that will
+  # always render HTML, again call {#render_and_parse}.
+  #
+  # When using this, there are some matchers that can help assert what the page has done:
+  #
+  # * `have_redirected_to` to check that the page redirected elsewhere, instead of rendering.
+  # * `have_returned_http_status` to check that the page returned an HTTP status instead of rendering.
   def render(component,&block)
     if component.kind_of?(Brut::FrontEnd::Page)
       if !block.nil?
@@ -20,12 +28,23 @@ module Brut::SpecSupport::ComponentSupport
       end
       component.handle!
     else
-      component.yielded_block = block
-      component.render
+      if block.nil?
+        component.call
+      else
+        component.call do
+          component.raw(component.safe(block.()))
+        end
+      end
     end
   end
 
-  # Render a component and parse it into a Nokogiri Node for examination.
+  # Render a component or page and parse it into a Nokogiri Node for examination.  There are several matchers
+  # you can use with the return value of this method:
+  #
+  # * `have_html_attribute` to check if a node has a value for an HTML attribute.
+  # * `have_i18n_string` to check if the text of a node is exactly an i18n string you have set up.
+  # * `have_link_to` to check that a node contains a link to a page or page routing
+  #
   #
   # @example
   #
@@ -41,7 +60,7 @@ module Brut::SpecSupport::ComponentSupport
   # @return [Brut::SpecSupport::EnhancedNode] a wrapper around a Nokogiri node to provide convienience methods.
   def render_and_parse(component,&block)
     rendered_text = render(component,&block)
-    if !rendered_text.kind_of?(String) && !rendered_text.kind_of?(Brut::FrontEnd::Templates::HTMLSafeString)
+    if !rendered_text.kind_of?(String)
       if rendered_text.kind_of?(URI::Generic)
         raise "#{component.class} redirected to #{rendered_text} instead of rendering"
       else
@@ -80,9 +99,4 @@ module Brut::SpecSupport::ComponentSupport
   def routing_for(klass,**args)
     Brut.container.routing.path(klass,**args)
   end
-
-  # Escape HTML using the same code Brut uses for rendering templates.
-  def escape_html(...)
-    Brut::FrontEnd::Templates::EscapableFilter.escape_html(...)
-  end
 end

data/lib/brut/spec_support/e2e_support.rb

@@ -0,0 +1,4 @@
+# Convienience methods for writing E2E tests
+module Brut::SpecSupport::E2eSupport
+  include Brut::I18n::ForBackEnd
+end

data/lib/brut/spec_support/general_support.rb

@@ -5,6 +5,9 @@ module Brut::SpecSupport::GeneralSupport
   end
 
   module ClassMethods
+    # Used to indicate that a test does need to be written, but that
+    # its implementation can wait until a given date before causing
+    # `bin/ci` to fail the test suite.
     def implementation_is_needed(check_again_at:)
       check_again_at = if check_again_at.kind_of?(Time)
                          check_again_at

data/lib/brut/spec_support/handler_support.rb

@@ -2,7 +2,12 @@ require_relative "flash_support"
 require_relative "clock_support"
 require_relative "session_support"
 
-# Convienience methods for testing handlers.
+# Convienience methods for testing handlers.  When testing handlers, the following matchers may be useful:
+#
+#
+# * `have_redirected_to` to check that the handler redirected to a give URI
+# * `have_rendered` to check that the handler rendered a specific page
+# * `have_returned_http_status` to check that the handler returned an HTTP status
 module Brut::SpecSupport::HandlerSupport
   include Brut::SpecSupport::FlashSupport
   include Brut::SpecSupport::ClockSupport

data/lib/brut/spec_support/matcher.rb

@@ -10,4 +10,5 @@ require_relative "matchers/have_i18n_string"
 require_relative "matchers/have_redirected_to"
 require_relative "matchers/have_rendered"
 require_relative "matchers/have_returned_http_status"
+require_relative "matchers/have_returned_rack_response"
 require_relative "matchers/have_link_to"

data/lib/brut/spec_support/matchers/be_page_for.rb

@@ -1,3 +1,4 @@
+# E2E
 RSpec::Matchers.define :be_page_for do |klass|
   match do |page|
     meta = page.locator("meta[name='class']")

data/lib/brut/spec_support/matchers/have_html_attribute.rb

@@ -1,3 +1,4 @@
+# Component/Page
 RSpec::Matchers.define :have_html_attribute do |attribute|
   if attribute.kind_of?(Hash)
     if attribute.keys.length != 1

data/lib/brut/spec_support/matchers/have_i18n_string.rb

@@ -1,5 +1,7 @@
+# Component/Page
 RSpec::Matchers.define :have_i18n_string do |key,**args|
-  include Brut::I18n::ForHTML
+  include Brut::I18n::ForBackEnd
+
   match do |nokogiri_node|
 
     text        = nokogiri_node.text.strip

data/lib/brut/spec_support/matchers/have_link_to.rb

@@ -1,3 +1,4 @@
+# Component/Page
 RSpec::Matchers.define :have_link_to do |page_klass,**args|
   match do |node|
     node.css("a[href='#{page_klass.routing(**args)}']").any?

data/lib/brut/spec_support/matchers/have_redirected_to.rb

@@ -1,3 +1,4 @@
+# Page
 RSpec::Matchers.define :have_redirected_to do |page_or_uri,**page_params|
   match do |result|
     if page_or_uri.kind_of?(URI)

data/lib/brut/spec_support/matchers/have_rendered.rb

@@ -1,3 +1,4 @@
+# Handler
 RSpec::Matchers.define :have_rendered do |component_or_page|
   match do |result|
     result.class.ancestors.include?(component_or_page)

data/lib/brut/spec_support/matchers/have_returned_rack_response.rb

@@ -0,0 +1,44 @@
+# Handler
+RSpec::Matchers.define :have_returned_rack_response do |http_status: :any, headers: :any, body: :any|
+  match do |result|
+    case result
+    in [ response_status, response_headers, response_body ]
+      http_status_match = http_status == :any || response_status == http_status
+      headers_match     = headers == :any || response_headers == headers
+      body_match        = body == :any || response_body == body
+
+      http_status_match && headers_match && body_match
+    else
+      false
+    end
+  end
+
+  failure_message do |result|
+    case result
+    in [ response_status, response_headers, response_body ]
+      http_status_match = http_status == :any || response_status == http_status
+      headers_match     = headers == :any || response_headers == headers
+      body_match        = body == :any || response_body == body
+      errors = [
+        http_status_match ? nil : "HTTP status #{response_status} did not match #{http_status}",
+        headers_match     ? nil : "Headers #{response_headers} did not match #{headers}",
+        body_match        ? nil : "Body #{response_body} did not match #{body}",
+      ].compact.join(", ")
+    else
+      if result.kind_of?(Array)
+        "Response was a #{result.class} of length #{result.length}, which could not be interpreted as a Rack response."
+      else
+        "Response was a #{result.class}, which could not be interpreted as a Rack response."
+      end
+    end
+  end
+  failure_message_when_negated do |result|
+    case result
+    in [ response_status, response_headers, response_body ]
+      "Response was a Rack response and/or array of size 3"
+    else
+      "failure_message_when_negated encounterd a code-path for a non-Rack response, which should not have happened when have_returned_rack_response was negated"
+    end
+  end
+
+end

data/lib/brut/spec_support/rspec_setup.rb

@@ -80,6 +80,7 @@ class Brut::SpecSupport::RSpecSetup
     @config.include Brut::SpecSupport::GeneralSupport
     @config.include Brut::SpecSupport::ComponentSupport, component: true
     @config.include Brut::SpecSupport::HandlerSupport, handler: true
+    @config.include Brut::SpecSupport::E2eSupport, e2e: true
     @config.include Playwright::Test::Matchers, e2e: true
 
     @config.around do |example|

data/lib/brut/spec_support.rb

@@ -1,15 +1,16 @@
 module Brut
   # Spec Support holds various matchers and helpers useful when writing tests with RSpec.
   # Note that this module and it's contents aren't loaded by default when you `require "brut"`.
-  # Your app's `spec_helper.rb` should require these properly.
+  # Your app's `spec_helper.rb` should require these explicitly.
   module SpecSupport
   end
 end
-require_relative "spec_support/matcher"
 require_relative "spec_support/component_support"
-require_relative "spec_support/handler_support"
-require_relative "spec_support/general_support"
+require_relative "spec_support/e2e_support"
 require_relative "spec_support/e2e_test_server"
+require_relative "spec_support/general_support"
+require_relative "spec_support/handler_support"
+require_relative "spec_support/matcher"
 require_relative "spec_support/rspec_setup"
 require_relative "factory_bot"
 # Convention here is different. We don't want to autoload

data/lib/brut/version.rb

@@ -1,4 +1,4 @@
 module Brut
   # @!visibility private
-  VERSION = "0.0.13"
+  VERSION = "0.0.21"
 end