active_element 0.0.12 → 0.0.13

data/lib/active_element/default_controller/search.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  module DefaultController
+    # Full text search and datetime querying for DefaultController, provides full text search
+    # filters for all controllers with configured searchable fields. Includes support for querying
+    # across relations.
+    class Search
+      def initialize(controller:, model:)
+        @controller = controller
+        @model = model
+      end
+
+      def search_filters
+        @search_filters ||= controller.params.permit(*searchable_fields).transform_values do |value|
+          value.try(:compact_blank) || value
+        end.compact_blank
+      end
+
+      def text_search?
+        search_filters.present?
+      end
+
+      def text_search
+        conditions = search_filters.to_h.map do |key, value|
+          next relation_matches(key, value) if relation?(key)
+          next datetime_between(key, value) if datetime?(key)
+
+          model.arel_table[key].matches("#{value}%")
+        end
+        conditions[1..].reduce(conditions.first) do |accumulated, condition|
+          accumulated.and(condition)
+        end
+      end
+
+      def search_relations
+        search_filters.to_h.keys.map { |key| relation?(key) ? key.to_sym : nil }.compact
+      end
+
+      private
+
+      attr_reader :controller, :model
+
+      def searchable_fields
+        controller.active_element.state.searchable_fields.map do |field|
+          next field unless field.to_s.end_with?('_at')
+
+          { field => %i[from to] }
+        end
+      end
+
+      def noop
+        Arel::Nodes::True.new.eq(Arel::Nodes::True.new)
+      end
+
+      def datetime?(key)
+        model.columns.find { |column| column.name.to_s == key.to_s }&.type == :datetime
+      end
+
+      def datetime_between(key, value)
+        return noop if value[:from].blank? && value[:to].blank?
+
+        model.arel_table[key].between(range_begin(value)...range_end(value))
+      end
+
+      def range_begin(value)
+        value[:from].present? ? Time.zone.parse(value[:from]) + timezone_offset : -Float::INFINITY
+      end
+
+      def range_end(value)
+        value[:to].present? ? Time.zone.parse(value[:to]) + timezone_offset : Float::INFINITY
+      end
+
+      def timezone_offset
+        controller.request.cookies['timezone_offset'].to_i.minutes
+      end
+
+      def relation_matches(key, value)
+        fields = searchable_relation_fields(key)
+        relation_model = relation(key).klass
+        fields.select! do |field|
+          relation_model.columns.find { |column| column.name.to_s == field.to_s }&.type == :string
+        end
+
+        return noop if fields.empty?
+
+        relation_conditions(fields, value, relation_model)
+      end
+
+      def relation_conditions(fields, value, relation_model)
+        fields[1..].reduce(relation_model.arel_table[fields.first].matches("#{value}%")) do |condition, field|
+          condition.or(relation_model.arel_table[field].matches("#{value}%"))
+        end
+      end
+
+      def searchable_relation_fields(key)
+        Components::Util.relation_controller(model, controller, key)
+                        &.active_element
+                        &.state
+                        &.fetch(:searchable_fields, []) || []
+      end
+
+      def relation?(attribute)
+        relation(attribute.to_sym).present?
+      end
+
+      def relation(attribute)
+        model.reflect_on_association(attribute.to_sym)
+      end
+    end
+  end
+end

data/lib/active_element/default_controller.rb

@@ -1,137 +1,15 @@
 # frozen_string_literal: true
 
