brut 0.0.29 → 0.1.0

data/brutrb.com/recipes/text-field-component.md

@@ -0,0 +1,182 @@
+# Creating your Own Text Field Component
+
+Brut's `Brut::FrontEnd::Components::Input::InputTag` creates only the `<input>` HTML
+element.  You will likely want something more sophsticated. You can achieve this by
+creating your own component.
+
+## Feature
+
+We'll make a text field that has a label, error messages, and styling.  It will
+support three sizes: small, normal, and large.
+
+It will require a form and an input name, and optional index as well.
+
+## Recipe
+
+### Create the Initializer
+
+First, we'll create the component:
+
+```
+bin/scaffold component text_field
+```
+
+Now, edit the initializer to accept the parameters we need:
+
+```ruby
+# app/src/front_end/components/text_field_component.rb
+class TextFieldComponent < AppComponent
+  def initialize(form:,
+                 input_name:,
+                 index: 0, # default for non-array values
+                 size: :normal)
+    @form       = form
+    @input_name = input_name
+    @index      = index
+    @size       = size
+  end
+end
+```
+
+### Outline the HTML
+
+We'll want HTML like so:
+
+```html
+<label>
+  <input ...>
+  <span>LABEL HERE</span>
+  <brut-cv-messages></brut-cv-messages>
+</label>
+```
+
+Before we worry about CSS or styling, let's sketch this out in `view_template`.  The
+actual label text will come from our I18n setup. We'll assume a "labels" top-level
+section that has sections for each form and then inside that, each input name:
+
+```ruby
+# app/config/i18n/en/2_app.rb
+{
+  "labels": {
+    "LoginForm": {
+      "email": "Email addressed you used when singing up",
+      "password": "Your password",
+    }
+  }
+}
+```
+
+```ruby
+# app/src/front_end/components/text_field_component.rb
+class TextFieldComponent < AppComponent
+
+  include Brut::FrontEnd::Components
+
+  private attr_reader :form, :input_name, :index
+  def view_template
+    label do
+      InputTag(form:, input_name:, index: )
+      span { raw(t([ "labels", form.class.name, input_name ])) }
+      ConstraintViolations(form:, input_name:, index:)
+    end
+  end
+end
+```
+
+### Styling the Component
+
+Styling can happen in a few ways.  For simplicity, we'll use CSS and have minimal
+classes on our HTML.  Since the structure is all inside a `<label>`, we'll add a
+class on that, named for our component. We'll also include form and input names
+in the class to allow overriding if needed.  Lastly, we'll include the
+size as well.
+
+```ruby {8-14}
+# app/src/front_end/components/text_field_component.rb
+class TextFieldComponent < AppComponent
+
+  include Brut::FrontEnd::Components
+
+  private attr_reader :form, :input_name, :index
+  def view_template
+    label_classes = [
+      class.name,
+      class.name + "-#{@size}",
+      form.class.name,
+      input_name
+    ]
+    label(class: label_classes) do
+      InputTag(form:, input_name:, index: )
+      span { raw(t([ "labels", form.class.name, input_name ])) }
+      ConstraintViolations(form:, input_name:, index:)
+    end
+  end
+end
+```
+
+Let's create `app/src/front_end/css/TextFieldComponent.css`, which we'll need to
+`@import`:
+
+```css
+/* app/src/front_end/css/index.css */
+@import "TextFieldComponent.css";
+```
+
+The CSS will assume BrutCSS's design system is available:
+
+```css
+/* app/src/front_end/css/TextFieldComponent.css */
+.TextFieldComponent {
+  label {
+    display: flex;
+    flex-direction: column;
+    gap: var(--sp-2);
+  }
+  input {
+    border: solid thin var(--gray-500);
+    border-radius: var(--br-3);
+    padding: var(--sp-2);
+    font-size: var(--fs-3);
+  }
+  span {
+    font-size: var(--fs-2);
+    font-stye: italic;
+    color: var(--gray-400);
+  }
+  /** We assume the general styling for brut-form
+      and brut-cv exists in index.css */
+  brut-cv {
+    color: red;
+  }
+  &.TextFieldComponent-small {
+    input {
+      font-size: var(--fs-1);
+    }
+  }
+  &.TextFieldComponent-large {
+    input {
+      font-size: var(--fs-4);
+    }
+  }
+}
+```
+
+### Using the Component
+
+To use this component, we can create an instance and send it to Phlex's `render`:
+
+
+```ruby
+def view_template
+  brut_form do
+    FormTag(for: @form) do
+      render TextFieldComponent.new(form: @form,
+                                    input_name: :name)
+      render TextFieldComponent.new(form: @form,
+                                    input_name: :quantity,
+                                    size: :small)
+      button { "Save" }
+    end
+  end
+end
+```