-module ActiveElement
-  # Encapsulation of all logic performed for default controller actions when no action is defined
-  # by the current controller.
-  class DefaultController
-    def initialize(controller:)
-      @controller = controller
-    end
-
-    def index
-      return render_forbidden(:listable) unless configured?(:listable)
-
-      controller.render 'active_element/default_views/index',
-                        locals: {
-                          collection: collection,
-                          search_filters: default_text_search.search_filters
-                        }
-    end
-
-    def show
-      return render_forbidden(:viewable) unless configured?(:viewable)
-
-      controller.render 'active_element/default_views/show', locals: { record: record }
-    end
-
-    def new
-      return render_forbidden(:editable) unless configured?(:editable)
-
-      controller.render 'active_element/default_views/new', locals: { record: model.new, namespace: namespace }
-    end
-
-    def create # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      return render_forbidden(:editable) unless configured?(:editable)
-
-      new_record = model.new(default_record_params.params)
-      # XXX: Ensure associations are applied - there must be a better way.
-      if new_record.save && new_record.reload.update(default_record_params.params)
-        controller.flash.notice = "#{new_record.model_name.to_s.titleize} created successfully."
-        controller.redirect_to record_path(new_record, :show).path
-      else
-        controller.flash.now.alert = "Failed to create #{model.name.to_s.titleize}."
-        controller.render 'active_element/default_views/new', locals: { record: new_record, namespace: namespace }
-      end
-    rescue ActiveRecord::RangeError => e
-      render_range_error(error: e, action: :new)
-    end
-
-    def edit
-      return render_forbidden(:editable) unless configured?(:editable)
-
-      controller.render 'active_element/default_views/edit', locals: { record: record, namespace: namespace }
-    end
-
-    def update # rubocop:disable Metrics/AbcSize
-      return render_forbidden(:editable) unless configured?(:editable)
-
-      if record.update(default_record_params.params)
-        controller.flash.notice = "#{record.model_name.to_s.titleize} updated successfully."
-        controller.redirect_to record_path(record, :show).path
-      else
-        controller.flash.now.alert = "Failed to update #{model.name.to_s.titleize}."
-        controller.render 'active_element/default_views/edit', locals: { record: record, namespace: namespace }
-      end
-    rescue ActiveRecord::RangeError => e
-      render_range_error(error: e, action: :edit)
-    end
-
-    def destroy
-      return render_forbidden(:deletable) unless configured?(:deletable)
-
-      record.destroy
-      controller.flash.notice = "Deleted #{record.model_name.to_s.titleize}."
-      controller.redirect_to record_path(model, :index).path
-    end
-
-    private
+require_relative 'default_controller/controller'
+require_relative 'default_controller/actions'
+require_relative 'default_controller/params'
+require_relative 'default_controller/json_params'
+require_relative 'default_controller/search'
 
-    attr_reader :controller
-
-    def render_forbidden(type)
-      controller.render 'active_element/default_views/forbidden', locals: { type: type }
-    end
-
-    def configured?(type)
-      return state.deletable? if type == :deletable
-
-      state.public_send("#{type}_fields").present?
-    end
-
-    def state
-      @state ||= controller.active_element.state
-    end
-
-    def default_record_params
-      @default_record_params ||= ActiveElement::DefaultRecordParams.new(controller: controller, model: model)
-    end
-
-    def default_text_search
-      @default_text_search ||= ActiveElement::DefaultSearch.new(controller: controller, model: model)
-    end
-
-    def record_path(record, type = nil)
-      ActiveElement::Components::Util::RecordPath.new(record: record, controller: controller, type: type)
-    end
-
-    def namespace
-      controller.controller_path.rpartition('/').first.presence&.to_sym
-    end
-
-    def model
-      controller.controller_name.classify.constantize
-    end
-
-    def record
-      @record ||= model.find(controller.params[:id])
-    end
-
-    def collection
-      return model.all unless default_text_search.text_search?
-
-      model.left_outer_joins(default_text_search.search_relations).where(*default_text_search.text_search)
-    end
-
-    def render_range_error(error:, action:)
-      controller.flash.now.alert = formatted_error(error)
-      controller.render "active_element/default_views/#{action}", locals: { record: record, namespace: namespace }
-    end
-
-    def formatted_error(error)
-      return error.cause.message.split("\n").join(', ') if error.try(:cause)&.try(:message).present?
-      return error.message if error.try(:message).present?
-
-      I18n.t('active_element.unexpected_error')
-    end
+module ActiveElement
+  # Provides default boilerplate functionality for quick setup of an application.
+  # Implements all standard Rails controller actions, provides parameter permitting of configured
+  # fields and text search functionality.
+  module DefaultController
   end
 end

data/lib/active_element/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveElement
-  VERSION = '0.0.12'
+  VERSION = '0.0.13'
 end

data/lib/active_element.rb

@@ -15,8 +15,6 @@ require_relative 'active_element/controller_interface'
 require_relative 'active_element/controller_state'
 require_relative 'active_element/controller_action'
 require_relative 'active_element/default_controller'
-require_relative 'active_element/default_record_params'
-require_relative 'active_element/default_search'
 require_relative 'active_element/pre_render_processors'
 require_relative 'active_element/rails_component'
 require_relative 'active_element/route'

data/rspec-documentation/_head.html.erb

@@ -3,6 +3,7 @@
 <%= File.read('app/assets/javascripts/active_element/setup.js') %>
 <%= File.read('app/assets/javascripts/active_element/json_field.js') %>
 <%= File.read('app/assets/javascripts/active_element/text_search_field.js') %>
+<%= File.read('app/assets/javascripts/active_element/popover.js') %>
 ActiveElement.debug = true;
 ActiveElement.getRequestId = () => 'fake-request-id';
 const textSearchNames = <%= text_search_names.to_json %>;
@@ -24,6 +25,7 @@ window.fetch = (_, { body }) => {
 <style>
 <%= application_css %>
 </style>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/2.9.2/umd/popper.min.js" integrity="sha512-2rNj2KJ+D8s1ceNasTIex6z4HWyOnEYLVC3FigGOmyQCZc2eBXKgOxQmo3oKLHyfcj53uz4QMsRCWNbLd32Q1g==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
 <script>
 /*!
  * Font Awesome Free 6.4.0 by @fontawesome - https://fontawesome.com

data/rspec-documentation/pages/000-Introduction.md

@@ -1,18 +1,21 @@
 # Introduction
 
-_ActiveElement_ provides a range of rich [components](components.html) for fast, painless development of front end applications, primarily intended for (but not limited to) building administration areas.
+_ActiveElement_ is a [Ruby on Rails](https://rubyonrails.org/) framework primarily intended for building admin applications with minimal effort.
 
 An [authorization framework](access-control.html) is provided, intended to work alongside existing frameworks such as [Devise](https://github.com/heartcombo/devise), [Pundit](https://github.com/varvet/pundit), and [CanCanCan](https://github.com/CanCanCommunity/cancancan).
 
+_ActiveElement_ is designed to avoid the all-or-nothing approach that many frameworks provide, allowing you to build a fully functional administration tool in minutes, while still allowing you to customize every aspect of your application. _ActiveElement_ is just a _Rails_ application with extra features: when you need to build custom functionality, you do it the same way you would any other _Rails_ application and you can use as much or as little of _ActiveElement_ as you like.
+
+Take a look at the [Setup Guide](setup.html) to build your first _ActiveElement_ application and see how easily you can mix in standard _Rails_ behaviours.
+
 ## Highlights
 
+* Build an entire application by defining models and controllers with just a few lines of configuration in each controller.
+* [Components](components.html) that can be re-used throughout your application.
 * Feature-rich [forms](components/forms.html) including a powerful [JSON form field component](components/form-fields/json.html).
 * Simple and secure [auto-suggest text search](components/form-fields/text-search.html) widgets.
-* [Tables](components/tables.html) with built-in pagination and action buttons for viewing/editing/deleting records.
 * [Decorators](decorators.html) for overriding default display fields with simple _Rails_ view partials.
-* Automated [permissions](access-control/authorization/permissions.html) that can be applied to all application endpoints with minimal effort.
-* Sensible defaults to help you build your application quickly while also allowing you to customize when needed.
-* _ActiveElement_ attempts to provide a framework of familiar patterns that work with you instead of against you. It does not attempt to do everything for you and avoids behind-the-scenes magic where possible.
+* Automated [route-based permissions](access-control/authorization/permissions.html) that can be applied to all application endpoints with minimal effort.
 * [Bootstrap](https://getbootstrap.com/) styling with [customizable themes](themes.html).
 
 See the [Setup Guide](setup.html) and browse the rest of the documentation for full usage examples.

data/rspec-documentation/pages/005-Setup.md

@@ -1,7 +1,5 @@
 # Setup
 
-To integrate _ActiveElement_ into your _Rails_ application, follow the steps below:
-
 ## Installation
 
 Install the `active_element` gem by adding the following to your `Gemfile`:
@@ -20,7 +18,7 @@ $ bundle install
 
 Inherit from `ActiveElement::ApplicationController` in the controller you want to use with _ActiveElement_. In most cases this will either be your main `ApplicationController`, or a namespaced admin area controller, e.g. `Admin::ApplicationController`. This will apply the default _ActiveElement_ layout which includes a [Navbar](components/navbar.html), [Theme Switcher](components/theme-switcher.html), and all the required _CSS_ and _Javascript_.
 
-If you want to add custom content to the layout, see the [Hooks](hooks.html) documentation.
+If you want to add custom content to the layout, see the [Hooks](hooks.html) documentation, or if you want to use a completely custom layout, simply specify `layout 'my_layout'` in your `ApplicationController`.
 
 ```ruby
 # app/controllers/application_controller.rb
@@ -30,23 +28,13 @@ class ApplicationController < ActiveElement::ApplicationController
 end
 ```
 
-## Create a View
+## Default Controller Actions
 
-We'll use `UsersController` in this example, but you can replace this with whatever controller you want to use with _ActiveElement_.
+_ActiveElement_ provides default controller actions for all controllers that inherit from `ActiveElement::ApplicationController` (directly or indirectly).
 
-Assuming your controller is defined something like this:
+Each action provides boilerplate functionality to get your application off the ground as quickly as possible. See the [Default Controller](default-controller.html) for full details.
 
-```ruby
-# app/controllers/users_controller.rb
-
-class UsersController < ApplicationController
-  def index
-    @users = User.all
-  end
-end
-```
-
-And your routes are defined something like this:
+The below example creates a `/users` endpoint for your application with boilerplate to list, search, view, create, edit, and delete users:
 
 ```ruby
 # config/routes.rb
@@ -56,20 +44,25 @@ Rails.application.routes.draw do
 end
 ```
 
-Edit or create `app/views/users/index.html.erb`. Add a page title and a table component:
-
-```erb
-<%# app/views/users/index.html.erb %>
-
-<%= active_element.component.page_title 'Users' %>
+```ruby
+# app/controllers/users_controller.rb
 
-<%= active_element.component.table collection: @users, fields: [:id, :email, :name] %>
+class UsersController < ApplicationController
+  active_element.listable_fields :name, :email, :created_at, order: :name
+  active_element.viewable_fields :name, :email, :created_at, :updated_at
+  active_element.editable_fields :name, :email
+  active_element.searchable_fields :name, :name, :created_at, :updated_at
+  active_element.deletable
+end
 ```
 
-Adjust the `fields` to match whatever attributes you want to display for each `User` in your table.
+```ruby
+# app/models/user.rb
 
-Start your _Rails_ application and browse to `/users` to see your new users index.
+class User < ApplicationRecord
+end
+```
 
-## Next Steps
+You can now browse to `/users` on your local development server and see all the default behaviour provided by _ActiveElement_.
 
-Now that you know how to render components, take a look at the [Components](components.html) section of this documentation to see what components are available and how to use them.
+See the [Default Controller](default-controller.html) and [Custom Controllers](custom-controllers.html) sections for more details.

data/rspec-documentation/pages/010-Components/Form Fields.md

@@ -44,3 +44,38 @@ end
 
 it { is_expected.to include 'class="form-control my-class"' }
 ```
+
+## Custom Fields
+
+If you're using the [Default Controller](../default-controller.html) or you simply want to separate your configuration from your views, you can customize each form field by creating a file named `config/forms/<model>/<field>.yml`.
+
+The `User` `email` field can be configured by creating `config/forms/user/email.yml`:
+
+```yaml
+# config/forms/user/email.yml
+
+type: email_field
+options:
+  class: 'form-control my-email-field-class'
+  description: 'We will use your email address to send your account details.'
+  placeholder: 'Enter your email address, e.g. user@example.com'
+```
+
+```rspec:html
+subject do
+  active_element.component.form model: User.new,
+                                fields: [:email, :name, :date_of_birth]
+end
+
+it { is_expected.to include 'class="form-control my-email-field-class"' }
+```
+
+The `options` configuration receives a small number of options specific to _ActiveElement_ such as `description` and [Text Search](form-fields/text-search.html) configuration, otherwise they are passed directly to the underlying _Rails_ form helper.
+
+The `type` configuration corresponds to either a _Rails_ form helper _ActiveElement_ extension field, i.e. `email_field` will call some variation of:
+
+```ruby
+form_with do |form|
+  form.email_field :email
+end
+```

data/rspec-documentation/pages/015-Custom Controllers.md

@@ -0,0 +1,32 @@
+# Custom Controllers
+
+The [Default Controller](default-controller.html) provides out-of-the-box functionality to get you up and running quickly, but as your application progresses you will likely need to provide custom functionality in some areas.
+
+A custom controller is just a regular _Rails_ controller. You can still benefit from default actions provided by _ActiveElement_ and only override the specific actions you need.
+
+In the example below we'll implement a custom `#show` action on a `UsersController` and create a custom view.
+
+```ruby
+# app/controllers/users_controller.rb
+
+class UsersController < ApplicationController
+  active_element.listable_fields :name, :email, :created_at, order: :name
+  active_element.editable_fields :name, :email
+  active_element.searchable_fields :name, :name, :created_at, :updated_at
+  active_element.deletable
+
+  def show
+    @user = User.find(params[:id])
+  end
+end
+```
+
+```erb
+<%# app/views/users/index.html.erb %>
+
+<%= active_element.component.page_title 'Users' %>
+
+<%= active_element.component.table item: @user, fields: [:email, :name, :created_at, :updated_at] %>
+```
+
+You can customize any action or view you like, simply by following standard _Rails_ patterns.

data/rspec-documentation/pages/016-Default Controller.md

@@ -0,0 +1,132 @@
+# Default Controller
+
+The default controller in _ActiveElement_ provides all the standard _Rails_ actions:
+
+* `#index`
+* `#show`
+* `#new`
+* `#create`
+* `#edit`
+* `#update`
+* `#destroy`
+
+All controllers that inherit from `ActiveElement::ApplicationController` automatically receive these routes, but they must be explicitly enabled in order to serve content, otherwise a default `403 Forbidden` page will be rendered.
+
+Each controller expects to find a model whose name corresponds to the controller, in line with typical _Rails_ conventions. For example, if you have a `RestaurantsController` then _ActiveElement_ will expect to find a `Restaurant` model. Each of the declarations covered below describe interactions with a corresponding model.
+
+Depending on which declarations are defined in your controllers, you will see different _UI_ elements (e.g. a _Delete_ button for each record will only be present when `active_element.deletable` has been called).
+
+## Associations
+
+Model associations are supported, so you can list database columns as well as relations defined on your model.
+
+Here's a basic example:
+
+```ruby
+# app/models/restaurant.rb
+
+class Restaurant < ApplicationRecord
+  belongs_to :restaurateur
+end
+```
+
+```ruby
+# app/models/restaurateur.rb
+
+class Restaurateur < ApplicationRecord
+  has_many :resaturants
+end
+```
+
+```ruby
+# app/controllers/restaurants_controller.rb
+
+class RestaurantsController < ApplicationController
+  active_element.listable_fields :name, :restaurateur, :created_at
+end
+```
+
+Now when you browse to `/restaurants` you'll see a link to each restaurants owner in the rendered table.
+
+## Listable Fields
+
+The `active_element.listable_fields` declaration provides a list of fields on your model that should be displayed in the default `#index` view.
+
+A table of results will be rendered containing each record corresponding for the corresponding record, including _View_, _Edit_, and _Delete_ buttons, as well as a button above the table to create a new record.
+
+The `order` keyword allows you to sort the results by a given field. This value is passed directly to the `ActiveRecord` `order` method, so you can use `:name` or `{ name: :desc }` or any other variation that `ActiveRecord` accepts.
+
+```ruby
+# app/controllers/restaurants_controller.rb
+
+class RestaurantsController < ApplicationController
+  active_element.listable_fields :name, :restaurateur, :created_at, order: :name
+end
+```
+
+As mentioned above, associations are supported, so the `restaurateur` association will automatically map to the associated record and you'll be provided with a link to that record in the results table.
+
+Pagination is also provided by the default `#index` action.
+
+## Searchable Fields
+
+The `active_element.searchable_fields` declaration provides a list of fields on your model that can be searched by a user. You can specify `string`, `integer`, and `datetime` fields.
+
+A search form is generated and user input is processed according to column type.
+
+* `string` fields generate an `ILIKE` (case-insensitive `LIKE`) query from user input: `"joh"` will match `"John Smith"`.
+* `integer` fields require an exact match.
+* `datetime` fields provide a range, allowing users to provide a start date/time, an end date/time, or both.
+* Association fields will join on the relevant association and search all `string` and `integer` fields defined in the `searchable_fields` for the controller corresponding to the association model.
+
+```ruby
+# app/controllers/restaurants_controller.rb
+
+class RestaurantsController < ApplicationController
+  active_element.searchable_fields :name, :restaurateur, :created_at
+end
+```
+
+```ruby
+# app/controllers/restaurateurs_controller.rb
+
+class RestaurateursController < ApplicationController
+  active_element.searchable_fields :name, :address
+end
+```
+
+## Viewable Fields
+
+The `active_element.viewable_fields` declaration provides a list of fields on your model that will be included when viewing an individual record via the `#show` action.
+
+The results will be rendered in a horizontal table with one row for each item, including a _Delete_ and _Edit_ button above the table.
+
+```ruby
+# app/controllers/restaurants_controller.rb
+
+class RestaurantsController < ApplicationController
+  active_element.searchable_fields :name, :restaurateur, :created_at
+end
+```
+
+## Editable Fields
+
+The `active_element.editable_fields` declaration provides a list of fields on your model that can be modified by a user.
+
+This declaration enables both the `#edit`, `#new`, `#update`, and `#create` actions as well as defining the permitted parameters for `#update` and `#create`. A form is automatically generated and each field is selected according to the column data type.
+
+Note that each field type can be overridden and configured by defining `config/forms/<model>/<field.yml>`, allowing you to make many customizations to each field without having to work with views or override the default controller actions, as well as allowing each field configuration to be re-used in multiple places. See the [Form Fields](components/form-fields.html) documentation for more details.
+
+By default, `json` and `jsonb` fields use the [JSON Field](form-fields/json.html) type, allowing you to edit complex _JSON_ data structures via user-friendly _HTML_ forms. A [schema file](form-fields/json/schema.html) **must** be defined for these fields. See the `json_field` documentation for more details.
+
+## Deletable
+
+The `active_element.deletable` declaration does not receive any arguments but specifies that a record can be deleted by a user.
+
+```ruby
+# app/controllers/restaurants_controller.rb
+
+class RestaurantsController < ApplicationController
+  active_element.deletable
+end
+```

data/rspec-documentation/pages/Themes.md

@@ -0,0 +1,3 @@
+# Themes
+
+TODO

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_element
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - Bob Farrell
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-20 00:00:00.000000000 Z
+date: 2023-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bootstrap
@@ -116,6 +116,7 @@ files:
 - app/assets/javascripts/active_element/application.js
 - app/assets/javascripts/active_element/confirm.js
 - app/assets/javascripts/active_element/form.js
+- app/assets/javascripts/active_element/highlight.js
 - app/assets/javascripts/active_element/json_field.js
 - app/assets/javascripts/active_element/pagination.js
 - app/assets/javascripts/active_element/popover.js
@@ -318,8 +319,11 @@ files:
 - lib/active_element/controller_interface.rb
 - lib/active_element/controller_state.rb
 - lib/active_element/default_controller.rb
-- lib/active_element/default_record_params.rb
-- lib/active_element/default_search.rb
+- lib/active_element/default_controller/actions.rb
+- lib/active_element/default_controller/controller.rb
+- lib/active_element/default_controller/json_params.rb
+- lib/active_element/default_controller/params.rb
+- lib/active_element/default_controller/search.rb
 - lib/active_element/engine.rb
 - lib/active_element/json_field_schema.rb
 - lib/active_element/permissions_check.rb
@@ -354,6 +358,8 @@ files:
 - rspec-documentation/pages/010-Components/Tables/Item Table.md
 - rspec-documentation/pages/010-Components/Tables/Options.md
 - rspec-documentation/pages/010-Components/Tabs.md
+- rspec-documentation/pages/015-Custom Controllers.md
+- rspec-documentation/pages/016-Default Controller.md
 - rspec-documentation/pages/020-Access Control.md
 - rspec-documentation/pages/020-Access Control/010-Authentication.md
 - rspec-documentation/pages/020-Access Control/020-Authorization.md
@@ -367,6 +373,7 @@ files:
 - rspec-documentation/pages/040-Decorators/View Decorators.md
 - rspec-documentation/pages/300-Alternatives.md
 - rspec-documentation/pages/900-License.md
+- rspec-documentation/pages/Themes.md
 - rspec-documentation/spec_helper.rb
 - rspec-documentation/support.rb
 - sig/active_element.rbs