data/brutrb.com/routes.md

@@ -1,26 +1,35 @@
 # Routes
 
-The primary function of a web framework like Brut is to map URLs requested by the browser or an HTTP client and invoke code based on
-them.
+The primary function of a web framework like Brut is to map URLs requested by the browser or an HTTP client and invoke code based on them.
 
-Brut has a fairly simple routing system. It's not desgined to be flexible—it's designed to make the most common cases you
-will need as straigthforward as possible.
+Brut has a fairly simple routing system that's not designed for flexibility.
 
 ## Overview
 
-### Route Syntax
+Your app has a subclass of `Brut::Framework::App`, called `App`. It includes a call
+to the `routes` class method.  In there, you declare your routes by using one of
+four methods:
 
-A route is a string that contains the path part of a [URL](https://developer.mozilla.org/en-US/docs/Web/API/URL).  *Segments* of the
-path (i.e. the stuff between each forward slash `/`) can be either *static* or a *placeholder*.  The route is given as a parameter to
-a method that indicates the purpose of the route (e.g. `page`), and these two factors determine the  name of the class that will
-handle requests to that route.
+| Method                           | HTTP Method | Purpose                                                                                       |
+|----------------------------------|-------------|-----------------------------------------------------------------------------------------------|
+| `page «route»`                   | GET         | Declare a page                                                                                |
+| `form «route»`                   | POST        | Declare a form to be submitted to a handler                                                   |
+| `action «route»`                 | POST        | Declare an element-less form to be submitted to a handler (akin to Rails' `button_to` helper) |
+| `path «route», method: «method»` | `«method»`  | Declare an arbitrary path to a handler                                                        |
 
-Specifically:
+The value for `«route»`, along with the method called, is used to determine what
+class(es) will be used to handle the route.
+
+### «route» Syntax
+
+A route is a string that contains the *path part* of a [URL](https://developer.mozilla.org/en-US/docs/Web/API/URL).  *Segments* of the path (i.e. the stuff between each forward slash `/`) can be either *static* or a *placeholder*.
+
+As such:
 
 * Only the [pathname](https://developer.mozilla.org/en-US/docs/Web/API/URL/pathname) of a request may be specified.
 * All routes must start with a slash
-* The segements of the pathname may be static or placeholders. Placeholders must be a valid Ruby keyword argument prepended with a
-colon.
+* A placeholder segment must be a valid Ruby identifier preceded by a colon, e.g.
+`:company_id` is allowed, but `:company-id` is not.
 * Routes may not start with a placeholder.
 
 Some examples:
@@ -32,50 +41,23 @@ Some examples:
 "/"
 ```
 
-### Specifying Routes
-
-As mentioned above, routes are passed to methods that determine their purpose.  There are currently four types of routes, and thus
-four possible methods you would use to configure them:
-
-|Method|Purpose| HTTP Method | More Info |
-|------|-------|-------------|-----------|
-|`page` | Specifies a web page at that route | `GET` | [Pages](/pages) |
-|`form` | Indicates a form will exist and post its form data to this route | `POST` | [Forms](/pages) |
-|`action` | Indicates a form with no form data will exist and post to this route | `POST` | [Handlers](/handlers) |
-|`path` | This route will respond to an arbitrary HTTP method, which must be specified as an additional parameter | Any | [Handlers](/handlers) |
-
-Brut is designed around generating HTML.  HTML provides the ability to navigate to new web pages via `GET`, or submit data to the
-server from a `<form>` via `POST`.  That is why three of the four methods are focused on these use-cases.
-
-To specify routes, you can call these methods inside the `routes do` block of your `App` class, located in `app/src/app.rb`:
-
-```ruby{6-9} [app/src/app.rb]
-class App < Brut::Framework::App
-  def id           = "my-app"
-  def organization = "my-org"
-
-  routes do
-    page   "/widgets/:id"
-    form   "/new_widget"
-    action "/archive_widget/:id"
-    path   "/widget_payment_received", method: :put
-  end
-end
-```
+### Class Naming Conventions
 
-> [!NOTE]
-> Brut does not use an abstraction like resources to manage the routes of your web app.
-> Few non-programmers know what a resource is, so the routing API is designed to match
-> concepts a non-programmer can observe or identify, like URLs, forms, and pages.
+Brut is convention-based, so you are not able to specify the name of the classes
+used to handle routes.  Brut will use the method you called (e.g. `page`) and the
+route your provided to determine the class name.
 
-### Connecting Routes to Code
+Some examples:
 
-Brut is convention-based, so the routes you specify, and the method you pass them to, determine the class that will handle the
-request.  For `page` routes, Brut will locate a page class (see [Pages](/pages)), which will be used to
-render the web page.  All other routes will be managed by a handler (see [Handlers](/handlers)), which are somewhat like a controller
-in Rails, but with only a single method.
+| Route invocation                              | Expected Class Name(s)             |
+|-----------------------------------------------|------------------------------------|
+| `page "/dashboard"`                           | `DashboardPage`                    |
+| `page "/widgets/:id"`                         | `WidgetsByIdPage`                  |
+| `form "/login"`                               | `LoginForm` and `LoginHandler`     |
+| `action "/delete_widget/:id"`                 | `DeleteWidgetWithIdHandler`        |
+| `path "/tokens/personal/:token, method :put"` | `Tokens::PersonalWithTokenHandler` |
 
-The name of the class is determined as follows:
+Specifically, the name of the class(es) is/are determined as follows:
 
 * Static segments of the pathname are mapped to namespaces or a class based on converting the path segment to camel-case. For example `new_widget` becomes `NewWidget`.
 * The final static segment in the path represents a class name.  All other static segments represent modules in which the final class is namespaced
@@ -89,15 +71,6 @@ The name of the class is determined as follows:
 * These are now connected to form a valid Ruby class name.
 * The route `/` is special and always maps to `HomePage`.
 
-The examples in the previous section demonstrate how this works:
-
-| Route | Class name |
-|-------|------------|
-| `page   "/widgets/:id"` | `WidgetsByIdPage` |
-| `form   "/new_widget"` | `NewWidgetForm` and `NewWidgetHandler`
-| `action "/archive_widget/:id"` | `ArchiveWidgetByIdHandler`
-| `path   "/widget_payment_received", method: :put` | `WidgetPaymentReceivedHandler`
-
 Note that deeply nested routes that contain several placeholders will work, and create complicated classnames.
 
 ```ruby
@@ -105,10 +78,12 @@ page "/company/:company_id/location/:location_id"
 # => CompanyByCompanyId::LocationByLocationIdPage
 ```
 
-> [!TIP]
-> If you don't like long complicated names, deeply-nested namespaces, and long directory names, name your routes accordingly.
+> [!NOTE]
+> All routes can receive query string parameters. These are not factored
+> into the name of the class that will handle the route, but they
+> *are* made available to your Page or Handler.
 
-### Creating URIs from Routes
+### Creating URIs for Routes
 
 Because each route is associated with a class, you can use the class to create the route, including any placeholders and query string
 parameters.
@@ -120,6 +95,8 @@ The most direct way to do this is with the `routing` method available on each pa
 # => /widgets/42
 > WidgetsByIdPage.routing(id: 42, compact: true)
 # => /widgets/42?compact=true
+> WidgetsByIdPage.routing(id: 42, compact: true, anchor: "summary")
+# => /widgets/42?compact=true#summary
 > ArchiveWidgetByIdHandler.routing(id: 42)
 # => /archive_widget/42
 ```
@@ -147,7 +124,7 @@ explaining the problem.
 ```
 
 > [!NOTE]
-> You can use `routing` to create `<form>` actions, but `form_tag`, which we'll discuss in [Forms](/forms), can do this for you.
+> You can use `routing` to create `<form>` actions, but `Brut::FrontEnd::Components::FormTag`, which we'll discuss in [Forms](/forms), can do this for you.
 
 The `routing` method isn't an abstraction around routes. It's more of a strongly-typed translation.  This means when you change
 something, your app won't route to non-existent routes—it'll blow up with a helpful error.
@@ -157,40 +134,37 @@ rename the class.  At this point, any code that routes to `DashboardPage.routing
 
 ## Testing
 
-Routes are configuration, so you do not need to test them.  Your end-to-end tests will ensure your links and form actions are working, and your page tests will ensure any routes they generate in HTML are valid.
+Routes are configuration, so you do not need to test them.  In fact, you can't test them directly. Your end-to-end tests should adequately cover the correct usage of your routes. If you always using `.routing` to generate routes, Ruby's runtime check swill also ensure you have not used a non-existent or invalid route.
 
 ## Recommended Practices
 
-Brut does not provide flexibility with routes.  For example, you cannot specify an optional placeholder.  While this may change, Brut
-is designed to isolate logic to classes like pages, forms, hooks, middlewares, or handlers.  Brut does not want logic to exist at the
-routing layer.
-
-Beyond these technical limitations, here are some recommendations regarding routes.
+Brut does not provide flexibility with routes, nor is logic intended to exist where
+you are declaring them.
 
 ### Routes Should be Named for Concepts Anyone Can Understand
 
-You don't need your routes to be the names of models or database tables.  If you have an account management page that allows modifying data in a table called `user_preferences`, but everyone just calls it "the account management page", the route should be `/account_management`.
+If you have an account management page that allows modifying data in a table called `user_preferences`, but everyone just calls it "the account management page", the route should be `/account_management`.
 
-Although routes are primarily for programmers to manage, there's no reason not to name them using the terms everyone involved in your
-app uses.  This is part of the reason Brut inserts `By` or `With` when there is a placeholder.  It allows you to have a page for all
-widgets—the "widgets page"—and a page for a specific widget by id—the "widgets by id page".
+Although routes are primarily for programmers, there's no reason not to name them using the terms everyone involved in your app uses.  This is part of the reason Brut inserts `By` or `With` when there is a placeholder.  It allows you to have a page for all widgets—the "widgets page"—and a page for a specific widget by id—the "widgets by id page".
 
 ### Prefer Shallow Routes with a Single Placeholder
 
 The more path segments your route has, and the more placeholders it is, the longer your class name will be and the more you lose the
 connection to reality.  The "company by company id location by location id page" doesn't exactly roll off the tongue.
 
-Life will be easier if you can choose names and routes that have a single placeholder.  Multiple path segments can be useful for
-namespacing.
+Life will be easier if you can choose names and routes that have a single placeholder.  Multiple path segments can be useful for namespacing.
 
 ### Placeholders Identify Things, Query Strings Search for Things
 
-You could certainly have a `/widgets` route, and then look at a query string parameter named `id` to know what widget to show.  This
-is likely not what you want.  If a route should always identify a specific thing in your back-end, it should have a placeholder where
-that thing's identifier goes.
+A query string is for just that: querying. The query string is not for identifying
+things.  That's what URIs are for.
+
+As such, for routes where a specific *thing* is being identified, use route
+placeholders like `/widgets/:id`. When a route is used for searching or locating
+*things*, a query string is better: `/widgets?type=«type»`.
 
-If a route allows searching for things with multiple optional critiera, a query string is more appropriate.  This is the HTTP spec, so
-if you follow its guidelines, you'll be fine.
+Remember that the query string is *not* part of the class name. The values for the
+query string will be made available to your page or handler.
 
 ### Pluralization Is Up to You
 

data/brutrb.com/security.md

@@ -100,6 +100,3 @@ This may change in the future.
 Session cookies are set to expire after 1 year and use the value `Lax` for
 [`SameSite`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Cookies#controlling_third-party_cookies_with_samesite). "Lax" allows other sites to submit the Brut-powered site's cookies, but only if the user navigates to the site.  They are not sent if another site submits an Ajax request.  We feel this is the right tradeoff betweeen usability and security.
 
-### Content Security Policy headers and tools
-
-### `bundle audit`

data/brutrb.com/space-time-continuum.md

@@ -1,29 +1,25 @@
 # Space/Time Continuum - Making Sense of Times and Time Zones
 
-Time zones are the worst.  But they are fact of life.  This means that answer a question like "what is the date?"
-or "is it Monday?" are not that easy to answer.
+Time zones are the worst.  But they are fact of life.  This means that answer a question like "what is the date?" or "is it Monday?" are not that easy to answer. Brut tries to help.
 
 ## Timezones Outside of Web Requests
 
-For back-end code, storing dates to the database, etc., Brut falls back to the normal Ruby app mechanisms for
-determining the "current time zone", which is to say, it super duper depends.  The system, the database, and Ruby
-can all configure a time zone that is in effect when dates are parsed or stored.
+For back-end code, storing dates to the database, etc., Brut falls back to the normal Ruby app mechanisms for determining the "current time zone", which is to say, it super-duper depends.  The system, the database, and Ruby can all configure a time zone that is in effect when dates are parsed or stored.
 
-The main way to deal with this is in how [Brut manages your database schema](/database-schema), which is to say that it
-defaults to using `timestamp with time zone` and encourages you to do the same.  What this data type means is if
-your system is set to UTC, stores a timestamp, then restarts with the time zone set to America/Los\_Angeles, that timestamp will be read back without ambiguity.  If you use `timestamp without time zone` (which is typically `timestamp`), this will not be the case.
+The main way to deal with this is in how [Brut manages your database schema](/database-schema), which is to say that it defaults to using `timestamp with time zone` and encourages you to do the same. 
+
+What this data type means is if your system is set to UTC, stores a timestamp, then restarts with the time zone set to America/Los\_Angeles, that timestamp will be read back without ambiguity.  If you use `timestamp without time zone` (or SQL's standard `timestamp`), this will not be the case.
 
 All this is to say, if you use `timestamp with time zone`, you should generally not have to worry about this.
 Just be careful when serializing these values.
 
-## Timezones for User Sessions
+## Timezones for Sessions
 
 Depending on what your app does, you may need to show dates or times to the site visitor.  And you'll probably
 want to show those in their time zone.  Brut can help with this.
 
 As mentioned in [Flash and Session](/flash-and-session), the session provides access to timezone information.
 Brut also provides a `Clock` class that represents the current date and time in the current session's time zone.
-Here is how that works.
 
 There are two ways to determine a visitor's time zone: you can ask them, or you can ask their browser.
 
@@ -51,8 +47,8 @@ If you have a way to ask the user what their timezone is, you can set it via `se
 done this, *that* value is returned instead of the above logic.
 
 Note that in all cases, the timezone that is serialized into the session is the name. This means it's technically
-possible for the name to valid when stored and invalid when read, if you have updated the `tzinfo` gem and
-something changed.
+possible for the name to be valid when stored and invalid when read, if you have updated the `tzinfo` gem and
+something changed (this should be exceedingly rare).
 
 Therefore, it's recommended that if you have asked the visitor their preferred time zone, you store that
 somewhere in the database, so you can detect when the value from the session has drifted.

data/brutrb.com/tutorial.md

@@ -1,3 +1,3 @@
 # Tutorial
 
-This section will walk you through creating a Brut app and should touch on most of the major features.
+TBD - this will be created once Brut is somewhat stabilized.

data/brutrb.com/why.md

@@ -0,0 +1,19 @@
+# Why Does Brut Exist?
+
+I love writing Ruby, but grew tired of writing Rails. Rails is great, and has been
+great to me over the years. I've written a lot of books about it!  But the churn and
+increasing configuration burden made me think: what if we had another way to build
+web apps in Ruby?
+
+What if it was totally different, but still focused on being straightforward and
+simple?  What if it had *fewer* abstractions, *less* configuration, and not as much
+*stuff*?
+
+My thinking is, you need to know HTML, JavaScript, CSS, SQL, Ruby, HTTP, and a few
+other things to make a web app. What if we tried to limit the additional
+abstractions you'd have to learn?
+
+That's what Brut is trying to be.  Straightfoward, direct abstractions or
+translations of stuff you already know. The raw web…or at least as raw as it can be.
+
+

data/docs/404.html

@@ -6,16 +6,21 @@
     <title>404 | Brut RB</title>
     <meta name="description" content="Not Found">
     <meta name="generator" content="VitePress v1.6.3">
-    <link rel="preload stylesheet" href="/assets/style.B2o1L9eN.css" as="style">
+    <link rel="preload stylesheet" href="/assets/style.prAgp4yQ.css" as="style">
     <link rel="preload stylesheet" href="/vp-icons.css" as="style">
     
-    <script type="module" src="/assets/app.BhrfSt68.js"></script>
+    <script type="module" src="/assets/app.ClaS47Ru.js"></script>
+    <link rel="icon" href="/favicon.ico">
+    <meta property="og:title" content="BrutRB Documentation">
+    <meta property="og:type" content="website">
+    <meta property="og:image" content="https://github.com/thirdtank/brut/blob/main/assets/SocialImage.png?raw=true">
+    <script defer data-domain="brutrb.com" src="https://plausible.io/js/script.js"></script>
     <script id="check-dark-mode">(()=>{const e=localStorage.getItem("vitepress-theme-appearance")||"auto",a=window.matchMedia("(prefers-color-scheme: dark)").matches;(!e||e==="auto"?a:e==="dark")&&document.documentElement.classList.add("dark")})();</script>
     <script id="check-mac-os">document.documentElement.classList.toggle("mac",/Mac|iPhone|iPod|iPad/i.test(navigator.platform));</script>
   </head>
   <body>
     <div id="app"></div>
-    <script>window.__VP_HASH_MAP__=JSON.parse("{\"ai.md\":\"_6HCDL6d\",\"assets.md\":\"D3wunzLx\",\"brut-js.md\":\"o2DAO2s2\",\"business-logic.md\":\"BY4hGy0m\",\"cli.md\":\"RmeA2b0i\",\"components.md\":\"CRUMdRoN\",\"configuration.md\":\"LG-zIBww\",\"css.md\":\"DJgj2clw\",\"custom-element-tests.md\":\"BrYJQEl3\",\"database-access.md\":\"C7l-Vuvb\",\"database-schema.md\":\"BUjR0VS1\",\"deployment.md\":\"BLseERGV\",\"dev-environment.md\":\"GZv6xvi9\",\"doc-conventions.md\":\"-kN3Xo5C\",\"end-to-end-tests.md\":\"yfQHC0b5\",\"flash-and-session.md\":\"BXY8RvT0\",\"forms.md\":\"B-koVgyw\",\"getting-started.md\":\"Dj0qtZI2\",\"handlers.md\":\"089DVD3v\",\"hooks.md\":\"C4-moMny\",\"i18n.md\":\"Do9i1qWl\",\"index.md\":\"CuBB-BdM\",\"instrumentation.md\":\"a9Pjps4P\",\"javascript.md\":\"GWbhRS51\",\"jobs.md\":\"S-2amAYp\",\"keyword-injection.md\":\"Dt2tKREs\",\"layouts.md\":\"cPnh3NId\",\"lsp.md\":\"Bsu-f6VU\",\"markdown-examples.md\":\"CCFEQO44\",\"middleware.md\":\"Czz_UlJN\",\"not-released.md\":\"BBy28McC\",\"overview.md\":\"DVKRM8zl\",\"pages.md\":\"BE3kfOc5\",\"recipes_authentication.md\":\"CAsXf7hk\",\"routes.md\":\"BMM7peut\",\"security.md\":\"C668yXCi\",\"seed-data.md\":\"BvFZlqIk\",\"space-time-continuum.md\":\"KPUIKysQ\",\"tutorial.md\":\"BnoGjrdK\",\"unit-tests.md\":\"DUGrnLj5\"}");window.__VP_SITE_DATA__=JSON.parse("{\"lang\":\"en-US\",\"dir\":\"ltr\",\"title\":\"Brut RB\",\"description\":\"Documentation for the Brut.RB web framework.\",\"base\":\"/\",\"head\":[],\"router\":{\"prefetchLinks\":true},\"appearance\":true,\"themeConfig\":{\"search\":{\"provider\":\"local\"},\"nav\":[{\"text\":\"Home\",\"link\":\"/\"},{\"text\":\"Getting Started\",\"link\":\"/getting-started\"},{\"text\":\"Overview\",\"link\":\"/overview\"},{\"text\":\"Brut API\",\"link\":\"/api/index.html\",\"target\":\"_self\"},{\"text\":\"BrutJS\",\"link\":\"/brut-js/api/index.html\",\"target\":\"_self\"},{\"text\":\"BrutCSS\",\"link\":\"/brut-css/index.html\",\"target\":\"_self\"}],\"outline\":[2,3],\"sidebar\":[{\"text\":\"Overview\",\"collapsed\":false,\"items\":[{\"text\":\"Getting Started\",\"link\":\"/getting-started\"},{\"text\":\"Concepts\",\"link\":\"/overview\"},{\"text\":\"Documentation Conventions\",\"link\":\"/doc-conventions\"},{\"text\":\"Tutorial\",\"link\":\"/tutorial\"},{\"text\":\"Dev Environment\",\"link\":\"/dev-environment\"},{\"text\":\"AI Declaration\",\"link\":\"/ai\"}]},{\"text\":\"Front-End\",\"collapsed\":false,\"items\":[{\"text\":\"Routes\",\"link\":\"/routes\"},{\"text\":\"Pages\",\"link\":\"/pages\"},{\"text\":\"Layouts\",\"link\":\"/layouts\"},{\"text\":\"Forms\",\"link\":\"/forms\"},{\"text\":\"Handlers and Actions\",\"link\":\"/handlers\"},{\"text\":\"Components\",\"link\":\"/components\"},{\"text\":\"Flash and Session\",\"link\":\"/flash-and-session\"},{\"text\":\"Space/Time Continuum\",\"link\":\"/space-time-continuum\"},{\"text\":\"JavaScript\",\"link\":\"/javascript\"},{\"text\":\"CSS\",\"link\":\"/css\"},{\"text\":\"Assets\",\"link\":\"/assets\"},{\"text\":\"BrutJS\",\"link\":\"/brut-js\"}]},{\"text\":\"Back-End\",\"collapsed\":false,\"items\":[{\"text\":\"Database Schema\",\"link\":\"/database-schema\"},{\"text\":\"Database Access\",\"link\":\"/database-access\"},{\"text\":\"Seed Data\",\"link\":\"/seed-data\"},{\"text\":\"Jobs\",\"link\":\"/jobs\"},{\"text\":\"Business Logic\",\"link\":\"/business-logic\"}]},{\"text\":\"Framework\",\"collapsed\":false,\"items\":[{\"text\":\"Configuration\",\"link\":\"/configuration\"},{\"text\":\"Keyword Injection\",\"link\":\"/keyword-injection\"},{\"text\":\"I18n\",\"link\":\"/i18n\"},{\"text\":\"CLI / Tasks\",\"link\":\"/cli\"},{\"text\":\"Deployment\",\"link\":\"/deployment\"}]},{\"text\":\"Testing\",\"collapsed\":false,\"items\":[{\"text\":\"Unit Tests\",\"link\":\"/unit-tests\"},{\"text\":\"End-to-End Tests\",\"link\":\"/end-to-end-tests\"},{\"text\":\"Testing Custom Elements\",\"link\":\"/custom-element-tests\"}]},{\"text\":\"Advanced Topics\",\"collapsed\":true,\"items\":[{\"text\":\"Route Hooks\",\"link\":\"/hooks\"},{\"text\":\"Middleware\",\"link\":\"/middleware\"},{\"text\":\"Instrumentation\",\"link\":\"/instrumentation\"},{\"text\":\"Security\",\"link\":\"/security\"},{\"text\":\"LSP Support\",\"link\":\"/lsp\"}]},{\"text\":\"Recipes\",\"collapsed\":true,\"items\":[{\"text\":\"Authentication\",\"link\":\"/recipes/authentication\"},{\"text\":\"Form Validations\",\"link\":\"/recipes/form-validations\"},{\"text\":\"Database Migrations\",\"link\":\"/recipes/database-migrations\"},{\"text\":\"Ajax Form Submission\",\"link\":\"/recipes/ajax-form\"},{\"text\":\"Custom Telemetry\",\"link\":\"/recipes/telemetry\"},{\"text\":\"CLI App/Task\",\"link\":\"/recipes/cli-app\"}]}],\"socialLinks\":[{\"icon\":\"github\",\"link\":\"https://github.com/thirdtank/brut\"}]},\"locales\":{},\"scrollOffset\":134,\"cleanUrls\":false}");</script>
+    <script>window.__VP_HASH_MAP__=JSON.parse("{\"ai.md\":\"Cy9GWnER\",\"assets.md\":\"7C3HWkga\",\"brut-js.md\":\"B4GYxQVw\",\"business-logic.md\":\"BY4hGy0m\",\"cli.md\":\"CjsktgFz\",\"components.md\":\"DatoNgFo\",\"configuration.md\":\"DeyhpqEx\",\"css.md\":\"CltvJqAa\",\"custom-element-tests.md\":\"B_rbta32\",\"database-access.md\":\"gnluu54N\",\"database-schema.md\":\"CSYk6E6v\",\"deployment.md\":\"BLseERGV\",\"dev-environment.md\":\"BroAOLhF\",\"dir-structure.md\":\"CWir1pic\",\"doc-conventions.md\":\"BzmSrTEW\",\"end-to-end-tests.md\":\"DzqRpZ43\",\"features.md\":\"DPFXsy0z\",\"flash-and-session.md\":\"nPvUpnUx\",\"form-constraints.md\":\"x5tNpTTI\",\"forms.md\":\"C2Dizvzq\",\"getting-started.md\":\"C93e0odB\",\"handlers.md\":\"Chyri6KA\",\"hooks.md\":\"Jmb5VOLA\",\"i18n.md\":\"xQhiGo1G\",\"index.md\":\"CAMqGBJE\",\"instrumentation.md\":\"BgcaGVYH\",\"javascript.md\":\"DzrMxUmI\",\"jobs.md\":\"S-2amAYp\",\"keyword-injection.md\":\"95Zgh2eN\",\"layouts.md\":\"CJGDFY-m\",\"lsp.md\":\"Dn1rIiW0\",\"markdown-examples.md\":\"CCFEQO44\",\"middleware.md\":\"Czz_UlJN\",\"not-released.md\":\"BBy28McC\",\"overview.md\":\"Bdq4qt3L\",\"pages.md\":\"B7Hc-i6H\",\"recipes_alternate-layouts.md\":\"BwEytl59\",\"recipes_authentication.md\":\"Dzvi_g69\",\"recipes_blank-layouts.md\":\"fyAUJyJR\",\"recipes_custom-flash.md\":\"CrQbI5eH\",\"recipes_indexed-forms.md\":\"CstYyOSo\",\"recipes_text-field-component.md\":\"H4wLAK0Z\",\"routes.md\":\"B8kfUPHU\",\"security.md\":\"C0G_AZR-\",\"seed-data.md\":\"BvFZlqIk\",\"space-time-continuum.md\":\"xl44xDos\",\"tutorial.md\":\"a4a0eVOy\",\"unit-tests.md\":\"DUGrnLj5\",\"why.md\":\"C-hk5xgJ\"}");window.__VP_SITE_DATA__=JSON.parse("{\"lang\":\"en-US\",\"dir\":\"ltr\",\"title\":\"Brut RB\",\"description\":\"Documentation for the Brut.RB web framework.\",\"base\":\"/\",\"head\":[],\"router\":{\"prefetchLinks\":true},\"appearance\":true,\"themeConfig\":{\"search\":{\"provider\":\"local\"},\"nav\":[{\"text\":\"Home\",\"link\":\"/\"},{\"text\":\"Getting Started\",\"link\":\"/getting-started\"},{\"text\":\"Overview\",\"link\":\"/overview\"},{\"text\":\"Brut API\",\"link\":\"/api/index.html\",\"target\":\"_self\"},{\"text\":\"BrutJS\",\"link\":\"/brut-js/api/index.html\",\"target\":\"_self\"},{\"text\":\"BrutCSS\",\"link\":\"/brut-css/index.html\",\"target\":\"_self\"}],\"outline\":[2,3],\"sidebar\":[{\"text\":\"Overview\",\"collapsed\":false,\"items\":[{\"text\":\"Getting Started\",\"link\":\"/getting-started\"},{\"text\":\"Concepts\",\"link\":\"/overview\"},{\"text\":\"Features\",\"link\":\"/features\"},{\"text\":\"Directory Structure\",\"link\":\"/dir-structure\"},{\"text\":\"Dev Environment\",\"link\":\"/dev-environment\"},{\"text\":\"Tutorial\",\"link\":\"/tutorial\"},{\"text\":\"Documentation Conventions\",\"link\":\"/doc-conventions\"}]},{\"text\":\"Front-End\",\"collapsed\":false,\"items\":[{\"text\":\"Routes\",\"link\":\"/routes\"},{\"text\":\"Pages\",\"link\":\"/pages\"},{\"text\":\"Layouts\",\"link\":\"/layouts\"},{\"text\":\"Forms\",\"link\":\"/forms\"},{\"text\":\"Form Constraints\",\"link\":\"/form-constraints\"},{\"text\":\"Handlers and Actions\",\"link\":\"/handlers\"},{\"text\":\"Components\",\"link\":\"/components\"},{\"text\":\"Flash and Session\",\"link\":\"/flash-and-session\"},{\"text\":\"Space/Time Continuum\",\"link\":\"/space-time-continuum\"},{\"text\":\"JavaScript\",\"link\":\"/javascript\"},{\"text\":\"CSS\",\"link\":\"/css\"},{\"text\":\"Assets\",\"link\":\"/assets\"},{\"text\":\"BrutJS\",\"link\":\"/brut-js\"}]},{\"text\":\"Back-End\",\"collapsed\":false,\"items\":[{\"text\":\"Database Schema\",\"link\":\"/database-schema\"},{\"text\":\"Database Access\",\"link\":\"/database-access\"},{\"text\":\"Seed Data\",\"link\":\"/seed-data\"},{\"text\":\"Jobs\",\"link\":\"/jobs\"},{\"text\":\"Business Logic\",\"link\":\"/business-logic\"}]},{\"text\":\"Framework\",\"collapsed\":false,\"items\":[{\"text\":\"Configuration\",\"link\":\"/configuration\"},{\"text\":\"Keyword Injection\",\"link\":\"/keyword-injection\"},{\"text\":\"I18n\",\"link\":\"/i18n\"},{\"text\":\"CLI / Tasks\",\"link\":\"/cli\"},{\"text\":\"Deployment\",\"link\":\"/deployment\"}]},{\"text\":\"Testing\",\"collapsed\":false,\"items\":[{\"text\":\"Unit Tests\",\"link\":\"/unit-tests\"},{\"text\":\"End-to-End Tests\",\"link\":\"/end-to-end-tests\"},{\"text\":\"Testing Custom Elements\",\"link\":\"/custom-element-tests\"}]},{\"text\":\"Advanced Topics\",\"collapsed\":true,\"items\":[{\"text\":\"Route Hooks\",\"link\":\"/hooks\"},{\"text\":\"Middleware\",\"link\":\"/middleware\"},{\"text\":\"Instrumentation\",\"link\":\"/instrumentation\"},{\"text\":\"Security\",\"link\":\"/security\"},{\"text\":\"LSP Support\",\"link\":\"/lsp\"}]},{\"text\":\"Recipes\",\"collapsed\":true,\"items\":[{\"text\":\"Authentication\",\"link\":\"/recipes/authentication\"},{\"text\":\"Alternate Layouts\",\"link\":\"/recipes/alternate-layouts\"},{\"text\":\"Blank Layouts\",\"link\":\"/recipes/blank-layouts\"},{\"text\":\"Custom Flash Class\",\"link\":\"/recipes/custom-flash\"},{\"text\":\"Indexed Form Elements\",\"link\":\"/recipes/indexed-forms\"},{\"text\":\"Text Field Component\",\"link\":\"/recipes/text-field-component\"}]},{\"text\":\"Meta\",\"collapsed\":false,\"items\":[{\"text\":\"Why?!\",\"link\":\"/why\"},{\"text\":\"AI Declaration\",\"link\":\"/ai\"}]}],\"socialLinks\":[{\"icon\":\"github\",\"link\":\"https://github.com/thirdtank/brut\"}]},\"locales\":{},\"scrollOffset\":134,\"cleanUrls\":false}");</script>
     
   </body>
 </html>